c++面向过程笔记

1 C++初识

1.2 注释

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

两种格式

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

1.3 变量

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

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

示例：

int main() {
	int a = 10;
	cout << "a = " << a << endl;
	return 0;
}

1.4 常量

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

C++定义常量两种方式

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

示例：

//1、宏常量
#define day 7

int main() {

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

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

补充：
预处理命令：以#开头
宏定义：
而宏只是符号代换，不存在值传递

无参宏

#define M 5

下面所有的M会用5替换，叫做宏展开
2. 有参宏

#define COUNT(M) M * M

不仅会替换，还会
这看上去用法与函数调用类似，但实际上是有很大差别的:

#define COUNT(M) M * M               //定义有参宏
int x = 6;
printf("COUNT = %d\n", COUNT(x + 1));// 输出结果： COUNT = 13
//被替换为COUNT(x + 1 * x + 1)，
//解决办法则是：尽量用括号把整个替换文本及其中的每个参数括起来：
// #define COUNT(M) ((M) * (M))  
printf("COUNT = %d\n", COUNT(++x));  // 输出结果： COUNT = 56     
//这种没法解决，最好不要在宏定义用这个玩意

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

1.6 标识符命名规则

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

2 数据类型

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

typedef关键字

用户为一个已定义的类型赋予一个新的数据类型名

typedef long long LL;

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关键字可以统计数据类型所占内存大小

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

示例：

int main() {

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

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

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

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

	return 0;
}

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;
	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;
	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 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

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

2.6 字符串型

作用：用于表示一串字符

两种风格

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

示例：
```
	char str1[] = "hello world";
	cout << str1 << endl;
```

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

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

示例：
```
	string str = "hello world";
	cout << str << endl;
```

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

2.7 布尔类型 bool

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

bool类型只有两个值：

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

2.8 枚举类型

enum <类型名> {<枚举常量表>};
这个类型名就像结构体的名字一样

编译系统为每个枚举常量指定一个整数值，默认状态下，这个整数就是所列举元素的序号，序号从0开始。可以在定义枚举类型时为部分或全部枚举常量指定整数值，在指定值之前的枚举常量仍按默认方式取值，而指定值之后的枚举常量按依次加1的原则取值。

enum fruit_set {apple, orange, banana=1, peach, grape}
//枚举常量apple=0,orange=1, banana=1,peach=2,grape=3。

枚举常量只能以标识符(变量名）形式表示，而不能是整型、字符型等文字常量

类型名可省

enum {Sun,Mon,Tue,Wed,Thu,Fri,Sat} weekday1, weekday2;
weekday1=Sun;//可以这样赋值

输出是整数

enum fruit_set {apple, orange, banana=1, peach, grape};  
int main() {  
    fruit_set f;  
    f=orange;  
    cout<<f;//1  
    return 0;  
}

3 运算符

左值：能够出现在赋值运算符左边的分量
左值代表着一个可以存放数据的存储空间
左值是能够变化的值

右值：能够出现在赋值运算符右边的分量

一般都从左往右算（左结合）
可以连续运算的单目运算符!、赋值运算符、条件运算符从右向左依次计算
(j=i=66)++
i=66,j=i,j++

单目运算符(只有一个操作数a)
包括赋值运算符（=）、算术运算符（$+ 、-、*、/$）、逻辑运算符（|| 、&& 、！）、位逻辑运算符（& 、| 、^ 、~）、位移运算符（>>、<<）、关系运算符（> 、< 、$==$）、自增自减运算符（++ 、--)

自增自减运算符的对象不能是常量和表达式

双目运算符（两个操作数，比如a+b）
三目（条件）运算符

单目运算符优先于双目运算符
乘除膜优先于加减

3.1 算术运算符

作用：用于处理四则运算

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

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10 + 5	15
-	减	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 5	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;
！重点

在除法运算中，除数不能为0
整数除以整数 20/3 的结果仍为整数（甩掉小数部分），而整数除以浮点数20/3.0的结果则为浮点数。
只有整型变量可以进行取模运算
负数取模!!!

对于 a%n
a = nq + r  |r| < |a|
假设 q 是 a、b 相除得到的商(quotient)，r 是相应的余数(remainder)

我们知道商 q = a/n，从而得出
r = a - (a/n) * n
而 (a/n) 这个结果取决于上面几种方式用哪个

区分前缀加和后缀加

int a=3;
a+=a++*a
/* 
计算a++*a，即3*3=9 
计算a+=9，即a=3+9=12 
计算a++，即a=12+1=13
*/
a+=++a*a
/*
计算++a的值，该表达式值为4
计算(++a)*a，即4*4=16
计算a+=16，即a=4+16=20
*/

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;

复合(默认等号右边是一个整体，自动加了括号)
i*=j-1
相当于
i=i*(j-1)

运算是从右向左
a=b=j-1
相当于 b=j-1,a=b

3.3 比较运算符

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

比较运算符有以下符号：

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

3.4 逻辑运算符

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

逻辑运算符有以下符号：

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

总结：逻辑与运算符总结：全1为1

逻辑或运算符总结：有1为1

优先级：！> && > ||

!x<0 && y>1 || y<0
等同于 
( ((!x)<0) && (y>1) ) || (y<0)

短路

()&&()&&()&&()&&()……
第一个括号如果为假，后面就直接不算了，返回假
()||()||()||……
第一个括号如果为真，后面就直接不算了，返回真

int i=3,j=5;
int c = i>j&&j++&&i++;
结果c=0,i=3,j=5

int i=3,j=5;
int c = i>j&&j++||i++;

i > j：比较 i 是否大于 j，结果为假（0）。
j++：后缀自增，先使用 j 的值进行运算，然后再将 j 的值加 1。此时 j 的值仍为 5，但会在后续语句中自增。
i > j && j++：根据逻辑与运算符的短路规则，由于第一个操作数 i > j 的结果为假（0），则不再执行后续的 j++ 自增操作。整个表达式的结果为假（0）。
i++：后缀自增，先使用 i 的值进行运算，然后再将 i 的值加 1。此时 i 的值为 3，但会在后续语句中自增

位运算符

符号	描述	运算规则
&	与	全1才1
\|	或	有1则1
^	异或	不同为1
~	取反	0变1，1变0
<<	左移	各二进位全部左移若干位，高位丢弃，低位补0
>>	右移	各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移）

注意！
$x<<y = x*2^y$

~优先于<<和>>优先于&优先于^优先于|

条件运算符

也叫三目运算符
<表达式1> ? <表达式2> : <表达式3>
计算表达式1，如果非0则计算表达式2，如果为0则计算表达式3

最低优先级的3个运算符
条件运算符>赋值运算符>逗号运算符

逗号运算符
从左往右逐个计算表达式
它的值为最后一个表达式的值

已知a、b为整形变量，表达式a=2,b=3,a++,++b,a=b++的值是 4
最后一个表达式是a=4

4 程序流程结构

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

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

4.1 选择结构

4.1.1 if

if语句的三种形式

单行格式if语句

	if(a>1) cout<<a;

多行格式if语句

if(a>1) {
	a=1;
}
else {
	a=0;
}

多条件的if语句

if() {

} else if() {

} else if() {

} else {

}

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

if内是个赋值表达式，那么永远不会执行else部分

if(a=4) {

}
else {

}

4.1.2 三目运算符

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

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

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

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

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

4.1.3 switch语句

(比较清晰，但不能判断区间)
执行多条件分支语句

语法：

switch(表达式){
	case 结果1：执行语句;break;

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

	...

	default:执行语句;break;

}

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

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

    int n=read<int>();
    switch (n)
    {
    case 1:
        cout<<"1"<<endl;
    case 2:
        cout<<"2"<<endl;
    default:
        cout<<"def"<<endl;
        break;
    }

输入1
会输出1，2，def
原理是从上到下找和n的值相同的语句去执行，找到了1进入1去执行，如果没有break就会一直往下继续执行（不再管case后的值）；如果没找到直接执行default
如果把default写在最前面也不影响

    switch (n)
    {
    case 1:
    case 2:
        cout<<"2"<<endl;
        cout<<"1"<<endl;
        break;
    default:
        cout<<"def"<<endl;
        break;
    }

1,2都执行2的语句

4.2 循环结构

4.2.1 while

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

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

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

4.2.2 do...while

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

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

4.2.3 for循环语句

for(表达式1;表达式2;表达式3) { 循环语句; }
运行步骤：

表达式1
表达式2
1. 假，退出for循环
2. 真，进入循环体
运行完循环体后，执行表达式3

4.3 跳转语句

4.3.1 break语句

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

break使用的时机：

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

4.3.2 continue语句

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

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

输出1,5

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

5 数组

5.1 概述

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

数组是由连续的内存位置组成的

5.2 一维数组

定义方式

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

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

示例

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 };
	//一个一个输出太麻烦，因此可以利用循环进行输出
	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;
	}
	return 0;
}

数组名

一维数组名称的用途：

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

示例：

int main() {

	//数组名用途
	//1、可以获取整个数组占用内存空间大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;

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

	//arr = 100; 错误，数组名是常量，因此不可以赋值
	return 0;
}

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

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

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

5.3 二维数组

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

定义方式

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

数据类型数组名[ 行数 ][ 列数 ];
数据类型数组名[ 行数 ][ 列数 ] = { {数据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;
	//方式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 };
	return 0;
}

数组名

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

示例：

int main() {

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

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

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

	//地址
	cout << "二维数组首地址：" << arr << endl;
	cout << "二维数组第一行地址：" << arr[0] << endl;
	cout << "二维数组第二行地址：" << arr[1] << endl;

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

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

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

5.4 一维字符数组与字符串

如果一维字符数组包含字符\0，则该字符之前的数组元素构成字符串
对一维字符数组进行初始化时，下面三种情况为字符串

1.系统自动在结尾加'\0'
char str1[7]="china";//str1[5]='\0'
2.自己手动加
char str2[7]={'c','h','i','n','a','\0'};
3.输入，系统自动在结尾加'\0'
char str3[7];
cin>>str3;

输出

char s[]={'a','b','\0','c'};  
cout<<s;  
//ab
for(int i=0;i<4;i++)
	cout<<s[i];
//ab c

常用函数
#include <cstring>
strlen 求字符串长度，不包括\0
strcat(str1,str2)将字符串str1和str2连接，将连接后
得到的字符串作为函数的返回值

char a[]="hello";  
char b[]="world";  
cout<<strcat(a,b);
//helloworld

strcpy(str1,str2) 将字符串str2赋值给str1

char a[]="hello";  
char b[]="world";  
strcpy(a,b);  
cout<<a;  
//world
char a[]="hello";  
char b[]="hi"; 
strcpy(a,b);  
//a变成了"hi\0lo\0"
cout<<a;
//hi
cout<<a[4];
//o

strcmp(str1,str2) 字符串比较
str1和str2的相同位置的每个字符都相同，而且长度相同，函数返回值为0
否则返回第一个不相同的字符，返回值为整数 str2[i]-str1[i]

string

string str="hello";
字符串变量不包含\0

求字符串长度 str.length()
将字符串str2赋值给str1 str1=str2
连接

string word1 = "hello";
string word2 = "C++";
string word3 = word1 + " " + word2;
cout<<word3<<endl;

比较 s1.compare(s2)
相等则返回0,s1>s2则返回1，s1<s2返回-1
子串，s.substr(开始位置，子串长度)
查找 str.find(s1) 返回值子字符串开始的位置（从0开始）;若查找失败，返回npos，即-1（打印出来为4294967295）
to_string(变量名) 把别的变量变为string类型

6 函数

6.1 函数的作用

实现程序结构的简化
实现程序代码的重用

6.2 函数的定义

函数的定义

属性说明 返回值类型 函数名 （参数列表）{
       函数体
}

返回值类型：一个函数只能返回一个值，但类型可以是数组、结构体……void类型可省略返回值
属性说明：可省略，一般可以是下面的关键字之一
- inline内联函数:因为函数调用会进行控制转移，较耗时间。内联函数在编译时进行内联置换，编译器会用函数体替换函数调用，从而减少了函数调用的开销，节省执行时间,但会扩大其代码空间。【有声明必须在声明处加inline，无声明在定义处加】
- static静态函数
- virtual虚函数
- friend友元函数

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

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "mian中的 a = " << a << endl;
	cout << "mian中的 b = " << b << endl;
	return 0;
}

6.5 参数

可缺省参数(参数的默认值)
允许在函数定义处为其中最后面的连续若干个参数设置默认值(也称缺省值)
在调用处也只能缺省后面的连续若干个实参

void add(int a=1,int b=1){
	cout<<a+b<<endl;
}
int main() {
	add();
	//2
	add(3);
	//4
	add(3,2);
	//5
	add(,1);//这是错误的
	return 0;
}

占位参数 ——省略参数名
形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法： 返回值类型函数名 (数据类型){}

//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
	cout << "this is func" << endl;
}

int main() {
	func(10,10); //占位参数必须填补
	return 0;
}

下面的例子也是正确的

void output(int [2][3]) ;

多维数组做参数

可以写为
int a[][10];
int a[10][10];
不能写为
int a[][];
int a[10][];

6.6 函数的声明

也叫 函数原型

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

函数的声明可以多次，但是函数的定义只能有一次
如果同时存在函数声明和函数定义，函数定义可以出现在函数调用之后;如果只有函数定义，必须出现在调用之前
函数声明的参数表中，参数名可以省略;函数定义的参数表中，必须给出参数名

[<属性说明>]<返回值类型><函数名>([<参数表>]);
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

int main() {

	int a = 100;
	int b = 200;

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

	return 0;
}

函数定义不能出现在任何函数体中，函数原型可以出现在其它函数体中

void printString();//声明
	printString();//调用
	return 0;
}
void printString(){//函数定义
    cout<<"Hello!"<<endl;
	return; 
}

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

	return 0;
}

6.8 函数重载

函数名可以相同，提高复用性

函数重载满足条件：

同一个作用域下
函数名称相同
函数参数类型不同 或者 个数不同 或者 顺序不同

注意: 函数的返回值不可以作为函数重载的条件

void func()
{
	cout << "func 的调用！" << endl;
}
void func(int a)
{
	cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
	cout << "func (double a)的调用！" << endl;
}
void func(int a ,double b)
{
	cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a ,int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
}
int main() {
	func();
	func(10);
	func(3.14);
	func(10,3.14);
	func(3.14 , 10);
	return 0;
}

注意事项

//函数重载注意事项
//1、引用作为重载条件
void func(int &a) {
	cout << "func (int &a) 调用 " << endl;
}
void func(const int &a) {
	cout << "func (const int &a) 调用 " << endl;
}
//2、函数重载碰到函数默认参数
void func2(int a, int b = 10) {
	cout << "func2(int a, int b = 10) 调用" << endl;
}
void func2(int a) {
	cout << "func2(int a) 调用" << endl;
}
int main() {
	int a = 10;
	func(a); //调用无const
	func(10);//调用有const
	//func2(10); //碰到默认参数产生歧义，需要避免
	return 0;
}

6.9 运算符重载

<返回值类型> operator <重载的运算符>(参数表){}

为了区别前缀++和后缀++,后缀++重载函数的原型参数表中增加一个int 型的无名参数

– <类型> operator ++ (<类型>)
– <类型> operator ++ (<类型>,int)

6.10 函数与结构化程序设计

生存期

全局的、静态的、外部的语法实体被分配到全局数据区，生存期为整个程序
局部的(在函数内，语句块内说明的)语法实体被分配到局部数据区(栈区等)，局部语法的生存期从被说明开始，到所在的语句块结束

静态生存期：程序运行结束时消亡。存放在全局数据区，如全局变量、静态全局变量、静态局部变量。未被用户初始化的情况下，系统会自动将其初始化为0
局部生存期：函数或块的结束处消亡。存放在栈区。如果未被初始化，其内容是随机的，不可引用。
动态生存期：（new，malloc），使用delete或free时消亡。存放在自由存储区。

作用域

程序级作用域也称多文件级作用域
文件级作用域也称单文件级作用域
类级作用域
函数级作用域
块级作用域：块指一对大括号括起来的程序段

变量

全局变量：存放在全局数据区，初始化为全0，在定义后的任何位置都是可以访问的
局部变量：定义在函数内或块内，若未初始化，其值为随机数
静态变量：static分为局部静态变量和全局静态变量，也称内部静态变量和外部静态变量
局部静态变量具有局部作用域，但却具有全局生存期（均存储在全局数据区）。静态变量有记忆性。

void fun() {
	int a=1;
	static int b=1;
	cout<<a<<" "<<b<<endl;
	a++;b++;
	cout<<a<<" "<<b<<endl;
}
int main() {
	for(int i=1;i<=3;i++)
		fun();
	return 0;
}
/*
1 1
2 2
1 2(记忆性)
2 3
1 3
2 4
*/

但是，静态变量的记忆性也是有限制的。它们只在其作用域内有效。一旦超出这个作用域，静态变量就无法被访问或修改了。此外，静态变量的初始化通常只能进行一次，即在第一次函数调用时进行，之后即便函数被调用多次，静态变量也不会再次被初始化。
下面这个例子就不满足记忆性：

int mul(int n) {
	static int m=2;
	m*=n;
	return m;
}
int add(int n) {
	static int m;
	m+=n;
	return m;
}
int main(){
	cout<<mul(3)<<",";
	cout<<add(3)<<endl;
	//6,3
	return 0;
}

当函数定义时没给出存储类别时，系统默认它为外部(extern)存储类别,所以实用程序中几乎从不使用extern来说明外部函数
如果不想该程序外的程序访问这个变量，且在该程序内全局可访问，可设置为静态变量。

6.11 函数模板

template<typename T>
T max(T a,T b) {
	return a>b?a:b;
}

函数模板与函数同名,编译器都将首先检查是否存在重载函数，若匹配成功则调用该函数，否则再去匹配函数模板

template <typename type> 
type Min (type a, type b){
	//type型的a与b要能够进行“<”比较运算!
	return (a<b?a:b); 
}
char* Min (char* a, char* b){
	 //函数min，字符串型参数，不能直接使用“<”来进行比较
	return (strcmp(a,b)<0?a:b); 
}
int main() {
	//使用函数模板 
	cout<<Min(3,-10)<<"\n"; 
	cout<<Min(2.5,99.5)<<endl; 
	cout<<Min('m','c')<<endl;
	char* str1="The C program", * str2="The C++ program";
	//使用重载函数!
	cout<<Min(str1, str2)<<endl;
	return 0;
}

7 指针

7.1 指针的基本概念

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

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

指针所占内存空间
32位系统占4字节
本地测试mac占8字节

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

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

7.2 指针变量的定义和使用

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

指针指向首地址，指针的类型来决定解引用(取内容)时取几个字节

示例：

int main() {

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


	int * p1,* p2;//每个都得带*
	
	//2、指针的使用
	//通过*操作指针变量指向的内存(*p=a)
	cout << "*p = " << *p << endl;
	//初始化为空
	int * p=nullptr;
	int * p = NULL;//NULL其实就是0，不推荐这种写法
	return 0;
}

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

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

指针只能赋值为已经分配了内存的变量/nullptr

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

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

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

7.3 指针运算

赋值运算

	int a=5;
	int *p=&a;
	int *q=&a;
	cout<<*p++<<endl;
	//5 指针往后一位
	cout<<*p<<endl;
	//0 

	cout<<(*q)++;
	//5 a这个值+1
	cout<<*q;
	//6

对于类型相同的指针变量，+是没有意义的

7.4 空指针和野指针

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

用途： 初始化指针变量

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

示例1：空指针

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

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

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

示例2：野指针

	//指针变量p指向内存地址编号为0x1100的空间
	int * p;
	//访问野指针报错 
	cout << *p << endl;

避免野指针——每次定义都赋值（不知道的赋nullptr)
malloc

char *str=(char *)malloc(64);//申请内存

free(str);//释放(如果不释放，会导致内存泄露)
str=nullptr;

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

7.5 const修饰指针

const修饰指针有三种情况

const修饰指针 --- 常量指针
const修饰常量 --- 指针常量
const即修饰指针，又修饰常量

示例：

	int a = 10;
	int b = 10;

	//const修饰的是值，指针指向可以改，指针指向的值不可以更改
	const int * 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; //错误

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

7.6 指针和数组

作用： 利用指针访问数组中元素
数组名就是首元素的地址,是指针常量，不能改arr的值（like arr++)
示例：

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

	*(p+2) ~ *(a+2) ~ a[2] ~ p[2] (~等价于)

二维数组

int a[3][4]={};
int *p = a[0];//*p=a是错误的

指向数组的指针

int arr[][2]={1,2,3,4};
int (*p)[2]=arr;//p指向一维整型数组，该数组包含2个整型元素

cout<<*p[1]<<endl;//[]优先级高于*

cout<<*(*(p+1))<<endl;//与前面的等价

cout<<(*p)[1]<<" ~ "<<*((*p)+1)<<endl;


int A[3][4]={0,2,4,6,8,10,12,14,16,18,20,22};
int (*pa)[4];

pa = A;
/*
A ~ &A[0] ~ pa ~

&A ~ &pa

*A ~ A[0] ~ *pa ~ &A[0][0]

*A[0] ~ A[0][0] ~ *(*pa)

*A[i] ~ A[i][0] ~ *(*(pa+i))

*(A[i]+j) ~ A[i][j] ~ *(*(pa+i)+j)
*/

cout<<*A<<" "<<&A[0][0];

指针数组

int a,b,c,d;
int * p1[4]={&a,&b,&c,&d};
int A[2][10];
int * p2[2]={A[0],A[1]};

7.7 字符指针

char a[10]="hello";
cout<<a<<endl;
//hello 
cout<<(int *)a<<endl;
//地址
cout<<*a<<endl;
//h 

char *p=a;
//这里也要注意没有取地址（想成字符数组，数组名就是地址）
cout<<p<<endl;
//hello 
//字符指针输出的是内容，从首地址一直输出到'\0'
cout<<*p;
//h
cout<<("%p\n" , (void*)&a[0]);
//地址

char *str=(char *)malloc(128);
//动态内存

二维

char s[4][6]={"zhang","gao","tang","wang"};

cout<<s[2]<<endl;

//tang

cout<<*s[2];

//t

实现

句子颠倒顺序(字符指针数组)

int main() {
	char *str[5];
	for(int i=0;i<4;i++) {
		str[i]=(char *)malloc(sizeof(char)*128);
		scanf("%s",str[i]);
	}	
	for(int i=3;i>=0;i--) 
		cout<<str[i]<<" ";
	

	return 0;
}
/*
I am a pig
output:
pig a am I
*/

7.8 多重指针

const char * name[]={"zhang","gao","tang","wang"};

const char **p;

p=name+2;

cout<<p<<" "<<name+2<<endl;
//地址

cout<<*p<<" "<<name[2]<<" "<<*(name+2)<<endl;
//tang

cout<<**p<<" "<<*name[2]<<endl;
//t

7.9 指针和函数

指针作函数参数

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

//值传递
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;
	return 0;
}

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

对于函数，这么传就是传地址，会修改数组

void fun(int arr[]) {

}

如果不想修改，可以复制一份再传

指针的引用做函数的参数

void swap(int *&a,int *&b) {
    int *t=a;
    a=b;
    b=t;
}
int main() {
    int a=1,b=2;
    int *pa=&a,*pb=&b;
    swap(pa,pb);
    cout<<*pa<<" "<<*pb;
    return 0;
}```
#### 函数返回指针
注意不能返回局部变量的指针
```c
char * match(char c, char * s) { //找str中第一个c字符出现的位置并返回 
	int i=0;
	while( s[i]!=c && s[i]!='\0' )
		i++;
	if( s[i]==c )
		return (&s[i]); //若找到，返回在s串的地址 else
	else
		return(nullptr); //没找到时返空指针
}

函数指针

void print() {
	printf("hello");
}
int add(int x,int y){
	return x+y;
}
int main() {
	void (*p)();//定义函数指针
	p=print;//这里加不加取地址都对
	p();//~print()

	int (*q)(int ,int );
	q=add;
	cout<<q(1,2);
	return 0;
}

案例描述： 封装一个函数，利用冒泡排序，实现对整型数组的排序(手写sort)

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

bool Less(int a,int b) {
	return a>b?1:0;
}
bool Greater(int a,int b) {
	return a<b?1:0;
}
void sort(int a[],int len,bool (*p)(int ,int )) {
	for(int i=0;i<len-1;i++) {
		for(int j=0;j<len-i-1;j++) {
			if(p(a[j],a[j+1])) {
				swap(a[j],a[j+1]);
			}
		}
	}
}
int main() {
	int a[10]={5,4,9,2,5,3};
	sort(a,6,Greater);
	for(int i=0;i<6;i++)
		cout<<a[i]<<" ";
	return 0;
}

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

8 结构体

8.1 结构体基本概念

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

8.2 结构体定义和使用

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

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

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

示例：

//结构体定义
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;

	return 0;
}

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

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

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

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

	return 0;
}

8.4 结构体指针

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

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

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};


int main() {
	
	struct student stu = { "张三",18,100, };
	
	struct student * p = &stu;
	
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	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;
}

//地址传递
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;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

8.7 结构体中 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);
	
	return 0;
}

9 动态内存分配

new

内存分配

<类型名> *指针名=new <类型名>  //动态变量
int *p=new int(10);//初始化为10
<类型名> *指针名=new <类型名> [元素个数]//一维动态数组

int **array= new int *[m];//二维动态数组
for( int i=0; i<m; i++ ) 
	array[i] = new int [n];

生成一个所给类型的无名动态变量,返回所生成变量的指针
生成一个所给类型的无名动态数组,返回所生成数组的首地址
元素个数可以是变量（与数组区分）

delete

释放内存运算符

delete <指针名> 
delete [] <指针名> // 数组

//二维动态数组释放
for( int i=0; i<m; i++ ) 
	delete [] array[i]; 
delete [] array;

示例

	int *p=new int;
	int *q=new int(5);//生成动态变量并赋初值5
	cout<<*p<<" "<<*q;
	delete p;

	int n;
	cin>>n;
	int *p1=new int[n];//动态数组
	for(int i=0;i<n;i++)
		cin>>*(p1+i);
	for(int i=0;i<n;i++)
		cout<<*(p1+i)<<" ";
	delete []p1;

	//二维动态数组
	int line,column;
	cin>>line>>column;
	int **a=new int*[line];
	for(int i=0;i<line;i++)
		a[i]=new int[column];
	for(int i=0;i<line;i++)
		for(int j=0;j<column;j++)
			cin>>a[i][j];
	for(int i=0;i<line;cout<<"\n",i++)
		for(int j=0;j<column;j++)
			cout<<a[i][j]<<" ";
			
	for(int j=0;j<column;j++) 
		delete []a[j];
	delete []a;

要保护动态变量的地址。
如果变了就释放不了了

	int a=6;
	int *pi=new int;
    pi=&a;
    delete pi;//会报错

malloc

malloc引入头文件#include <cstdlib>
new：此操作符分配的内存空间是在自由存储区；
malloc：申请的内存是在堆空间。

	int n;
	cin>>n;
	char *str=(char *)malloc(sizeof(char *)*n);
	for(int i=0;i<n;i++)
		cin>>*(str+i);
	for(int i=0;i<n;i++)
		cout<<*(str+i);
	free(str);//释放(如果不释放，会导致内存泄露)
	str=nullptr;

malloc（）可能无法获得所需数量的内存。在那种情形下，函数返回空指针，程序终止。

new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。

posted @ 2025-01-13 20:03 AuroraKelsey 阅读(42) 评论(0) 收藏举报

刷新页面返回顶部

Loading

Kelsey's Blog

c++面向过程笔记

1 C++初识

1.2 注释

1.3 变量

1.4 常量

1.5 关键字

1.6 标识符命名规则

2 数据类型

typedef关键字

2.1 整型

2.2 sizeof关键字

2.3 实型（浮点型）

2.4 字符型

2.5 转义字符

2.6 字符串型

2.7 布尔类型 bool

2.8 枚举类型

3 运算符

3.1 算术运算符

3.2 赋值运算符

3.3 比较运算符

3.4 逻辑运算符

位运算符

条件运算符

4 程序流程结构

4.1 选择结构

4.1.1 if

4.1.2 三目运算符

4.1.3 switch语句

4.2 循环结构

4.2.1 while

4.2.2 do...while

4.2.3 for循环语句

4.3 跳转语句

4.3.1 break语句

4.3.2 continue语句

4.3.3 goto语句

5 数组

5.1 概述

5.2 一维数组

定义方式

数组名

5.3 二维数组

定义方式

数组名

5.4 一维字符数组与字符串

string

6 函数

6.1 函数的作用

6.2 函数的定义

6.3 函数的调用

6.4 值传递

6.5 参数

6.6 函数的声明

6.7 函数的分文件编写

6.8 函数重载

6.9 运算符重载

6.10 函数与结构化程序设计

生存期

作用域

变量

6.11 函数模板

7 指针

7.1 指针的基本概念

7.2 指针变量的定义和使用

7.3 指针运算

7.4 空指针和野指针

7.5 const修饰指针

7.6 指针和数组

7.7 字符指针

7.8 多重指针

7.9 指针和函数

指针作函数参数

函数指针

8 结构体

8.1 结构体基本概念

8.2 结构体定义和使用

8.3 结构体数组