1.for嵌套循环
外层循环控制行数，内层循环控制列数
2.break语句
#注意
（1）switch语句中：终止case并跳出switch
（2）循环语句：跳出当前循环语句
（3）嵌套循环：跳出最近的内层循环语句
3.continue语句
作用：跳出本次循环中余下尚未执行的语句，继续执行下一次循环
#注意
（1）continue并没有使整个循环终止，而break会跳出循环
（2）i%2=0为偶数，i%2=1为奇数
4.goto语句
作用：无条件跳转语句
如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
语法:
goto 标记名； 标记名：
#注意
（1）标记名称一般用大写字母来表示
（2）在程序中不建议用goto，会造成程序流程混乱
5.一维数组
//1.数据类型 数组名 [数组长度];
//2.数据类型 数组名 [数组长度] = {值1，值2，...};
int arr2[5] = { 10,20,30 };//如果给的值个数不够定义的5个，会自动用0补齐
//3.数据类型 数组名 [] = {值1，值2,...};
//定义数组的时候，必须有初始长度
//数组名不要和变量名重名
数组下标是从0开始索引的
6.一维数组名
（1）可以统计整个数组在内存中的长度
sizeof(数组名) 比如：sizeof(arr)
sizeof（数组名[索引]) 比如：sizeof（arr[0])
数组元素个数=sizeof(arr)/sizeof(arr[0])
（2）可以获取数组在内存中的首地址
//用cout << 数组名 << endl;来查看数组在内存中的首地址,输出为16进制
cout << "数组首地址为：" << (int)arr_name << endl;//(int)arr强制转换为十进制
//用cout << &数组名[索引] << endl;来查看数组中第i个元素的地址,输出为16进制
cout << "数组中第一个元素地址为" << (int)&arr_name[0] << endl;
cout << "数组中第一个元素地址为" << (int)&arr_name[1] << endl;//每个元素之间相差四个字节，证明数组是连续的
//数组名是常量，不可以进行赋值操作
//arr = 100; //错误，数组名是常量，不可以进行赋值操作
直接打印数组名，可以查看数组所占内存的首地址
对数组名进行sizeof可以获取整个数组占内存空间的大小
7.冒泡排序法
实现元素互换：
int maopao_temp = arr_maopao[j];
arr_maopao[j] = arr_maopao[j + 1];
arr_maopao[j + 1] = maopao_temp;
8.二维数组
（1） 数据类型 数组名[行数][列数];
（2）数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
（3）数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
（4）数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };
#注意
在定义二维数组时，如果初始化了数据，可以省略行数
9、二维数组名称
（1）可以查看占用内存空间大小
int arr_ername[2][3]=
{
{1,2,3},
{4,5,6}
};
cout << "二维数组占用内存空间为：" << sizeof(arr_ername) << endl;//int四个字节，double八个字节
cout << "二维数组第一行占用内存为：" << sizeof(arr_ername[0]) << endl;
cout << "二维数组第一个元素占用内存为：" << sizeof(arr_ername[0][0]) << endl;
cout << "二维数组的行数为：" << sizeof(arr_ername) / sizeof(arr_ername[0]) << endl;
//行数=二维数组内存空间/一行内存空间
cout << "二维数组的列数为：" << sizeof(arr_ername[0]) / sizeof(arr_ername[0][0]) << endl;
//列数=一行内存空间/一个元素内存空间
（2）可以查看二维数据的首地址
cout << "二维数组的首地址为：" << (int)arr_ername << endl;
cout << "二维数组第一行首地址为：" << (int)arr_ername[0] << endl;
cout << "二维数组第二行首地址为：" << (int)arr_ername[1] << endl;//两行首地址之间差了一行的字节数
cout << "二维数组第一个元素首地址：" << (int)&arr_ername[0][0] << endl;
#注意
（1）直接打印二维数组名，输出就是这个数组的首地址
（2）通过sizeof来获取二维数组占用的内存空间大小
（3）对于具体第几行第几列元素必须加&
代码
#include <iostream>
#include <string> //用c++风格字符串时候，要包含这个头文件
#include <ctime> //time系统时间头文件包含
using namespace std;
//常量的定义方式
//1.#define 宏常量 #define 常量名 常量值 比如：#define Day 7
//2.const 数据类型 常量名 = 常量值;
//标识符的命名规则
//1.标识符不可以是关键字
//2.标识符由字母、数字、下划线构成
//3.标识符开头不能是数字，只能字母或下划线
//4.标识符中区分大小写
#define Day 7
int main()
{
//整型
//1.短整型 -32768~32767
short num1 = 10;
//short num1 = 32769;//错误，超出最大范围，运行出来的数字有问题！
//2.整型
int num2 = 20;
//3.长整型
long num3 = 30;
//4.长长整型
long long num4 = 40;
cout << "Number1=" << num1 << endl;
cout << "Number2=" << num2 << endl;
cout << "Number3=" << num3 << endl;
cout << "Number4=" << num4 << endl;
//用sizeof来求出数据类型占用内存大小
//语法： sizeof(数据类型或者变量名）
//short占2个字节，int占4个字节
//long在windows系统占4个字节，long在linux（32位）占4个字节，在linux（64）占8个字节
//long long占8个字节
//整型所占字节数大小比较：short <= int <= long <= long long
cout << "short占用内存空间为" << sizeof(short) << endl;
cout << "定义为short类型的num1占用内存空间为" << sizeof(num1) << endl;
cout << "int占用内存空间为" << sizeof(int) << endl;
cout << "定义为int类型的num2占用内存空间为" << sizeof(num2) << endl;
cout << "long占用内存空间为" << sizeof(long) << endl;
cout << "定义为long类型的num3占用内存空间为" << sizeof(num3) << endl;
cout << "long long占用内存空间为" << sizeof(long long) << endl;
cout << "定义为long long类型的num4占用内存空间为" << sizeof(num4) << endl;
//实型（浮点型） 有效数字个数不光是指小数点后，小数点前也算。比如3.14是三位有效数字
//1.单精度 float 占用4个字节，有效数字7位
//2.双精度 double 占用8个字节，有效数字15-16位
float f1 = 3.14;//正确，如果直接是3.14的话，编译器会将所有小数默认是double双精度的，这里编译器认为将双精度转换为单精度并赋值给f1
float f2 = 3.15f;//正确，这样是直接告诉编译器3.15是个单精度的，然后把单精度3.15赋给单精度f2
cout << f1 << " " << f2 << endl;
double f3 = 3.1415926;
cout << f3 << endl; //输出3.14159 默认情况下，输出一个小数只显示6位有效数字
//统计 float、double占用内存空间
cout << "float占用内存空间为" << sizeof(float) << endl;
cout << "double占用内存空间为" << sizeof(double) << endl;
//科学计数法
float f4 = 3e2;//3*10^2
cout << f4 << endl;
float f5 = 3e-2; //3*10^(-2)
cout << f5 << endl;
//int int=10; //错误，标识符不可以是关键字
int abc = 10; //标识符由字母、数字、下划线组成
int _abc = 20;
int _123 = 30;
//int 123_abc = 40; //错误，标识符开头不能是数字
int aaa = 10;
cout << aaa << endl;
//cout << AAA << endl; //错误，标识符区分大小写
//建议：给变量起名的时候，最好能够做到见名知意
int sum_abc__abc = abc + _abc;
cout << sum_abc__abc << endl;
//变量创建的语法：数据类型 变量名 = 变量初始值;
//不要用关键字给变量或者常量起名称
//int int = 10;//错误，第二个int是关键字，不可以作为变量的名称
int a = 10;
const int month = 12;
//month = 24; //错误，const定义的是常量，一旦修改就会报错！
//1.字符型变量创建方式： char 字符型变量名称 = '单个字符';
//注意用单引号！单引号！单引号！单引号内只能是一个字符！
char ch = 'a';
//char ch = 100;//正确，此时cout输出100，其实=‘a’将对应字符的ASCII码赋给变量，直接用ASCII码赋值是一样的。
//ch = 100; //正确，此时cout输出100，可以直接用ASCII码给字符型变量赋值
//char ch = "b"; //错误，不能使用双引号，一定要用单引号！
//char ch = 'abc'; //错误，会溢出，运行结果是c
cout << ch << endl;
//2.字符型变量所占内存大小 sizeof（char或者字符变量名称）
cout << "char所占内存大小为" << sizeof(char) << endl;
cout << "定义为char字符型的变量ch所占内存大小为" << sizeof(ch) << endl;
//3.字符型变量对应ASCII码
cout << (int)ch << endl;//通过将字符型变量强制转换成整型，用十进制表示出来
//字符型变量并不是将字符本身存储到内存中，而是将字符对应的ASCII码存储到内存中
//a对应ASCII码97.A对应ASCII码65
//转义字符:换行符\n 反斜杠符\\ 水平制表符\t
cout << "Hello world\n";// cout << "Hello world\n";等价于cout << "Hello world" << endl;
cout << "\\" << endl;//要输出\，得需要\\才能输出，第一个\告诉编辑器我要输出一个特殊符号。
//cout << "\" << endl;//错误，必须得是\\才能输出\。
cout << "hello\tworld" << endl;//hello跟\t一共占八个位置，输出hello+三个空格+world
//水平制表符\t可以整齐输出数据
//字符串类型
//1.C风格：char 变量名[] = "字符串值"; //变量名后跟[]，字符串值用双引号！字符型变量用单引号！
char str1[] = "Hello world!";//如果str1后面不跟[]的话会认为创建字符型变量，后面跟双引号是不对的
//cout << str1[] << endl;//错误
cout << str1 << endl;
//2.C++风格：string 变量名 = "字符串值";//C++风格需要加入头文件#include<string>
string str2 = "Hello world!!";
cout << str2 << endl;
//布尔类型bool true对应1，false对应0
//1.创建bool数据类型 bool 变量名 = true或者false；
bool flag = true;//true代表1
cout << flag << endl;
flag = false;//false代表0
cout << flag << endl;
//2.查看bool类型所占内存空间 sizeof（bool或者布尔变量名）
//数据的输入，用于从键盘获取数据
//语法： cin >> 变量名；
/*
//1.整型
int a_1 = 0;
cout << "请给整型变量a_1赋值" << endl;
cin >> a_1;
cout << a_1 << endl;
//2.浮点型
float f_1 = 0;
cout << "请给浮点型变量f_1赋值" << endl;
cin >> f_1;
cout << f_1 << endl;
//3.字符型
char ch_1 = 'a';
cout << "请给字符型变量ch_1赋值" << endl;
cin >> ch_1;
cout << ch_1 << endl;
//4.字符串型
string str_1 = "";
cout << "请给字符串型变量str_1赋值" << endl;
cin >> str_1;
cout << str_1 << endl;
//5.布尔类型 只要是非0值都代表真！！！(-1,1)都为假，因为读的整数位，把小数位去掉了！
bool flag_1 = true;
cout << "请给布尔类型flag_1赋值" << endl;
cin >> flag_1;
cout << flag_1 << endl;
*/
//加减乘除运算
int a_1 = 10;
int b_1 = 3;
cout << a_1 + b_1 << endl;
cout << a_1 - b_1 << endl;
cout << a_1 * b_1 << endl;
cout << a_1 / b_1 << endl;//a_1是int型，b_1是int型，一除以后结果还是int型，故结果是3
//两个整数相除，结果依然是整数，将小数部分去除
//两个数相除，除数不能为0
double d1 = 0.5;
double d2 = 0.22;
cout << d1 / d2 << endl;
//取模=求余数，%两端必须是整数
cout << a_1 % b_1 << endl;//10%3=1,10÷3=3。。。1，余数为1
int a3 = 10;
int a4 = 20;
cout << a3 % a4 << endl;//10%20=10
int a5 = 0;
//cout << a3 % a5 << endl;//错误，除数不可以为0，不可求余数，程序会闪退。
//两个小数是不可以做取模运算的
//cout << d1 % d2 << endl;//错误，%左右两端不能是小数
//递增递减
//前置递增
int a6 = 10;
++a6;//让变量+1
cout << a6 << endl;
//后置递增
int a7 = 20;
a7++;//让变量+1
cout << a7 << endl;
//前置和后置的区别
//前置递增：先让变量+1，再进行表达式运算
//后置递增：先进行表达式计算，再让变量+1
int a8 = 10;
int a9 = 10;
int b1 = ++a8 * 10;//先算10+1=11，再算11*10=110
int b2 = a9++ * 10;//先算10*10=100，再算10+1=11
cout << b1 << endl;
cout << b2 << endl;
//赋值运算符
//=
int a10 = 10;
a10 = 100;
cout << "a10=" << a10 << endl;
//+=
a10 = 10;
a10 += 2;//a=a+2
cout << "a10=" << a10 << endl;
//-=
a10 = 10;
a10 -= 2;//a=a-2
cout << "a10=" << a10 << endl;
//*=
a10 = 10;
a10 *= 2;//a=a*2
cout << "a10=" << a10 << endl;
// /=
a10 = 10;
a10 /= 2;//a=a/2
cout << "a10=" << a10 << endl;
// %=
a10 = 10;
a10 %= 2;//a=a%2
cout << "a10=" << a10 << endl;
//比较运算符
// ==
int a11 = 10;
int a12 = 20;
cout << (a11 == a12) << endl;//加个括号，让比较运算优先级大于endl换行
//!=
cout << (a11 != a12) << endl;
//>
cout << (a11 > a12) << endl;
//<
cout << (a11 < a12) << endl;
//>=
cout << (a11 >= a12) << endl;
//<=
cout << (a11 <= a12) << endl;
//逻辑运算符
//非 ！
int a13 = 10;//在c++中除了0都为真
cout << !a << endl;
cout << !!a << endl;
//与&& 同真为真，其余为假
int a14 = 10;
cout << (a13 && a14) << endl;
cout << (a13 && 0) << endl;
//或 || 同假为假，其余为真
cout << (a13 || a14) << endl;
cout << (a13 || 0) << endl;
cout << (0 || 0) << endl;
//程序流程结构
//选择结构
//单行if 语句
//语法： if（条件）{满足条件执行的语句}
//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
/*
//1.用户输入分数
int score = 0;
cout << "请输入一个分数：" << endl;
cin >> score;
//2.打印用户输入的分数
cout << "您输入的分数为：" << socre << endl;
//3.判断分数是否大于600，如果大于就输出
if (score > 600) //if条件后面不要加分号，如果加了分号，不管满不满足条件都会输出恭喜您。。。。
{
cout << "恭喜您考上了一本大学！" << endl;
}
*/
//多行if语句
//语法： if（条件）{满足条件执行的语句} else {不满足条件执行的语句}
//输入考试分数，如果分数大于600，视为考上一本大学，在屏幕上输出；否则打印未考上
/*
//1.输入考试分数
int score = 0;
cout << "请输入您的分数" << endl;
cin >> score;
//2.提示用户输入的分数
cout << "您输入的分数为：" << score << endl;
//3.判断 如果大于600，打印考上一本，否则打印未考上一本
if (score > 600)
{
cout << "恭喜您考上一本大学！" << endl;
}
else
{
cout << "未考上一本大学！" << endl;
}
*/
//多条件的if语句
//语句： if（条件1）{条件1满足执行的语句} else if（条件2） {条件2满足执行的语句} else{都不满足执行的语句}
//输入一个考试分数，如果大于600，为一本；大于500，为二本，大于400，为三本，其余为未考上
/*
//1.输入考试分数
int score = 0;
cout << "请输入您的分数" << endl;
cin >> score;
//2.提示用户输入的分数
cout << "您输入的分数为：" << score << endl;
//3.判断 如果大于600，一本；如果大于500，二本；如果大于400，三本；其余为未考上本科
if (score > 600)
{
cout << "一本" << endl;
}
else if (score > 500) //第二个条件判断
{
cout << "二本" << endl;
}
else if (score > 400) //第三个条件判断
{
cout << "三本" << endl;
}
else //都不满足时候执行
{
cout << "未考上" << endl;
}
*/
//嵌套if语句
//如果大于600，一本；如果大于500，二本；如果大于400，三本；其余为未考上本科
//在一本分数中，大于700，北大；大于650，清华；大于600，人大
/*
//1.输入考试分数
int score = 0;
cout << "请输入您的分数" << endl;
cin >> score;
//2.提示用户输入的分数
cout << "您输入的分数为：" << score << endl;
//3.判断 如果大于600，一本；如果大于500，二本；如果大于400，三本；其余为未考上本科
if (score > 600)
{
cout << "一本" << endl;
if (score > 700)
{
cout << "北大" << endl;
}
else if (score > 650)
{
cout << "清华" << endl;
}
else
{
cout << "人大" << endl;
}
}
else if (score > 500) //第二个条件判断
{
cout << "二本" << endl;
}
else if (score > 400) //第三个条件判断
{
cout << "三本" << endl;
}
else //都不满足时候执行
{
cout << "未考上" << endl;
}
*/
//三只小猪称体重
/*
//1.创建三只小猪的体重变量
int pigA = 0;
int pigB = 0;
int pigC = 0;
//2.输入三只猪的体重
cout << "请输入小猪A的体重" << endl;
cin >> pigA;
cout << "请输入小猪B的体重" << endl;
cin >> pigB;
cout << "请输入小猪C的体重" << endl;
cin >> pigC;
cout << "小猪A的体重为：" << pigA << endl;
cout << "小猪B的体重为：" << pigB << endl;
cout << "小猪C的体重为：" << pigC << endl;
//3.判断哪只最重
//先判断A和B谁更重
if (pigA > pigB) // A比B重
{
if (pigA > pigC) //A比C重
{
cout << "A最重" << endl;
}
else //C比A重
{
cout << "C最重" << endl;
}
}
else //B比A重
{
if (pigB > pigC) //B比C重
{
cout << "B最重" << endl;
}
else //C比B重
{
cout << "C最重" << endl;
}
}
*/
//三目运算符
//语法：表达式1 ? 表达式2 : 表达式3;
//如果表达式1为真，执行表达式2，并返回表达式2的结果
//如果表达式1为假，执行表达式3，并返回表达式3的结果
//创建三个变量a b c
//将a和b作比较，将变量大的值赋值给变量c
int aa = 10;
int bb = 20;
int cc = 0;
cc = (aa > bb ? aa : bb);//或者不加括号也可以cc = aa > bb ? aa : bb;
cout << "cc=" << cc << endl;
//在C++中三目运算符返回的是变量，可以继续赋值
(aa > bb ? aa : bb) = 100; //aa>bb返回变量aa，aa不大于bb返回变量bb
cout << "aa=" << aa << endl << "bb=" << bb << endl;
//switch语句
//语法
/*
switch (表达式)
{
case 结果1:
执行语句;
break;
case 结果2:
执行语句;
break;
default:
执行语句;
break;
}
*/
/*
//给电影进行打分
//10~9 经典
//8~7非常好
//6~5一般
//5以下 烂片
//1.提示用户给电影评分
cout << "请给电影进行打分" << endl;
//2.用户开始进行打分
int score = 0;
cin >> score;
cout << "您打的分数为：" << score << endl;
//3.根据用户输入的分数来提示用户最后的结果
switch (score)
{
case 10:
cout << "您认为是经典电影" << endl;
break; //退出当前分支，如果不加的话，会从第一个分支开始一直往下执行到最后一个分支
case 9:
cout << "您认为是经典电影" << endl;
break;
case 8:
cout << "您认为电影非常好" << endl;
break;
case 7:
cout << "您认为电影非常好" << endl;
break;
case 6:
cout << "您认为电影一般" << endl;
break;
case 5:
cout << "您认为电影一般" << endl;
break;
default:
cout << "您认为电影是烂片" << endl;
break;
}
*/
//switch语句中表达式只能是整型或字符型
//switch结构清晰，执行效率高，但是不可以判断区间
//case里如果没有break，会一直往下执行
//while循环语句
//语法：while(循环条件）{循环语句；}
//只要循环条件的结果为真，就一直执行循环语句
//在写循环时一定要避免死循环的出现
//在屏幕中打印0~9这十个数字
int num = 0;
while (num < 10)
{
cout << num << endl;
num++;
}
//猜数字游戏
/*
//添加随机数种子 利用当前系统时间生成随机数，防止每次随机数都一样
srand((unsigned int)time(NULL));
//1.系统生成随机数
int suijishu = rand() % 100 + 1; //rand()%100生成0~99的随机数，%后的数字代表区间
//2.玩家进行猜测
int caice = 0;
while (1)
{
cout << "请输入猜测的数字" << endl;
cin >> caice;
//3.判断玩家的猜测
//猜错 提示猜的结果 过大或者过小，重新返回第二步
if (caice > suijishu)
{
cout << "过大" << endl;
}
else if (caice < suijishu)
{
cout << "过小" << endl;
}
else
{
cout << "恭喜" << endl;
break; //在循环中，可以利用break来退出当前循环
//猜对 退出游戏
}
}
*/
//do...while循环语句
//语法：do(循环语句)while(循环条件);
//do...while会先执行一次循环语句，再判断循环条件
//在屏幕中输出0~9这十个数字
int num_do = 0;
do
{
cout << num_do << endl;
num_do++;
} while (num_do < 10);
//ctrl+c+k注释多行；ctrl+k+u取消注释
//水仙花数
//获取个位=对数字取模于10 例如：153%10=3
//获取十位=先整除于10，再对数字取模于10 例如153/10%10=5
//获取百位=整除于100 例如153/100=1
//1.先打印所有的三位数字
int num_shui = 100;
do
{
//2.从所有三位数字中找到水仙花数
int num_ge = 0;//个位
int num_shi = 0;//十位
int num_bai = 0;//百位
num_ge = num_shui % 10;//获取数字的个位
num_shi = num_shui / 10 % 10;//获取数字的十位
num_bai = num_shui / 100;//获取数字的百位
if (num_ge*num_ge*num_ge + num_shi*num_shi*num_shi + num_bai*num_bai*num_bai == num_shui)
{
cout << num_shui << endl;
}
num_shui++;
} while (num_shui < 1000);
//for循环
//语句：
/*
for (起始表达式；条件表达式；末尾循环体)
{
循环语句；
}
*/
//打印数字0~9
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
//敲桌子游戏
//1.先输出1~100数字
for (int i = 1; i < 100; i++)
{
//2.从100个数字中找到特殊数字，打印敲桌子。7的倍数、个位有7、十位有7
//i%10==7 个位数字是否为7
//i/10==7 十位数字是否为7
//i%7==0 是否为7的倍数
if (i % 10 == 7 || i / 10 == 7 || i % 7 == 0)
{
cout << "敲桌子" << endl;
}
else //如果不是特殊数字，打印该数字
{
cout << i << endl;
}
}
//利用嵌套循环实现星图
//打印星图
//外层执行一次，内层执行一周
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
cout << "* " ;
}
cout << endl;
}
//乘法口诀表
//外层循环控制行数，内层循环控制列数=外行内列
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout << j << "*" << i << "=" << i * j << "\t";
}
cout << endl;
}
//break 语句
//作用：跳出选择结构或者循环结构
/*
//1.出现在switch语句中，终止case并跳出switch
cout << "请选择副本难度" << endl;
cout << "1.普通" << endl;
cout << "2.中等"<< endl;
cout << "3.困难"<< endl;
int select_fuben = 0; //创建选择结果的变量
cin >> select_fuben; //等待用户的输入
switch (select_fuben)
{
case 1:
cout << "您选择的是普通难度" << endl;
break;
case 2:
cout << "您选择的是中等难度" << endl;
break;
case 3:
cout << "您选择的是困难难度" << endl;
break;
default:
break;
}
*/
//2.出现在循环语句中，跳出当前的循环语句
for (int i = 0; i < 10; i++)
{
//如果i=5，退出循环，不再打印
if (i == 5)
{
break;//退出循环，最后只输出0,1,2,3,4
}
cout << i << endl;
}
//3.出现在嵌套循环中，跳出最近的内层循环语句
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
//每行只有五个星星
if (j == 5)
{
break;//退出内层循环，不会影响外层循环=break终止多层嵌套中最近的一层循环
}
cout << "* ";
}
cout << endl;
}
//continue语句
//作用：在循环语句中，跳过本次循环中余下的尚未执行的语句，继续执行下一次循环
for (int i = 0; i < 100; i++)
{
//如果是奇数输出，偶数不输出 i%2=0为偶数，i%2=1为奇数
if (i % 2 == 0)
{
continue;//可以筛选条件，执行到此就不再向下执行，再执行下一次循环
//break会退出循环，而continue不会
}
cout << i << endl;
}
//goto语句
//作用：可以无条件跳转语句
//语法：
/*goto 标记；
标记：
*/
//标记名称一般用大写字母来表示
//如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
cout << "1" << endl;
cout << "2" << endl;
goto FLAG;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
//在程序中不建议使用goto，会造成程序流程混乱
//数组
//数组索引从0开始
//特点：1.数组中每个数据元素都是相同的数据类型
//2.数组由连续的内存位置组成的
//数组定义的三种方式
//1.数据类型 数组名 [数组长度];
int arr[5];
//给数组中的元素进行赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
//访问数据元素
cout << arr[0] << endl;
cout << arr[1] << endl;
cout << arr[2] << endl;
cout << arr[3] << endl;
cout << arr[4] << endl;
//2.数据类型 数组名 [数组长度] = {值1，值2，...};
int arr2[5] = { 10,20,30 };//如果给的值个数不够定义的5个，会自动用0补齐
//cout << arr2[0] << endl;
//cout << arr2[1] << endl;
//cout << arr2[2] << endl;
//cout << arr2[3] << endl;
//cout << arr2[4] << endl;
//利用for循环输出数组中的元素
for (int i = 0; i < 5; i++)
{
cout << arr2[i] << endl;
}
//3.数据类型 数组名 [] = {值1，值2,...};
//定义数组的时候，必须有初始长度
int arr3[] = { 90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 9; i++)
{
cout << arr3[i] << endl;
}
//数组名不要和变量名重名
//一维数组数组名
//1.可以统计整个数组在内存中的长度
//sizeof(数组名) 比如：sizeof(arr)
//sizeof（数组名[索引]) 比如：sizeof（arr[0])
//数组元素个数=sizeof(arr)/sizeof(arr[0])
int arr_name[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组占用内存空间为" << sizeof(arr_name) << endl;
//输出40，因为int类型一个为4字节，10个一共40字节
cout << "每个元素占用内存空间为：" << sizeof(arr_name[0]) << endl;
cout << "数组中元素个数为：" << sizeof(arr_name) / sizeof(arr_name[0]) << endl;
//2.可以获取数组在内存中的首地址
//用cout << 数组名 << endl;来查看数组在内存中的首地址,输出为16进制
cout << "数组首地址为：" << (int)arr_name << endl;//(int)arr强制转换为十进制
//用cout << &数组名[索引] << endl;来查看数组中第i个元素的地址,输出为16进制
cout << "数组中第一个元素地址为" << (int)&arr_name[0] << endl;
cout << "数组中第一个元素地址为" << (int)&arr_name[1] << endl;//每个元素之间相差四个字节，证明数组是连续的
//数组名是常量，不可以进行赋值操作
//arr = 100; //错误，数组名是常量，不可以进行赋值操作
//五只小猪称体重
//1.创建五只小猪体重的数组
int arr_pig[5] = { 300,350,500,400,250 };
//2.从数组中找到最大值
int pig_max = 0;//假设最大值为pig_max=0
for (int i = 0; i < 5; i++)
{
if (arr_pig[i] > pig_max)//如果访问的数组中元素比我认定的最大值还大，则更新最大值
{
pig_max = arr_pig[i];
}
}
//3.打印最大值
cout << "最重体重为:" << pig_max << endl;
//数组元素逆置
//1.创建数组
int arr_nizhi[5] = { 1,3,2,5,4 };
cout << "数组逆置前：" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr_nizhi[i] << endl;
}
//2.实现逆置
//2.1记录起始下标位置
//2.2记录结束下标位置
//2.3起始下标与结束下标的元素互换
//2.4起始位置++ 结束位置--
//2.5循环执行2.1操作，直道起始位置>=结束位置
int arr_start = 0;//起始元素下标
int arr_end = sizeof(arr) / sizeof(arr[0]) - 1;//末尾元素下标=元素个数-1
while (arr_start < arr_end)
{
//实现元素互换
int arr_temp = arr_nizhi[arr_start];//用 temp来暂存数据
arr_nizhi[arr_start] = arr_nizhi[arr_end];
arr_nizhi[arr_end] = arr_temp;
//下标更新
arr_start++;
arr_end--;
}
//3.打印逆置后的数组
cout << "数组元素逆置后：" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr_nizhi[i] << endl;
}
//冒泡排序法实现升序排列
int arr_maopao[9] = { 2,4,0,5,7,1,3,8,9 };
cout << "排序前：" << endl;
for (int i = 0; i < 9; i++)
{
cout << arr_maopao[i] << endl;
}
//总共排序轮数为：元素个数-1，从0开始
for (int i = 0; i < 9 - 1; i++)
{
//内层循环： 对比次数=元素个数-1-当前轮数
for (int j = 0; j < 9 - 1 - i; j++)
{
//如果第一个数字比第二个数字大，交换两个数字
if (arr_maopao[j] > arr_maopao[j + 1])
{
int maopao_temp = arr_maopao[j];
arr_maopao[j] = arr_maopao[j + 1];
arr_maopao[j + 1] = maopao_temp;
}
}
}
cout << "排序后：" << endl;
for (int i = 0; i < 9; i++)
{
cout << arr_maopao[i] << endl;
}
//二维数组定义方式
//1. 数据类型 数组名[行数][列数];
//2. 数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
//3. 数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
//4. 数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };
//1. 数据类型 数组名[行数][列数];
int arr_erwei1[2][3];
arr_erwei1[0][0] = 1;
arr_erwei1[0][1] = 2;
arr_erwei1[0][2] = 3;
arr_erwei1[1][0] = 4;
arr_erwei1[1][1] = 5;
arr_erwei1[1][2] = 6;
//外层循环打印行数，内层循环打印列数
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr_erwei1[i][j] << endl;
}
}
//2. 数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
int arr_erwei2[2][3]=
{
{1,2,3,},
{4,5,6}
};
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr_erwei2[i][j] << " ";
}
cout << endl;
}
//3. 数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
int arr_erwei3[2][3] = { 1,2,3,4,5,6 };
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr_erwei3[i][j] << " ";
}
cout << endl;
}
//4. 数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };
int arr_erwei4[][3] = { 1,2,3,4,5,6 };
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr_erwei4[i][j] << " ";
}
cout << endl;
}
//在定义二维数组时，如果初始化了数据，可以省略行数
//二维数组名称用途
//1.可以查看占用内存空间大小
int arr_ername[2][3]=
{
{1,2,3},
{4,5,6}
};
cout << "二维数组占用内存空间为：" << sizeof(arr_ername) << endl;//int四个字节，double八个字节
cout << "二维数组第一行占用内存为：" << sizeof(arr_ername[0]) << endl;
cout << "二维数组第一个元素占用内存为：" << sizeof(arr_ername[0][0]) << endl;
cout << "二维数组的行数为：" << sizeof(arr_ername) / sizeof(arr_ername[0]) << endl;
//行数=二维数组内存空间/一行内存空间
cout << "二维数组的列数为：" << sizeof(arr_ername[0]) / sizeof(arr_ername[0][0]) << endl;
//列数=一行内存空间/一个元素内存空间
//2.可以查看二维数据的首地址
cout << "二维数组的首地址为：" << (int)arr_ername << endl;
cout << "二维数组第一行首地址为：" << (int)arr_ername[0] << endl;
cout << "二维数组第二行首地址为：" << (int)arr_ername[1] << endl;//两行首地址之间差了一行的字节数
cout << "二维数组第一个元素首地址：" << (int)&arr_ername[0][0] << endl;
//考试成绩统计
//1.创建二维数组
int scores[3][3]=
{
{100,100,100},
{90,50,100},
{60,70,80}
};
string names[3] = { "张三","李四","王五" };
//2.统计每个人的总分数
for (int i = 0; i < 3; i++)
{
int sum = 0;//统计分数总和的变量
for (int j = 0; j < 3; j++)
{
sum += scores[i][j];
//cout << scores[i][j] << "\t";
}
cout << names[i] << "的总分为：" << sum << endl;
}
/*
cout << "一年有" << month << "个月。" << endl;
cout << "a = " << a << " " << a+10 << endl;
cout << "Love life."; //不加endl不换行
cout << endl; //endl是用来换行的
cout << "一周有" << Day << "天。" << endl;
cout << "Hello world!" << endl;
*/
system("pause");
//cin.get();
return 0;
}
509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
