1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
using namespace std;
//1、#define 宏常量：
#define Day 7
int main() {
//Day = 14;
//错误：Day是常量，不可修改
cout << "一周有 " << Day <<"天" << endl;
//2、const修饰的变量 
const int month = 12;
//month = 24;
//错误：const修饰的变量也是不可修改
cout << "一年总共有" << month << "月" << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream>
using namespace std;
int main() {
short num1 = 10;
cout << "short所占内存大小：" << sizeof(num1) << endl;
cout << "short所占内存大小：" << sizeof(short) << endl;
int a = 10;
cout << "int所占内存大小：" << sizeof(int) << endl;
cout << "a 所占内存大小：" << sizeof( a ) << endl;
cout << "long所占内存大小：" << sizeof(long) << endl;
cout << "long long 所占内存大小：" << sizeof(long long) << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
using namespace std;
int main() {
float f1 = 3.1415926f;
//否则默认双精度
double d1 = 3.14;
double d2 = 3.141592653;
double d3 = 3.14159265354579;
cout << "f1= " << f1 << endl;
cout << "d1= " << d1 << endl;
cout << "d2= " << d2 << endl;
cout << "d3= " << d3 << endl;
//统计float 和double占用内存空间
cout << "float 占用内存空间：" << sizeof(float) << endl;
//4字节
cout << "double占用内存空间：" << sizeof(double) << endl; //8字节
//科学计数法
float f2 = 3e2; //3* 10 ^2
float f3 = 3e-2; //3* 0.1 ^2
cout << "f2=" << f2 << endl;
cout << "f3=" << f3 << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
using namespace std;
int main()
{
//1、字符型变量创建方式
char ch = 'a';
cout << "ch= " << ch << endl;
//2、字符型变量所占内存大小
cout << "char所占内存大小为：" << sizeof(char) << endl;
//3、字符型变量常见错误
//char ch2 = "b";
//注意用单引号
//char ch3 = 'abc'
//注意单个字符
//4、字符型变量对应ASCII编码
cout <<(int) ch << endl;
//a 对应的ASCII是 97
字符型强转为整型
char ch1 = 'A';
cout << (int)ch1 << endl;
//A 对应的ASCII是 65
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
using namespace std;
int main() {
//
换行
n

cout << "hello world n";
//
反斜杠
\ 
cout << "\" << endl;
//
水平制表符
t
cout << "aaaaaahelloworld n" ;
cout << "aaa t helloworld n" ;//一共8个宽度，作用：对齐输出
cout << "aaaaaaaahelloworld n" ;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
using namespace std;
#include<string>
int main() {
//1、c风格字符串
//注意事项 char 字符串名[]
//注意事项2 等号后面 要用双引号 包含起来字符串
char str1[] = "hello world";
cout << str1 << endl;
//2、c++风格字符串
--注意
包含头文件
string str2 = "hello World";
cout << str2<<endl ;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream>
using namespace std;
int main() {
//1、创建bool数据类型
bool flag = true;
cout << flag << endl; //1
flag = false;
cout << flag << endl;
//0
//2、查看bool
cout << "bool类型所占内存空间" << sizeof(bool) << endl; //1
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include<iostream>
using namespace std;
int main() {
//1、整型输入
int a = 0;
cout << "请给整型变量a赋值：" << endl;
cin >> a;
cout << "整型变量a = " << a << "n";
//2、浮点型输入
float f = 3.14f;
cout << "请给浮点型变量f赋值：" << endl;
cin >> f;
cout << "浮点型变量f=" << f << endl;
//3、字符型输入
char ch = 'a';
cout << "请给字符型变量ch赋值：" << endl;
cin >> ch;
cout << "字符型变量ch=" << ch << endl;
//4、字符串型输入
string str = "abc";
cout << "请给字符串型变量str赋值：n";
cin >> str;
cout << "字符串变量str=" << str << endl;
//5、bool型输入(bool类型除了非0的值都代表真)
bool flag = true;
cout << "请给bool类型赋值：n";
cin >> flag;
cout << "bool型flag=" << flag << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
using namespace std;
int main() {
//加减乘除
int a1 = 10;
int b1 = 3;
cout << a1 + b1 << endl;
cout << a1 - b1 << endl;
cout << a1 * b1 << endl;
cout << a1 / b1 << endl;
//两个数整除，结果依然是整数，将小数部分去除
int a2 = 10;
int b2 = 20;
cout << a2 / b2 << endl;
//int a3 = 10;
//int b3 = 0;
//cout << a3 / b3 << endl;
//0不可以是被除数
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream>
using namespace std;
int main() {
//取模运算的本质是取余数
int a1 = 10;
int b1 = 3;
cout << a1 % b1 << endl;
int a2 = 10;
int b2 = 20;
cout << a2 % b2 << endl;
//两个小数不可以做取模运算
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<iostream>
using namespace std;
int main() {
//1、前置递增
int a = 10;
++a;
cout << "a=" << a << endl;
//2、后置递增
int b = 10;
b++;
cout << "b=" << b << endl;
//3、前值和后置区别
//前置递增 先让变量+1
然后进行表达式运算
int a2 = 10;
int b2 = ++a2 * 2;
cout << "b2=" << b2 << endl;
//后置递增 先让进行表达式运算
然后在+1
int a3 = 10;
int b3 = a3++ * 2;
cout << "a3=" << a3 << endl;
cout << "b3=" << b3 << endl;
int a4 = 10;
int c3 = a4++ * 2;
int c4 = a4++ * 2;
int c2 = ++a4 * 2;
cout << "c2=" << c2 << endl;
cout << "a4=" << a4 << endl;
cout << "c3=" << c3 << endl;
cout << "c4=" << c4 << endl;
cout << "a4=" << a4 << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include<iostream>
using namespace std;
int main() {
//赋值运算
// =
int a = 10;
a = 100;
cout << "a=" << a << endl;
// +=
a = 10;
a += 2 ;
cout << "a=" << a << endl;
// -=
a = 10;
a -= 2;
cout << "a=" << a << endl;
// *=
a = 10;
a *= 2;
cout << "a=" << a << endl;
// /=
a = 10;
a /= 2;
cout << "a=" << a << endl;
// %=
a = 10;
a %= 2;
cout << "a=" << a << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream>
using namespace std;
int main() {
int a = 10;
int b = 20;
cout << (a == b) << endl; // 0 
cout << (a != b) << endl; // 1
cout << (a > b) << endl; // 0
cout << (a < b) << endl; // 1
cout << (a >= b) << endl; // 0
cout << (a <= b) << endl; // 1
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
int main() {
int a = 10;
cout << !a << endl; // 0
cout << !!a << endl; // 1
system("pause")
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//逻辑运算符
--- 与
#include<iostream>
using namespace std;
int main() {
int a = 10;
int b = 10;
cout << (a && b) << endl;// 1
a = 10;
b = 0;
cout << (a && b) << endl;// 0 
a = 0;
b = 0;
cout << (a && b) << endl;// 0
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//逻辑运算符
--- 或
#include <iostream>
using namespace std;
int main() {
int a = 10;
int b = 10;
cout << (a || b) << endl;// 1
a = 10;
b = 0;
cout << (a || b) << endl;// 1 
a = 0;
b = 0;
cout << (a || b) << endl;// 0
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<iostream>
using namespace std;
int main() {
//用户输入分数，如果分数大于600，是为考上一本，在屏幕上输出
//1、用户输入分数
int score = 0;
cout << "请输入一个分数：" << endl;
cin >> score;
//2、打印用户输入信息
cout << "您输入的分数是：" << score << endl;
//3、判断分数是否大于600，如果大于，输出恭喜
if (score > 600)
{
cout << "恭喜您考上一本大学" << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
using namespace std;
int main() {
int score = 0;
cout << "请输入考试分数：" << endl;
cin >> score;
if (score > 600)
{
cout << "我考上了一本大学" << endl;
}
else
{
cout << "我未考上一本大学" << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<iostream>
using namespace std;
int main() {
//选择结构
多条件语句
//输入一个考试分数，如果大于600，视为考上一本，在屏幕上输出
//大于500，视为考上二本大学，屏幕输出
//大于400，视为考上三本大学，屏幕输出
//小于等于400视为未考上本科，屏幕输出
//1、用户输入分数
int score = 0;
cout << "请输入您的分数：" << endl;
cin >> score;
//2、提示用户输入的分数
cout << "您输入的分数是：" << score << endl;
//3、判断用户输入的分数
if (score > 600)
{
cout << "恭喜您考上一本大学" << endl;
}
else if (score > 500)
{
cout << "您考上了二本大学" << endl;
}
else if (score > 400)
{
cout << "您考上了三本大学" << endl;
}
else
{
cout << "您未考上本科，再接再厉" << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//案例需求：
//提示用户输入一个高考考试分数，根据分数做如下判断
//分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
//在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。
#include<iostream>
using namespace std;
int main() {
//1、提示输入高考分数
int score = 0;
cout << "请输入您的分数：" << endl;
cin >> score;
//2、显示输入高考分数
cout << "你输入的分数是：" << score << endl;
//3、判断
//如果大于600，一本
//大于700，清华
//大于650，北大
//其余人大
//如果大于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;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//练习案例： 三只小猪称体重
//有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重？
#include<iostream>
using namespace std;
int main() {
//1、提示
int A = 0;
int B = 0;
int C = 0;
//2、让用户输入三只小猪的重量
cout << "请输入小猪A的重量" << endl;
cin >> A;
cout << "请输入小猪B的重量" << endl;
cin >> B;
cout << "请输入小猪C的重量" << endl;
cin >> C;
//3、判断哪只最重
if (A > B)
{
if (A > C)
{
cout << "A小猪最重" << endl;
}
else
{
cout << "C小猪最重" << endl;
}
}
else
{
if (B > C)
{
cout << "B小猪最重" << endl;
}
else
{
cout << "C小猪最重" << endl;
}
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<iostream>
using namespace std;
int main() {
//创建三个变量a
b
c
//将a
和b作比较，将变量大的值赋值给变量c
int a = 10;
int b = 20;
int c = 0;
c = (a > b ? a : b);
cout << "c=" << c << endl;
//在c++中三目运算符返回的是变量，可以继续赋值
(a < b ? a : b) = 100;
cout << "a=" << a<< endl;
cout << "b=" << b << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<iostream>
using namespace std;
//if 和switch 区别：
//switch 缺点：判断的时候只能是整型或者字符型，不可以是一个区间
//
优点：结构清晰，执行效率高
//case里面如果没有break会一直向下执行
int main() {
//请给电影评分 
//10 ~ 9
经典

// 8 ~ 7
非常好
// 6 ~ 5
一般
// 5分以下 烂片
int score = 0;
cout << "请给电影打分" << endl;
cin >> score;
cout << "您打的分数为：" << score << endl;
switch (score)
{
case 10:
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;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream>
using namespace std;
int main() {
//while循环
//打印0~9 10个数字
int num = 0;
while (num < 10)
{
cout << num << endl;
num++;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<iostream>
using namespace std;
//time系统时间头文件包含
#include <ctime>
int main() {
//添加随机种子 作用利用当前系统时间生成随机数，防止每次随机数都一样
srand((unsigned int)time(NULL));
//1、系统生成随机数
int num = rand() % 100 + 1 ; //随机生成 1~100随机数
//cout << num << endl;
//2、玩家进行猜测
int val = 0;
//玩家输入数据
while (1)
//一直循环
{
cin >> val;
//3、判断玩家的猜测
//猜错
提示猜的结果
过大或过小 重新返回第二步
if (val > num)
{
cout << "数字过大" << endl;
}
else if (val < num)
{
cout << "数字过小" << endl;
}
else
{
cout << "恭喜您猜对了" << endl;
break;//猜对了
退出 游戏
}
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include<iostream>
using namespace std;
int main() {
//do...while
//在屏幕上输出10个数
int num = 0;
//do {
//	cout << num << endl;
//	num++;
//} 
//while (num < 10);
//do while 和while区别：前者先执行一次循环，在判断循环条件
//比较1
和 2的区别
1
//while (num )
//{
//	cout << num << endl;
//	num++;
//}
// 此时 num = 0 条件为假
输出为空
1.1
//while (++num )
//{
//	cout << num << endl;
//
//}
// 此时一开始 num = 1 条件为真
一直输出
2
//do {
//	cout << num << endl;
//	num++;
//} 
//while (num );
//此时 num = 1 条件为真
一直循环下去
2.1
//do {
//	cout << num << endl;
//	
//} while (++num);
//此时num =1 条件为真 一直循环下去
2.2
//do {
//	cout << num << endl;
//} while (num++);
//此时num =0 条件为假 
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include<iostream>
using namespace std;
//水仙花数
int main() {
//1、先打印所有三位数字
int num = 100;
do
{
//2、从所有三位数中找到水仙花数
int a = 0;
//各位
int b = 0;
//十位
int c = 0;
//百位
a = num % 10;
//获取个位
b = num / 10 % 10;
//获取十位
c = num / 100;
//获取百位
if (num == a * a * a + b * b * b + c * c * c)
{
cout << num << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//for循环：满足循环条件，执行循环语句
//语法：for（起始表达式；条件表达式；末未循环体）{循环语句}
#include<iostream>
using namespace std;
int main() {
//从0打印到9
for (int i = 0; i < 10; i++)
//分号分割
{
cout << i << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 100; i++)
{
if (i % 10==7 ||
i/10==7 || i%7==0)
{
cout << "敲桌子" << endl;
}
else
{
cout << i << endl;
}
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<iostream>
using namespace std;
int main() {
//利用循环嵌套实现星图
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
cout << "*";
}
cout << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//练习案例：九九乘法口诀表
//案例描述：利用嵌套循环，实现九九乘法表
#include<iostream>
using namespace std;
int main() {
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout << j << "*" << i << " = " << i * j <<"
" ;
}
cout << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//break作用：用于跳出选择结构 或 循环结构
//出现时机：1）出现在switch语句中，作用是终止case并跳出switch
//
2）出现在循环语句中，作用是跳出当前循环
//
3）出现在嵌套循环中，跳出最近的循环语句
#include<iostream>
using namespace std;
int main()
{
//1、在switch 语句中使用
//cout << "请选择您挑战副本的难度：" << endl;
//cout << "1、普通" << endl;
//cout << "2、中等" << endl;
//cout << "3、困难" << endl;
//int num = 0;
//创建一个选择结果
//cin >> num;
//等待用户输入
//switch (num)
//{
//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++)
{
if (i == 5)
{
break;
//退出当前循环
}
cout << i << endl;
//0 1 2 3 4
}
//3、出现在嵌套循环语句中
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
if (j == 5)
{
break;
}
cout << "*" ;
}
cout << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//**作用：continue在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
//
break退出循环，结束
#include<iostream>
using namespace std;
int main()
{
for (int i =1; i < 100; i++)
{
if (i % 2 == 0)
//打印奇数
{
continue;
//跳过下面循环，重头开始执行
}
cout << i << endl;
//1 3 5 7 ...
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//goto语句：无条件跳转语句
//goto语法；goto标记
//解释：如果标记的名称存在，执行goto语句时，会跳转标记位置
#include<iostream>
using namespace std;
int main()
{
cout << "1" << endl;
goto FLAG;
cout << "2" << endl;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<iostream>
using namespace std;
int main()
{
定义方式1
数据类型 数组名[元素个数];
//int score[10];
利用下标赋值
//score[0] = 100;
//score[1] = 99;
//score[2] = 85;
利用下标输出
//cout << score[0] << endl;
//cout << score[1] << endl;
//cout << score[2] << endl;
第二种定义方式
数据类型 数组名[元素个数] =
{值1，值2 ，值3 ...};
如果{}内不足10个数据，剩余数据用0补全
//int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
逐个输出
cout << score2[0] << endl;
cout << score2[1] << endl;
一个一个输出太麻烦，因此可以利用循环进行输出
//for (int i = 0; i < 10; i++)
//
//	cout << score2[i] << endl;
//}
//定义方式3
//数据类型 数组名[] =
{值1，值2 ，值3 ...};
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 10; i++)
{
cout << score3[i] << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//一维数组名称的用途：
//1）可以统计整个数组在内存中的长度
//2）可以获取数组在内存中的首地址
#include<iostream>
using namespace std;
int main() {
//1、通过数组名统计整个数组占用内存大小
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组占用内存空间为：" << sizeof(arr) << endl;
//40
cout << "每个数组占用内存空间为：" << sizeof(arr[0]) << endl;
//4
cout << "整组中共有元素个数：" << sizeof(arr) / sizeof(arr[0]) << endl;
//10
//2、可以通过数组名查看数组首地址
cout << "数组首地址为：" << arr << endl;
//结果为16进制
cout << "数组首地址为：" << (int)arr << endl;
//强转为10进制
cout << "数组中第一个元素地址为：" << (int)&arr[0] << endl;
cout << "数组中第一个元素地址为：" << (int)&arr[1] << endl;
//数组名是常量，不可以进行赋值操作
//arr = 100;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
using namespace std;
int main() {
int arr[] = { 100,200,350,300,201 };
int max = 0;
for (int i = 0; i < 5; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
cout << "最重小猪体重："<< max << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//元素逆置--声明一个5个元素的数组，并且将元素逆置
//如：原数组元素为：1,3，2，5，4
逆置后输出结果为4,5,2,3,1
#include<iostream>
using namespace std;
int main() {
int arr[] = { 1,3,2,5,4 };
cout << "数组逆置前" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
//2、实现逆置
//2.1记录起始下标位置
//2.2记录结束下标位置
//2.3起始下标与结束下标的元素互换
//2.4起始位置++，结束位置--
//2.5循环执行2.1操作，直到起始位置>=结束位置
int start = 0;
int end = sizeof(arr) / sizeof(arr[0]) - 1;
while (start < end)
{
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
//下标更新
start++;
end--;
}
//3、打印逆置后数组
cout << "逆置后数组" <<
endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//冒泡排序
//作用： 最常用的排序算法，对数组内元素进行排序
//比较相邻的元素。如果第一个比第二个大，就交换他们两个。
///对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
//重复以上的步骤，每次比较次数 - 1，直到不需要比较
#include<iostream>
using namespace std;
int main() {
int arr[9] = { 2,4,0,5,7,1,3,8,9 };
for (int i = 0; i < 9 - 1; i++)
{
for (int j = 0; j < 9 - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < 9; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
//二维数组定义的四种方式：
//数据类型 数组名[行数][列数];
//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
//数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
//数据类型 数组名[
][列数] = { 数据1，数据2，数据3，数据4 };
#include<iostream>
using namespace std;
int main() {
//1、数据类型 数组名[行数][列数];
int arr[2][3];
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 5;
arr[1][2] = 6;
//cout << arr[0][0] << endl;
//cout << arr[0][1] << endl;
//cout << arr[0][2] << endl;
//外层循环打印行数，内层循环打印列数
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr[i][j] << endl;
}
}
//2、数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr2[i][j] <<" ";
}
cout << endl;
}
//3、数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
int arr3[2][3] = { 1,2,3,4,5,6 };
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr3[i][j] << " ";
}
cout << endl;
}
//3、数据类型 数组名[
][列数] = { 数据1，数据2，数据3，数据4 };
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
using namespace std;
int main() {
//二维数组名称用途
//1、可以查看占用内存空间大小
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
cout << "二维数组第一行占用内存空间：" << sizeof(arr[0]) << endl;
cout << "二维数组第一个元素占用内存空间：" << sizeof(arr[0][0]) << endl;
cout << "二维数组行数：" << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组列数：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
//2、可以查看二维数组的首地址
cout << "二维数组首地址：" << arr << endl;
cout << "二维数组第一行地址：" << arr[0] << endl;
cout << "二维数组第二行地址：" << arr[1] << endl;
cout << "二维数组第一个元素的地址：" << &arr[0][0] << endl;
cout << "二维数组第二个元素地址为：" << &arr[0][1] << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<iostream>
using namespace std;
#include<string>
int main() {
//二维数组案例-考试成绩统计
//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 << names[i]<< "的总分为：" << sum << endl;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
using namespace std;
//函数的定义
//语法：
//返回值类型
函数名 （参数列表） {函数体语句
return表达式}
//加法函数
实现两个两个整型相加，并且将相加的结果进行返回
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
int main() {
//main
是入口函数
system("pause");//按任意键继续
return 0;
//返回退出
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<iostream>
using namespace std;
//加法函数
实现两个两个整型相加，并且将相加的结果进行返回
int add(int num1, int num2)
//num1 num2是形参
{
int sum = num1 + num2;
return sum;
}
int main() {
//main函数中调用add函数
int a = 10;
int b = 20;
//函数调用语法：函数名称（参数）
//a b是实际参数
//当调用函数的时候，实参的值会传递给形参
int c = add(a, b);
cout <<"c=" << c << endl;
//30
a = 100;
b = 200;
c = add(a, b);
cout << "c=" << c << endl;
//300
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include<iostream>
using namespace std;
//定义函数 实现两个数字进行交换函数
//如果函数不需要返回值，声明的时候可以写void
void swap(int num1, int num2)
{
cout << "交换前：" << endl;
cout << "num1=" << num1 << endl;
cout << "num2=" << num2 << endl;
int temp = num1;
num1 = num2;
num2 = temp;
cout << "交换后：" << endl;
cout << "num1=" << num1 << endl;
cout << "num2=" << num2 << endl;
return;//返回值不需要的时候可以不写return
}
int main() {
int a = 10;
int b = 20;
cout << "a=" << a << endl;
//10
cout << "b=" << b << endl;
//20
//当我们做值传递的时候，函数的形参发生改变，并不会影响实参
swap(a, b);
cout << "a=" << a << endl;
//10
cout << "b=" << b << endl;
//20
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<iostream>
using namespace std;
//函数常见样式
//1、无参无返
void test01()
{
cout << "this is test01" << endl;
//this is test01
}
//2、有参无返
void test02(int a)
{
cout << "this is test02 a= " << a << endl;
//this is test02 a= 100
}
//3、无参有返
int test03()
{
cout << "this is test03"
<< endl;
//this is test03
return 10;
}
//4、有参有返
int test04(int b)
{
cout << "this is test04 b=" <<b<< endl;
//this is test04 b=10000
return b;
}
int main() {
//无参无返函数调用
test01();
//有参无返函数调用
test02(100);
//无参有返函数调用
int c = test03();
cout << "c=" << c << endl;
//c=10
//有参有返函数调用
int num2 = test04(10000);
cout << "num2=" << num2 << endl;
//num2=10000
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
using namespace std;
//函数的声明
//比较函数，实现两个整型数字进行比较，返回比较大的值
//提前告诉编译器函数的存在，可以利用函数的声明
//函数的声明
//声明可以写多次
定义只能写一次
int max(int a, int b);
int main() {
int a = 10;
int b = 20;
cout << max(a, b) << endl;
system("pause");
return 0;
}
//定义
int max(int a, int b)
{
return a > b ? a : b;
}

1
2
3
4
5
#include<iostream>
using namespace std;
//函数的声明
void swap(int a, int b);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream>
using namespace std;
#include "swap.h"
函数的声明
//void swap(int a, int b);
//
函数的定义
//void swap(int a, int b)
//{
//	int temp = a;
//	a = b;
//	b = temp;
//
//	cout << "a= " << a << endl;
//	cout << "b=" << b << endl;
//}
int main() {
int a = 10;
int b = 20;
swap(a, b);
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
#include"swap.h"
//双引号代表自定义头文件
//函数的定义
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a= " << a << endl;
cout << "b=" << b << endl;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include<iostream>
using namespace std;
int main() {
//1、定义指针
int a = 10;
//指针定义语法：数据类型 * 指针变量名
int*p;
//让指针记录变量a的地址

p = &a;
//& 取址符号
cout << "a的地址为：" << &a << endl;
//十六进制
cout << "a的地址为：" << (int)&a << endl;
//强转为十进制
cout << "指针p为：" << (int)p << endl;
//和上面结果相同，所以指针就是地址
//2、使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000;
//p前面加个*代表找到了p指向的内存中的数据
cout << "a=" << a << endl;
//1000
通过p可以找到a所在的内存 并且通过*p修改这个内存
cout << "*p=" << *p << endl;
//1000
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<iostream>
using namespace std;
int main() {
//指针所占内存空间
int a = 10;
//int * p;
//p = &a;
int* p = &a;
//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
//64位操作系统下，8个字节
cout << "sizeof(int *)=" << sizeof(int*) << endl;
//整型指针
cout << "sizeof(int *)=" << sizeof(p) << endl;
//同上
cout << "sizeof(int *)=" << sizeof(float *) << endl;
cout << "sizeof(int *)=" << sizeof(double *) << endl;
cout << "sizeof(int *)=" << sizeof(char *) << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
using namespace std;
int main() {
//1、空指针用于给指针变量进行初始化
int* p = NULL;
//2、空指针是不可以进行指针访问的
//0~255之间的内存编号是系统占用的，不允许用户访问
*p = 100； //报错，可以指向，但不可以访问
cout << *p << endl;
//会出错
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
#include<iostream>
using namespace std;
int main() {
//在程序中，尽量避免出现野指针
int* p = (int*)0x1100;
//0x1100是十六进制的数，前面加上（int*）变为指针类型，没有权限操作那块内存
cout << *p << endl;
//报错
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<iostream>
using namespace std;
int main() {
//1、const修饰指针 常量指针
int a = 10;
int b = 20;
const int* p = &a;
//指针指向的值不可以改，指针的指向可以改
//*p = 20;错误
p = &b;
//正确
//2、const修饰常量
指针常量
//指针的指向不可以改，指针指向的值可以改
int* const p2 = &a;
*p2 = 100;//正确
//p2 = &b;//错误，指针的指向是不可以改的
//3、const修饰指针和常量
const int* const p3 = &a;
//指针的指向 和指向的值
都不可以改
//*p3 = 100;
//错误
//p3 = &b;
//错误
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream>
using namespace std;
int main() {
//指针和数组
//利用指针访问数组中的元素
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素为：" << arr[0] << endl;
int* p = arr;
//arr就是数组首地址
cout << "利用指针访问第一个元素：" << *p << endl;
p++;
cout << "利用指针访问第二个元素：" << *p << endl;//让指针向后偏移4个字节
cout << "利用指针遍历数组" << endl;
int* p2 = arr;
for (int i = 0; i < 12; i++)
{
//cout << arr[i] << endl;
cout << *p2 << endl;
p2++;
}
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include<iostream>
using namespace std;
//实现两个数字进行转换
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "swap01 a= " << a << endl;
//形参改变了
cout << "swap01 b= " << b << endl;
}
void swap02(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
//cout << "swap01 *p1= " << *p1 << endl;
//形参改变了
//cout << "swap01 *p2= " << *p2 << endl;
}
int main() {
//指针和函数
//1、值传递
int a = 10;
int b = 20;
//swap01(a, b);
//2、地址传递
//如果是地址传递，可以修改实参
swap02(&a, &b);
cout << "a= " << a << endl;
//实参未改变
cout << "b= " << b << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include<iostream>
using namespace std;
//冒泡排序函数
参数1
数组的首地址
参数2
数组的长度
void bubbleSort(int * arr,int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
//如果j>j+1的值
交换数字
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
//打印数组
void printArray(int* arr, int len)
{
for (int i = 0; i < len; i++)
{
cout << arr[i] << endl;
}
}
int main() {
//1、先创建数组
int arr[] = { 4,3,6,9,1,2,10,8,7,5 };
//数组长度
int len = sizeof(arr) / sizeof(arr[0]);
//2、创建函数，实现冒泡排序
bubbleSort(arr, len);
//3、打印排序后的数组
printArray(arr, len);
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<iostream>
using namespace std;
#include<string>
// 1、创建学生数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型集合组成的一个类型
//语法：struct 结构体名{结构体成员列表}；
struct Student
{
//成员列表
//姓名
string name;
//年龄
int age;
//分数
int score;
}s3;//顺便创建结构体变量
//2、通过学生类型创建具体学生
int main() {
//2.1 struct Student s1
//struct是可以省略（创建时可以省略，定义时不可以）
struct Student s1;
//给s1属性赋值，通过.访问结构体变量中的属性
s1.name = "张三";
s1.age = 19;
s1.score = 100;
cout << "姓名是：" << s1.name << "年龄是" << s1.age << "分数是：" << s1.score << endl;
//2.2 struct Student s2= {...}
struct Student s2 = { "张三",18,99 };
cout << "姓名是：" << s2.name << "年龄是" << s2.age << "分数是：" << s2.score << endl;
//2.3 在定义结构体时顺便创建结构体变量
s3.name = "张三";
s3.age = 19;
s3.score = 100;
cout << "姓名是：" << s3.name << "年龄是" << s3.age << "分数是：" << s3.score << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include<iostream>
using namespace std;
#include<string>
//结构体定义
//1、定义结构体
struct Student
{
string name;
int age;
int score;
};
int main() {
//2、创建数组结构体
struct Student StuArray[3] =
{
{"张三",18,100},
{"李四",19,101},
{"王五",20,102}
};
//3、给结构体数组中的元素赋值
StuArray[2].name = "李二";
StuArray[2].age = 21;
StuArray[2].score = 104;
//4、遍历结构体数组
for (int i = 0; i < 3; i++)
{
cout << "姓名 " << StuArray[i].name
<< "年龄 " << StuArray[i].age
<< "分数" << StuArray[i].score << endl;
}
system("pause");
return
0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include<iostream>
using namespace std;
//结构体定义
struct student
{
string name;
int age;
int score;
};
int main() {
//1、创建学生结构体变量
struct student s = { "张三",18 ,200 };
//2、通过指针指向结构体变量
student* p = &s;
//struct省略
//3、通过指针访问结构体变量中的数据
//通过结构体指针
访问结构体中的属性
需要利用‘ -> ’
cout << "姓名：" << p->name
<< " 年龄" << p->age
<< " 分数" << p->score << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include<iostream>
using namespace std;
#include<string>
//定义学生结构体
struct student
{
string name;
int age;
int score;
};
//定义老师结构体
struct teacher
{
int id;
string name;
int age;
struct student stu;
};
int main() {
//结构体嵌套结构体
//创建老师 
teacher t;
t.id = 100;
t. name = "老王";
t.age = 50;
t.stu.name = "小李";
t.stu.age = 19;
t.stu.score = 99;
cout << "
老师工号：" << t.id
<< "
老师姓名：" << t.name
<< "
老师年龄：" << t.age
<< "
学生姓名：" << t.stu.name
<< "
学生年龄：" << t.stu.age
<< "
学生分数: " << t.stu.score << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include<iostream>
using namespace std;
//定义学生结构体
struct student
{
string name;
int age;
int score;
};
//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{
s.age = 100;
cout << "子函数 1 中
姓名：" << s.name << "
年龄：" << s.age << "
分数：" << s.score << endl;
}
//2、地址传递
void printStudent2(struct student * p)
{
p->age = 200;
cout << "子函数 2 中
姓名：" << p->name << "
年龄：" << p->age << "
分数：" << p->score << endl;
}
int main() {
struct student s;
s.name = "小王";
s.age = 18;
s.score = 400;
printStudent2(&s);
printStudent1(s);
cout << "main函数中
姓名：" << s.name << "
年龄：" << s.age << "
分数：" << s.score << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<iostream>
using namespace std;
//定义学生结构体
struct student
{
string name;
int age;
int score;
};
//创建打印函数
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudents(const student *s) //原来是值传递，但是占用内存空间，用指针的地址传递，但修改子函数中的参数，主函数也会发生改变，故加入const防止误操作
{
//s->age = 100;
//加入const之后，一旦有修改的操作就会报错，可以防止我们的误操作
cout<< "姓名：" << s->name << "
年龄：" << s->age << "
分数：" << s->score << endl;
}
int main() {
//创建结构体变量
struct student s = { "张三", 18 , 400 };
//通过函数打印结构体变量信息
printStudents(&s);
cout <<"
main中年龄：" << s.age << endl;
system("pause");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
//案例1--3名老师带 5名学生做毕设
//学生--姓名、考试分数、
#include<iostream>
using namespace std;
#include<string>
#include<ctime>
//学生结构体
struct student
{
string sname;
int score;
};
struct teacher
{
string tname;
struct student sArray[5];
};
void allocateSpace(struct teacher tArray[], int len)
{
string nameSeed = "ABCDE";
//开始给老师赋值
for (int i = 0; i < len; i++)
{
tArray[i].tname = "Teacher_";
tArray[i].tname += nameSeed[i];
//通过循环给每名老师所带的学生赋值
for (int j = 0; j < 5; j++)
{
tArray[i].sArray[j].sname = "Student_";
tArray[i].sArray[j].sname += nameSeed[j];
int random = rand() % 61 + 40;
// 40~100
tArray[i].sArray[j].score = random;
}
}
}
//打印所有信息
void printInfo(struct teacher tArray[], int len)
{
for (int i = 0; i < len; i++)
{
cout << "老师姓名：" << tArray[i].tname << endl;
for (int j = 0; j < 5; j++)
{
cout << "t学生姓名：" << tArray[i].sArray[j].sname <<
" 考试分数：" << tArray[i].sArray[j].score << endl;
}
}
}
int main() {
//随机种子
srand((unsigned int)time(NULL));
//1、创建3名老师数组
struct teacher tArray[3];
//2、通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
int len = sizeof(tArray) / sizeof(tArray[0]);
allocateSpace(tArray, len);
//3、打印所有老师及所带的学生信息
printInfo(tArray, len);
system("pause");
return 0;
}