C++基础入门

林深归海

于 2024-02-02 19:23:08 发布

阅读量1k

点赞数 19

分类专栏： C/C++ 文章标签： c++

本文链接：https://blog.csdn.net/m0_60842098/article/details/135999227

版权

C/C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

C++基础入门

类型系统和类型安全

1. 类型系统

1. 强类型定义和弱类型定义

强类型定义语言：在该类型语言中一旦一个变量被指定了某个数据类型，如果不经过强制类型转换，那么它就永远是这个数据类型。如 c/c++
弱类型定义语言：在该类型语言中，在定义变量时可以忽略数据类型。一个变量可以赋不同数据类型的值。如JavaScript, python

2. 动态类型语言和静态类型语言

静态类型语言：其程序中的数据类型是在编译阶段检查的，在使用变量之前要定义它们的数据类型。由于编译时就能发现数据类型错误，因此通常能增强最终程序的可靠性，程序有较高的执行效率。如 c++/java/c
动态类型语言：在执行期间才去做类型检查

2. 类型安全

类型安全很大程度上等价于内存安全

c/c++都不是类型安全的语言

1 C++初识

1.1 第一个C++程序

编写一个C++程序总共分为4个步骤

创建项目
创建文件
编写代码
运行程序

1.1.1 创建项目

Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.1.2 创建文件

右键源文件，选择添加->新建项

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

给C++文件起个名称，然后点击添加即可。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.1.3 编写代码

#include<iostream>
using namespace std;

int main() {

	cout << "Hello world" << endl;

	system("pause");

	return 0;
}

1.1.4 运行程序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.2 注释

作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码

两种格式

单行注释：// 描述信息
- 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明
多行注释： /* 描述信息 */
- 通常放在一段代码的上方，对该段代码做整体说明

提示：编译器在编译代码时，会忽略注释的内容

1.3 变量

变量：一段连续内存空间的别名。如果一个变量占用内存空间的多个内存字节，其第一个字节地址就是它的存储地址

作用：给一段指定的内存空间起名，方便操作这段内存

语法：数据类型变量名 = 初始值;

示例：

#include<iostream>
using namespace std;

int main() {

	//变量的定义
	//语法：数据类型  变量名 = 初始值

	int a = 10;

	cout << "a = " << a << endl;
	
	system("pause");

	return 0;
}

注意：C++在创建变量时，必须给变量一个初始值，否则会报错

在有同名全局变量和局部变量时，可以使用 域运算符 提供对全局变量的访问

变量的存储类别

auto：

自动变量。在缺省的情况下，所有的局部变量都是自动变量。这种变量的存储空间由系统自动分配和释放，系统不会自动初始化。故 c语言中的局部变量需要手动初始化，否则会是一个垃圾值。静态局部变量编译器会自动初始化为0

register：
- 寄存器变量。存放在CPU内部寄存器中，存取速度最快。通常只将需要频繁读写的变量定义为寄存器变量。这类变量不能进行取地址。（有的编译器会将寄存器变量当做自动变量处理，这时候能够对其取地址）只有局部自动变量和函数形参才可以定义为寄存器变量。寄存器变量的数量不能超过寄存器个数
extern：
- 外部变量（函数外部定义的变量称为外部变量）全局变量默认初始化为 0
static：
- 静态变量。用 static修饰的变量。有静态局部变量（作用域：函数内。未初始化的静态局部变量，系统默认初始化为 0）和静态全局变量（作用域：当前源文件内，不能声明为外部变量被其他源文件访问）。
- 在定义时初始化的静态局部变量，初始化仅仅执行一次；未初始化的静态局部变量，编译器自动初始化为0
- 静态全局变量和普通全局变量的区别：静态全局变量只能初始化一次，以防止在其他源程序文件中访问

变量静态分配和动态分配方式

静态分配：在程序编译期间分配固定的存储空间的方式。
动态分配：在程序执行期间根据需要申请堆空间的方式。

变量的声明和定义

声明：使用extern关键字；不会为变量分配新空间。

定义：为变量分配空间，还可以为变量指定初始值。

定义包括声明

1.4 常量

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

C++定义常量两种方式

#define 宏常量： #define 常量名常量值
- 通常在文件上方定义，表示一个常量 (宏替换发生在编译阶段)
const修饰的变量 const 数据类型常量名 = 常量值
- 通常在变量定义前加关键字const，修饰该变量为常量，不可修改
数值常量 100 9.2
字符常量 ‘a’ , ‘b’, ‘\n’
字符串常量 “hello”, char * s = “hello” 常量区 data域

示例：

//1、宏常量
#define day 7

int main() {

	cout << "一周里总共有 " << day << " 天" << endl;
	//day = 8;  //报错，宏常量不可以修改

	//2、const修饰变量
	const int month = 12;
	cout << "一年里总共有 " << month << " 个月份" << endl;
	//month = 24; //报错，常量是不可以修改的
	
	
	system("pause");

	return 0;
}

const 修饰的常量解析

const 修饰的全局变量不可以修改
const 修饰的局部变量可以通过指针修改（现在的编译器好像都拒绝这个功能，vs2013可以，但vs2019不行）。因为类型不匹配，const修饰的局部变量，应该用 const类型的指针来指向，而该指针不能改变它指向的变量的值

1.5 关键字

**作用：**关键字是C++中预先保留的单词（标识符）

在定义变量或者常量时候，不要用关键字

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
catch	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
continue	for	public	throw	while
default	friend	register	true
delete	goto	reinterpret_cast	try

提示：在给变量或者常量起名称时候，不要用C++的关键字，否则会产生歧义。

1.6 标识符命名规则

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

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

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

2 数据类型、字符串详解

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

数据类型的本质

数据类型可理解为创建变量的模具：是固定内存大小的别名。
数据类型的作用：编译器预算对象（变量）分配的内存空间大小。
注意：数据类型只是模具，编译器并没有分配空间，只有根据类型（模具）创建变量（实物），编译器才会分配空间

size_t 为 unsigned int 类型（无符号整型）的别名

2.1 整型

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

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

数据类型	占用空间	取值范围
short(短整型)	2字节	(-2^15 ~ 2^15-1)
int(整型)	4字节	(-2^31 ~ 2^31-1)
long(长整形)	Windows为4字节，Linux为4字节(32位)，8字节(64位)	(-2^31 ~ 2^31-1)
long long(长长整形)	8字节	(-2^63 ~ 2^63-1)

2.2 sizeof关键字

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

**返回值：**无符号整形 unsigned int (与有符号类型数据做运算时会进行强制类型转换)

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

sizeof 是操作符，不是函数；sizeof 测量的实体大小为编译期间就已确定

int i = 1;
cout << i << endl;

sizeof(++i);
cout << i << endl; //1 sizeof中的++i作用并没有显示出来。运营商编译时sizeof执行以后将++i处理了，++i的作用因此被消除，所以sizeof只能求出静态分配空间的大小，而不能求出动态分配空间的大小（运行时确定）

char* b = (char *)malloc(20 * sizeof(char));
cout << sizeof(b) << endl; //输出指针b的地址空间大小4（32位机），而不是动态分配的20字节空间

示例：

int main() {

	cout << "short 类型所占内存空间为： " << sizeof(short) << endl;

	cout << "int 类型所占内存空间为： " << sizeof(int) << endl;

	cout << "long 类型所占内存空间为： " << sizeof(long) << endl;

	cout << "long long 类型所占内存空间为： " << sizeof(long long) << endl;

	system("pause");

	return 0;
}

整型结论：short < int <= long <= long long

2.3 实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

单精度float
双精度double

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

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

示例：

int main() {

	float f1 = 3.14f;
	double d1 = 3.14;

	cout << f1 << endl;
	cout << d1<< endl;

	cout << "float  sizeof = " << sizeof(f1) << endl;
	cout << "double sizeof = " << sizeof(d1) << 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;
}

2.4 字符型

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

语法：char ch = 'a';

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

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

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

示例：

int main() {
	
	char ch = 'a';
	cout << ch << endl;
	cout << sizeof(char) << endl;

	//ch = "abcde"; //错误，不可以用双引号
	//ch = 'abcde'; //错误，单引号内只能引用一个字符

	cout << (int)ch << endl;  //查看字符a对应的ASCII码
	ch = 97; //可以直接用ASCII给字符型变量赋值
	cout << ch << endl;

	system("pause");

	return 0;
}

ASCII码表格：

ASCII值	控制字符	ASCII值	字符	ASCII值	字符	ASCII值	字符
0	NUT	32	(space)	64	@	96	、
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	\|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	`
31	US	63	?	95	_	127	DEL

ASCII 码大致由以下两部分组成：

ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

c++中字符的比较：利用ASCII码

两字符比较大小的时候一定要带单引号，否则的话会出错

int main
{
	char A;
	char C;
	if('A' > 'C') // 不能写成 if(A > C)
	{
		cout << 1 << endl;
	}
	else if('A' < 'C')
	{
		cout << 0 << endl;
	}
	
	return 0;
}

printf 函数和 putchar 函数

printf 是输出一个字符串，putchar 输出一个 char。

scanf 函数与 getchar 函数

getchar 是从标准输入设备读取一个 char。
scanf 通过%转义的方式可以得到用户通过标准输入设备输入的数据。

2.5 转义字符

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

现阶段我们常用的转义字符有： \n \\ \t \"

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符""	092
’	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
?	代表一个问号	063
\0	数字0	000
\ddd	8进制转义字符，d范围0~7	3位8进制
\xhh	16进制转义字符，h范围0_9，af，A~F	3位16进制

示例：

int main() {
	
	
	cout << "\\" << endl;
	cout << "\tHello" << endl;
	cout << "\n" << endl;

	system("pause");

	return 0;
}

2.6 字符串(见7.11)

作用：用于表示一串字符

两种风格

C风格字符串： char 变量名[] = "字符串值" \0表示字符串的末尾

示例：

int main() {

	char str1[] = "hello world"; 
	cout << str1 << endl;
    str1[5] = "0";  //等效于 str1[5] = '\0';  \0 的 ASCII码 是 0
    cout << str1 << endl;
    
	system("pause");

	return 0;
}

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

包含 ‘\0’ 字符的一维 char 数组，就是一个字符串。其中存放的字符串即为 ‘\0’ 前面的字符组成。
用 char 数组存放字符串，数组元素个数应该至少为 字符串长度+ 1（留一个存放 ‘\0’）
用 cin 或 scanf 将字符串读入到字符数组时，会自动在字符数组中字符串的末尾加上 ‘\0’

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

要包含头文件

示例：

int main() {

	string str = "hello world";
	cout << str << endl;
	
	system("pause");

	return 0;
}

注意：C++风格字符串，需要加入头文件 == #include<string> ==

补充：

字符串常量（data区）
- 字符串常量占据内存的字节数等于字符串中字符数目加1，多出来的是结尾字符 ‘\0’
- 字符串的长度不包含 ‘\0’
- “” 称为空串，空串会占据一个字节的存储空间，存放 ‘\0’
- 如果字符串常量中包含双引号，则双引号应写为 ‘\"’。而 ‘\’ 字符在字符串中出现时，需连续写两次，变成 ‘\\’
```
cout << "he said: \"I am a stu\\dent.\""
```
用scanf 读入字符串
- 用scanf 可以将字符串读入字符数组
- scanf 会自动添加结尾的 ‘\0’
- scanf 读入到空格或换行终止
```
char line[100];
scanf("%s", line); // 注意：不是 &line 字符串变量的名字就是它的首地址，不用加取地址符
printf("%s", line);
```
- 在数组长度不足的情况下，scanf 可能导致数组越界
```
char line[5];
scanf("%s", line);
//若输入“12345”, 则数组越界
```
- 借助正则表达式
  
  scanf(“%[^\n]s”, str) [除什么之外]。 scanf 函数接收除 \n 之外的数据。即获取带有空格的字符串
读入一行到字符数组
- cin.getline(char buf[], int bufSize) 不会发生数组越界问题
  
  读入一行（行长度不超过 bufSize - 1）或 bufSize -1 个字符到 buf，自动添加 ‘\0’ 。会读入空格，但不会停止。回车换行符不会写入buf，但是会从输入流中去掉（如果字符串长度大于 bufSize，它只读
  
  入 bufSize -1 个字符）
```
char line[10];
cin.getline(line, sizeof(line)); //sizeof(line)：line数组所占空间的大小（字节）
cout << line;
```
- gets(char buf[])
  
  读入一行，自动添加 ‘\0’，回车换行不会写入buf，但是会从输入流中去掉。允许输入的字符串含有空格（与scanf不同，scanf遇空格表示结束）；可能导致数组越界
字符串库函数
- 使用字符串函数要添加头文件 #include
- 字符串函数都根据 ‘\0’ 来判断字符串结尾
- 形参为char[] 类型，则实参可以是 char 数组或字符串常量
  
  字符串拷贝： strcpy(char[] dest, char[] src); 拷贝 src 到 dest (dest不够大，可能数组越界)
  
  字符串比较大小：int strcmp(char[] s1, char[] s2); 返回 0 则相同，按字典顺序比较
  
  求字符串长度,不包含字符串结束符‘\0’：int strlen(char[] s);
  
  字符串拼接：strcat(char[] s1, char[] s2); // s2拼接到 s1后面（s1不够大，可能数组越界）
  
  字符串转成大写：strupr(char []);
  
  字符串转成小写：strlwr(char []);

注意：数组作为函数参数时，形参不是实参的拷贝（即不是值传递）。数组作为函数参数时，形参等价于实参

字符串输入输出函数

gets()

#include <stdio.h>
char *gets(char *s);
功能：从标准输入读入字符，并保存到 s 指定的内存空间，直到出现换行符或读到文件结尾
为止。
参数：
s：字符串首地址
返回值：
成功：读入的字符串
失败：NULL

gets(str)与 scanf(“%s”,str)的区别：

gets(str)允许输入的字符串含有空格

scanf(“%s”,str)不允许含有空格

注意：由于 scanf()和 gets()无法知道字符串 s 大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况
```
char str[100];
printf("请输入 str: ");
gets(str);
printf("str = %s\n", str);
```

fgets() 建议使用

#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
功能：从 stream 指定的文件内读入字符，保存到 s 所指定的内存空间，直到出现换行字符、
读到文件结尾或是已读了 size - 1 个字符为止，最后会自动加上字符 '\0' 作为字符串结束。
参数：
s：字符串
size：指定最大读取字符串的长度（size - 1）
stream：文件指针，如果读键盘输入的字符串，固定写为 stdin
返回值：
成功：成功读取的字符串
读到文件尾或出错： NULL

fgets()在读取一个用户通过键盘输入的字符串的时候，同时把用户输入的回车也做为字符串的一部分。通过 scanf 和 gets 输入一个字符串的时候，不包含结尾的“\n”，但通过 fgets 结尾多了“\n”。fgets()函数是安全的，不存在缓冲区溢出的问题。

char str[100];
printf("请输入 str: ");
fgets(str, sizeof(str), stdin);
printf("str = \"%s\"\n", str);

//去掉换行符
if('\n' == str[strlen(str) -1]){
    str[strlen(str) -1] = '\n';
}

puts()

#include <stdio.h>
int puts(const char *s);
功能：标准设备输出 s 字符串，在输出完成后自动输出一个'\n'。
参数：
s：字符串首地址
返回值：
成功：非负数
失败：-1

#include <stdio.h>
int main()
{
printf("hello world");
puts("hello world");
return 0;
}

fputs()

#include <stdio.h>
int fputs(const char * str, FILE * stream);
功能：将 str 所指定的字符串写入到 stream 指定的文件中， 字符串结束符 '\0' 不写入文件。
参数：
str：字符串
stream：文件指针，如果把字符串输出到屏幕，固定写为 stdout
返回值：
成功：0
失败：-1

fputs()是 puts()的文件操作版本，但 fputs()不会自动输出一个’\n’。

printf("hello world");
puts("hello world");
fputs("hello world", stdout);

strlen()的使用

strlen()的函数原型：

#include <string.h>
size_t strlen(const char *s);
功能：计算指定指定字符串 s 的长度，不包含字符串结束符‘\0’ 参数：
s：字符串首地址
返回值：字符串 s 的长度，size_t 为 unsigned int 类型

strlen() 常见糟糕用法

char s[100] = "test";
for(int i = 0; i < strlen(s); i++)
{
	s[i] = s[i] + 1; //这句话不重要，只是为了说明要访问s[i]
}

strlen函数的执行是需要时间的，且时间和字符串长度成正比（从头查找，直到找到 '\0’结束）
for循环每进行一次，都要调用 strlen 函数，这是效率上的很大浪费

应取出 s 的长度放到一个变量里面，然后在循环的时候使用该变量

char s[100] = "test";
int len = strlen(s);
for(int i = 0; i < len; i++)
{
	s[i] = s[i] + 1; //这句话不重要，只是为了说明要访问s[i]
}

sizeof 和 strlen 的区别

sizeof 为一个操作符，执行 sizeof 的结果，在编译期间就已经确定；

strlen 是一个函数，是在程序执行的时候才确定结果。

sizeof 和 strlen 对于求字符串来讲，sizeof() 字符串类型的大小，包括’\0’；

strlen() 字符串的长度不包括‘\0’（数字 0 和字符‘\0’等价）strlen遇到 ’\0‘ 结束。
strlen返回字符串长度，sizeof操作符返回静态分配空间的大小

char str[] = "hello";
cout << sizeof(str) << endl;
cout << strlen(str) << endl;

char str2[100] = "hello";
cout << sizeof(str2) << endl;
cout << strlen(str2) << endl;

char str3[] = "hello\0world";
cout << sizeof(str3) << endl;
cout << strlen(str3) << endl; // \0 字符串结束标志，故这里为 5

char str4[] = "hello\012world"; // \012 换行
cout << sizeof(str4) << endl;
cout << strlen(str4) << endl;

2.7 布尔类型 bool

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

bool类型只有两个值：

true — 真（本质是1）
false — 假（本质是0）

计算机中，true 存为 1，false 存为 0

bool类型占1个字节大小

示例：

int main() {

	bool flag = true;
	cout << flag << endl; // 1

	flag = false;
	cout << flag << endl; // 0

	cout << "size of bool = " << sizeof(bool) << endl; //1
	
	system("pause");

	return 0;
}

2.8 数据的输入

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

**关键字：**cin

语法： cin >> 变量

cin是istream类的对象，是带有缓冲区的输入流对象，输入数据后会被存放到缓冲区，并不能被">>" 运算提取，按下回车键后，缓冲区的内容才被刷新成缓冲流，被">>"提取后传递给cin对象，由cin对象发送到变量中存储

示例：

int main(){

	//整型输入
	int a = 0;
	cout << "请输入整型变量：" << endl;
	cin >> a;
	cout << a << endl;

	//浮点型输入
	double d = 0;
	cout << "请输入浮点型变量：" << endl;
	cin >> d;
	cout << d << endl;

	//字符型输入
	char ch = 0;
	cout << "请输入字符型变量：" << endl;
	cin >> ch;
	cout << ch << endl;

	//字符串型输入
	string str;
	cout << "请输入字符串型变量：" << endl;
	cin >> str;
	cout << str << endl;

	//布尔类型输入
	bool flag = true;
	cout << "请输入布尔型变量：" << endl;
	cin >> flag;
	cout << flag << endl;
	system("pause");
	return EXIT_SUCCESS;
}

2.9 类型限定符

extern ：声明一个变量而非定义它。没有储存空间，无法存值（C++Primer P41）
const ：常量不能修改
volatile ：防止编译器优化代码。每次都必须从内存中读取值，不能将其放在Cache或寄存器中重复使用
register ：定义寄存器变量，没有内存地址（cpu有没有空闲寄存器）

寄存器在cpu内部，内存不在

volate案例（在嵌入式中会经常用到）

int square(volatile int *ptr){
    return *ptr * *ptr;
}

上述函数功能是返回指针变量prt指向值的平方，但由于 *ptr 指向一个 volatile 型参数，编译器产生如下代码

int square(volatile int *ptr){
    int a, b;
    a = *ptr;
    b = *ptr;
    return a * b;
}

由于ptr指向的值可能被意外地修改，因此a 和 b 的值可能不同，这个代码也就不能用来求平方。正确的代码如下

int square(volatile int *ptr){
   int a;
    a = *ptr;
    return a * a;
}

3 运算符

**作用：**用于执行代码的运算

本章我们主要讲解以下几类运算符：

运算符类型	作用
算术运算符	用于处理四则运算
赋值运算符	用于将表达式的值赋给变量
比较运算符	用于表达式的比较，并返回一个真值或假值
逻辑运算符	用于根据表达式的值返回真值或假值

3.1 算术运算符

作用：用于处理四则运算

算术运算符包括以下符号：

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10 + 5	15
-	减	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 4	2
%	取模(取余)	10 % 3	1
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
–	前置递减	a=2; b=–a;	a=1; b=1;
–	后置递减	a=2; b=a–;	a=1; b=2;

示例1：

//加减乘除
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


	//两个小数可以相除
	double d1 = 0.5;
	double d2 = 0.25;
	cout << d1 / d2 << endl;

	system("pause");

	return 0;
}

总结：在除法运算中，除数不能为0

示例2：

//取模
int main() {

	int a1 = 10;
	int b1 = 3;

	cout << 10 % 3 << endl;

	int a2 = 10;
	int b2 = 20;

	cout << a2 % b2 << endl;

	int a3 = 10;
	int b3 = 0;

	//cout << a3 % b3 << endl; //取模运算时，除数也不能为0

	//两个小数不可以取模
	double d1 = 3.14;
	double d2 = 1.1;

	//cout << d1 % d2 << endl;

	system("pause");

	return 0;
}

总结：只有整型变量可以进行取模运算。

示例3：

//递增
int main() {

	//后置递增
	int a = 10;
	a++; //等价于a = a + 1
	cout << a << endl; // 11

	//前置递增
	int b = 10;
	++b;
	cout << b << endl; // 11

	//区别
	//前置递增先对变量进行++，再计算表达式（先运算后赋值）
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << b2 << endl;

	//后置递增先计算表达式，后对变量进行++（先赋值后运算）
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << b3 << endl;

	system("pause");

	return 0;
}

总结：前置递增先对变量进行++，再计算表达式，后置递增相反

++、–运算只需要一条机器指令就可以完成，而 n=n+1要对应 3条机器指令
编译器实现 n++/n-- 时是先创建 n 的一个临时变量存放n的值，然后 n 自增/自减 1，最后返回这个临时变量的值（该副本与n的地址不同），所以 n++/n-- 不能作为左值（因为作为左值时改变的是临时变量的值）
编译器实现 ++n/–n 时是先 n 自增/自减 1，最后返回 n 的值（不是副本的值），所以 ++n/–n 可以作为左值。例如 (++n) += 1 或者 (–n) += 1是正确的
建议使用 ++n 而不是使用 n++ 作为 for循环的递增量【n++返回的是临时变量的地址，++n返回的是n的地址】

补充：左值（location value）表示可寻址；右值（read value）表示可读

3.2 赋值运算符

**作用：**用于将表达式的值赋给变量

赋值运算符包括以下几个符号：

运算符	术语	示例	结果
=	赋值	a=2; b=3;	a=2; b=3;
+=	加等于	a=0; a+=2;	a=2;
-=	减等于	a=5; a-=3;	a=2;
*=	乘等于	a=2; a*=2;	a=4;
/=	除等于	a=4; a/=2;	a=2;
%=	模等于	a=3; a%2;	a=1;

示例：

int main() {

	//赋值运算符

	// =
	int a = 10;
	a = 100;
	cout << "a = " << a << endl;

	// +=
	a = 10;
	a += 2; // a = a + 2;
	cout << "a = " << a << endl;

	// -=
	a = 10;
	a -= 2; // a = a - 2
	cout << "a = " << a << endl;

	// *=
	a = 10;
	a *= 2; // a = a * 2
	cout << "a = " << a << endl;

	// /=
	a = 10;
	a /= 2;  // a = a / 2;
	cout << "a = " << a << endl;

	// %=
	a = 10;
	a %= 2;  // a = a % 2;
	cout << "a = " << a << endl;

	system("pause");

	return 0;
}

3.3 比较运算符

**作用：**用于表达式的比较，并返回一个真值或假值

比较运算符有以下符号：

运算符	术语	示例	结果
==	相等于	4 == 3	0
!=	不等于	4 != 3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
<=	小于等于	4 <= 3	0
>=	大于等于	4 >= 1	1

示例：

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;
}

注意：C和C++ 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。

3.4 逻辑运算符

**作用：**用于根据表达式的值返回真值或假值

逻辑运算符有以下符号：

运算符	术语	示例	结果
!	非	!a	如果a为假，则!a为真；如果a为真，则!a为假。
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
\|\|	或	a \|\| b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

**示例1：**逻辑非

//逻辑运算符  --- 非
int main() {

	int a = 10;

	cout << !a << endl; // 0

	cout << !!a << endl; // 1

	system("pause");

	return 0;
}

总结：真变假，假变真

**示例2：**逻辑与

//逻辑运算符  --- 与
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;
}

总结：逻辑与运算符总结：同真为真，其余为假

**示例3：**逻辑或

//逻辑运算符  --- 或
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;
}

逻辑或运算符总结：同假为假，其余为真

3.5 位运算符

运算符	含义
&	按位与（双目）
\|	按位或（双目）
^	按位异或（双目）
~	按位取反（单目）
<<	左移（双目）
>>	右移（双目）

右移：无符号补 0，有符号正数补 0，负数补 1

补充

条件运算符：？：：

逗号运算符：（ , ），返回逗号后面的结果

在C++中，逻辑运算符 || (双竖线) 和 && (双与符号) 是用于布尔逻辑运算的。

|| (逻辑或) 运算符用于判断两个条件中的至少一个是否为真。它的特点是短路求值，也就是**如果第一个条件为真，那么不会再对第二个条件进行求值。**只要有一个条件为真，整个表达式就为真。

| (按位或) 运算符是用于在二进制级别执行按位或操作的。它将两个操作数的对应位进行或操作，并返回结果。

类似地，&& (逻辑与) 运算符用于判断两个条件是否都为真。也是短路求值的，即**如果第一个条件为假，那么不会再对第二个条件进行求值。**只有两个条件都为真时，整个表达式才为真。

& (按位与) 运算符用于在二进制级别执行按位与操作。它将两个操作数的对应位进行与操作，并返回结果。

需要注意的是，逻辑或运算符和逻辑与运算符的求值结果是布尔值（true或false），而按位或运算符和按位与运算符对整数进行位操作。因此，两者的操作对象和使用场景有很大的差别。

3.6 类型转换

隐式类型转换：

参与运算的量的类型不同，先转成同一类型，然后进行运算。一般都是向上转，即向高精度转。如 int和long型运算，int型先要转为long型再做运算
所有浮点运算都是以双精度进行的，即使是仅含float运算的表达式，都会先转换成 double

char型和 short型参与运算时必须转成 int型

char ch = -1;
printf("%x", ch); //这里的 ch 已经被隐式转换为 int型了

有符号转无符号，符号位当数值位
无符号转有符号，最高位当符号位
无符号短长度数据类型转无/有符号长数据类型：低位部分相同，高位部分补 0
有符号短长度数据类型转无/有符号长数据类型：采用符号位向高位扩展的方式
长长度转短长度：直接截取低位部分即可

4 程序流程结构

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

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

4.1 选择结构

4.1.1 if语句

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

if语句的三种形式

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例：

int main() {

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

	int score = 0;
	cout << "请输入一个分数：" << endl;
	cin >> score;

	cout << "您输入的分数为： " << score << endl;

	//if语句
	//注意事项，在if判断语句后面，不要加分号
	if (score > 600)
	{
		cout << "我考上了一本大学！！！" << endl;
	}

	system("pause");

	return 0;
}

注意：if条件表达式后不要加分号

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例：

int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	if (score > 600)
	{
		cout << "我考上了一本大学" << endl;
	}
	else
	{
		cout << "我未考上一本大学" << endl;
	}

	system("pause");

	return 0;
}

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例：

	int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	if (score > 600)
	{
		cout << "我考上了一本大学" << endl;
	}
	else if (score > 500)
	{
		cout << "我考上了二本大学" << endl;
	}
	else if (score > 400)
	{
		cout << "我考上了三本大学" << endl;
	}
	else
	{
		cout << "我未考上本科" << endl;
	}

	system("pause");

	return 0;
}

嵌套if语句：在if语句中，可以嵌套使用if语句，达到更精确的条件判断

案例需求：

提示用户输入一个高考考试分数，根据分数做如下判断
分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。

示例：

int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	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;
}

4.1.2 三目运算符

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

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

解释：

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

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

示例：

int main() {

	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;
	cout << "c = " << c << endl;

	system("pause");

	return 0;
}

总结：和if语句比较，三目运算符优点是短小整洁，缺点是如果用嵌套，结构不清晰

4.1.3 switch语句

**作用：**执行多条件分支语句

语法：

switch(表达式)

{

	case 结果1：执行语句;break;

	case 结果2：执行语句;break;

	...

	default:执行语句;break;

}

示例：

int main() {

	//请给电影评分 
	//10 ~ 9   经典   
	// 8 ~ 7   非常好
	// 6 ~ 5   一般
	// 5分以下 烂片

	int score = 0;
	cout << "请给电影打分" << endl;
	cin >> score;

	switch (score)
	{
	case 10:
	case 9:
		cout << "经典" << endl;
		break;
	case 8:
		cout << "非常好" << endl;
		break;
	case 7:
	case 6:
		cout << "一般" << endl;
		break;
	default:
		cout << "烂片" << endl;
		break;
	}

	system("pause");

	return 0;
}

注意1：switch语句中表达式类型只能是整型或者字符型或者布尔型

case后面的值只能是整型或字符型或者布尔型

注意2：case里如果没有break，那么程序会一直向下执行

总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

C++11及以后的版本支持对字符串类型的switch。也就是说，case后面的值可以是字符串常量或字符串变量。

4.1.4 注意事项

使用if时：

当实数变量f 和 0 值进行比较时，由于实数有精度限制，不能写成 if(f == 0.0) 的形式，而应该写为

if(f >= -EPSINON && f <= EPSINON)，其中 EPSINON 是允许的误差，如float类型的精度为小数点后六位， EPSINON 取值为 0.000001。即 |f-0| <= EPSINON
两实数之间作比较不能仅仅通过 “==”，而是要将两实数做差，判断差值是否属于区间 [-e, e]，e比实数的精度大一个数量级
不要将 “==” 写成 “=” 。通常将 if(n == 2) 写为 if(2 == n)，避免出错

4.2 循环结构

4.2.1 while循环语句

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

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例：

int main() {

	int num = 0;
	while (num < 10)
	{
		cout << "num = " << num << endl;
		num++;
	}
	
	system("pause");

	return 0;
}

注意：在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环

4.2.2 do…while循环语句

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

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例：

int main() {

	int num = 0;

	do
	{
		cout << num << endl;
		num++;

	} while (num < 10);
	
	
	system("pause");

	return 0;
}

总结：与while循环区别在于，do…while先执行一次循环语句，再判断循环条件

练习案例：水仙花数

**案例描述：**水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身

例如：1^3 + 5^3+ 3^3 = 153

请利用do…while语句，求出所有3位数中的水仙花数

4.2.3 for循环语句

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

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

示例：

int main() {

	for (int i = 0; i < 10; i++)
	{
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

详解：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

注意：for循环中的表达式，要用分号进行分隔

总结：while , do…while, for都是开发中常用的循环语句，for循环结构比较清晰，比较常用

练习案例：敲桌子

案例描述：从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4.2.4 嵌套循环

作用： 在循环体中再嵌套一层循环，解决一些实际问题

例如我们想在屏幕中打印如下图片，就需要利用嵌套循环

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例：

int main() {

	//外层循环执行1次，内层循环执行1轮
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			cout << "*" << " ";
		}
		cout << endl;
	}

	system("pause");

	return 0;
}

**练习案例：**乘法口诀表

案例描述：利用嵌套循环，实现九九乘法表

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4.3 跳转语句

4.3.1 break语句

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

break使用的时机：

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

示例1：

int main() {
	//1、在switch 语句中使用break
	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;
	}

	system("pause");

	return 0;
}

示例2：

int main() {
	//2、在循环语句中用break
	for (int i = 0; i < 10; i++)
	{
		if (i == 5)
		{
			break; //跳出循环语句
		}
		cout << i << endl;
	}

	system("pause");

	return 0;
}

示例3：

int main() {
	//在嵌套循环语句中使用break，退出内层循环
	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;
}

4.3.2 continue语句

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

示例：

int main() {

	for (int i = 0; i < 100; i++)
	{
		if (i % 2 == 0)
		{
			continue;
		}
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

注意：continue并没有使整个循环终止，而break会跳出循环

4.3.3 goto语句

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

语法： goto 标记;

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

示例：

int main() {

	cout << "1" << endl;

	goto FLAG;

	cout << "2" << endl;
	cout << "3" << endl;
	cout << "4" << endl;

	FLAG:

	cout << "5" << endl;
	
	system("pause");

	return 0;
}

注意：在程序中不建议使用goto语句，以免造成程序流程混乱

5 数组

5.1 概述

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

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

5.2 一维数组

5.2.1 一维数组定义方式

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

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

注意: c++对数组初始化进行赋值时用的是花括号{}；而其他语言，如 java，python对于数组的初始化赋值用的都是[]

示例

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：数组中下标是从0开始索引

5.2.2 一维数组数组名

一维数组名称的用途：

可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址(数组名即指向数组中的第一个元素，相当于指针)
数组名是指针常量，不能赋值（指向不可以改，指向的值可以改 int * [指针]const [常量] 指针常量）
除了以下两种情况，数组名都可以看作数组第一个元素的地址
- sizeof(数组名) 获取的是整个数组的大小
- 对数组名取地址。
  
  &数组名 + 1 得到的步长是一个数组的大小。如果他是指针的话，步长大小应该与该数组的数据类型相同。故其为数组指针

示例：

int main() {

	//数组名用途
	//1、可以获取整个数组占用内存空间大小
    // arr[i]  ====> *(arr + i)
	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;

	//arr = 100; 错误，数组名是指针常量，因此不可以赋值 （*arr可以改）
    
    cout << &arr << endl; // arr为一维数组指针类型
    cout << (&arr + 1) << endl; //步长：一下跳跃的是整个数组的长度。这种指针称为：数组指针 
    
    // int* p = &arr;  int** p = &arr; //报错
    int *p = arr; //yes 等价于 int *p = &arr[0];

	system("pause");
  
	return 0;
}

注意：数组名是常量，不可以赋值

总结1：直接打印数组名，可以查看数组所占内存的首地址

总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小；对数组中某个元素进行sizeof，可以获得单个元素所占内存空间的大小，两者相除得到数组的长度
int arr[] = {1, 5, 9, 10, 9, 2};
int length = sizeof(arr) / sizeof(arr[0]);
cout << length << endl;
总结3：char类型的数组可以使用函数strlen(数组名)来获取字符串数组的长度
char a[] = "fasfwfewfewetg";
cout << strlen(a) << endl;
数组作为函数参数传递时，传递的是指针，所以不能正确的求出子函数中传递进去的数组长度，而求的是指针所占空间的大小（不同编译器的指针类型所占空间一般不同。例如，在vscode中，int* 类型占 8 个字节，而在visual studio中，它占 4 个字节）
int GetSize(int data[])
{
   	return sizeof(data);
}
int main()
{
   	int data1[] = {1, 2, 3, 4, 5};
   	int size1 = sizeof(data1);

   	int* data2 = data1;
   	int size2 = sizeof(data2);
   
   	int size3 = GetSize(data1);

   	cout << "size1: " << size1 << endl; // 得到的是数组所占内存空间的大小
   	cout << "size2: " << size2 << endl; // 下面两个得到的都是指针所占内存空间的大小
   	cout << "size3: " << size3 << endl;  

   	system("pause");
}

补充

定义的未初始化全局数组和静态局部数组存放在BSS段
定义的已初始化全局数组和静态局部数组存放在Data段
函数内部定义的局部数组（不包括静态数组）存放在栈空间

1.定义数组时，“长度表达式”指出数组的长度，长度表达式可以常量，但不能包含变量。

int n = 10;
int a[n]; //err

由于const定义的常量有变量的性质，故这类常量也不能作为定义数组长度的“长度表达式”（c语言会有这种限制，但c++中没有这种限制）

可以用宏定义来用作“长度表达式”

const int NUM = 10;

int a[NUM];

这种语法是错误的

2.对于数组的访问，有

int arr[] = {12，212，211};
arr[i]; //相当于 *(arr + i)

int a[i][j];
arr[i][j]; //相当于 *(*(a + i) + j)

5.2.3 冒泡排序

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例： 将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序

int main() {

	int arr[9] = { 4,2,8,0,5,7,1,3,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;
}

5.3 二维数组

二维数组就是在一维数组上，多加一个维度。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

5.3.1 二维数组定义方式

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

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

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

示例：

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;

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

	//方式2 
	//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
	int arr2[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	//方式3
	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr3[2][3] = { 1,2,3,4,5,6 }; 

	//方式4 
	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr4[][3] = { 1,2,3,4,5,6 };
	
	system("pause");

	return 0;
}

总结：在定义二维数组时，如果初始化了数据，可以省略行数

5.3.2 二维数组数组名

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

示例：

int main() {

	//二维数组数组名
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};
    //int arr[2][3] = {1, 2, 3, 4, 5, 6};
    //int arr[][3] = {1, 2, 3, 4, 5, 6};

	cout << "二维数组大小： " << sizeof(arr) << endl;	// 24
	cout << "二维数组一行大小： " << sizeof(arr[0]) << endl; // 12 
	cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl; // 4

	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl; //2
	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl; // 3

	//地址
	cout << "二维数组首地址：" << arr << endl; // 0x61fe00
	cout << "二维数组第一行第一个元素地址：" << arr[0] << endl; // 0x61fe00
    cout << "二维数组第一行第一个元素：" << *arr[0] << endl; // 1
    
	cout << "二维数组第二行第一个元素地址：" << arr[1] << endl; // 0x61fe0c
    cout << "二维数组第二行第一个元素：" << *arr[1] << endl; // 4
    // 利用一级指针访问二维数组
    int *p = arr[1];
    for(int i < 0; i < 3; ++i){
        cout << *p++ << endl;
    }
    
    cout << "二维数组第二行第二个元素地址：" << arr[1] + 1<< endl; // *arr +1

	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl; // 0x61fe00
	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl; //0x61fe04

	system("pause");

	return 0;
}

总结1：二维数组名就是这个数组的首地址

总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

除了以下两种情况，二维数组的数组名，可以理解为指向第一个一维数组的数组指针，它的步长为一个一维数组的大小，+1 指向第二个一维数组

void test()
{
	int arr[2][3] =
	{ 
		{1,2,3},
		{4,5,6}
	};
    
    int (*p)[2] = arr; //arr 可以理解为指向 第一个一维数组的数组指针
    printf("&arr = %d\n", arr);
    printf("&arr + 1 = %d\n", arr + 1); //差值为 12
    
    printf("arr[1][2] = %d\n", a[1][2]);
	printf("arr[1][2] = %d\n", *(*(p + 1) + 2));
    printf("arr[1][2] = %d\n", *(*p + 5));
    
    
    //除了以下两种情况，二维数组的数组名，可以理解为指向  第一个一维数组的数组指针,步长为一个一维数组大小
    int (*p)[3] = arr;
    printf("a[1][2] = %d\n", arr[1][2]);
    printf("a[1][2] = %d\n", *(*(p + 1) + 2));  //  *(*p + 5) 其中 p可以换为 arr
    	
    //情况1：sizeof 统计整个二维数组的大小
    printf("sizeof arr = %d\n", sizeof(arr));
    //情况2：对数组名取地址 步长：二维数组的大小（arr为 二维数组指针类型）
    int (*p)[2][3] = &arr;
    printf("&arr = %d\n", &arr);
    printf("&arr + 1 = %d\n", &arr + 1); //差值为 24  	
    
    //都指向的是二维数组首元素的地址， 但它们的步长不一样：都进行 +1 操作，得到的值不一样
    printf("%d\n", &arr[0][0]); //步长为一个数组元素大小
    printf("%d\n", arr); //步长为一个数组长度大小
    printf("%d\n", &arr) //步长为一个二维数组长度大小
}

5.3.3 二维数组应用案例

考试成绩统计：

案例描述：有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩

	语文	数学	英语
张三	100	100	100
李四	90	50	100
王五	60	70	80

参考答案：

int main() {

	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80},
	};

	string names[3] = { "张三","李四","王五" };

	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;
}

5.4 常数组

用const关键字修饰的数组。常数组中的元素不能被更新

定义：类型说明符 const 数组名[大小]

#include <iostream>
using namespace std;
int main()
{
    int const arr[5] = {1,2,3,4,5};
    arr[0] = 7; //报错
    

    system("pause");
    return 0;
}

6 函数

6.1 概述

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

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

6.2 函数的定义

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

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

返回值类型 函数名 （参数列表）
{

       函数体语句

       return表达式

}

返回值类型：一个函数可以返回一个值。在函数定义中
函数名：给函数起个名称
参数列表：使用该函数时，传入的数据
函数体语句：花括号内的代码，函数内需要执行的语句
return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

**示例：**定义一个加法函数，实现两个数相加

//函数定义
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

6.3 函数的调用

**功能：**使用定义好的函数

语法： 函数名（参数）

示例：

//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
	int sum = num1 + num2;
	return sum;
}

int main() {

	int a = 10;
	int b = 10;
	//调用add函数
	int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
	cout << "sum = " << sum << endl;

	a = 100;
	b = 100;

	sum = add(a, b);
	cout << "sum = " << sum << endl;

	system("pause");

	return 0;
}

总结：函数定义里小括号内称为形参，函数调用时传入的参数称为实参

6.4 值传递

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

示例：

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;

	swap(a, b);

	cout << "mian中的 a = " << a << endl;
	cout << "mian中的 b = " << b << endl;

	system("pause");

	return 0;
}

总结：值传递时，形参是修饰不了实参的

6.5 函数的常见样式

常见的函数样式有4种

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

示例：

//函数常见样式
//1、 无参无返
void test01()
{
	//void a = 10; //无类型不可以创建变量,原因无法分配内存
	cout << "this is test01" << endl;
	//test01(); 函数调用
}

//2、 有参无返
void test02(int a)
{
	cout << "this is test02" << endl;
	cout << "a = " << a << endl;
}

//3、无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 10;
}

//4、有参有返
int test04(int a, int b)
{
	cout << "this is test04 " << endl;
	int sum = a + b;
	return sum;
}

//5.指针函数
int* func(int * p){
    return p;
}

6.6 函数的声明

作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数的声明可以多次，但是函数的定义只能有一次

示例：

//声明可以多次，定义只能一次

//声明
int max(int a, int b);
int max(int a, int b); //也可以写成 int max(int, int)

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

int main() {

	int a = 100;
	int b = 200;

	cout << max(a, b) << endl;

	system("pause");

	return 0;
}

6.7 函数的分文件编写

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

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

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

示例：

//swap.h文件
#include<iostream>
using namespace std;

//实现两个数字交换的函数声明
void swap(int a, int b);

//swap.cpp文件
#include "swap.h"

void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

//main函数文件
#include "swap.h"
int main() {

	int a = 100;
	int b = 200;
	swap(a, b);

	system("pause");

	return 0;
}

防止头文件重复包含

当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件include 多次，或者头文件嵌套包含

a.h 中包含 b.h ：

#include "b.h"

b.h 中包含 a.h：

#include "a.h"

main.c 中使用其中头文件：

#include "a.h"

int main()
{
	return 0;
}

为了避免同一个文件被 include 多次，C/C++中有两种方式，一种是 #ifndef方式，一种是 #pragma once 方式。

方法一：跨平台

宏定义的格式通常为

#ifndef 头文件名_H

#define 头文件名_H

//头文件内容

#endif

// 头文件名为 somefile.h 则在条件编译里写 __SOMEFILE_H__(首尾两个下划线，中间一个下划线),也可以写SOMEFILE_H
#ifndef __SOMEFILE_H__  //#ifndef SOMEFILE_H #define SOMEFILE_H
#define __SOMEFILE_H__
// 声明语句 函数声明， include头文件，类型定义，宏定义
#endif

这样，其他文件只用 #include "somefile.h"就行了，防止重复包含

方法二：只在win平台下有用

#pragma once
// 声明语句

6.8 inline 内联函数

类的内联函数必须在类体外用关键字inline定义
编译时将内联函数的目标代码插入每个调用该函数的地方，节省了参数传递、控制转移等开销
如果代码很长或者很复杂，不适合转变为内联函数
内联函数是一种特殊的函数，具有普通函数的特征（参数检查，返回类型等）
内联函数由 编译器处理，直接将编译后的函数体插入调用的地方，

宏代码片段 由预处理器处理，进行简单的文本替换，没有任何编译过程
不建议将内联函数的声明和定义分离。如果非要分开写，则声明和定义前都要加inline关键字，否则编译器将其看作普通函数

内联函数体内不能有循环语句和switch语句。
内联函数的声明必须出现在内联函数第一次被调用之前。
对内联函数不能进行异常接口声明

函数体不能过于庞大

不能对函数进行取址操作

#include <iostream>
using namespace std;

const double PI = 3.14159265358979;
inline double calArea(double radius) {
	return PI * radius * radius;
}

int main() {
	double r = 3.0;
	double area	= calArea(r);
	cout << area << endl;
	return 0;
}

内联成员函数

为了提高运行时的效率，对于较简单的函数可以声明为内联形式。
内联函数体中不要有复杂结构（如循环语句和switch语句）。
在类中声明内联成员函数的方式：

将函数体放在类的声明中。

使用inline关键字。

class Point {
 public:
    void init(int initX, int initY) {//其实编译器会优化代码，会在成员函数前隐式的添加 inline关键字
      x = initX;
      y = initY;
    }
    int getX() { return x; }
    int getY() { return y; }
 private:
    int x, y;
};


class Point {
 public:
    void init(int initX, int initY);
    int getX()； 
    int getY()；
 private:
    int x, y;
};

inline void Point::init(int initX,int initY) {
    x = initX;
    y = initY;
}

inline int Point::getX() {
    return x;
}

inline int Point::GetY() {
    return y;
}

以下情况编译器可能考虑不会将函数进行内联编译

存在循环语句
存在过多的条件判断语句
函数体过于庞大
对函数进行取地址操作

内联仅仅是给编译器一个建议，如果没有将函数声明为内联函数，编译器也有可能将该函数做内联编译。编译器具体如何实现，由它自己决定

6.9 main 函数与 exit 函数

在 main 函数中调用 exit 和 return 结果是一样的，但在子函数中调用 return只是代表子函数终止了，在子函数中调用 exit，那么程序终止。使用 exit 函数要包含头文件 <stdlib.h>

#include <stdio.h>
#include <stdlib.h>  
void fun()
{
	printf("fun\n");
	//return;
	exit(0);
}
int main()
{
	fun();
	while (1);
	return 0;
}

7 指针

7.1 指针的基本概念

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

%p 打印指针变量的地址

内存编号是从0开始记录的，一般用十六进制数字表示

可以利用指针变量保存地址

注意事项：

用变量地址作为初值时，该变量必须在指针初始化之前已声明过，且变量类型应与指针类型一致。
可以用一个已赋初值的指针去初始化另一个指针变量。
不要用一个内部 auto 变量(局部变量)去初始化 static 指针。

内部auto变量所对应的存储单元随函数的调用而存在，随函数的执行完毕而回收，

而静态指针却长期占用内存，不随函数的调用或执行结束而释放，当再次进入函数后该指针又成为可见的。

因此，用内部auto变量的地址去初始化一个静态指针是没有意义的。

1. 不同类型指针的区别、指针步长的意义

步长不同， +1 后跳跃的字节数量不同 p+ n* sizeof(datatype) or p-n*sizeof(datatype)

解引用时，取出的字节数量不同（大端，小端序）

// 1.步长不同， +1 后跳跃的字节数量不同
void test01()
{
	char* p1 = NULL;
    printf("%d\n", p1);
    printf("%d\n", p1 + 1);
    
    int* p2 = NULL;
    printf("%d\n", p2);
    printf("%d\n", p2 + 1);
    
    double* p3 = NULL;
    printf("%d\n", p3);
    printf("%d\n", p3 + 1);
}

// 2. 解引用时，取出的字节数量不同
void test02()
{
    int num = 0x01020304;
    
    int *p = &num;
    printf("%#x\n", *p);
    
    short *p2 = &num;
    printf("%#x\n", *p2);
    
    char *p3 = &num;
    printf("%#x\n", *p3);
}

步长的练习，通过偏移量访问结构体中的成员

struct Person {
	char a; // 0 ~ 3
	int b;	// 4 ~ 7
	char buf[64]; // 8 ~ 71
	int d; // 72 ~ 75
};

int main()
{
	struct Person p = { 'a', 10, "hello world", 1000 };

	//d的偏移量的获取
	printf("d的偏移量：%d\n", offsetof(struct Person, d)); //需要添加头文件 <stddef.h>
	printf("buf的偏移量：%d\n", offsetof(struct Person, buf));

	//通过偏移量 获取到 d 的值 
    //这里可以看出，char类型指针 每进行一次 +1，跳跃 1 个字节 
	printf("d 的值为：%d\n", *(int *)((char *)&p + offsetof(struct Person, d)));
	printf("buf的值为：%s\n", (char*)&p + offsetof(struct Person, buf));

	return 0;
}

7.2 指针变量的定义和使用

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

示例：

int main() {

	//1、指针的定义
	int a = 10; //定义整型变量a
	
	//指针定义语法： 数据类型 * 变量名 ;
	int * p;

	//指针变量赋值
	p = &a; //指针指向变量a的地址
	cout << &a << endl; //打印数据a的地址
	cout << p << endl;  //打印指针变量p

	//2、指针的使用
	//通过*操作指针变量指向的内存
    // p = &a 即  *p = a
	cout << "*p = " << *p << endl;
    
    //3.传地址还是传值？
    p = 0x321f; //err,p是指针，只能接收地址，不能接收值
    p = (int *)0x321f; //这里的321f

	system("pause");

	return 0;
}

指针变量和普通变量的区别

普通变量存放的是数据,指针变量存放的是地址。指针变量本身也有地址
指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结1：我们可以通过 & 符号获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

左值和右值

如果作左值，存数据到空间中；如果作右值，取出空间中的内容

如果已知一个变量的地址，可以通过强制类型转换，然后解引用，修改变量的值。

VS中，每次运行程序时，变量的地址是随机的。可以将其设置为固定的（右键项目 —> 属性 —> 链接器 —>

高级 —> 随机基址设置为否平台要对应），然后执行下面的代码

int main()
{
	int a = 10;
	//1703640
	printf("%d\n", &a);
	*((int*)1703640) = 100;
	printf("%d\n", a);

	return 0;
}

7.3 指针所占内存空间

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

示例：

int main() {

	int a = 10;

	int * p;
	p = &a; //指针指向数据a的地址

	cout << *p << endl; //* 解引用
	cout << sizeof(p) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl;

	system("pause");

	return 0;
}

总结：所有指针类型在32位操作系统下是4个字节，在64位操作系统下是8个字节

指针变量所占空间大小与其指向的数据是何数据类型无关

7.4 空指针和野指针,空类型指针,悬空指针

空指针：指针变量指向内存中编号为0的空间。特殊的指针变量，表示不指向任何东西

**用途：**初始化指针变量

**注意：**空指针指向的内存是不可以访问的，不要对空指针进行解引用

示例1：空指针

int main() {

	//指针变量p指向内存地址编号为0的空间
	int * p = NULL;

	//访问空指针报错 
	//内存编号0 ~255为系统占用内存，不允许用户访问
	cout << *p << endl;

	system("pause");

	return 0;
}

**示例2：空类型指针（void ）*

空类型指针就是void *类型的指针。

void 只能声明指针，不能用 void声明变量

void 类型的指针，又称万能指针，可以不通过强制类型转换就转成其他类型指针

最好在声明空类型指针时将它进行初始化

void * 可以指向任何类型对象的地址，表示这是一个指针，和地址值有关，但不知道存储在此地址上的对象的类型，所以在取空类型指针所指向的值的时候，应将空类型指针转换为对应的指针类型（强制类型转换),

总之，不能出现对void类型指针解引用，即 *类型空指针是错误的

由于缺少具体的值和大小，因此无法对void指针进行指针算术运算。

int a = 10;
char b = 'a';
float c = 12.0;
//void * 可以指向任何类型对象的地址
void *pa = &a;
void *pb = &b;
void *pc = &c;

// void obj ;  //错误，不能声明void类型的变量	

 
// (int *)(pa) 转换成int类型的指针
// int *p = (int *)(pa); //正确 将void类型指针转为int类型指针
int aa = (int)(*pa);    //错误
int aa = *(int *)(pa)    //正确

1）空类型指针支持的操作

a. 与另一个指针比较

b. 向函数传递void *指针

c. 在函数里返回void *指针

d. 给另一个void *指针赋值

2）空类型指针不支持的操作

a. 不支持解引用，不能获取指向对象的值

b. 不能进行指针运算，比如移位操作

int main()
{
	double a = 3.14;
	double *p1 = &a;
	void *p2 = &a;                 //正确，将一个double型数据的地址赋给一个空类型指针
    //void 类型的指针，又称 万能指针，可以不通过强制类型转换就转成其他类型指针
	void *p3 = p1;                 //正确，将一个double型指针赋给一个空类型指针
 
	//double b = *p2;              //错误，无法对一个空类型指针解引用
	double d = *((double*)p2);     //正确，先将空类型指针强转为double型指针，然后再解引用
	cout << d << endl;
 
	int array[5] = { 1,2,3,4,5 };
	void *p4 = array;
	//for (int i = 0; i < 5; i++)
	//{
	//	cout << *(p4 + i)) << endl; //错误，不能对空类型指针进行移位操作
	//}
 
	for (int i = 0; i < 5; i++)
	{
		cout << *((int*)p4 + i));   //正确，先将空类型指针强转为int型指针，然后再解引用
	}
	cout << endl;
 
	system("pause");
	return 0;
}

返回值为 void * 类型的库函数

memset
memcpy

野指针

野指针是指向未分配或已释放的内存地址

指针变量指向非法的内存空间（未分配的空间）或已销毁（释放）的内存空间（“野指针”则是不确定其具体指向的指针：未分配，已释放）

产生野指针的原因：

1.指针变量没有被初始化（定义指针时须初始化）

任何指针变量被刚创建时不会被自动初始化为NULL指针，它的缺省值是随机的。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。

char *p;     //野指针，p的值是随机的(vs直接寄)

为了避免此类野指针的出现，指针变量在创建的同时应该被不必初始化，要么将它设置为NULL，要么让它指向合法的内存，例如：

char *p = NULL  //#define NULL 0 c++11: char *p = nullptr;
char *p = (char*) malloc(100);

2.指针被free或者delete之后，没有设置为NULL，后面还使用它（指针指向的内存空间被释放后应该指向NULL）

free和delete只是把指针所指向的内存给释放掉，但并没有把指针本身给清理掉。这时候的指针依然指向原来的位置，只不过这个位置的内存数据已经被毁尸灭迹，此时的这个指针指向的内存就是一个垃圾内存。但是此时的指针由于并不是一个NULL指针（在没有置为NULL的前提下），在做如下指针校验的时候
if(p != NULL)  //NULL 是一个值为 0 的宏常量 #define NULL ((void *)0)
会逃过校验，此时的p不是一个NULL指针，也不指向一个合法的内存块，造成后面程序中指针访问的失败。

char str1[] = "Hello";
char str2[] = "world";
char *pd = (char*)malloc(100);
strcpy(pd, str1);         //正确，将字符串str1复制到指定的内存中去
printf("%p\n", pd);
printf("%s\n", pd);
 
free(pd);
if (pd != NULL)
{
	strcpy(pd, str2);    //错误，将字符串str2放到没有经过系统指定的内存中去
}
printf("%p\n", pd);
printf("%s\n", pd);

我们发现，1）内存经过free释放后，指针的值并没有被释放，还是指在同样的位置里；2）第一个strcpy复制语句正确，将一个字符串复制到系统分配的内存中去，然后第二个strcpy复制语句虽然得到了正确的结果，但它是极其危险的，因为它将一个字符串复制到一个没有经过系统分配的内存中去了，此时的pd指针也是一个野指针

解决此类野指针问题，我们应该当指针指向的内存被释放时，我们也应该将指针置空

if(p != NULL)
{
	free(p);
	p = NULL;
}

3.指针操作超越了所指变量的作用范围（在所指变量的作用域结束前释放掉变量的地址空间，并让指针指向NULL）

由于C/C++中指针有++操作，因而在执行该操作的时候，稍有不慎，就容易指针访问越界，访问了一个不该访问的内存，结果程序崩溃

另一种情况是指针指向一个临时变量的引用，当该变量被释放时，此时的指针就变成了一个野指针，

不要返回指向栈内存的指针或者引用，因为栈内存在函数结束的时候会被释放。

int * test()
{
	int a = 20;
	return &a;
}
int main()
{
	int *p = NULL;
	p = test();
	printf("%d\n", *p);
	return 0;
}

示例2：野指针

int main() {
	//指针变量指向非法的内存空间
	//指针变量p指向内存地址编号为0x1100的空间
	int * p = (int *)0x1100;

	//访问野指针报错 
	cout << *p << endl;

	system("pause");

	return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

野指针不会直接引发错误，操作野指针指向的内存区域才会出问题

int a = 100;
int *p;
p = a; //把 a 的值赋值给指针变量 p，p 为野指针， ok，不会有问题，但没有意义
p = 0x12345678; //给指针变量 p 赋值，p 为野指针， ok，不会有问题，但没有意义
*p = 1000; //操作野指针指向未知区域，内存出问题，err

规避方法：

1.初始化指针的时候将其置为nullptr或 NULL或指向具体对象，之后对其操作。
2.释放指针后（free§）将其置为nullptr或 NULL（p = NULL）。

空指针可以free，野指针不能free

见提高篇内存管理第4节

int main()
{
	int *p2 = (int *)malloc(sizeof(int));
	*p2 = 100;
	printf("%d\n", *p2);
	
	free(p2);//此时p2是野指针，报错
	free(p2);
	
//	p2 = NULL;
//	free(p2);  //p2为空指针，可以多次free

	return 0;
}

悬空指针

悬空指针”是指向被释放内存的指针。“野指针”则是不确定其具体指向的指针

C语言中的指针可以指向一块内存，如果这块内存稍后被操作系统回收（被释放），但是指针仍然指向这块内存，那么，此时该指针就是“悬空指针”。

void *p = malloc(size);
assert(p);
free(p); 
// 现在 p 是“悬空指针”

assert§是判断如果指针p存在，则程序往下执行。如果这块内存被操作系统回收（被释放），但是指针仍然指向原来分配给他的这块内存空间，那么此时该指针就是“悬空指针”.

C语言中的“悬空指针”会引发不可预知的错误，而且这种错误一旦发生，很难定位。这是因为在 free§ 之后，p 指针仍然指向之前分配的内存，如果这块内存暂时可以被程序访问并且不会造成冲突，那么之后使用 p 并不会引发错误。

所以在实际的C语言程序开发中，为了避免出现“悬空指针”引发不可预知的错误，在释放内存之后，常常会将指针 p 赋值为 NULL：

void *p = malloc(size);
assert(p);
free(p);
// 避免“悬空指针”
p = NULL;

这么做的好处是一旦再次使用被释放的指针 p，就会立刻引发“段错误”，程序员也就能立刻知道应该修改C语言代码了。

7.5 const修饰指针（***）

const修饰指针有三种情况

const修饰指针(const int * p) — 常量指针（指向可以改变）
const修饰常量(int *const p) — 指针常量（指向的值可以改变）
const即修饰指针，又修饰常量

示例：

int main() {

	int a = 10;
	int b = 10;

	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; //等同于 int const *p1 =  &a;
	p1 = &b; //正确
	//*p1 = 100;  报错
	

	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量， 指针指向不可以改，指针指向的值也不可以改
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");

	return 0;
}

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

示例：指向常量的指针做形参(const int* p)

#include<iostream>
using namespace std;

const int N = 6;
void print(const int *p, int n);

int main() 
{
  int array[N];
  for (int i = 0; i < N; i++)
    cin>>array[i];
  print(array, N);
  return 0;
}

void print(const int *p, int n) 
{
  cout << "{ " << *p;
  for (int i = 1; i < n; i++)
    cout << ", " << *(p+i);
  cout << " }" << endl;
}

在编辑程序时，指针作为函数参数，如果不想修改指针对应内存空间的值，需要使用 const 修饰指针数据类型。

7.6 指针和数组

7.6.1指向数组中元素的指针（**）

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

示例：

int main() {

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

	int * p = arr;  //指向数组的指针

	cout << "第一个元素： " << arr[0] << endl;
	cout << "指针访问第一个元素： " << *p << endl;

	for (int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl; // 直接 cout << *(p++) <<endl; 也等同于 p[i] *(p + i)
		p++;
        

 	}
    
    int a[] = {10, 20, 30},*p = a;
    cout << (*p)++ <<endl; //执行*p 后返回 10  这个结果不能作为左值
    cout << *p << endl;//然后将*p的结果加1,*p = 11
    
    cout << *(p++) << endl; //执行*p 后返回 10
    cout << *p << endl; // 然后将指针后移一位 20
    
    // ++ 和 * 有相同的优先级，从右向左结合
    cout << *p++ << endl; //后缀++，先赋值后运算 10
    cout << *p << endl; //20
    
    cout << ++*p << endl; //前缀++，先运算后赋值 11
    cout << *p << endl; //11

	system("pause");

	return 0;
}

补充：

数组名字是数组的首元素地址，但它是一个常量（可以用数组名给指针赋值，但数组名不能被赋值）

a[i] == *(a + i) == p[i] == *(p + i)

int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
printf("a = %p\n", a);
printf("&a[0] = %p\n", &a[0]);
//a = 10; //err, 数组名只是常量，不能修改

char src[] = "bi chou sao sasfd";
while(*src){
    str++;// 错误，数组名虽然可以表示数组首元素地址，但它是一个常量，不能像指针一样进行递增递减运算
}

char *p = str;
while(*p){
    p++;
}

案例：指针操作数组元素

#include <stdio.h>
int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0;
	int n = sizeof(a) / sizeof(a[0]);
    
	for (i = 0; i < n; i++)
	{
		//printf("%d, ", a[i]);
		printf("%d, ", *(a+i));
	}
    
	printf("\n");
	int *p = a; //定义一个指针变量保存 a 的地址
    
	for (i = 0; i < n; i++)
	{
		p[i] = 2 * i;
	}
    
	for (i = 0; i < n; i++)
	{
		printf("%d, ", *(p + i));
	}
    
	printf("\n");
	return 0;
}

指针加减运算

1)加法运算

指针计算不是简单的整数相加（+步长）

如果是一个 int *，+1 的结果是增加一个 int 的大小

如果是一个 char *，+1 的结果是增加一个 char 大小

#include <stdio.h>
int main()
{
	int a;
	int *p = &a;
	printf("%d\n", p);
	p += 2;//移动了 2 个 int
	printf("%d\n", p);
	char b = 0;
	char *p1 = &b;
	printf("%d\n", p1);
	p1 += 2;//移动了 2 个 char
	printf("%d\n", p1);
	return 0;
}

2）减法运算

两同类型指针相减，并非它们的两个地址值之间进行减法运算，而是两指针所指地址之间的数据个数

int a[] = {1, 2, 3};
int *p = a; // int *p = &a; 错误，&a的步长为一个数组长度大小（见7.6.4）
int *q = &a[2];
cout << q-p << endl; //2

7.6.2 指针数组

是一个数组, 里面的每一个元素都是一个指针。（多个指针）

int * arr[]; //指针数组的定义

案例一：整形指针数组

const int MAX = 3;

int main ()
{
   int  var[MAX] = {10, 100, 200};
   int *ptr[MAX];
 
   for (int i = 0; i < MAX; i++)
   {
      ptr[i] = &var[i]; // 赋值为整数的地址
   }
    
   for (int i = 0; i < MAX; i++)
   {
      cout << "Value of var[" << i << "] = ";
      cout << *ptr[i] << endl; // *(ptr + i)
   }
   
   system("pause");
    
   return 0;
}

案例二：字符串指针数组

const int MAX = 4;
 
int main ()
{
 //字符串在数组中存放的就是地址
 const char *names[MAX] = {
                   "Zara Ali",
                   "Hina Ali",
                   "Nuha Ali",
                   "Sara Ali"
   };
 
   for (int i = 0; i < MAX; i++)
   {
      cout << "Value of names[" << i << "] = ";
      cout << names[i] << endl;
   }
   return 0;
}

7.6.3 数组名做函数参数

数组名做函数参数，数组名会退化为指针。传递的是数组的首地址。所以当整形数组作函数参数时，通常在函数定义中，封装两个参数，一个表示数组首地址，一个表示数组元素个数

#include <stdio.h>
void printArrary(int *a, int n) // int *p ===> int p[]; int(*p)[3]  ===> int p[2][3]
{
	int i = 0;
	for (i = 0; i < n; i++) 	 
	{
	printf("%d, ", a[i]);
	}
	printf("\n");
}
int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int n = sizeof(a) / sizeof(a[0]);
	//数组名做函数参数
	printArrary(a, n);
	return 0;
}

7.6.4 数组指针（&arr）

定义：是一个指针，指向一个数组。（一个指针）

数据类型（*变量名）[数组大小] = &数组名

int arr[5] = {1,2,3,4,5};

int (*parr)[5] = &arr; //parr为指向arr这个数组的指针，parr == arr

数组指针的三种定义方式：

void test()
{
	int arr[] = {1, 2, 3, 4, 5};
	
	int (*parr)[5] = &arr;
	
	//*parr 等价于 arr
	for(int i = 0; i < 5; i++)
	{
		printf("%d\n", (*parr)[i]);
		//printf("%d\n", *((*parr) + i);		
	}
}

void test()
{
	int arr[] = {1, 2, 3, 4, 5};
    //2. 先定义数组指针的类型，再通过数组指针的类型 定义数组指针变量
    typedef int(*arrayType)[5];  
    arrayType parr = &arr;
    
    /*
    	3. 先定义数组的类型，再通过数组类型定义数组指针变量
    	typedef int(arrayType)[5]  //arryType 是存放了 5个 int 元素类型的数组类型
    	arrayType * parr = &arr;
    */
    
    //*parr 等价于 arr
	for(int i = 0; i < 5; i++)
	{
		printf("%d\n", (*parr)[i]);  // p[i] = *(p + i);	[i] == *( +i)
		//printf("%d\n", *((*parr) + i);
	}
}

int a[2][3] = {{1,2,3}, {4,5,6}};

//定义二维数组指针
int (*pa)[3] = a; //pa相当于a

for(int i = 0 ; i < 2; ++i){
    for(int j = 0; j < 3; ++j){
        cout << *(*(pa +i) + j) << " "; //相当于 a[i]][j]
    }
    cout << endl;
}

一维数组名取地址后可以看作是一维数组指针类型，步长为一维数组大小

int a[10];
// a表示数组首元素的地址，和 &a[0]的含义是一致的；但是 &a表示整个数组的首地址，与a不同
//其中 a的步长为 一个数组元素大小：a + i = a + i * sizeof(int)
//    &a的步长为  一个数组的大小：&a +i = &a + i * 10 *sizeof(int)
printf("%x, %x\n", a, &a);

二维数组名取地址后可以看作是二维数组指针类型 &arr，步长为二维数组大小。&arr[i] 可以看作一维数组指针类型，步长为一维数组大小

7.7 指针和函数

栈帧：

当函数调用时，系统会在 stack 空间上申请一块内存区域，用来供函数调用，只要存放函数的形参和局部变量；当函数调用结束时，这块内存区域自动被释放掉

传值和传址：

传值：函数调用期间，实参将自己的值，拷贝一份给形参

传址：函数调用期间，实参将自己所占空间的地址，拷贝一份给形参（传地址，改变了栈帧内部的局部变量的值，从而改变了实参）

指针做函数参数的输入输出特性

一级指针做函数参数的输入输出特性

输入特性：主调函数分配内存，被调函数使用

输出特性：被调函数分配内存，主调函数使用（只能分配堆区内存，栈区内存在被调函数执行完毕后被释放）

//输入特性 
void func(char *p)
{
    strcpy(p, "abcde");
}

void test01()
{
    //栈上分配内存
    char buf[1024] = {0};
    
    func(buf);
    
    printf("%s\n", buf);
}

//堆区分配内存
void printString()
{
    printf("%s\n", p); 
}
void test02()
{
    char *p = (char *)malloc(sizeof(char) * 64);
    memset(p, 0, sizeof(p));
    printString(p);
}

// 输出特性 
void allocate(char ** pp)
{
    char *temp = (char *)malloc(sizeof(char) * 64); //只能动态分配内存。静态分配内存在函数结束后空间就会被释放
    memset(temp, 0, sizeof(p));
    strcpy(temp, "hello world");
    *pp = temp;
}
void test()
{
    char *p = NULL;
    allocateSpace(&p);
    printf("%s\n", p);
}

二级指针做函数参数的输入输出特性

输入特性：

主调函数中在堆区分配内存【（即在主调函数中使用二级指针）或者在栈上分配内存（使用一级指针）】，被调函数中使用内存【将二级指针做函数参数，使用主调函数中分配的内存或者将一级指针（数组名）做函数参数】

//打印数组
void print_array(int **arr,int n){
	for (int i = 0; i < n;i ++){
		printf("%d ",*(arr[i]));
	}
	printf("\n");
}
//二级指针输入特性(由主调函数分配内存)
void test(){
	int a1 = 10;
	int a2 = 20;
	int a3 = 30;
	int a4 = 40;
	int a5 = 50;
	int n = 5;
	int** arr = (int **)malloc(sizeof(int *) * n);
	arr[0] = &a1;
	arr[1] = &a2;
	arr[2] = &a3;
	arr[3] = &a4;
	arr[4] = &a5;
	print_array(arr,n);
    
	free(arr);
	arr = NULL;
}

输出特性：

在被调函数中分配二级指针指向的内存（二级指针做函数参数），主调函数中传入一级指针的地址

//被调函数,由参数n确定分配多少个元素内存
void allocate_space(int **arr,int n){
	//堆上分配n个int类型元素内存
	int *temp = (int *)malloc(sizeof(int)* n);
	if (NULL == temp){
	return;
	}
    
	//给内存初始化值
	int *pTemp = temp;
	for (int i = 0; i < n;i ++){
		//temp[i] = i + 100;
		*pTemp = i + 100;
		pTemp++;
	}
    
	//指针间接赋值
	*arr = temp;
}
//打印数组
void print_array(int *arr,int n){
	for (int i = 0; i < n;i ++){
		printf("%d ",arr[i]);
	}
	printf("\n");
}
//二级指针输出特性(由被调函数分配内存)
void test(){
	int *arr = NULL;
	int n = 10;
    
	//给arr指针间接赋值
	allocate_space(&arr,n);
    
	//输出arr指向数组的内存
	print_array(arr, n);
    
	//释放arr所指向内存空间的值
	if (arr != NULL){
		free(arr);
		arr = NULL;
	}
}

7.7.1指针作为函数参数

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

示例： 传递指针给函数

//值传递
void swap1(int a ,int b)
{
	int temp = a;
	a = b; 
	b = temp;
}
//地址传递
void swap2(int * p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() 
{

	int a = 10;
	int b = 20;
	swap1(a, b); // 值传递不会改变实参

	swap2(&a, &b); //地址传递会改变实参

	cout << "a = " << a << endl;

	cout << "b = " << b << endl;

	system("pause");

	return 0;
}

总结：如果不想修改实参，就用值传递；如果想修改实参，就用地址传递，即用指针

7.7.2指针函数 (指针做函数的返回值)

**作用：**从函数返回指针

指针函数：带指针的函数，即本质是一个函数。函数返回类型是某一类型的指针

指针函数的声明：**类型标识符 *函数名(参数表) **

int f(x，y);*

C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static变量。

局部变量在函数执行结束后被销毁。静态变量保存在全局区（data）不会被销毁

首先它是一个函数，只不过这个函数的返回值是一个地址值。指针函数一定有函数返回值，即返回指针变量。而且在主调函数中，函数返回值必须赋给同类型的指针变量。

当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。由于返回的是一个地址，所以类型说明符一般都是int

int* f(int a, int b);

float* fun();
float *p;
p = fun( );

案例：

typedef struct _Data{
    int a;
    int b;
}Data;

//指针函数
Data* f(int a,int b){
    Data* data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

int main()
{
    //调用指针函数
    Data* myData = f(4,5);
    cout << "f(4,5) = " << myData->a << " " << myData->b;

    return 0;
}

7.7.3函数指针

指向函数首地址的指针变量，本质是一个指针变量

函数指针说的就是一个指针，但这个指针指向的函数，不是普通的基本数据类型或者类对象

指向函数的指针包含了函数的地址，可以通过它来调用函数

函数名本身就是函数指针，指向的是一个函数的入口地址

函数指针的声明：类型标识符 (* 指针变量名)(函数的形参列表)

 // 这里就定义了一个指向函数的指针 fp。(这个函数的参数列表 仅有 一个 int 类型的参数、函数返回值是 int 类型)
int (*fp)(int a);

案例1：用函数指针分别求两个整数的最大值和最小值

/* 求最大值，返回值是int类型，返回两个整数中较大的一个*/
int max(int a, int b)
{
	return a > b ? a : b;
} 

/* 求最小值，返回值是int类型，返回两个整数中较小的一个*/
int min(int a, int b) 
{
	return a < b ? a : b;
}
  
int main()
{

    int (*f)(int, int); // 声明函数指针，指向返回值类型为int，有两个参数类型都是int的函数
    // 函数指针f指向求最大值的函数max(将max函数的首地址赋给指针f)
    // f = &max(int, int) 则 (*f) (int, int) = max(int, int)
	f = max; //从这句来讲，函数名可以当作该函数在内存中的首地址
	int c = (*f)(1, 2);
 
	cout << "最大值：" << c << endl;
 
	f = min; // 函数指针f指向求最小值的函数min(将min函数的首地址赋给指针f)
	c = (*f)(1, 2);
 
	cout << "最小值：" << c << endl;
	
    system("pause");
	
	return 0;
}

2、typedef 定义可以简化函数指针的定义

int test(int a)
{
    return a;
}
 
int main(int argc, const char * argv[])
{
    
    typedef int (*fp)(int a);
    fp f = test;
    /*
    第二种：typedef int (FUNC_TYPE)(int);
    	   FUNC_TYPE *p = test;
    	   p(2);
   	第三种：typedef int(*FUNC_TYPE)(int);
   		   FUNV_TYPE p = test;
   		   p(2);
    */
    
    cout <<f(2) <<endl;
    
    system("pause");
    return 0;
}

3、函数指针同样是可以作为参数传递给函数的

回调函数：用函数指针做函数的参数

int test(int a)
{
    return a-1;
}
int test2(int (*fun)(int),int b)
{
    
    int c = fun(10)+b; 
    return c;
}
 
int main(int argc, const char * argv[])
{
    
    typedef int (*fp)(int a);
    fp f = test;
    cout<<test2(f, 1)<<endl; // 调用 test2 的时候，把test函数的地址作为参数传递给了 test2，通过test2的调用间接调用了test
    
    system("pause");
    return 0;
}

案例

4、利用函数指针，我们可以构成函数指针数组，更明确点的说法是构成指向函数的指针数组。

void t1(){cout<<"test1"<<endl;}
void t2(){cout<<"test2"<<endl;}
void t3(){cout<<"test3"<<endl;}
 
int main(int argc, const char * argv[])
{
    
    typedef void (*fp)(void);
    fp b[] = {t1,t2,t3}; // b[] 为一个指向函数的指针数组
    b[0](); // 利用指向函数的指针数组进行下标操作就可以进行函数的间接调用了
    
    /*
    第二种：void(*fp[3])();
    	   fp[0] = t1;
    	   fp[1] = t2;
    	   fp[3] = t3;
    	   for(int i = 0; i < 3; i++){
    	   		fp[i]();
    	   }
    */
    
    return 0;
}

7.7.4指向类成员函数的函数指针

定义：类成员函数指针（member function pointer），是 C++ 语言的一类指针数据类型，用于存储一个指定类具有给定的形参列表与返回值类型的成员函数的访问信息。

基本上要注意的有两点：

1、函数指针赋值要使用 &
2、使用 (实例对象). *(类成员函数指针名)(待传入的参数) 或者

**（实例对象指针)->*(类成员函数指针名)(待传入的参数)**调用类成员函数指针所指向的函数

A) 类成员函数指针指向类中的非静态成员函数

对于 **nonstatic member function （非静态成员函数）**取地址，获得该函数在内存中的实际地址

对于 virtual function（虚函数）, 其地址在编译时期是未知的，所以对于 virtual member function（虚成员函数）取其地址，所能获得的只是一个索引值

//指向类成员函数的函数指针
#include <iostream>
#include <cstdio>
using namespace std;
 
//基类
class A
{
    public:
        A(int aa = 0):a(aa){} //构造函数，初始化列表
 
        ~A(){}
 
        void setA(int aa = 1)
        {
            a = aa;
        }
        
        //函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
        virtual void print() 
        {
            cout << "A: " << a << endl;
        }
 
        virtual void printa()
        {
            cout << "A1: " << a << endl;
        }
    private:
        int a;
};
 
//子类
class B:public A
{
    public:
        B():A(), b(0){}
        
        B(int aa, int bb):A(aa), b(bb){}
 
        ~B(){}
 
        virtual void print()
        {
            A::print(); //调用基类的print()方法
            cout << "B: " << b << endl;
        }
 
        virtual void printa()
        {
            A::printa();
            cout << "B: " << b << endl;
        }
    private:
        int b;
};
 
int main(void)
{
    A a;
    B b;
    void (A::*ptr)(int) = &A::setA; //定义类成员函数指针
    
    A* pa = &a; //pa指针指向对象a
    
    //对于非虚函数，返回其在内存的真实地址
    cout << "A::set():  " << &A::setA;
    //对于虚函数， 返回其在虚函数表的偏移位置
    cout << "A::print(): " << &A::print;
    cout << "A::printa(): " << &A::printa;
 
    a.print();
    
    a.setA(10);
    a.print();
    
    a.setA(100);
    a.print();	
    
    //对于指向类成员函数的函数指针，引用时必须传入一个类对象的this指针，所以必须由类实体调用
    //(实例对象指针)->*(类成员函数指针名)(待传入的参数)
    (pa->*ptr)(1000);
 
    a.print();
 
    //  (实例对象).*(类成员函数指针名)(待传入的参数)
    (a.*ptr)(10000);
    a.print();
    
    system("pause");
    
    return 0;
}

B) 类成员函数指针指向类中的静态成员函数

对类的静态成员的访问不依赖于对象，可以用普通的指针来指向和访问静态成员

#include <iostream>
using namespace std;
 
class A{
public:
    
    //p1是一个指向非static成员函数的函数指针
    void (A::*p1)(void);
    
    //p2是一个指向static成员函数的函数指针
    void (*p2)(void);
    
    A(){
        /*对
         **指向非static成员函数的指针
         **和
         **指向static成员函数的指针
         **的变量的赋值方式是一样的，都是&ClassName::memberVariable形式
         **区别在于：
         **对p1只能用非static成员函数赋值
         **对p2只能用static成员函数赋值
         **
         **再有，赋值时如果直接&memberVariable，则在VS中报"编译器错误 C2276"
         **参见：http://msdn.microsoft.com/zh-cn/library/850cstw1.aspx
         */
        p1 = &A::funa; //函数指针赋值一定要使用 &
        p2 = &A::funb;
        
        //p1 =&A::funb;//error
        //p2 =&A::funa;//error
        
        //p1=&funa;//error,编译器错误 C2276
        //p2=&funb;//error,编译器错误 C2276
    }
    
    void funa(void){
        puts("A");
    }
    
    static void funb(void){
        puts("B");
    }
};
 
int main()
{
    A a;
    //p是指向A中非static成员函数的函数指针
    void (A::*p)(void);
    
    (a.*a.p1)(); //打印 A
    
    //使用.*(实例对象)或者->*（实例对象指针）调用类成员函数指针所指向的函数
    p = a.p1;
    (a.*p)();//打印 A
    
    A *b = &a;
    (b->*p)(); //打印 A
    
    /*尽管a.p2本身是个非static变量,但是a.p2是指向static函数的函数指针，
     **所以下面这就话是错的!
     */
//    p = a.p2;//error
    
    void (*pp)(void);
    pp = &A::funb;
    pp(); //打印 B
    
    return 0;
}

案例二：通过指针访问类的静态数据成员

#include <iostream>
using namespace std;

class Point {	//Point类定义
public:	//外部接口
	Point(int x = 0, int y = 0) : x(x), y(y) 
    { 
		count++;
	}	
    
	Point(const Point &p) : x(p.x), y(p.y) 
    {
		count++;
	}
    
	~Point() {  count--; }
    
	int getX() const { return x; }
	int getY() const { return y; }
	static int count;
    
private:	//私有数据成员
	int x, y;
};

int Point::count = 0;	//静态成员初始化要在类外进行

int main() {	//主函数实现
  //定义一个int型指针，指向类的静态成员
	int *ptr = &Point::count;	

	Point a(4, 5);	//定义对象a
	cout << "Point A: " << a.getX() << ", " << a.getY();
	cout << " Object count = " << *ptr << endl;	

	Point b(a);	//定义对象b
	cout << "Point B: " << b.getX() << ", " << b.getY();
	cout << " Object count = " << *ptr << endl; 	

    system("pause");
	return 0;
}

案例三：通过指针访问类的静态函数成员

#include <iostream>
using namespace std;

class Point 
{	//Point类定义
public:	//外部接口
	Point(int x = 0, int y = 0) : x(x), y(y){ count++; }
	Point(const Point &p) : x(p.x), y(p.y) { count++; }
	~Point() {  count--; }
    
	int getX() const { return x; }
	int getY() const { return y; }
    
	static void showCount() 
    {
     cout << "  Object count = " << count << endl;
  	}
private:	//私有数据成员
	int x, y;
	static int count;
};
int Point::count = 0;

int main() 
{	//主函数实现
   //定义一个指向函数的指针，指向类的静态成员函数
	void (*funcPtr)() = Point::showCount;

	Point a(4, 5);	//定义对象A
	cout << "Point A: " << a.getX() << ", " << a.getY();
	funcPtr();	//输出对象个数，直接通过指针访问静态函数成员

	Point b(a);	//定义对象B
	cout << "Point B: " << b.getX() << ", " << b.getY();
	funcPtr();	//输出对象个数，直接通过指针访问静态函数成员

    system("pause");
	return 0;
}

总结：

类成员函数指针与普通函数指针不是一码事。前者要用 .* 与 ->* 运算符来使用，而后者可以用 ***** 运算符（称为"解引用"dereference，或称"间址"indirection）。
普通函数指针实际上保存的是函数体的开始地址，因此也称"代码指针"，以区别于 C/C++ 最常用的数据指针。
类成员函数指针就不仅仅是类成员函数的内存起始地址，还需要能解决因为 C++ 的多重继承、虚继承而带来的类实例地址的调整问题，所以类成员函数指针在调用的时候一定要传入类实例对象。

总结2：通过指向成员的指针只能访问公有成员

声明指向成员的指针:
声明指向公有数据成员的指针类型说明符类名::*指针名；
声明指向公有函数成员的指针类型说明符 (类名::*指针名)(参数表)；

指向数据成员的指针,说明指针应该指向哪个成员
指针名 = &类名::数据成员名；
通过对象名（或对象指针）与成员指针结合来访问数据成员：
对象名.*类成员指针名
对象指针名->*类成员指针名

指向函数成员的指针
初始化指针名=&类名::函数成员名；
通过对象名（或对象指针）与成员指针结合来访问函数成员：
(对象名.*类成员指针名)(参数表)
(对象指针名->*类成员指针名)(参数表)

7.8二级指针(指针的指针)

7.8.1 二级指针定义和初始化

**作用：**二级指针，是一种指向指针的指针。我们可以通过它实现间接访问数据，和改变一级指针的指向问题

示例：

int a = 10;
int * pi = a;
//二级指针的定义 
//二级指针ppi存放的是一级指针pi的地址，所以ppi指向pi
int ** ppi = &pi;

cout << a << endl;
cout << *pi << endl;
cout << **ppi << endl;
// ppi存放的是pi的地址； *ppi存放的是pi的值，也就是a的地址；**ppi是a的值

7.8.2 间接数据访问

通过二级指针变量改变一级指针指向

int i = 30;
int *pi = &i;
int ** ppi = &pi;

cout << "*pi = " << *pi << endl; //30
cout << "*ppi = " << **ppi << endl; //30

*pi = 20;
cout << "*pi = " << *pi << endl;  //20
cout << "*ppi = " << **ppi << endl;  //20

// 通过二级指针修改一级指针的指向 
// *ppi存放的是pi值，也就是指向a的地址，现在把它改为b的地址，导致pi指向了b
int b = 10;
*ppi = &b;
cout << "*pi = " << *pi << endl; // 10
cout << "*ppi = " << **ppi << endl; //10

通过以上案例，我们可以发现，通过 n 级指针，可以修改 n - 1 级指针的指向

由于二级指针存放的是一级指针的地址，所以二级指针所占字节也是4个(win32) 或者8个(win64)

通过做函数形参改变一级指针指向

二级指针做函数参数，存放的是一级指针的地址

int find(char *s, char src, char **rt)//从s中查询出src字符所在的位置并在rt中返回。
{
	int i = 0;
	while (*(s + i))
	{
		if (*(s + i) == src)//只会出现一次满足条件，此时将此地址给*rt，即p
		{
			* rt = s + i;//这里修改了p的指向
		}
		i++;
	}
	return 0;
 }
 
 
int main(void)
{
   char a[10] = "zhuyujia";
   char *p=NULL;
   find(a, 'y', &p);//改变p的指向，在子函数中实现
	
   cout << p;
    
   return 0;
}

7.8.3二级指针与指针数组

一级指针与普通数组名等价，通过一级指针能够读取一维数组中的元素

二级指针与一级指针数组名等价，通过二级指针或指一级针数组能够读取二维数组中的元素

一级的指针数组相当于二维普通数组， n级的指针数组相当于 n+1级的普通数组

案例：二维指针与一级指针数组

int main()
{
	char * pArray[] ={"apple","pear","banana","orange","pineApple"};
    
	cout << "**********pArray[i]************" << endl;
	for(int i=0; i<sizeof(pArray)/ sizeof(*pArray); i++)
	{ 
       cout << pArray[i] << endl;
	}
		
	char **pArr = pArray; //二级指针与指针数组名等价
    
	cout << "**********pArr[i]************" << endl;
	for(int i=0; i<sizeof(pArray)/ sizeof(*pArray); i++)
	{
		cout << pArr[i] << endl;
	}
    
	system("pause");
	return 0;
}

7.9指针和类

一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。

与所有的指针一样，必须在使用指针之前，对指针进行初始化。

7.9.1指向类的指针

#include <iostream>
 
using namespace std;

class Box
{
   public:
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2
   Box *ptrBox;   			   // 定义类的指针
    
   // 保存第一个对象的地址
   ptrBox = &Box1;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box1: " << ptrBox->Volume() << endl;

   // 保存第二个对象的地址
   ptrBox = &Box2;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box2: " << ptrBox->Volume() << endl;
  
   return 0;
}

7.9.2 指向类中成员的指针（补充7.7.4）

（1）指向类的成员函数的指针：

类型 (类名:😗 函数成员指针名)(参数表);

函数成员指针名 = &类名::函数成员名;

即：

类型 (类名:😗 函数成员指针名)(参数表) = &类名::函数成员名;

int (CTest:😗 pFunAdd2)(int, int) = &CTest::testAdd;

class CTest
{
public:
	int testAdd(int a, int b) { return a + b; }
public:
	string m_str;
};
//指向类的成员函数的指针
int (CTest::* pFunAdd)(int, int);
pFunAdd = &CTest::testAdd;

cout << pFunAdd;

(2) 指向类的数据成员的指针：

通过指向成员的指针只能访问公有成员，类的数据成员的指针不能指向私有数据成员

string CTest::* str;
str = &CTest::m_str;

类型类名:😗 数据成员指针名;

数据成员指针名 = &类名::数据成员名;

即

类型类名:😗 数据成员指针名 = &类名::数据成员名;

string CTest:😗 str1 = &CTest::m_str;

class CTest
{
public:
	int testAdd(int a, int b) { return a + b; }
public:
	string m_str;
};
int main()
{
    string CTest::* str; //声明指向类的数据成员的指针
    str = &CTest::m_str; 
    
    CTest test;
    CTest* pTest = & test;

    test.*str = "456";
    cout << test.m_str << std::endl;

    string CTest::* str1 = &CTest::m_str;

    pTest->*str1 = "789";
    cout << pTest->m_str << std::endl;
}

7.10 指针和引用

7.10.1 指向引用的指针

没有指向引用的指针!

因为引用不是对象，没有地址

因为引用不是对象，故无引用的数组，无指向引用的指针，无到引用的引用

7.10.2 指针的引用（重点）

指针作为一种变量，在传递参数的时候，指针也是按照值传递的，这样就会导致一个问题，当我们使用值传递的时候，如果我们在函数中修改了指针变量的指向，当函数退出时这种影响不会保留。

如果我们想在一个函数中修改指针的指向，并且在退出函数后这种影响保留，就需要使用指针变量的指针或者指针的引用传递参数。

定义：数据类型* &指针引用名 = 指针变量名 // 初始化指针变量的引用

int v = 1;
int *p = &v; //p指向v的指针
int* &rp = p; // rp是int*类型的引用，应该将指针变量赋给它。rp就是p指针的别名，rp相当于p

案例

struct point 
{
    int x;
    int y;
};

void changenum1(point* &pnum)//point* &pnum表示指向point类型的指针的引用，即point*类型变量的引用 
{ 
    pnum = new point;
    pnum->x = 4;
}

void changenum2(point *pnum)  
{
    pnum = new point;
    pnum->x = 4;
}

void changenum3(point **pnum)  
{
    *pnum = new point;
    (*pnum)->x = 4;
}

void test1()
{
    point *num = new point;
    num->x = 10;
    changenum1(num);
    std::cout << "指针引用" << num->x << endl;
}

void test2() 
{
    point *num = new point;
    num->x = 10;
    changenum2(num);
    std::cout << "指针" << num->x << endl;
}

void test3() 
{
    point *num = new point;
    point **pnum = &num;
    changenum2(pnum);
    std::cout << "指针" << (*pnum)->x << endl;
}

int main() 
{
    cout << "开始执行程序" << endl;
    test1();
    test2();
    test3();
    cout << "执行程序完毕" << endl;
    return 0;
}

总结：

使用指针的引用作为参数我们成功修改了指针变量的指向，而没有使用引用的则没有修改成功。其实使用指向指针的指针也可以达到同样的效果。

注意：没有指向引用的指针，因为引用是原变量的一个别名，指向引用的指针还是指向原来的变量。

总之，普通的变量作为函数的形参，要想通过该形参改变实参的值，要么传入该变量的引用，要么传入指向该变量的指针。指针变量作为函数的形参，要想通过该形参改变实参的值，要么传入该指针变量的引用，要么传入指向该指针变量的指针。

在数据结构中经常会看到指针的引用，例如在下面代码：初始化单链表的操作中，传入的参数就是指针的引用

typedef struct Lnode{
	int data; //结点的数据域
	struct Lnode *next; //结点的指针域
}Lnode,*LinkList; //LinkList为指向结构体LNode的指针类型

//Lnode为单链表的结点，LinkList为指向结点LNode的指针（LNode*与LinkList等价，这样使用是为了更好地区分链表与结点）
//给这个结构定义了一个别名:LNode，一个指针的别名:LinkList;
//LNode a; 等价于 struct node a;
//都是声明一个struct node结构体类型的结构体变量 a;
//LinkList b; 等价于 struct LNode *b;等价于 LNode *b;

//L为指向头结点的头指针
bool InitList_L(LinkList &L){//构造一个空的单链表L
    L=new Lnode;     //生成新结点作为头结点，用头指针L指向头结点
	if(!L)
		return false;  //生成结点失败
	L->next=NULL;   //头结点的指针域置空
	return true;
}

7.11 指针和字符串

c语言存放字符串的方式是存放字符串的首地址

在C语言中，字符串实际上是一个字符数组，其每个元素都是一个字符。在定义一个字符串时，我们通常使用一个字符数组来存储它们。这个字符数组的第一个元素的地址就是该字符串的首地址。

所以可以说，字符串的首地址代表着整个字符串的起始位置。也就是说，通过获取字符串首地址，我们可以访问该字符串中的所有元素。

需要注意的是，在使用C语言中的一些函数（比如printf()、puts()等）时，传递给它们的参数如果是指向字符串的指针，则默认输出指针所指向字符串的内容。因为这些函数内部会自动取出该指针所指向字符串的首地址，并以该地址为起点输出整个字符串。

字符数组和字符串指针常量区别

字符数组：栈上创建

字符串指针常量：

没有使用malloc，常量区（data）创建。相当于const char *
使用malloc，堆区创建

//下列条件成立的前提是在 VS 平台
//编译器在 栈上 创建一个字符串str1，将“hi”从常量区复制到 str1，这样的话修改str[0] 就是修改一个局部变量
//str1数组名为首元素的地址
//初始化列表中初值个数少于数组元素个数：其余元素自动赋值为空格符ASCII为32（空格符!=空字符，ASCII为0）
char str1[] = {'h', 'i', '\0'}; //变量，可读可写
str1[0] = 's'; //用 “''”修改元素
cout << str1 << endl;

//str2 和 str1的区别：str1不会自动添加“\0”, 而 str2会自动添加 “\0”,str3结尾也没有 “\0”
//为str2和str3分配空间时：必须用 strlen(str2/str3) + 1,预留一个空间给 “\0”
char str2[] = "hi"; //变量，可读可写 字符末尾存在一个‘\0’结尾符
cout << sizeof(str2) << endl; //3 包括 “\0”
cout << strlen(str2) << endl; //2 不包括 “\0”





//str3 直接指向 常量区 ，即str3里面存放的是“hi”在常量区的地址。结尾也没有‘\0’（.data区）
//编译器将"hi"分配到常量区（即：静态数据区），在程序执行结束时自动释放
//常量区的内容（hi）不能被更改，所以用指针修改常量区的值 str3[0] = 's' 是错误的.会发生  l-value specifies const object(左值说明是一个常量对象)  的编译错误。如果非要更改，可采取下述方式
char *str3 = "hi"; //常量 只读 等同于 const char *str3 = "hi"
str3[0] ='s'; //错误 
cout << str3 << endl;

char *str3;
str3 = (char *)malloc(6 *sizeof(char)); //必须先分配空间才能赋值。需要考虑‘\0’占用的空间
strcpy(str3, "hello");
*str3='c';
cout << str3; //可以修改，str3指向的是堆区的一块空间，hi保存在堆区，是可以修改其的值的

char *str4 = {'h', 'i', '\0'}; //错误

当字符串（字符数组）作为函数参数时，不需要提供两个参数。因为每个字符串都有 ‘\0’；‘\0’ 即为函数结束的标志

    char a[] = "abcdef";
    char b[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    char *c = "abcdef";
    cout << sizeof(a) << endl; //7 包含结束符
    cout << sizeof(b) << endl; //6 不包含结束符
    cout << sizeof(c) << endl; //8 算的是指针所占用地址空间

void test()
{
	//在vs下，相同的字符串常量，共享。都指向了常量区的同一块地址空间
	char *p1 = "hello"; //返回的是字符串的首地址， p1指向了常量区中的字符串。
	char *p2 = "hello";
	char *p3 = "hello";
	printf("%d\n", p1);
	printf("%d\n", p2);
	printf("%d\n", p3);
}

void test2()
{
	//在 vs 下，字符串常量是不可以修改的
	char *p1 = "hello";//不可以修改，常量区中的值不能被修改
	
	char p1[] = "hello"; //可以修改。 p1的值为 hello。将常量区的值复制给了p1
	p1[0] = 'x';
	printf("%s\n", p);
}

尽量不要修改字符串常量

不同厂商对字符串常量的修改，字符串常量在内存中的存储有着不同的规定

7. 11.1 字符指针

#include <stdio.h>
int main()
{
	char str[] = "hello world";
	char *p = str;
	*p = 'm';
	p++;
	*p = 'i';
	printf("%s\n", str);
	p = "mike jiang";
	printf("%s\n", p);
	char *q = "test";
	printf("%s\n", q);
	return 0;
}

7.11.2 字符指针做函数参数

当字符串（字符数组）作为函数参数时，不需要提供两个参数。因为每个字符串都有 ‘\0’；‘\0’ 即为函数结束的标志

案例：实现字符串的拼接

#include <stdio.h>
void mystrcat(char *dest, const char *src)
{
	int len1 = 0;
	int len2 = 0;
	while (dest[len1]) //遇到 \0, 说明以经到了字符串结尾，\0 的ASCII码值为 0， 退出while循环
	{
		len1++;
	}
	while (src[len2])
	{
		len2++;
	}
	int i;
	for (i = 0; i < len2; i++)
	{
		dest[len1 + i] = src[i];
	}
}
int main()
{
	char dst[100] = "hello mike";
	char src[] = "123456";
	mystrcat(dst, src);
	printf("dst = %s\n", dst);
	return 0;
}

/*
字符串拷贝：
		while(*dest++  = *src++){};
*/

7.11.3 const 修饰的指针变量(7.5)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
	//const 修饰一个变量为只读。定义时必须初始化
	const int a = 10;
	//a = 100; //err
	//指针变量， 指针指向的内存， 2 个不同概念
	char buf[] = "aklgjdlsgjlkds";
    
	//从左往右看，跳过类型，看修饰哪个字符
	//如果是*， 说明指针指向的内存不能改变
	//如果是指针变量，说明指针的指向不能改变，指针的值不能修改
    
	const char *p = buf; //字符串名字即字符串的首地址
	// 等价于上面 char const *p1 = buf;
	//p[1] = '2'; //err
	p = "agdlsjaglkdsajgl"; //ok
    
	char * const p2 = buf;
	p2[1] = '3';
	//p2 = "salkjgldsjaglk"; //err
    
	//p3 为只读，指向不能变，指向的内存也不能变
	const char * const p3 = buf;
	return 0;
}

7.11.4 指针数组做为 main 函数的形参

int main(int argc, char *argv[]);

main 函数是操作系统调用的，第一个参数标明 argc 数组的成员数量，argv数组的每个成员都是 char *类型
argv 是命令行参数的字符串数组
argc 代表命令行参数的数量，程序名字本身算一个参数

#include <stdio.h>
//argc: 传参数的个数（包含可执行程序）
//argv：指针数组，指向输入的参数
int main(int argc, char *argv[])
{
	//指针数组，它是数组，每个元素都是指针
	char *a[] = { "aaaaaaa", "bbbbbbbbbb", "ccccccc" };
	int i = 0;
    
	printf("argc = %d\n", argc);
    
	for (i = 0; i < argc; i++){
	printf("%s\n", argv[i]);
	}
    
	return 0;
}

测试1：在Linux环境下，使用gcc编译生成可执行文件，如test

test.exe abc xyz zhangsan ni chousha

测试2：在VS中。项目名称上 --》右键 --》属性 --》调试 --》命令行参数 --》将 test.exe abc xyz zhangsan nichousha 写入

VS快捷导入代码：

VS --》工具 --》代码片段管理器 --》Visual C++

7.11.5 字符串处理函数（见2.6）

strcpy/strncpy

1. strcpy()

会自动添加结尾符

#include <string.h>
char *strcpy(char *dest, const char *src);
功能：把 src 所指向的字符串复制到 dest 所指向的空间中，'\0'也会拷贝过去
参数：
dest：目的字符串首地址
src：源字符首地址
返回值：
成功：返回 dest 字符串的首地址
失败：NULL

注意：如果参数 dest 所指的内存空间不够大，可能会造成缓冲溢出的错误情况

char dest[20] = "123456789";
char src[] = "hello world";
strcpy(dest, src); //数组名退化为指针
printf("%s\n", dest);

2. strncpy

不会自动添加结尾符

#include <string.h>
char *strncpy(char *dest, const char *src, size_t n);
功能：把 src 指向字符串的前 n 个字符复制到 dest 所指向的空间中，是否拷贝结束符看指定的长度是否包含'\0'。
参数：
	dest：目的字符串首地址
	src：源字符首地址
	n：指定需要拷贝字符串个数
返回值：
	成功：返回 dest 字符串的首地址
	失败：NULL

案例：

char dest[20] ;
char src[] = "hello world";
strncpy(dest, src, 5);
printf("%s\n", dest);
dest[5] = '\0';
printf("%s\n", dest);

strcat/strncat

1.strcat

#include <string.h>
char *strcat(char *dest, const char *src);
功能：将 src 字符串连接到 dest 的尾部，‘\0’也会追加过去
参数：
dest：目的字符串首地址
src：源字符首地址
返回值：
成功：返回 dest 字符串的首地址
失败：NULL

char str[20] = "123";
char *src = "hello world";
printf("%s\n", strcat(str, src));

2. strncat

#include <string.h>
char *strncat(char *dest, const char *src, size_t n);
功能：将 src 字符串前 n 个字符连接到 dest 的尾部，‘\0’也会追加过去
参数：
dest：目的字符串首地址
src：源字符首地址
n：指定需要追加字符串个数
返回值：
成功：返回 dest 字符串的首地址
失败：NULL

char str[20] = "123";
char *src = "hello world";
printf("%s\n", strncat(str, src, 5));

strcmp/strncmp

1. strcmp

#include <string.h>
int strcmp(const char *s1, const char *s2);
功能：比较 s1 和 s2 的大小，比较的是字符 ASCII 码大小。
参数：
s1：字符串 1 首地址
s2：字符串 2 首地址
返回值：
相等：0
大于：>0 在不同操作系统 strcmp 结果会不同 返回 ASCII 差值
小于：<0

//字符串常量的比较 不能直接 str1 > str2，这种比较的是 str1 和 str2 的地址，需使用系统提供的库函数strcmp
char *str1 = "hello world";
char *str2 = "hello mike";
if (strcmp(str1, str2) == 0){
	printf("str1==str2\n");
}else if (strcmp(str1, str2) > 0){
	printf("str1>str2\n");
}else{
	printf("str1<str2\n");
}

// 使用 == 比较两字符串，不仅仅比较内容，更比较地址
char str1[] = "abc";
char str2[] = "abc"; // str1 == str2 false

const char str1[] = "abc";
const char str2[] = "abc"; // str1 == str2 false

char* str1 = "abc";
char* str2 = "abc";
const char* str3 = "abc";
const char* str4 = "abc"; //str1 == str2 == str3 == str4 true 常量区

2. strncmp

#include <string.h>
int strncmp(const char *s1, const char *s2, size_t n);
功能：比较 s1 和 s2 前 n 个字符的大小，比较的是字符 ASCII 码大小。
参数：
s1：字符串 1 首地址
s2：字符串 2 首地址
n：指定比较字符串的数量
返回值：
相等：0
大于： > 0
小于： < 0

char *str1 = "hello world";
char *str2 = "hello mike";
if (strncmp(str1, str2, 5) == 0)
{
	printf("str1==str2\n");
}
else if (strcmp(str1, "hello world") > 0)
{
	printf("str1>str2\n");
}
else
{
	printf("str1<str2\n");
}

sprintf/sscanf

1. sprintf

#include <stdio.h>
int sprintf(char *str, const char *format, ...);
功能：根据参数 format 字符串来转换并格式化数据，然后将结果输出到 str 指定的空间中，
直到出现字符串结束符 '\0' 为止。
参数：
str：字符串首地址
format：字符串格式，用法和 printf()一样
返回值：
成功：实际格式化的字符个数
失败： - 1

int main()
{
    printf("%d%c%d=%d\n",10, '+', 34, 10+34);
    
    //sprintf
    char buf[100] = {0}; //buffer 缓冲区
    //将其格式化输出到 buf 缓冲区 上
    sprintf(buf, "%d%c%d=%d\n",10, '+', 34, 10+34);
    
    //打印缓冲区中的内容
    puts(buf);
    
    return 0;
}

2. sscanf

#include <stdio.h>
int sscanf(const char *str, const char *format, ...);
功能：从 str 指定的字符串读取数据，并根据参数 format 字符串来转换并格式化数据。
参数：
str：指定的字符串首地址
format：字符串格式，用法和 scanf()一样
返回值：
成功：参数数目，成功转换的值的个数
失败： - 1

int a;
int b;

char src[] = "a=10, b=20";
sscanf(src, "a=%d, b=%d", &a, &b); //数据来源于 src，而scanf中数据来源于从屏幕的输入
printf("a:%d, b:%d\n", a, b);

格式	作用
%s 或 %d	跳过数据（字符串/整数）
%[width]s	读指定宽度的数据
%[a-z]	匹配 a - z 中任意字符（尽可能多的匹配）
%[aBc]	匹配 a B c中的一员（尽可能多的匹配）
%[^a]	匹配非 a 的任意字符（尽可能多的匹配）
%[^a-z]	表示读取除 a - z 以外的所有字符

void test01()
{
    char * str = "abcd1234";
    char buf[1024] = {0};
    
    sscanf(str, "%*[a-z]s", buf); // 同%*[a-z]%s
    //sscanf(str, "%[^a-z]s", buf); 
    
    printf("%s\n", buf);
}

void test02()
{
    char * str = "abcd1234";
    char buf[1024] = {0};
    
    sscanf(str, "%6s", buf);
    
    printf("%s\n", buf);
}

void test03()
{
    char * str = "12345abcdeaaa";
    char buf[1024] = {0};
    
    sscanf(str, "%*d%[a-c]", buf); //只要匹配失败了，就不继续匹配了
    printf("%s\n", str);
}

void test4()
{
    char * str = "abcdef#zhangtao@123456";
    char buf[1024] = {0};
    sscanf(str, "%*[^#]#%[^@]", buf);
    
    printf("%s\n", buf);
}

strchr/strstr

1. strchr

#include <string.h>
char *strchr(const char *s, int c);
功能：在字符串 s 中查找字母 c 出现的位置
参数：
s：字符串首地址
c：匹配字母(字符)
返回值：
成功：返回第一次出现的 c 地址
失败：NULL

char src[] = "ddda123abcd";
char *p = strchr(src, 'a');
printf("p = %s\n", p);

prinf("%s\n", strchr("hehehahahoho", 'a')); ---> "ahahoho"

//返回 ‘a'所在的下标
printf("%d\n", p - src);

strrchr

自右向左，在字符串str 中找到第一个字符出现的位置。返回字符串中的地址。

prinf("%s\n", strchr("hehehahahoho", 'a')); ---> "ahoho"

2.strstr

、#include <string.h>
char *strstr(const char *haystack, const char *needle);
功能：在字符串 haystack 中查找字符串 needle 出现的位置
参数：
haystack：源字符串首地址
needle：匹配字符串首地址
返回值：
成功：返回第一次出现的 needle 地址
失败：NULL

char src[] = "ddddabcd123abcd333abcd";
char *p = strstr(src, "abcd");
printf("p = %s\n", p);

例题：

求字串出现的次数

int str_time(char *str, char *substr)

{
	int count = 0;
	char *p = strstr(str, substr);
	while(p != NULL)
	{
		count ++;
		p += strlen(substr);
		p = strstr(p, substr);
	}
	return count;
}

屏蔽禁语

int main()
{
    char buf[1024] = {0}; 
    
    fgets(buf, sizeof(buf), stdin);
    //将 buf中的 \n 改为 \0
    buf[strlen(buf) - 1] = '\0';
    
    char *p = buf; //创建临时变量，遍历字符串
    while(1)
    {
        //上单，你真sb sb， sb
        char *ret  = strstr(p, "sb");
        if(ret != NULL)
        {
            //找到禁语
            strcpy(p, "**", 2);
            p = ret + 2;
        }
        else
        {
            break;
        }
    }
    
    printf("%s\n", buf);
}

strtok 字符串分割

#include <string.h>
char *strtok(char *str, const char *delim);
功能：来将字符串分割成一个个片段。当 strtok()在参数 s 的字符串中发现参数 delim 中包含
的分割字符时, 则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0。
参数：
str：指向欲分割的字符串
delim：为分割字符串中包含的所有字符
返回值：
成功：分割后字符串首地址
失败：NULL
拆分：将分割字符用 '\0'替换

在第一次调用时：strtok()必需给予参数 s 字符串
往后的调用则将参数 s 设置成 NULL，每次调用成功则返回指向被分割出片段的指针

strtok拆分字符串是直接在原串上操作，所以要求参数 1 必须可读可写（char * str = "asfa"不行，因为str是常量）

char a[100] = "adc*fvcv*ebcy*hghbdfg*casdert";

char *s = strtok(a, "*");//将"*"分割的子串取出
while (s != NULL)
{
	printf("%s\n", s);
	s = strtok(NULL, "*");  //固定用法
}

拆分 “www.itcast.cn $T hi s i s a s t r t o k$ test”
```
char str[] =  "www.itcast.cn$This is a strtok$test";
char *p = strtok(str, "$ .");
whiel(p != NULL)
{
	p = strtok(NULL, " .$");
	printf("p= %s\n", p);
}
```

后面一般用正则表达式进行字符串的分割

atoi 字符串转整形

使用这类函数进行转换，要求：原串必须是可转换的字符串

#include <stdlib.h>
int atoi(const char *nptr);
功能：atoi()会扫描 nptr 字符串，跳过前面的空格字符，直到遇到数字或正负号才开始做转
换，而遇到非数字或字符串结束符('\0')才结束转换，并将结果返回返回值。
参数：
nptr：待转换的字符串
返回值：成功转换后整数

类似的函数有：

atof()：把一个小数形式的字符串转化为一个浮点数。

atol()：将一个字符串转化为 long 类型

char str1[] = "-10";
int num1 = atoi(str1);
printf("num1 = %d\n", num1);
char str2[] = "0.123bac321";
double num2 = atof(str2);
printf("num2 = %lf\n", num2);

字符（char）转整形（int）

char c = '6'; //字符型 c = '6'
int num = c - '0'; //转换结果：num = 6

大写字母转小写字母 +32；

小写字母转大写字母 -32；(a 97 A 65)

整型（int）转字符型（char）

int num = 5; //整型 num = 5
char c = num + '0'; //转换结果：字符型 c = '5'

整型（int）转字符串型（string）

#include <string> //需要引入string头文件

//基本数据类型均可转换
int num = 123456
string str = to_string(num); //转换为字符串 str = "123456"

7.12 一级指针易错点

指针越界

void test()
{
	char buf[8] = "zhangtao"; //长度不够，没有空间存放\0。会越界一直访问，直到找到\0才结束
	printf("buf: %s\n", buf);
}

返回局部变量的地址

char *getString()
{
	char str[] = "abcdefg"; //栈区
	printf("getString - str = %s\n", str);
	return str;
}

void test()
{
	char* str = getString();
	printf("test - str = %s\n", str);  //VS提供一次保留
    printf("test - str = %s\n", str);
}

同一块内存释放多次

不可以重复释放野指针，可以重复释放空指针

void test()
{
	char *p = (char *)malloc(sizeof(char) * 64);
    //free()函数的功能只是告诉系统 p 指向的内存可以回收了
	// 就是说，p 指向的内存使用权交还给系统
	//但是，p 的值还是原来的值(野指针)，p 还是指向原来的内存，尽管该内存已经被释放
	free(p); //p所指向的空间被释放，p现在是一个野指针
	free(p); //报错 野指针不能被重复释放。空指针可以重复释放
	
	p = NULL;
	free(p); //空指针可以重复释放
	free(p);
}

释放偏移后的地址

void test()
{
    char *p = (char *)malloc(sizeof(char) * 64);
    
    //解决方法：char *pp = p;
    for(int i = 0; i < 10; i++)
    {
    	*p = i + 97;  //*pp = i +97;
        printf("%c", *p); //printf("%c", *pp);
        p++; //pp++;
    }
    
    if(p != NULL)
    {
    	free(p); //err
        p = NULL;
    }
}

7.13指针、数组、函数

**案例描述：**封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

示例：

//冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			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() {

	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int len = sizeof(arr) / sizeof(int);

	bubbleSort(arr, len);

	printArray(arr, len);

	system("pause");

	return 0;
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

8 结构体

8.1 结构体基本概念

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

8.2 结构体定义和使用

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

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

struct 结构体名变量名
struct 结构体名变量名 = { 成员1值，成员2值…}
定义结构体时顺便创建变量

匿名结构体。只能使用一次，后面就无法通过这个结构体创建新的结构体变量了

// 匿名结构体。 后面就无法通过这个结构体创建新的结构体变量了
struct
{
    char name[64];
    int age;
}myPerson = {"b"}; // myPerson 是结构体变量

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名 
	int age;      //年龄
	int score;    //分数
}stu3; //结构体变量创建方式3 


int main() {

	//结构体变量创建方式1
	struct student stu1; //struct 关键字可以省略

	stu1.name = "张三"; 
	stu1.age = 18;
	stu1.score = 100;
	
	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

	//结构体变量创建方式2
	struct student stu2 = { "李四",19,60 };

	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;


	stu3.name = "王五";
	stu3.age = 18;
	stu3.score = 80;
	

	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;

	system("pause");

	return 0;
}

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

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

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

c语言中结构体中不能有函数，不能对结构体中的属性赋初始值

8.3 结构体数组

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

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

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}

int main() {
	
	//结构体数组
	struct student arr[3]=
	{
		{"张三",18,80 },
		{"李四",19,60 },
		{"王五",20,70 }
	};

	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
	}

	system("pause");

	return 0;
}

8.4 结构体和指针

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

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

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名  还有这两种定义 char *name; char name[]; 注意区分
	int age;      //年龄
	int score;    //分数
};

/*
	使用 char * name; 初始化该类型对象时，VS报错：类型不匹配。
	而使用 char name[]; 可以通过struct student stu = { "张三",18,100, };直接赋值。但是该值不能被修改
*/


int main() {
	
	struct student stu = { "张三",18,100, }; //这里的 “张三”是常量，保存在常量区
	
    //p为指向普通结构体的指针
	struct student * p = &stu; 
    
    // struct student *p1 = (struct student*)malloc(sizeof(struct student)) 
    //使用这种方法，p1为指向堆中结构体变量的指针，操作完成后记得要 free(p1)， p1 = NULL;
	
    p -> name = "李白";
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	
	system("pause");

	return 0;
}

总结：结构体指针可以通过 -> 操作符来访问结构体中的成员

8.4.2 结构体套一级指针，堆区创建结构体

见核心篇内存管理第2章第4节第5小节

#include<stdio.h>
#include <string.h>
#include <stdlib.h>
//结构体类型的定义
struct stu
{
	char *name; //只有name 指向堆区，才能够修改name 的值。否则的话 name 指向常量区，给该类型对象的name属性初始化后就不能更改了
	int age;
};

int main()
{
	struct stu *p = NULL;
    //在堆区创建结构体
	p = (struct stu *)malloc(sizeof(struct stu));
    
    //赋值操作
	p->name = malloc(strlen("test") + 1); // p-> name 指向堆中的一块内存
	strcpy(p->name, "test"); // "test"在常量区，通过 strcpy 函数拷贝将其拷贝到 p-> name 所指向内存
	p->age = 22;
    
    //输出
	printf("p->name = %s, p->age=%d\n", p->name, p->age);
	printf("(*p).name = %s, (*p).age=%d\n", (*p).name, (*p).age);
    
    
    //释放内存
    //先释放成员指针
	if (p->name != NULL)
	{
		free(p->name);
		p->name = NULL;
	}
    
    //后释放结构体指针	
	if (p != NULL)
	{
		free(p);
		p = NULL;
	}
	return 0;
}

8.5 结构体嵌套结构体

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

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

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//教师结构体定义
struct teacher
{
    //成员列表
	int id; //职工编号
	string name;  //教师姓名
	int age;   //教师年龄
	struct student stu; //子结构体 学生
};


int main() {

	struct teacher t1;
	t1.id = 10000;
	t1.name = "老王";
	t1.age = 40;

	t1.stu.name = "张三";
	t1.stu.age = 18;
	t1.stu.score = 100;

	cout << "教师 职工编号： " << t1.id << " 姓名： " << t1.name << " 年龄： " << t1.age << endl;
	
	cout << "辅导学员 姓名： " << t1.stu.name << " 年龄：" << t1.stu.age << " 考试分数： " << t1.stu.score << endl;

	system("pause");

	return 0;
}

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

8.6 结构体做函数参数

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

传递方式有两种：

值传递
地址传递

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//值传递  结构体普通变量做函数参数
void printStudent(student stu )
{
	stu.age = 28;
	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}

//地址传递  结构体指针变量做函数参数，
//有点：1.节省资源（使用指针 student *stu）2.防止误操作（加const关键字 const student *stu）
void printStudent2(student *stu)
{
	stu->age = 28;
	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}

int main() {

	student stu = { "张三",18,100};
	//值传递
	printStudent(stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;

	cout << endl;

	//地址传递
	printStudent2(&stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;

	system("pause");

	return 0;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递(指针或者&变量名)

结构体数组名做函数参数

#include<stdio.h>
//结构体类型的定义
struct stu
{
	char name[50];   //c语言用 strcpy(s.name, "张三")为 该属性赋值
	int age;
};
//void set_stu_pro(struct stu tmp[100], int n)
//void set_stu_pro(struct stu tmp[], int n)
void set_stu_pro(struct stu *tmp, int n)
{
	int i = 0;
	for (i = 0; i < n; i++)
	{
	sprintf(tmp->name, "name%d%d%d", i, i, i);
	tmp->age = 20 + i;
	tmp++;
	}
}
int main()
{
	struct stu s[3] = { 0 };
	int i = 0;
	int n = sizeof(s) / sizeof(s[0]);
	set_stu_pro(s, n); //数组名传递
	for (i = 0; i < n; i++)
	{
	printf("%s, %d\n", s[i].name, s[i].age);
	}
	return 0;
}

8.7 结构体中 const使用场景

**作用：**用const来防止误操作

**示例：**const 修饰结构体指针

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//const使用场景
void printStudent(const student *stu) //加const防止函数体中的误操作
{
	//stu->age = 100; //操作失败，因为加了const修饰
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;

}

int main() {

	student stu = { "张三",18,100 };

	printStudent(&stu);

	system("pause");

	return 0;
}

注意 const student *stu 和 student * const stu的区别

const student *stu stu所指向的结构体对象的属性值不可以改变，但 stu 的指向可以改变

student * const stu stu 的指向不可以改变，但stu所指向的结构体对象的属性值可以改变

8.8 结构体案例

8.8.1 案例1

案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生数据。

示例：

struct Student
{
	string name;
	int score;
};
struct Teacher
{
	string name;
	Student sArray[5];
};

void allocateSpace(Teacher tArray[] , int len)
{
	string tName = "教师";
	string sName = "学生";
	string nameSeed = "ABCDE";
	for (int i = 0; i < len; i++)
	{
		tArray[i].name = tName + nameSeed[i];
		
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].name = sName + nameSeed[j];
			tArray[i].sArray[j].score = rand() % 61 + 40;
		}
	}
}

void printTeachers(Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << tArray[i].name << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}

int main() {

	srand((unsigned int)time(NULL)); //随机数种子 头文件 #include <ctime>

	Teacher tArray[3]; //老师数组

	int len = sizeof(tArray) / sizeof(Teacher);

	allocateSpace(tArray, len); //创建数据

	printTeachers(tArray, len); //打印数据
	
	system("pause");

	return 0;
}

8.8.2 案例2

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄信息如下：

		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},

示例：

//英雄结构体
struct hero
{
	string name;
	int age;
	string sex;
};
//冒泡排序
void bubbleSort(hero arr[] , int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j].age > arr[j + 1].age)
			{
				hero temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
//打印数组
void printHeros(hero arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名： " << arr[i].name << " 性别： " << arr[i].sex << " 年龄： " << arr[i].age << endl;
	}
}

int main() {

	struct hero arr[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};

	int len = sizeof(arr) / sizeof(hero); //获取数组元素个数

	bubbleSort(arr, len); //排序

	printHeros(arr, len); //打印

	system("pause");

	return 0;
}

8.9 结构体的深拷贝和浅拷贝

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct Person
{
	char* name;
	int age;
};

int main()
{
	struct Person p1;
	p1.name = (char*)malloc(sizeof(char) * 64);
	strcpy(p1.name, "Tom");
	p1.age = 18;

	struct Person p2;
	p2.name = (char*)malloc(sizeof(char) * 168);
	strcpy(p2.name, "Jerry");
	p2.age = 19;

	p1 = p2; //进行浅拷贝，p1 和 p2指向的是同一块内存，释放了同一块内存两次

    /*
    通过深拷贝，解决上述问题
	if (p1.name != NULL)
	{
		free(p1.name);
		p1.name = NULL;
	}
	p1.name = (char*)malloc(strlen(p2.name) + 1);
	strcpy(p1.name, p2.name);
	p1.age = p2.age;
	*/

    printf("p1 姓名：%s  年龄：%d\n", p1.name, p1.age);
	printf("p2姓名：%s  年龄：%d\n", p2.name, p2.age);
    
	if (p1.name != NULL) 
	{
		free(p1.name);
		p1.name = NULL;
	}
	if (p2.name != NULL)
	{
		free(p2.name);
		p2.name = NULL;
	}


	return 0;
}

8.10 结构体的偏移量

通过 offset() 函数（头文件 <stddef.h>）可以得到结构体中某个元素的偏移量（相对于首地址的距离）

struct Person
{
    char a; // 0 ~ 3
    int b; // 4 ~ 7
};

void test01()
{
    struct Person p;
    int offset1 = offsetof(struct Person, b); //获取 b 的偏移量 (需要 #include <stddef.h>)
    int offset2 = (int)&p.b - (int)&p;  //获取 b 的偏移量

    printf("offset = %d\n", offset1);
    printf("offset = %d\n", offset2);
}

void test02()
{
    struct Person p1 = { 'a', 10 };

    printf("p1.b 的值为：%d\n", *(int*)((char*)&p1 + offsetof(struct Person, b)));
    printf("p1.bp1.b 的值为：%d\n", *(int*)((int*)&p1 + 1)); // *((int*)&p + 1)
}

//结构体嵌套结构体 
struct Person2
{
    char a;
    int b;
    struct Person c;
};

void test03()
{
    struct Person2 p = { 'a', 10, {'b', 20} };
    printf("p.c.b = %d\n", p.c.b);

    int offset1 = offsetof(struct Person2, c);
    int offset2 = offsetof(struct Person, b);

    printf("p.c.b = %d\n", *(int*)((char*)&p + offset1 + offset2));
    printf("p.c.b = %d\n", ((struct Person*)((char*)&p + offset1))->b);
}

8.11 结构体内存对齐

内存中最小单位为字节

在用 sizeof 运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。

从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列，而不是简单地顺序排列，这就是内存对齐

内存对齐的原因

某些平台只能在特定的地址处访问特定类型的数据。
提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个 int 型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要 2 个读取周期读取该变量。

如果没有内存对齐，为了访问一个变量，cpu可能必须进行二次读取，否则得不到完整的数据

有了内存对齐，可以提高操作系统访问内存的效率（以空间换时间）

对于内置数据类型：数据放在自身数据类型大小的整数倍地址即可

对于自定义数据类型：有一套对齐规则

结构体对齐计算规则

第一个属性：从偏移量 0 位置开始存储
第二个属性开始，放在 min{该属性数据类型的大小，对齐模数} 的整数倍上

整体计算完毕后算总大小，结构体总大小必须是 min{该结构体中最大数据类型的大小，对齐模数} 的整数倍，不足要补齐（该结构体中最大数据类型的大小：如果是嵌套结构体，则找子结构中最大数据类型）

#pragma pack(show) //查看对齐模数，在VS的生成程序时的 “错误列表”
// #pragma pack(1)  //修改对齐模数，可以是 2 的 n 次方
struct Student
{
    int a; // 0 ~ 3
    char b;  // 4 ~ 7 (5 ~ 7 的空间因为内存对齐而浪费掉了)
    double c; // 8 ~ 15
    float d;  // 16 ~ 19
};

//结构体嵌套结构体，按照子结构体最大类型计算
struct Person
{
  char a; // 0 ~ 7 
  struct Student b; // b 中最大数据类型为 double， 故 b 存放的位置为 8 的整数倍， 即 8 ~ 31
  double c; // 32 ~ 39
};

int main()
{
    printf("sizeof Student = %d\n", sizeof(struct Student)); //24
    printf("sizeof Person = %d\n", sizeof(struct Person));
    
    return 0;
}

#prama pack(show)可以查看对齐模数

默认情况下，数据成员的对齐规则(以最大的类型字节为单位)。

当然，字节对齐可以通过程序控制，采用指令：

#pragma pack(xx)
#pragma pack(1) //1 字节对齐
#pragma pack(2) //2 字节对齐
#pragma pack(4) //4 字节对齐
#pragma pack(8) //8 字节对齐
#pragma pack(16) //16 字节对齐

9 共用体(联合体)

联合 union 是一个能在同一个存储空间存储不同类型数据的类型；
联合体所占的内存长度等于其最长成员的长度倍数，也有叫做共用体；
同一内存段可以用来存放几种不同类型的成员，但每一瞬时只有一种起作用；
共用体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有的成员的值会被覆盖；
共用体变量的地址和它的各成员的地址都是同一地址

#include <stdio.h>
//共用体也叫联合体
union Test
{
	unsigned char a;  // 1 Byte(8 bits)
	unsigned int b;   
	unsigned short c; // 2 Bytes(16 bits)
};
int main()
{
	//定义共用体变量
	union Test tmp;
    
	//1、所有成员的首地址是一样的
	printf("%p, %p, %p\n", &(tmp.a), &(tmp.b), &(tmp.c));
    
	//2、共用体大小为最大成员类型的大小
	printf("%lu\n", sizeof(union Test));
    
	//3、一个成员赋值，会影响另外的成员
	//左边是高位，右边是低位
	//低位放低地址，高位放高地址 (高)0x44332211 (低) -->内存中：(低) 11 22 33 44 (高)（小端表示）
	tmp.b = 0x44332211;
	printf("%x\n", tmp.a); //11
	printf("%x\n", tmp.c); //2211
    
	tmp.a = 0x00;
	printf("short: %x\n", tmp.c); //2200
	printf("int: %x\n", tmp.b); //44332200
   	printf("%#x\n", tmp.a + tmp.b + tmp.c);	//44334400
    
    
    
    tmp.a = 10;
    tmp.b = 20;
  	tmp.c = 30;
    printf("%d\n", tmp.a + tmp.b + tmp.c); //90
    
	return 0;
}

10 c语言中的枚举

枚举：将变量的值一一列举出来，变量的值只限于列举出来的值的范围内。

枚举类型定义：

enum 枚举名

{

枚举值表

};

在枚举值表中应列出所有可用值，也称为枚举元素。
枚举值是常量，不能在程序中用赋值语句再对它赋值。
枚举元素本身由系统定义了一个表示序号的数值从 0 开始顺序定义为 0，1，2 …

#include <stdio.h>
enum weekday //weekday可以省略，枚举值可以赋值，并在程序其他位置直接使用
{
	sun = 2, mon, tue, wed, thu, fri, sat //sun = 2 则 mon = 3 tue = 4 依次递增
} ;

enum bool
{
	flase, true
};

int main()
{
	enum weekday a, b, c;
	a = sun;
	b = mon;
	c = tue;
	printf("%d,%d,%d\n", a, b, c);
    printf("%d\n", sun);
    
	enum bool flag;
	flag = true;
	if (flag == 1)
	{
		printf("flag 为真\n");
	}
    else
    {
    	printf("flag 为假\n");    
    }
    
	return 0;
}

11 typedef 关键字

typedef 为 C 语言的关键字，作用是为一种数据类型(基本类型或自定义数据类型)定义一个新名字，不能创建新类型。

与#define 不同，typedef 仅限于数据类型，而不是能是表达式或具体的值
#define 发生在预处理，typedef 发生在编译阶段

#include <stdio.h>
typedef int INT;
typedef char BYTE;
typedef BYTE T_BYTE;
typedef unsigned char UBYTE;
typedef struct type
{
	UBYTE a;
	INT b;
	T_BYTE c;
}TYPE, *PTYPE;

int main()
{
	TYPE t;
	t.a = 254;
	t.b = 10;
	t.c = 'c';
	PTYPE p = &t;
	printf("%u, %d, %c\n", p->a, p->b, p->c);
	return 0;
}

补充

1. 用 freopen 重定向输入

调试程序时，每次运行程序都要输入测试数据，太麻烦。

可以将测试数据存入文件，然后用 freopen 将输入由键盘重定向为文件，则运行程序时不再需要输入数据了（在提交程序时要把 freopen 语句注释掉)

int main()
{
    //这里用双斜杠是为了转义字符
    // r 文件打开的模式。 r -> 只读  w -> 写
    // stdin 默认从键盘读取数据，stdout默认输出数据到电脑屏幕
    freopen("c:\\tmp\\test.txt", "r", stdin);
    //此后所有输入来自文件 c:\tmp\test.txt
    int n, mx = 0;
    while(cin > n)
    {
        if(n > mx)
        {
            mx = n;
        }
    }
    cout << mx;
    
    return 0;
}

2. c语言中的格式化输出,读取

十进制 %d 八进制：%#o 十六进制：%#x(%#X)

无符号：%u %lu %llu %o %x

有符号：%d %ld %lld %f %lf

scanf(“%d”, &a);

3. const和 #define

由于 const 定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define 一样给出的是立即数，

所以，const 定义的常量在程序运行过程中只有一份拷贝，而#define 定义的常量在内存中有若干个拷贝

#define STRING "abcdefghijklmn" 
const char string[]="ABCDEFGHIJK";
printf(STRING); //为 STRING 分配了第一次内存
printf(string); //为 string 一次分配了内存，以后不再分配

printf(STRING); //为 STRING 分配了第二次内存
printf(string);

#define 和const

前者是宏替换，后者是语句。所以后者以 ; 结尾
前者在预处理时进行宏替换。后者定义的变量值变量改变
const常量有数据类型，宏常量没有数据类型。编译器对前者进行类型安全检查，对后者不进行类型安全检查
用const修饰的变量的值不能改变，所以必须在定义时初始化
可以把常量赋值给非常量变量

可以把const常量的地址赋值给指针变量

// c语言中允许这种隐式转换
const int i = 10;
int *p = &i;

// c++中会出现 cannot convert from 'const int *' to 'int *' 编译错误，需要用强制类型转换
int *p = (int *)&i;

vs2019常见操作

1. VS中的4996错误

微软在 VS2013 中不建议再使用 C 的传统库函数 scanf,strcpy,sprintf等，所以直接使用这些库函数会提示 C4996 错误

VS 建议采用带_s 的函数，如 scanf_s、strcpy_s，但这些并不是标准 C 函数。要想继续使用此函数，需要在源文件中添加以下指令就可以避免这个错误提示：

#define _CRT_SECURE_NO_WARNINGS //这个宏定义最好要放到.c 文件的第一行
#pragma warning(disable:4996) //或者使用这个

2. 更改启动项目

右键解决方案 ----> 属性 ----->点击 ”启动项目“ ----> 选择 ”当前选定内容“

常用快捷键

ctrl + shift + / 注释、取消注释

林深归海

关注

19
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
C++基础入门

黑马c++笔记
复制链接

扫一扫

专栏目录