C++基础入门（超详细）

话不多说，序言搞起来： 自从开始学老师布置的任务后，目前还是OpenCV，哈~哈。我就莫名问老师：“以后编程是用C++还是python？”，果然还是太年轻，老师说：“两们都要精通”。唉！于是乎为期两周的C++编程入门学了一遍，虽然不难，但很详细。

---

---

C++基础入门

1 C++初识

1.1 第一个C++程序

#include<iostream>
using namespace std;
int main()
{
	cout << "hello world" << endl;
	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9

1.2 注释

• 单行注释：//

• 多行注释：/**/

1.3 变量

数据类型 变量名 = 变量初始值；

1.4 常量

（1）作用：记录程序中不可更改的数据

（2）定义常量的两种方式：

• #define 宏常量：#define 常量名 常量值（通常定义在文件上方，一旦修改就会报错）
• const修饰的变量：const 数据类型 常量名=常量值（通常在变量定义前加关键字const)

1.5 关键字

说明：在定义变量或者常量的时候，不能使用关键字

double\int\long\......
1

1.6 标识符命名规则

说明：给变量起名的时候要做到见名知意

（1）标识符不能是关键字

（2）标识符只能由字母、数字、下划线

（3）第一个字符必须是字符或者下划线

（4）标识符中区分大小写

2、数据类型

说明：数据类型存在的意义是给变量分配合适的内存空间

2.1 整型

区别：在于所占内存空间不同

//短整型(-32768~32767)
	short num1 = 32769;//输出就是一个负数-32768
	//整型
	int num2 = 10;
	//长整型
	long num3 = 10;
	//长长整型
	long long num4 = 10;
	cout << "num1= " << num1 << endl;
	cout << "num2= " << num2 << endl;
	cout << "num3= " << num3 << endl;
	cout << "num4= " << num4 << endl;
1
2
3
4
5
6
7
8
9
10
11
12

2.2 sizeof关键字

作用：利用sizeof关键字统计数据类型所占内存大小

b = sizeof(a);
1

2.3 实型（浮点型）

作用：表示小数

两种表示形式：

• 1、单精度： float；占用空间：4字节；有效数字范围：7位有效数字
• 2、双精度：double；占用空间：8字节；有效数字范围：15~16位有效数字

float f1 = 3.14f;//不加f会默认double类型的，会多一步转化
	cout << f1 << endl;
	double d1 = 3.14;
	cout << d1 << endl;
	//统计float和double所占内存空间
	cout <<"float占用的内存空间："<< sizeof(float) << endl;
	cout << "double占用的内存空间：" << sizeof(double) << endl;
	//科学计数法
	float f2 = 3e2;//3*10^2;
	cout << "f2=" << f2 << endl;
	float f3 = 3e-2;//3*0.1^2;
	cout << "f3=" << f3 << endl;
1
2
3
4
5
6
7
8
9
10
11
12

2.4 字符型

作用：显示单个字符，只占用1个字节

语法：char ch=‘a’;

//1、字符型变量创建方式
	char ch = 'a';
	cout << ch << endl;
	//2、字符型变量所占内存空间大小
	cout << "char字符型所占内存：" << sizeof(ch) << endl;
	//3、字符型变量对应的ASCII编码
	cout << (int)ch << endl;

1
2
3
4
5
6
7
8

2.5 转义字符

作用：表示一些不能显示出来的ASCII字符

• \n：换行
• \t：水平制表：\t占用8个字符，如aaa+5个空格；aaaa+4个空格
• \ \：代表反斜线字符“\”

2.6 字符串型

两种形式：

• C：char 变量名[ ]=“字符串值”
• C++：string 变量名= “字符串值”

//C风格
	char str[] = "hello world";
	cout << str << endl;
	//C++风格
	string ss = "hello C++";  //需要一个#include<string>头文件
	cout << ss << endl;
1
2
3
4
5
6

2.7 布尔类型bool

作用：代表真和假的值

bool类型只有两个值，占1个字节大小

• true：真（本质是1）//非0的值都代表着真
• false：假（本质是0）

//1、创建bool类型
	bool flag = true;
	bool flag1 = false;
	cout << flag << endl;
	cout << flag1 << endl;
	//2、查看内存空间
	cout << "bool类型所占的内存空间：" << sizeof(flag) << endl;
1
2
3
4
5
6
7

2.8 数据的输入

关键字：cin>>变量，从键盘上获取数据

cout << "请输入a的值：" << endl;
cin >> a;
1
2

3、运算符

3.1 算术运算符

注意：

• 两数相除，除数不可以为0
• 两个小数不可以进行取模运算

3.2 赋值运算符

3.3 比较运算符

4 程序流程结构

• 顺序结构：程序按照顺序执行，不发生跳转
• 选择结构：依据条件是否满足，有选择的执行相应的功能
• 循环结构：依据条件是否满足，循环多次执行某段代码

4.1 选择结构

4.1.1 if语句

#include<iostream>
using namespace std;
int main()
{
	system("color 5F");
	cout << "请输入一个分数：" << endl;
	int score;
	cin >> score;
    //注意：if条件后面不要加分号
	if (score > 600)
		printf("你考上一本大学\n");
	else if(score>500)
        printf("你考上了二本\n");
    else
		printf("你什么都没有考上，二战吧\n");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

嵌套的if语句：

案例需求：如果上述大于600考上了一本大学，如果分数大于650就可以考上双一流

	if (score > 600)
	{
		printf("你考上一本大学\n");
		if (score > 650)
		{
			printf("可以上双一流了\n");
		}
	}
	else if (score > 500)
		printf("你考上了二本\n");
	else
		printf("你什么都没有考上，二战吧\n");
1
2
3
4
5
6
7
8
9
10
11
12

4.1.2 三目运算符

int a = 10;
	int b = 20;
	int c = 0;
	c = (a > b ? a : b);
	cout << "c= " << c << endl;
	//C++中三目运算符返回的是变量，可以继续赋值
	(a > b ? a : b) = 66;
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
1
2
3
4
5
6
7
8
9

4.1.3 switch语句

语法：

switch(表达式)
{
	case 结果1：执行语句；break；
	case 结果2：执行语句；break;
	....
	default:执行语句；break;
}
1
2
3
4
5
6
7

示例：给电影打分

cout << "请给电影打分：" << endl;
	int score = 0;
	cin >> score;
	switch (score)
	{
		case 3: cout << "你打的电影评分是：" << score << endl; break;
		case 6: cout << "你打的电影评分是：" << score << endl; break;
		case 9: cout << "你打的电影评分是：" << score << endl; break;
		case 4: cout << "你打的电影评分是：" << score << endl; break;
		default:cout << "你打的是其他分数：" << score << endl; break;

	}
1
2
3
4
5
6
7
8
9
10
11
12

4.2 循环结构

4.2.1 while循环语句

语法：while（循环条件）{循环语句}

注意：了解循环条件，避免死循环

//在屏幕打印0-9
	int num = 0;
	while (num < 10)
	{
		cout << num << endl;
		num++;
	}
1
2
3
4
5
6
7

4.2.2 do…while循环语句

语法：do{循环语句}while{循环条件}与while的区别是先执行一次循环语句，再判断循环条件

int num = 0;
do
{
	cout << num << endl;
	num++;
} while (num < 10);
1
2
3
4
5
6

4.2.3 for循环语句

语法：for(起始表达式；条件表达式；末尾循环体){ 循环语句；}

//在屏幕打印0-9
for (int i = 0; i < 10; i++)
{
	cout << i << endl;
}
1
2
3
4
5

4.2.4 嵌套循环

作用：循环中再加一层循环

	//在屏幕打印10x10的*阵
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			cout <<"* ";
		}
		cout << endl;
	}
1
2
3
4
5
6
7
8
9

示例：打印乘法口诀表

#include<iostream>
using namespace std;
int main()
{
	system("color 5F");
	for (int i = 1; i < 10; i++)
	{
		for (int j = 1; j <=i; j++)
		{
			cout << j << " x " << i << " = " << (i*j)<<"  ";
		}
		cout << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.3 跳转语句

4.3.1 break语句

作用：结束循环

	//在屏幕打印10x5的*阵
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
            if(j==5)
                break;
			cout <<"* ";
		}
		cout << endl;
	}
1
2
3
4
5
6
7
8
9
10
11

4.3.2 continue语句

作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

//在屏幕输出10以内偶数
	for (int i = 0; i < 10; i++)
	{
		if (i % 2 != 0)
			continue;
        cout << i << endl;
	}
1
2
3
4
5
6
7

4.3.3 goto语句

作用：goto标记之后，跳转到标记的语句

#include<iostream>
using namespace std;
int main()
{
	system("color 5F");
	//执行goto语句
	cout << "1.xxxxx" << endl;
	goto Flag;
	cout << "2.xxxxx" << endl;

	cout << "3.xxxxx" << endl;

	cout << "4.xxxxx" << endl;
	Flag:
	cout << "5.xxxxx" << endl;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.数组

5.1 概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

5.2 一维数组

1、定义方式

• 数据类型 数组名[数组长度];
• 数据类型 数据名[数组长度]={值1，值2…};
• 数据类型 数组名[ ]={值1，值2…};

2、数组特点

放在一块连续的内存空间，数组中每个元素都是相同的数据类型。

int main()
{
	system("color 5F");
	//1、数据类型 数组名[数组长度];
	int arr[5];
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	//2、数据类型 数据名[数组长度]={值1，值2.....};
	//若初始化没有五个数据，剩下的将会由0填补
	int arr1[5] = { 10,20,30,40};
	for (int i = 0; i < 5; i++)
	{
		cout << arr1[i] << " ";
	}
	cout << endl;
	//3、数据类型 数组名[ ]={值1，值2.....};
	int arr3[] = { 1,2,3,4,5 ,6,5,8,9};
	for (int i = 0; i < 9; i++)
	{
		cout << arr3[i] << " ";
	}
	cout << endl;
	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

5.2.2一维数组数组名

用途：

• 统计整个数组在内存中的长度
• 可以获取数组在内存中的首地址

#include<iostream>
using namespace std;
int main()
{
	system("color 5F");
	int arr[5] = { 1,2,3,4,5 };
	//1、通过数组名统计整个数组占用内存大小
	cout << "每个数组占用内存空间大小："<<sizeof(arr) << endl;
	cout << "每个元素所占用的内存空间大小：" << sizeof(arr[0]) << endl;
	cout << "数组中元素的个数为：" << sizeof(arr)/ sizeof(arr[0]) << endl;
	//2、通过数组名查看首地址
	cout << "数组首地址为：" << (int)arr << endl;
	cout << "数组中第一个元素地址：" << (int)&arr[1] << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

练习案例：数组元素逆置

请声明一个5个元素的数组，并且将元素逆置

#include<iostream>
using namespace std;
int main()
{
	system("color 5F");
	int arr[5] = { 1,2,3,4,5 };
	//1、数组逆置前序列
	cout << "数组逆置前序列:" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	//2、实现逆置
	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--;
	}
	cout << "数组逆置之后输出：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	
	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

5.3 二维数组

1、二维数组的四种定义类型：

• 数据类型 数组名[行数] [列数];
• 数据类型 数组名[行数] [列数]={{数据1，数据2}，{数据3，数据4}}；
• 数据类型 数组名[行数] [列数]={数据1，数据2，数据3，数据4}；
• 数据类型 数组名[ ] [列数]={数据1，数据2，数据3，数据4}；

#include<iostream>
using namespace std;
int main()
{
	system("color 5F");
	/*
		- 数据类型 数组名[行数] [列数];
		- 数据类型 数组名[行数] [列数]={{数据1，数据2}，{数据3，数据4}}；
		- 数据类型 数组名[行数] [列数]={数据1，数据2，数据3，数据4}；
		- 数据类型 数组名[ ] [列数]={数据1，数据2，数据3，数据4}；
	*/
	//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;
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}
	cout << 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 << arr[i][j] << " ";
		}
		cout << endl;
	}
	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 << arr[i][j] << " ";
		}
		cout << endl;
	}
	//4、数据类型 数组名[ ] [列数]={数据1，数据2，数据3，数据4}；
	int arr4[][3] = { 1,2,3,4,5,6 };
	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

2、二维数组数组名

int arr[2][3]=
	{
		{1,2,3},
		{4,5,6}
	};
	//1、查看占用内存空间大小
	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 << " 二维数组首地址: " << (int)arr << endl;
	cout << " 二维数组第一行元素首地址: " << (int)arr[0] << endl;
	cout << " 二维数组第二行元素首地址: " << (int)arr[1] << endl;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6 函数

6.1 概述

说明：将一段经常使用的代码封装起来，减少代码重复

6.2 函数的定义

步骤：

• 1、返回值类型
• 2、函数名
• 3、参数列表
• 4、函数体语句
• 5、return表达式

返回值类型 函数名 （参数列表）
{
	函数体语句；
	return 表达式；
}
1
2
3
4
5

#include<iostream>
using namespace std;
int add(int num1, int num2)
{
    //num1、num2没有真正的数据。是一个形式参数，也叫形参
	int sum = num1 + num2;
	return sum;
}
int main()
{
	system("color 5F");
    //a、b有实际的值，叫实参
    //当函数调用时，实参的值会传递给形参
	int a, b;
	cin >> a >> b;
	cout <<a<<" + "<<b<< " = " << add(a, b) << endl;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

6.3 值传递

• 值传递就是函数调用时实参将数值传给形参
• 值传递：如果形参发生，并不影响实参

#include<iostream>
using namespace std;
//值传递
//实现两个数字进行交换的函数

//若函数不需要返回值，声明的时候可以写void
void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;
	int temp;
	temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "交换后：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;

}
int main()
{
	system("color 5F");
	int a = 10, b = 20;
	//当做值传递的时候，函数的形参发生改变，不会影响实参
	swap(a, b);
	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

6.5 函数的常见形式

• 1、无参无返
• 2、有参无返
• 3、无参有返
• 4、有参有返

#include<iostream>
using namespace std;
//1、无参无返
void test01()
{
	cout << "this is 01" << endl;
}
//2、有参无返
void test02(int a)
{
	cout << "this is 02 a=" << a << endl;
}
//3、无参有返
int test03()
{
	cout << "this is 03" << endl;
	return 666;
}
//4、有参有返
int test04(int a)
{
	cout << "this is 04 a=" << a << endl;
	return 888;
}
int main()
{
	system("color 5F");
	//无参无返函数调用
	test01();
	//有参无返函数调用
	test02(3);
	//无参有返函数调用
	int num = test03();
	cout << "无参有返的num=" << num << endl;
	//有参有返函数调用
	cout << "有参有返的num=" << test04(20) << endl;
	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

6.6 函数的声明

作用：提前告诉编译器函数的存在，声明可以写多次，定义只能写一次。声明是说明存在这个函数，定义是说明这个函数如何写。

6.7 函数的分文件编写

作用：让代码结构更加清晰

步骤：

• 1、创建后缀名为.h的头文件
• 2、创建后缀名为.cpp的源文件
• 3、在头文件中写函数的声明
• 4、在源文件中写函数的定义

//在头文件中写函数的声明
#pragma once
#include<iostream>
using namespace std;
//函数声明
void swap(int a, int b);

1
2
3
4
5
6
7

//在源文件中写函数的定义
#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

//调用之后直接运行
#include<iostream>
#include"swap.h"
using namespace std;
int main()
{
	system("color 5F");
	int a = 10;
	int b = 20;
	swap(a, b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

7 指针

7.1 指针的基本概念

作用：可以通过指针间接访问内存

• 内存编号从0开始记录，一般用十六进制数字表示
• 可以利用指针变量保存地址

7.2 指针变量的定义和使用

指针定义语法： 数据类型 * 变量名；

#include<iostream>
using namespace std;
int main()
{
	system("color 5E");
	//1、定义指针
	int a = 10;

	//指针定义的语法：数据类型 * 指针变量名
	int * p;
	//让指针记录变量a的地址
	p = &a;
	cout << "a的地址为：" << p << endl;
	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加*代表解引用，找到指针指向的内存中的数据
	cout << "a的值是：" << *p << endl;
	if (a == *p)
		cout << "一样" << endl;
	else
		cout << "不一样" << endl;
	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

7.3 指针所占用内存空间

问： 指针也是种数据类型，那么占用多少内存呢？

答： 在32位操作系统下：占4个字节空间；在64为操作系统：占8个字节

#include<iostream>
using namespace std;
int main()
{
	system("color 5E");
	int a = 10;
	int *p;
	p = &a;
	cout << "sizeof(int *)=" << sizeof(int *) << endl;
	cout << "sizeof(double *)=" << sizeof(double *) << endl;
	cout << "sizeof(char *)=" << sizeof(char *) << endl;
	cout << "sizeof(float *)=" << sizeof(float *) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.4 空指针和野指针

（1）空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

（2）野指针：指针变量指向非法的内存空间

7.5 const修饰指针

const修饰指针有三种情况：

• （1）const修饰指针：常量指针

  const int *p=&a;
  1

  特点：指针的指向可以修改，但是指针指向的值不可以修改

  *p=20（×）

  p=&b（√）

• （2）const修饰常量：指针常量

  int * const p=&a;
  1

  特点：指针指向不可以改，指针指向的值可以改

  *p=20（√）

  p=&b（×）

• （3）const即修饰指针又修饰常量

  const int * const p=&a;
  1

  特点：指针指向不可以改，指针指向的值也不可以改

  *p=20（x）

  p=&b（×）

7.6 指针和数组

作用：利用指针访问数组元素

	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int *p = arr;//arr就是数组的首地址
	cout << "利用指针指向第一个元素：" << *p << endl;
	p++;//指针偏移4个字节
	cout << "利用指针指向第二个元素：" << *p << endl;
	for(int i=2;i<10;i++)
	{
		cout << *p << " ";
		p++;
	}
1
2
3
4
5
6
7
8
9
10

7.7 指针和函数

作用：利用指针作为函数参数，可以修改实参的值

#include<iostream>
using namespace std;
void swap(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	cout << "swap *p1=" << *p1 << endl;
	cout << "swap *p2=" << *p2 << endl;
}
int main()
{
	system("color 5E");
	//地址传递
	int a = 10;
	int b = 20;
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	swap(&a, &b);
	cout << endl << "交换后的a,b的值：" << endl;
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	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

7.8 案例：利用冒泡升序排序

序列：int arr[10] = { 4,2,3,6,1,8,7,9,5 };

#include<iostream>
using namespace std;
void bubbleSort(int *arr, int len)
{
	for(int i=0;i<len-1;i++)
		for (int j = 0; j < i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
}
int main()
{
	system("color 5E");
	//创建一个数组
	int arr[10] = { 4,2,3,6,1,8,7,9,5 };
	//求数组的长度
	int len = sizeof(arr) / sizeof(arr[0]);
	//排序前的序列
	cout << "排序前的序列:" << endl;
	for (int i = 0; i < len-1; i++)
		cout << arr[i] << " ";
	cout << endl;
	//利用冒泡排序
	bubbleSort(arr, len);
	cout << "排序后的序列:" << endl;
	for (int i = 0; i < len-1; i++)
		cout << arr[i] << " ";
	cout << endl;
	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

8 结构体

8.1 结构体基本概念

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。

8.2 结构体的定义和使用

语法：struct 结构体名 {结构体成员列表};

结构体创建的方式三种：

• （1）struct 结构体名 变量名
• （2）struct 结构体名 变量名={成员1值，成员2值…}
• （3）定义结构体是顺便创建变量

#include<iostream>
#include<string>
using namespace std;
//创建学生数据类型：学生包括（姓名，年龄，分数）
struct Student
{
	//成员列表

	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
}s3;  //3、定义结构体是顺便创建变量

int main()
{
	system("color 5E");
	//1、struct 结构体名 变量名
	struct Student s1;
	s1.name = "张铁蛋";
	s1.age= 23;
	s1.score = 100;
	cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;
	//2、struct 结构体名 变量名={成员1值，成员2值......}
	struct Student s2 = { "徐铁柱",24,100 };
	cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;

	s3.name = "憨憨";
	s3.age = 23;
	s3.score = 99;
	cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;
	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

注意：结构体定义的时候不能省略struct，创建变量的时候可以省略

8.3 结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法：struct 结构体名 数组名[元素个数]={{}，{}，{}…}

int main()
{
	system("color 5E");
	//创建结构体数组
	struct Student arr[3] =
	{
		{"张铁蛋",18,100},
		{"徐铁住",23,99},
		{"憨憨",22,90}
	};
	arr[2].name = "徐傻傻";
	for(int i=0;i<3;i++)
		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << 			arr[i].score << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

8.4 结构体指针

作用：通过指针访问结构体中的成员

• 利用操作符“->”可以通过结构体指针访问结构体属性

	//创建结构体变量
	struct student s = { "张三",18,100 };
	//通过指针指向结构体变量
	struct student *p=&s;
	//通过指针访问结构体中的数据
	p->name = "铁蛋";
	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
1
2
3
4
5
6
7

8.5 结构体嵌套结构体

作用：结构体的成员可以是另一个结构体

如：每个老师辅导一个学员，一个老师是一个结构体，记录一个学生结构体

#include<iostream>
#include<string>
using namespace std;
//定义学生结构体
struct student
{
	int num;//学号
	string name;
	int age;
};
//定义老师结构体
struct teacher
{
	int id;
	string name;
	int age;
	struct student stu;
};
int main()
{
	system("color 5E");
	//创建老师、学生
	teacher ter = { 2311,"王老师",35,{20180505,"张三",22} };
	cout << "老师的编号：" << ter.id << endl;
	cout << "老师的名字：" << ter.name << endl;
	cout << "老师的年龄：" << ter.age << endl;
	cout << "老师的学生学号：" << ter.stu.num << endl;
	cout << "老师的学生的名字：" << ter.stu.name << endl;
	cout << "老师的学生的年龄：" << ter.stu.age << endl;

	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

8.6 结构体做函数参数

作用：将结构体作为参数向函数中传递

传递的方式：

• 值传递
• 地址传递

#include<iostream>
#include<string>
using namespace std;
//定义学生结构体
struct student
{
	string name;
	int age;
	int score;
};
//值传递
void printStudent(struct student s)
{
	s.age = 55;
	cout << "子函数1打印的结果：" << endl;
	cout << "姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}
//地址传递
void printfStudent1(struct student *s)
{
	cout << "子函数2打印的结果：" << endl;
	cout << "姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
	s->name = "张铁蛋";
	s->score = 999;

}
int main()
{
	system("color 5E");
	student s = { "张三",23,99 };
	printStudent(s);
	cout << "main打印的结果：" << endl;
	cout << "姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
	cout << endl;
	printfStudent1(&s);
	cout << "main打印的结果：" << endl;
	cout << "姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
	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

8.7 结构体中const使用场景

作用：用const来防止误操作

#include<iostream>
#include<string>
using namespace std;
//定义学生结构体
struct student
{
	string name;
	int age;
	int score;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本
void printStudent(const struct student *s)
{
	//s->age = 55;
	//加入const之后，一旦有修改的操作就会报错，防止误操作
	cout << "姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
}
int main()
{
	system("color 5E");
	student s = { "张三",23,99 };
	//只读，不可修改
	printStudent(&s);
	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