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

菜菜的小博

已于 2023-02-21 09:56:03 修改

阅读量231

点赞数 1

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-02-21 09:44:06 首次发布

本文链接：https://blog.youkuaiyun.com/m0_67198021/article/details/129136535

版权

C++ 专栏收录该内容

2 篇文章

订阅专栏

常量

作用：用于记录程序中不可更改的数据

C++定义常量两种方式

#define宏常量:#define 常量名常量值
- 通常在文件上方定义，表示一个常量
const修饰的变量const 数据类型常量名 = 常量值
- 通常在变量定义前加关键字const，修饰该变量为常量，不可修改

示例：

#include <iostream>
using namespace std;

// 1.#define 宏常量
#define Day 7
int main(){
	//day = 8; // 报错，宏常量是不可修改的
	cout << "一周有" << Day << "天" << endl;
	// 2.const修饰变量
	const int month = 12;
	cout << "一年有：" << month << "个月" << endl;
	//month = 13; // 报错，常量是不可修改的

	system("pause");

	return 0;
}

C++关键字

asm	do	if	return	typedef
auto	double	inline	short	typeid
bool	dynamic_cast	int	signed	typename
break	else	long	sizeof	union
case	enum	mutable	static	unsigned
carch	explicit	namespace	static_cast	using
char	export	new	struct	virtual
class	extern	operator	switch	void
const	false	private	template	volatile
const_cast	float	protected	this	wchar_t
default	friend	register	true
delete	goto	reinterpret	try

标识符命名规则

作用:C++规定给标识符（变量，常量）命名时，有一套自己的规则

标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符中字母区分大小写

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读

数据类型

C++规定在创建一个变量或者常量时，必须要指出相应的数据类型，否则无法给变量分配内存

1.整型

作用：整型变量表示的是整数类型的数据

C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同：

数据类型	占用空间	取值范围
short(短整型)	2字节	(-2¹⁵-2¹⁵-1)
int(整型)	4字节	(-2³¹-2³¹-1)
long(长整型)	Windows为4字节，Linux为4字节(32位),8字节(64位)	(-2³¹-2³¹-1)
long long(长长整型)	8字节	(-2⁶³-2⁶³-1)

2.sizeof关键字

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

语法：sizeof(数据类型 / 变量)

示例：

#include <iostream>
using namespace std;

int main(){

	short num1 = 10;
	cout << "short占用的空间为" << sizeof(num1) << endl;

	int num2 = 20;
	cout << "int占用的空间为" << sizeof(num2) << endl;

	long num3 = 30;
	cout << "long占用的空间为" << sizeof(num3) << endl;

	long long num4 = 40;
	cout << "long long占用的空间为" << sizeof(num4) << endl;

	system("pause");
	return 0;
}

3.实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

1.单精度float

2.双精度double

两者的区别在于表示的有效数字范围不同。

数据类型	占用空间	有效数字范围
float	4字节	7位有效数字
double	8字节	15-16位有效数字

#include <iostream>
using namespace std;

int main(){

	// 1. 单精度 float
	// 2. 双精度 double

	float f1 = 3.1415926f;
	cout << "单精度float：" << f1 << endl;

	double d2 = 3.1415926;
	cout << "双精度double：" << d2 << endl;

	cout << "单精度float占用内存大小:" << sizeof(f1) << endl;
	cout << "双精度double占用内存大小:" << sizeof(d2) << endl;

	// 科学计数法
	float f2 = 3e2; // 3*10^2
	cout << "f2=" << f2 << endl;


	float f3 = 3e-2; // 3*0.1^2
	cout << "f3=" << f3 << endl;



	system("pause");

	return 0;
}

4.字符型

作用：字符型变量用于显示单个字符

语法：char ch = 'a';

注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号

注意2：单引号内只能有一个字符，不可以是字符串

C和C++中字符型变量只占用1个字节。
字符型变量并不是吧字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

示例：

#include <iostream>
using namespace std;

int main(){
	//1.字符型变量创建方式
	char ch = 'a';
	cout << ch << endl;
	//2.字符型变量所占内存大小
	cout << "char字符型变量所占内存：" << sizeof(char) << endl;
	//3.字符型变量常见错误
	//char ch2 = "b"; // 创建字符型变量的时候，要引用单引号
	//char chh2 = 'abcdef'; // 创建字符型变量时候，单引号内只能有一个字符

	//4.字符型变量对应ASCII编码
	//a-97
	//A-65
	cout << (int)ch << endl;

	system("pause");
	return 0;
}

5.字符串型

作用：用于表示一串字符

两种风格

C风格字符串：char 变量名[]="字符串值"

C++风格字符串：string 变量名 = "字符串值"

示例：

#include <iostream>
using namespace std;
#include <string>

int main(){

	// 1.C风格字符串
	// 注意事项1：char 字符串名 []
	// 注意事项2：等号后面要用双引号 包含起来字符串
	char str[] = "hello world";
	cout << str << endl;

	// 2.C++风格字符串
	// 包含一个头文件 #include<string>
	string str2 = "hello world";
	cout << str2 << endl;

	system("pause");
	return 0;
}

注意：1.C风格字符串要用双引号括起来

2.C++风格字符串，需要加入头文件==#include ==

6.布尔类型 bool

作用：布尔数据类型代表真或假的值

bool类型只有两个值：

true — 真(本质是1)
false — 假(本质是0)

bool类型占1个字节大小

示例：

#include <iostream>
using namespace std;

int main(){
	//1.创建bool数据类型
	bool flag = true; // true代表真
	cout << flag << endl;

	flag = false; // false代表假
	cout << flag << endl;

	// 本质上 1代表真 0代表假

	// 2。查看bool类型所占内存
	cout << "bool类型所占内存空间：" << sizeof(bool) << endl;

	system("pause");
	return 0;
}

7.数据的输入

作用：用于从键盘获取数据

关键字：cin

语法：cin >> 变量

示例：

#include <iostream>
using namespace std;
#include <string>

int main(){
	// 1.整型
	int a = 0;
	cout << "请给整型变量a赋值" << endl;
	cin >> a;
	cout << "整型变量a=" << a << endl;

	// 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赋值" << endl;
	cin >> str;
	cout << "字符串型变量str=" << str << endl;

	// 5.布尔类型
	bool flag = false;
	cout << "请给布尔类型flag赋值" << endl;
	cin >> flag; // bool类型只要是非0的值都代表真
	cout << "布尔类型型变量flag=" << flag << endl;


	system("pause");
	return 0;
}

程序流程结构

C/C++支持最基本的三种程序运行机构：顺序结构、选择结构、循环结构

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

1.选择结构

1.1 if语句

作用：执行满足条件的语句

if语句的三种形式

单行格式if语句
多行格式if语句
多条件的if语句

单行格式if语句：if(条件){条件满足执行的语句};

示例：

#include <iostream>
using namespace std;
int main(){
	// 选择结构 单行if语句
	// 用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
	int score = 0;
	cout << "请输入你的分数" << endl;
	//1.用户输入分数
	cin >> score;
	//2.打印用户输入的分数
	cout << "您的分数为" << score << endl;
	//3.判断分数是否大于600，如果大于，那么输出
	if (score > 600){
		cout << "你考上一本了" << endl;
	}
	system("pause");
	return 0;
}

多行格式if语句：if(条件){ 条件满足执行的语句 }else{条件不满足执行的语句};

示例:

#include <iostream>
using namespace std;
int main(){

	// 选择结构 - 多行if语句
	// 输入考试分数，如果大于600，视为考上一本大学，在屏幕上输出
	// 如果没考上一本大学，打印未考上一本大学

	// 1.输入考试分数
	int score = 0;
	cout << "请输入一个考试分数" << endl;
	cin >> score;
	// 2.提示用户输入分数
	cout << "您输入的分数为" << score << endl;
	// 3.判断 如果大于600，打印考上一本，否则打印未考上一本
	if (score > 600){
		cout << "一本" << endl;
	}
	else
	{
		cout << "没考上" << endl;
	}
	system("pause");
	return 0;
}

多条件的if语句：if(条件1){条件1满足执行的语句}else if(条件2){条件2满足执行的语句}...else{都不满足执行的语句}

示例：

#include <iostream>
using namespace std;
int main(){
	// 选择结构 多条件if语句
	// 输入一个考试分数，如果大于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 if (score <= 400)
	{
		cout << "你没考上本科" << endl;
	}


	system("pause");
	return 0;
}

1.2 三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1 ? 表达式2 : 表达式3

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

1.3 switch语句

作用：执行条件分支语句

语法：

switch(表达式)
{
	case 结果1: 执行语句; break;
	case 结果2: 执行语句; break;
	default: 执行语句; break;
}

2.循环结构

2.1 while循环语句

作用：满足循环条件，执行循环语句

语法：while(循环条件){循环语句}

解释：只要循环条件的结果为真，就执行循环语句

示例：

#include <iostream>
using namespace std;

int main(){
	
	int num = 0;
	while (num<9)
	{
		cout << num << endl;
		num++;
	}

	system("pause");
	return 0;
}

案例：

#include <iostream>
using namespace std;
#include <ctime>;

int main(){
	// 添加随机数种子 作用利用当前系统时间生成随机数，防止每次随机数都一样
	srand((unsigned int)time(NULL));

	// 1.系统生成随机数
	int num = rand() % 100 + 1; //  rand()%100  0 - 99 随机数 rand()%100+1 1-100
	// 2.玩家进行猜测
	int val = 0; // 玩家输入
	cout << "请输入数字" << endl;
	while (val != num){
		cin >>val;
		if (val > num){
			cout << "猜大了" << endl;
		}
		else if (val < num){
			cout << "猜小了" << endl;
		}
		else {
			cout << "猜对了" << endl;
			break;
		}
	}
	system("pause");
	return 0;
}

2.2 do…while循环语句

作用：满足循环条件，执行循环语句

语法：do{ 循环语句 }while{循环条件};

**注意：**与while的区别在于do…while会先执行一次循环语句，再判断循环条件。

#include <iostream>
using namespace std;
int main(){
	int num = 0;
	do {
		cout << num << endl;
		num++;
	} while (num<10);
	system("pause");
	return 0;
}

2.3 for循环语句

作用：满足循环条件，执行循环语句

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

#include <iostream>
using namespace std;
int main(){
	// for循环
	for (int i = 0; i <= 10; i++){
		cout << i<< endl;
	}
	system("pause");
	return 0;
}

3. 跳转语句

3.1 break语句

作用：用于跳出选择结构或者循环结构

break使用的时机：

出现在switch条件语句中，作用是终止case并跳出switch
出现在循环语句中，作用是跳出当前的循环语句
出现在嵌套循环中，跳出最近的内层循环语句

示例：

#include <iostream>
using namespace std;
int main(){
	// break的使用时机

	// 1.出现在switch语句中
	cout << "请选择副本难度" << endl;
	cout << "1、普通" << endl;
	cout << "2、中等" << endl;
	cout << "3、困难" << endl;

	int select = 0; // 创建选择结果的变量
	cin >> select; // 等待用户输入
	switch (select)
	{
	case 1:
	{
		 cout << "您选择了普通难度" << endl;
		 break;
	}
	case 2:
	{
		 cout << "您选择了中等难度" << endl;
	     break;
	}
	case 3:
	{
	     cout << "您选择了困难难度" << endl;
	     break;
	}
	default:
		break;
	}

	system("pause");
	return 0;
}

3.2 continue语句

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

示例：

#include <iostream>
using namespace std;
int main()
{
	for (int i = 0; i <= 100; i++){
		// 偶数不输出
		if (i % 2 == 0){
			continue;
		}
		cout << i << endl;
	}
	system("pause");
	return 0;
}

3.3 goto语句

作用：可以无条件跳转语句

语法：goto 标记;

**解释：**如果标记的名称存在，执行到goto语句时，会跳转到标记的位置。

#include <iostream>
using namespace std;
int main()
{
	cout << "1、xxxx" << endl;
	goto FLAG;
	cout << "2、xxxx" << endl;

	cout << "3、xxxx" << endl;
	FLAG:
	cout << "4、xxxx" << endl;

	system("pause");
	return 0;
}

4.数组

4.1 概述

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

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是有连续的内存位置组成的

4.2 一维数组

4.2.1 一维数组定义方式

一维数组定义的三种方式：

数据类型数组名[ 数组长度 ];
数据类型数组名[ 数组长度 ] = {值1,值2...};
数据类型数组名[ ] = {值1,值2 ...};

示例：

#include <iostream>
using namespace std;
int main()
{
	//int arr[5];
	//arr[0] = 10;
	//arr[1] = 20;
	//arr[2] = 30;
	//arr[3] = 40;
	//arr[4] = 50;
	int arr[5] = { 0, 1, 2, 3, 4 };

	for (int i = 0; i < 5; i++){
		cout << arr[i] << endl;
	}

	/*cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;*/
	system("pause");
	return 0;
}

4.2.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;
	cout << "每个元素占用内存空间为：" << sizeof(arr[0]) <<endl;
	cout << "数组中元素个数为：" << sizeof(arr) / sizeof(arr[0]) << endl;

	// 2. 可以通过数组名查看数组首地址
	cout << "数组首地址为：" << (int)arr << endl;
	cout << "数组中第一个元素地址为：" << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为：" << (int)&arr[1] << endl;

	// 数组名是常量，因此不能赋值

	system("pause");
	return 0;
}

4.2.3 冒泡排序

作用：最常见的排序算法，对数组内元素进行排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对乡林业元素做同样的工作，执行完毕后，找到第一个最大值。
重复以上的步骤，每次比较次数-1，直到不需要比较

示例：

#include <iostream>
using namespace std;
int main()
{
	// 利用冒泡排序实现升序序列
	int arr[9] = { 4, 2, 8, 0, 5, 7, 1, 3, 9 };
	cout << "排序前：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}

	// 总共排序轮数为 元素个数 - 1
	for (int i = 0; i < 9 - 1; i++)
	{
		// 内存循环对比 次数 = 元素个数 - 当前轮数 - 1
		for (int j = 0; j < 9 - i - 1; j++)
		{
			if (arr[j]>arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	cout << "排序后的：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}

	system("pause");
	return 0;
}

4.3 二维数组

4.3.1 二维数组的定义方式

二维数组定义的四种方式：

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

建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性

示例：

#include <iostream>
using namespace std;
int main()
{
	// 二维数组的定义方式
	    /*1. 数据类型 数组名[行数][列数]; 
		2. 数据类型 数组名[行数][列数] = { { 数据1, 数据2 }, { 数据3, 数据4 } }; 
		3. 数据类型 数组名[行数][列数] = { 数据1, 数据2, 数据3, 数据4 }; 
		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;
	/*cout << arr[0][0] << endl;
	cout << arr[0][1] << endl;
	cout << arr[0][2] << endl;
	cout << arr[1][0] << endl;
	cout << arr[1][1] << endl;
	cout << arr[1][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] = { 11, 21, 31, 41, 51, 61 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << " ";
		}
		cout << endl;
	}
	// 4.数据类型 数组名[][列数] = { 数据1, 数据2, 数据3, 数据4 };
	int arr4[][3] = {10,20,30,40,50,60};
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr4[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

4.3.2 二维数组数组名

查看二维数组所占内存空间
获取二维数组首地址

示例：

#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 << "二维数组首地址" << (int)&arr << endl;
	cout << "二维数组第一行首地址" << (int)arr[0] << endl;
	cout << "二维数组第二行首地址" << (int)arr[1] << endl;

	cout << "二维数组第一个元素的首地址" << (int)&arr[0][0] << endl;
	system("pause");
	return 0;
}

5 函数

5.1 概述

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

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

5.1.1 函数的定义

函数的定义一半主要有5个步骤：

返回值类型
函数名
参数列表
函数体语句
return 表达式

语法：

返回值类型 函数名 (参数列表)
{
 	函数体语句
 	
 	return 表达式
}

示例：

#include <iostream>
using namespace std;

int add(int num1,int num2)
{
	int sum = num1 + num2;
	return sum;

}

int main()
{
		
	int sum = add(1, 2);
	cout << sum << endl;
	system("pause");
	return 0;
}

5.1.2 值传递

所谓值传递，就是函数调用时实参将数值传入给形参
值传递时，如果形参发生改变，并不会影响实参

using namespace std;
// 值传递
// 定义函数，实现两个数字进行交换函数

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

}

int main()
{
	int a = 10;
	int b = 20;

	// 当我们做值传递的时候，函数的形参发生改变，并不会影响实参
	swap(a, b);

	system("pause");
	return 0;
}

5.1.3 函数的常见样式

常见的函数样式有4种

无参无返
有参无返
无参有返
有参有返

示例：

#include <iostream>
using namespace std;

// 函数常见样式
// 1、无参无返
void test01(){
	cout << "test01" << endl;
}
// 2、有参无返
void test02(int a){
	cout << "test02" << a << endl;
}
// 3、无参有反
int test03(){
	cout << "test03" << endl;
	return 100;
}

// 4、有参有返
int test04(int a){
	cout << "test04" << a << endl;
	return a;
}

int main(){
	// 无参无反调用
	test01();
	// 有参无返调用
	test02(100);
	// 无参有返调用
	int num1=  test03();
	cout << num1 << endl;
	// 有参有返调用
	int num2 = test04(3000);
	cout << num2 << endl;
	system("pause");
	return 0;
}

5.1.3 函数的分文件编写

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

函数份文件编写一般有4个步骤

创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义

#include <iostream>
#include "swap.h"
using namespace std;

int main(){
	int a = 10;
	int b = 20;
	swap(a, b);
	system("pause");
	return 0;
}

6.指针

6.1 指针的基本概念

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

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

6.2 指针变量的定义和使用

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

示例：

#include <iostream>
using namespace std;

int main(){
	// 1、指针定义
	int a = 10;
	// 指针定义的语法：数据类型 * 指针变量名；
	int * p;
	// 让指针记录变量a的地址
	p = &a;
	cout << "a的的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

	// 2、使用指针
	// 可以通过解引用的方式来找到指针指向的内存
	// 指针前加 * 代表解引用，找到指针指向的内存中的数据
	*p = 1000;
	cout << "a = " << a << endl;
	cout << "*p = " << *p << endl;

	system("pause");
	return 0;
}

6.3 空指针和野指针

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

用途：初始化指针变量

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

#include <iostream>
using namespace std;
int main(){
	// 空指针
	// 1、空指针用于给指针变量进行初始化
	int *p = NULL;
	// 2、空指针是不可以进行访问的
	*p = 100;

	system("pause");
	return 0;
}

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

示例2：

#include <iostream>
using namespace std;
int main(){

	// 野指针
	int *p = (int *)0x1100;
	cout << *p << endl;

	system("pause");
	return 0;
}

6.4 const修饰指针

const修饰指针有三种情况：

const修饰指针 – 常量指针

const int *p = &a;

常量指针

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

*p = 20; 错误，指针指向的值不可以改

p = ab; 正确，指针指向可以改
const修饰常量 --指针常量

int * const p = &a;

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

*p = 20; 正确，指向的值可以改

p = &b; 错误，指向不可以改
const即修饰指针，又修饰常量

const int * const p = &a;

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

*p = 20; 错误

p = &b; 错误

技巧：看const右侧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量

6.5 指针和数组

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

示例：

#include <iostream>
using namespace std;
int main34(){

	// 指针和数组
	// 利用指针访问数组中的元素

	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++;//让指针向后偏移4个字节
	cout << "利用指针访问第二个元素:" << *p << endl;

	cout << "利用指针遍历数组" << endl;
	int *p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		cout << *p2 << endl;
		p2++;
	}

	system("pause");
	return 0;
}

7. 结构体

7.1 结构体基本概念

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

7.2 结构体定义和使用

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

通过结构体创建变量的方式有三种：

struct 结构体名变量名
struct 结构体变量名
定义结构体时顺便创建变量

#include <iostream>
#include <string>
using namespace std;

// 结构体定义
struct Student
{
	// 成员列表

	// 姓名
	string name;
	// 年龄
	int age; 
	// 分数
	int score;
}s3;

int main()
{
	// 创建具体结构体
	// struct 关键字可以省略
	// 1.struct Student s1
	 Student s1;
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;

	cout << "姓名 : " << s1.name << endl;
	cout << "年龄 : " << s1.age << endl;
	cout << "分数 : " << s1.score << endl;
	cout << "                         " << endl;
	// 2.在struct Student s2 = {...}
	 Student s2 = {"李四",20,90};
	cout << "姓名 : " << s2.name << endl;
	cout << "年龄 : " << s2.age << endl;
	cout << "分数 : " << s2.score << endl;
	cout << "                         " << endl;
	// 3.在定义结构体时顺便创建结构体变量
	s3.name = "王五";
	s3.age = 19;
	s3.score = 80;
	cout << "姓名 : " << s3.name << endl;
	cout << "年龄 : " << s3.age << endl;
	cout << "分数 : " << s3.score << endl;

	system("pause");
	return 0;
}

总结1：定义结构体时的关键字是struct，不可省略

总结2：创建结构体变量时，关键字struct可以省略

总结3：结构体变量利用操作符 " . "访问成员

7.3 结构体数组

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

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

#include <iostream>
#include <string>
using namespace std;

// 结构体数组
// 1.定义结构体
struct Student
{
   // 成员列表

   // 姓名
   string name;
   // 年龄
   int age;
   // 分数
   int score;
};


int main()
{
   // 2.创建结构体数组
   struct Student stuArr[3]=
   {
   	{ "张三", 20, 99 },
   	{ "李四", 30, 100 },
   	{ "王五", 40, 101 },
   };
   // 3.给结构体数组中的元素赋值
   stuArr[2].name = "赵六";
   stuArr[2].score = 0;

   // 4.遍历结构体数组
   for (int i = 0; i < 3; i++)
   {
   	cout << stuArr[i].name << endl;
   	cout << stuArr[i].age << endl;
   	cout << stuArr[i].score << endl;
   	cout <<"                " << endl;
   }
   system("pause");
   return 0;
}

7.4 结构体指针

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

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

#include <iostream>
#include <string>
using namespace std;
struct Student
{
	// 成员列表

	// 姓名
	string name;
	// 年龄
	int age;
	// 分数
	int score;
};
int main()
{
	// 1.创建学生结构体变量
	Student s = { "张三", 18, 100 };

	// 2.通过指针指向结构体变量
	Student *p = &s;
	// 3.通过指针访问结构体变量中的值
	cout << p->name << endl;
	cout << p->age << endl;
	cout << p->score << endl;
	system("pause");
	return 0;

}

7.5 结构体嵌套结构体

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

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

示例：

#include <iostream>
#include <string>
using namespace std;
struct stu
{
	string name;
	int age;
	int score;
};

struct teacher
{
	int age;
	string name;
	struct stu s;
};

int main()
{
	teacher t;
	t.name = "王";
	t.age = 33;
	t.s.name = "布鲁斯";
	t.s.age = 14;
	t.s.score = 0;
	cout << "老师的姓名 " << t.name << "老师的年龄 " << t.age << "老师的学生姓名 " << t.s.name << "老师的学生年龄 " << t.s.age << "老师的学生分数 " << t.s.score << endl;


	system("pause");
	return 0;
}

总结：在结构体中可以定义李宁一个结构体作为成员，用来解决实际问题

7.6 结构体做函数参数

#include <iostream>
#include <string>
using namespace std;

struct student
{
	string name;
	int age;
	int score;
};
void prinntStudent(struct student s)
{
	cout << "姓名:" << s.name << endl;
	cout << "年龄:" << s.age << endl;
	cout << "分数:" << s.score << endl;
}

void prinntStudent1(struct student *s)
{
	cout << "姓名:" << s->name << endl;
	cout << "年龄:" << s->age << endl;
	cout << "分数:" << s->score << endl;
}

int main()
{
	student s;
	s.name = "张三";
	s.age = 14;
	s.score = 90;
	prinntStudent(s);
	prinntStudent1(&s);
	system("pause");
	return 0;
}