C++概述

“c++”中的++来自于c语言中的递增运算符++，该运算符将变量加1。c++起初也叫”c with class”.通过名称表明，c++是对C的扩展，因此c++是c语言的超集，这意味着任何有效的c程序都是有效的c++程序。c++程序可以使用已有的c程序库。

C++程序员知识大全

库是编程模块的集合，可以在程序中调用它们。库对很多常见的编程问题提供了可靠的解决方法，因此可以节省程序员大量的时间和工作量。
$$
c++=c+泛型编程+面向对象
$$
c++融合了3种不同的编程方式:

1. c语言代表的过程性语言.
2. c++在c语言基础上添加的类代表的面向对象语言.
3. c++模板支持的泛型编程。

可移植性和标准

程序是否可移植性有两个问题需要解决。第一是硬件，针对特定硬件编程的程序是不可移植的。第二，语言的实现

为了兼容需要制定标准

新特性标准排序：（时间排序）

1. c++98 已有的c++特性+异常+运行阶段类型识别(RTTI)+模板+标准模板库([[STL]])
2. c++11
3. c++14
4. c++17

对于传统的结构化语言，我们向来没有太多的疑惑，函数调用那么自然而明显，只是从程序的某一个地点调到另一个地点去执行。但是对于面向对象(OO)语言，我们疑惑就会很多。其原因就是c++编译器为我们程序员做了太多隐藏的工作：构造函数，析构函数、虚函数、继承、多态....有时候它为我们合成出一些额外的函数,有时候它又偷偷在我们写的函数里，放进更多的操作。有时候也会给我们的对象里放进一些奇妙的东西，使得我们sizeof的时候结果可我们预期不一样。

简单的c++程序

1
2
3
4
5
6
7
8

#include<iostream>
using namespace std;

int main(){	
	cout << "hello world" << endl;
    //endl--end line表示刷新缓冲区并且换行
	return EXIT_SUCCESS;
}

注意：

c++头文件为什么没有.h？

在c语言中头文件使用扩展名.h,将其作为一种通过名称标识文件类型的简单方式。但是c++得用法改变了，c++头文件没有扩展名。但是有些c语言的头文件被转换为c++的头文件，这些文件被重新命名，丢掉了扩展名.h(使之成为c++风格头文件)，并在文件名称前面加上前缀c(表明来自c语言)。例如c++版本的math.h为cmath.

由于C使用不同的扩展名来表示不同文件类型，因此用一些特殊的扩展名(如hpp或hxx)表示c++的头文件也是可以的，ANSI/IOS标准委员会也认为是可以的，但是关键问题是用哪个比较好，最后一致同意不适用任何扩展名。

using namespace std 是什么?

namespace是指标识符的各种可见范围。命名空间用关键字namespace 来定义。命名空间是C++的一种机制，用来把单个标识符下的大量有逻辑联系的程序实体组合到一起。此标识符作为此组群的名字。

面向过程思想

面向过程是一种以过程为中心的编程思想。

通过分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向过程编程思想的核心：功能分解，自顶向下，逐层细化（程序=[[数据结构]]+[[算法]]）。

面向过程编程语言存在的主要缺点是不符合人的思维习惯，而是要用计算机的思维方式去处理问题，而且面向过程编程语言重用性低，维护困难。

面向对象思想

面向对象编程（Object-Oriented Programming）简称 OOP 技术，是开发计算机应用程序的一种新方法、新思想。过去的面向过程编程常常会导致所有的代码都包含在几个模块中，使程序难以阅读和维护。在做一些修改时常常牵一动百，使以后的开发和维护难以为继。而使用 OOP 技术，常常要使用许多代码模块，每个模块都只提供特定的功能，它们是彼此独立的，这样就增大了代码重用的几率，更加有利于软件的开发、维护和升级。

在面向对象中，**[[算法]]与[[数据结构]]被看做是一个整体，称作对象**，现实世界中任何类的对象都具有一定的属性和操作，也总能用[[数据结构]]与[[算法]]两者合一地来描述，所以可以用下面的等式来定义对象和程序：
$$
对象 = 算法 + 数据结构
$$

$$
程序 = 对象 + 对象 + ……
$$

面向对象编程思想的核心：应对变化，提高复用。

面向对象三大特性

封装特性

把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

类将成员变量和成员函数封装在类的内部，根据需要设置访问权限，通过成员函数管理内部状态。

继承特性

继承所表达的是类之间相关的关系，这种关系使得对象可以继承另外一类对象的特征和能力。

继承的作用：避免公用代码的重复开发，减少代码和数据冗余。

多态特性

多态性可以简单地概括为“一个接口，多种方法”，字面意思为多种形态。程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。

C++对C的扩展

::作用域运算符

1
2
3
4
5
6
7
8

//全局变量
int a = 10;
void test(){
	//局部变量
	int a = 20;
	//全局a被隐藏
	cout << "a:" << a << endl;
}

通常情况下，如果有两个同名变量，一个是全局变量，另一个是局部变量，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。

1
2
3
4
5
6
7
8
9
10

//全局变量
int a = 10;
//1. 局部变量和全局变量同名
void test(){
	int a = 20;
	//打印局部变量a
	cout << "局部变量a:" << a << endl;
	//打印全局变量a
	cout << "全局变量a:" << ::a << endl;
}

这个例子可以看出，作用域运算符可以用来解决局部变量与全局变量的重名问题，即在局部变量的作用域内，可用::对被屏蔽的同名的全局变量进行访问。

无限定名字查找

如果::限定作用符左侧留空，只会在全局命名空间查找；::a

名字控制

创建名字是程序设计过程中一项最基本的活动，当一个项目很大时，它会不可避免地包含大量名字。c++允许我们对名字的产生和名字的可见性进行控制。

我们之前在学习c语言可以通过static关键字来使得名字只得在本编译单元内可见，在c++中我们将通过一种通过命名空间来控制对名字的访问。

C++命名空间(namespace)

作用:解决命名冲突

在c++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突性的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

命名空间使用语法

1. 命名空间用途：解决名称冲突
2. 命名空间下可以存放：变量，函数，结构体，类…
3. 命名空间必须要声明在全局作用域
4. 命名空间可以嵌套命名空间
5. 命名空间是开放的，可以随时将新成员添加到命名空间下
6. 命名空间是可以匿名的

创建一个命名空间:

1
2
3
4
5
6

namespace A{
	int a = 10;
}
namespace B{
	int a = 20;
}

命名空间只能全局范围内定义（以下错误写法）

1
2
3
4
5
6
7
8

void test(){
	namespace A{
		int a = 10;
	}
	namespace B{
		int a = 20;
	}
}

命名空间可嵌套命名空间

1
2
3
4
5
6

namespace A{
	int a = 10;
	namespace B{
		int a = 20;
	}
}

命名空间是开放的，即可以随时把新的成员加入已有的命名空间中

1
2
3
4
5
6
7
8
9

namespace A{
	int a = 10;
}

namespace A{
	void func(){
		cout << "hello namespace!" << endl;
	}
}

声明和实现可分离

1
2
3
4
5
6

#pragma once

namespace MySpace{
	void func1();
	void func2(int param);
}

1
2
3
4
5
6

void MySpace::func1(){
	cout << "MySpace::func1" << endl;
}
void MySpace::func2(int param){
	cout << "MySpace::func2 : " << param << endl;
}

无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于给这个标识符加上了static，使得其可以作为内部连接

1
2
3
4
5
6
7
8
9
10

namespace{
	
	int a = 10;
	void func(){ cout << "hello namespace" << endl; }
}
void test(){
	cout << "a : " << a << endl;
    cout << "a : " << ::a << endl;//这两个都可以访问
	func();
}

命名空间别名

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

namespace veryLongName{
	
	int a = 10;
	void func(){ cout << "hello namespace" << endl; }
}

void test(){
	namespace shortName = veryLongName;
	cout << "veryLongName::a : " << shortName::a << endl;
	veryLongName::func();
	shortName::func();
}

using声明

using声明可使得指定的标识符可用。

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

namespace A{
	int paramA = 20;
	int paramB = 30;
	void funcA(){ cout << "hello funcA" << endl; }
	void funcB(){ cout << "hello funcA" << endl; }
}

void test(){
	//1. 通过命名空间域运算符
	cout << A::paramA << endl;
	A::funcA();
	//2. using声明
	using A::paramA;
	using A::funcA;
	cout << paramA << endl;
	//cout << paramB << endl; //不可直接访问
	funcA();
	//3. 同名冲突
	//int paramA = 20; //相同作用域注意同名冲突
}

using声明碰到函数重载

1
2
3
4
5
6
7
8
9
10
11

namespace A{
	void func(){}
	void func(int x){}
	int  func(int x,int y){}
}
void test(){
	using A::func;
	func();
	func(10);
	func(10, 20);
}

如果命名空间包含一组用相同名字重载的函数，using声明就声明了这个重载函数的所有集合。

using编译指令

using编译指令使整个命名空间标识符可用.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

namespace A{
	int paramA = 20;
	int paramB = 30;
	void funcA(){ cout << "hello funcA" << endl; }
	void funcB(){ cout << "hello funcB" << endl; }
}

void test01(){
	using namespace A;
	cout << paramA << endl;
	cout << paramB << endl;
	funcA();
	funcB();

	//不会产生二义性
	int paramA = 30;
	cout << paramA << endl;
}

namespace B{
	int paramA = 20;
	int paramB = 30;
	void funcA(){ cout << "hello funcA" << endl; }
	void funcB(){ cout << "hello funcB" << endl; }
}

void test02(){
	using namespace A;
	using namespace B;
	//二义性产生，不知道调用A还是B的paramA
	//cout << paramA << endl;
}

理解注意点：

1. using声明和普通声明在一个作用域同时存在，会报错。但using编译指令和普通声明在一个作用域同时存在时，优先普通声明，若不存在普通声明，此时才使用使用的命名空间中的声明。
2. 没有普通声明下，两个using编译指令会报错

注意：使用using声明或using编译指令会增加命名冲突的可能性。也就是说，如果有名称空间，并在代码中使用作用域解析运算符，则不会出现二义性。

我们刚讲的一些东西一开始会觉得难一些，这些东西以后还是挺常用，只要理解了它们的工作机理，使用它们非常简单。

需要记住的关键问题是当引入一个全局的using编译指令时，就为该文件打开了该命名空间，它不会影响任何其他的文件，所以可以在每一个实现文件中调整对命名空间的控制。比如，如果发现某一个实现文件中有太多的using指令而产生的命名冲突，就要对该文件做个简单的改变，通过明确的限定或者using声明来消除名字冲突，这样不需要修改其他的实现文件。

C++对C语言的增强以及扩展

全局变量检测增强

1
2
3
4
5
6
7

int a = 10; //赋值，当做定义
int a; //没有赋值，当做声明

int main(){
	printf("a:%d\n",a);
	return EXIT_SUCCESS;
}

此代码在c++下编译失败,在c下编译通过.

函数检测增强

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//i没有写类型，可以是任意类型
int fun1(i){
	printf("%d\n", i);
	return 0;
}
//i没有写类型，可以是任意类型
int fun2(i){
	printf("%s\n", i);
	return 0;
}
//没有写参数，代表可以传任何类型的实参
int fun3(){ 
	printf("fun33333333333333333\n");
	return 0;
}

//C语言，如果函数没有参数，建议写void，代表没有参数
int fun4(void){
	printf("fun4444444444444\n");
	return 0;
}

g(){
}

int main(){

	fun1(10);
	fun2("abc");
	fun3(1, 2, "abc");
	printf("g = %d\n", g());

	return 0;
}

以上c代码c编译器编译可通过，c++编译器无法编译通过。

• 在C语言中，int fun() 表示返回值为int，接受任意参数的函数，int fun(void) 表示返回值为int的无参函数。(汇编本质并没有区别，编译器也不会报错，都是接受任意参数)
• 在C++ 中，int fun() 和int fun(void) 具有相同的意义，都表示返回值为int的无参函数。

类型转换检测增强

在C++，不同类型的变量一般是不能直接赋值的，需要相应的强转。

1
2
3
4
5
6
7
8
9

typedef enum COLOR{ GREEN, RED, YELLOW } color;
int main(){

	color mycolor = GREEN;
	mycolor = 10;
	printf("mycolor:%d\n", mycolor);
	char* p = malloc(10);
	return EXIT_SUCCESS;
}

以上c代码c编译器编译可通过，c++编译器无法编译通过。

struct增强

• c中定义结构体变量需要加上struct关键字，c++不需要。
• c中的结构体只能定义成员变量，不能定义成员函数。c++即可以定义成员变量，也可以定义成员函数。

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

//1. 结构体中即可以定义成员变量，也可以定义成员函数
struct Student{
	string mName;
	int mAge;
	void setName(string name){ mName = name; }
	void setAge(int age){ mAge = age; }
	void showStudent(){
		cout << "Name:" << mName << " Age:" << mAge << endl;
	}
};

//2. c++中定义结构体变量不需要加struct关键字
void test01(){
	Student student;
	student.setName("John");
	student.setAge(20);
	student.showStudent();
}

bool数据类型扩展

标准c++的bool类型有两种内建的常量true(转换为整数1)和false(转换为整数0)表示状态。这三个名字都是关键字。

• bool类型只有两个值，true(1值)，false(0值)
• bool类型占1个字节大小
• 给bool类型赋值时，非0值会自动转换为true(1),0值会自动转换false(0)

1
2
3
4
5

	void test()
{	cout << sizeof(false) << endl; //为1，//bool类型占一个字节大小
	bool flag = true; // c语言中没有这种类型
	flag = 100; //给bool类型赋值时，非0值会自动转换为true(1),0值会自动转换false(0)
}

三目运算符增强

• c语言三目运算表达式返回值为数据值，为右值，不能赋值。

1
2
3
4
5
6
7

int a = 10;
int b = 20;
printf("ret:%d\n", a > b ? a : b);
//思考一个问题，(a > b ? a : b) 三目运算表达式返回的是什么？

//(a > b ? a : b) = 100;
//返回的是右值

• c++语言三目运算表达式返回值为变量本身(引用)，为左值，可以赋值。

1
2
3
4
5
6
7
8
9
10

int a = 10;
int b = 20;
printf("ret:%d\n", a > b ? a : b);
//思考一个问题，(a > b ? a : b) 三目运算表达式返回的是什么？

cout << "b:" << b << endl;
cout << (a > b ? a : b) << endl;//返回的是20
//返回的是左值，变量的引用
(a > b ? a : b) = 100;//返回的是左值，变量的引用
cout << "b:" << b << endl;

C语言中(a > b ? &a :& b)等价于 C++中(a > b ? a : b)*

[左值和右值概念]

在c++中可以放在赋值操作符左边的是左值，可以放到赋值操作符右面的是右值。

有些变量即可以当左值，也可以当右值。

左值为Lvalue，L代表Location，表示内存可以寻址，可以赋值。

右值为Rvalue，R代表Read,就是可以知道它的值。

比如:int temp = 10; temp在内存中有地址，10没有，但是可以Read到它的值。

理解：

左值引用。编译器对他做的操作是“自动提领”，就是自动加个*操作。所以左值引用更像一个常量指针，int const，它和常量指针唯一的区别就在于他不用每次都让我们自己写了，除此以外真的没什么区别。

1
2
3
4
5
6
7
8

  int a=1;
010913BE  mov     dword ptr [a],1  
   int b=1;
010913C5  mov     dword ptr [b],1  
   int c=a+b;
010913CC  mov     eax,dword ptr [a]  
010913CF  add     eax,dword ptr [b]  
010913D2  mov     dword ptr [c],eax  

在这里a+b就是一个右值，它是活在寄存器里的一个值，他在内存里根本没有存在的位置，你无法对它取地址，这就是个右值。

C/C++中const的区别

C中的const

常量的引进是在c++早期版本中，当时标准C规范正在制定。那时，尽管C委员会决定在C中引入const,但是，他们c中的const理解为”一个不能改变的普通变量”，也就是认为const应该是一个只读变量，既然是变量那么就会给const分配内存，const修饰全局变量时默认是外部链接属性。

1
2

const int arrSize = 10;
int arr[arrSize];

看似是一件合理的编码，但是这将得出一个错误。 因为arrSize占用某块内存，所以C编译器不知道它在编译时的值是多少？

C++中的const

在c++中，一个const不一定创建内存空间，而在c中，一个const总是需要一块内存空间。

在c++中，是否为const常量分配内存空间依赖于如何使用。一般说来，如果一个const仅仅用来把一个名字用一个值代替(就像使用#define一样)，那么该存储局空间就不必创建。

如果存储空间没有分配内存的话，在进行完数据类型检查后，为了代码更加有效，值也许会折叠到代码中。

不过，取一个const地址, 或者把它定义为extern,则会为该const创建内存空间。

在c++中，出现在所有函数之外的const作用于整个文件(也就是说它在该文件外不可见)，默认为内部连接，c++中其他的标识符一般默认为外部连接。

C/C++中const异同总结

链接属性区别

1. C语言默认外部链接（编译前自动加extern）
2. C++默认内部链接（想要外部链接需要手动加extern）

当c语言两个文件中都有const int a的时候，编译器会报重定义的错误。而在c++中，则不会，因为c++中的const默认是内部连接的。如果想让c++中的const具有外部连接，必须显示声明为: extern const int a = 10;

修改区别

1. C语言中const全局部变量直接修改编译失败，间接修改编译通过，但由于存储在只读数据段，运行失败
2. C语言中const局部变量直接修改编译失败。但可以通过指针间接修改。
3. C++中const全局变量与c一样
4. C++中const局部变量直接修改编译失败，若分配了变量内存的话，可以通过指针间接修改，若未分配内存，则指针修改仅仅修改了一个临时内存空间中的值， 对原值不影响。

C++中const分配内存的情况

1. 对于基础数据类型，也就是const int b = 10这种，编译器会把它放到符号表中，不分配内存，当对其取地址时，会分配临时内存。（无法间接修改原值）

   1 2 3 4

   const int b=10; int *p=(int*)&b; *p=20; cout<<"b="<<b<<endl;//显示为10，修改后无变化

2. 使用普通变量初始化const变量（可以间接修改原值）

   1 2 3 4 5

   int a=10; const int b=a; int *p=(int*)&b; *p=20; cout<<"b="<<b<<endl;//修改成功

3. 自定义数据类型（可以间接修改原值）

   1 2 3

   const Person p; Person* pp=(Person*)&p; pp->name="test";//修改成功

当上面未分配const变量内存的情况下，此时该const变量可以作为数组定义括号中的数值

1
2
3
4
5
6

const int a=10;
int c[a];//编译通过

int a=10;
const int b=a;
int c[b];//编译不通过，错误显示：表达式必须含有常量值

在支持c99标准的编译器中，可以使用变量定义数组。(2019VS都不支持完整的C99)

尽量以const替换#define

在旧版本C中，如果想建立一个常量，必须使用预处理器

1

#define MAX 1024;

我们定义的宏MAX从未被编译器看到过，因为在预处理阶段，所有的MAX已经被替换为了1024，于是MAX并没有将其加入到符号表中。但我们使用这个常量获得一个编译错误信息时，可能会带来一些困惑，因为这个信息可能会提到1024，但是并没有提到MAX.如果MAX被定义在一个不是你写的头文件中，你可能并不知道1024代表什么，也许解决这个问题要花费很长时间。

解决办法就是用一个常量替换上面的宏。

const int max= 1024;

const和#define区别总结:

1. const有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查.
2. const有作用域，而#define不重视作用域(虽然#undef A 可卸载宏常量A)，默认定义处到文件结尾.如果定义在指定作用域下有效的常量，那么#define就不能用。

宏常量不可以有命名空间

1
2
3
4
5
6
7
8

namespace MySpace {
#define num 1024
}
void test() {
	//cout << MySpace::NUM << endl; //错误
	//int num = 100; //命名冲突
	cout << num << endl;
}

引用(reference)

引用基本用法

引用是c++对c的重要扩充。在c/c++中指针的作用基本都是一样的，但是c++增加了另外一种给函数传递地址的途径，这就是按引用传递(pass-by-reference)，它也存在于其他一些编程语言中，并不是c++的发明。

1. 变量名实质上是一段连续内存空间的别名，是一个标号(门牌号)
2. 程序中通过变量来申请并命名内存空间
3. 通过变量的名字可以使用存储空间

对一段连续的内存空间只能取一个别名吗？

c++中新增了引用的概念，引用可以作为一个已定义变量的别名。

基本语法:
$$
Type&\ ref = val;
$$
注意事项：

1. &在此不是求地址运算，而是起标识作用。
2. 类型标识符是指目标变量的类型
3. 必须在声明引用变量时进行初始化。
4. 引用初始化之后不能改变。
5. 不能有NULL引用。必须确保引用是和一块合法的存储单元关联。
6. 可以建立对数组的引用。

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

//1. 建立数组引用方法一
typedef int ArrRef[10];
int arr[10];
ArrRef& aRef = arr;
for (int i = 0; i < 10;i ++){
	aRef[i] = i+1;
}
for (int i = 0; i < 10;i++){
	cout << arr[i] << " ";
}
cout << endl;
//2. 建立数组引用方法二
int(&f)[10] = arr;
for (int i = 0; i < 10; i++){
	f[i] = i+10;
}
for (int i = 0; i < 10; i++){
	cout << arr[i] << " ";
}
cout << endl;

函数中的引用

最常见看见引用的地方是在函数参数和返回值中。当引用被用作函数参数的时，在函数内对任何引用的修改，将对还函数外的参数产生改变。当然，可以通过传递一个指针来做相同的事情，但引用具有更清晰的语法。

如果从函数中返回一个引用，必须像从函数中返回一个指针一样对待。当函数返回值时，引用关联的内存一定要存在。

引用做参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//值传递
void ValueSwap(int m,int n){
	int temp = m;
	m = n;
	n = temp;
}
//地址传递
void PointerSwap(int* m,int* n){
	int temp = *m;
	*m = *n;
	*n = temp;
}
//引用传递
void ReferenceSwap(int& m,int& n){
	int temp = m;
	m = n;
	n = temp;
}
void test(){
	int a = 10;
	int b = 20;
	//值传递
	ValueSwap(a, b);
	cout << "a:" << a << " b:" << b << endl;
	//地址传递
	PointerSwap(&a, &b);
	cout << "a:" << a << " b:" << b << endl;
	//引用传递
	ReferenceSwap(a, b);
	cout << "a:" << a << " b:" << b << endl;
}

通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单：

1. 函数调用时传递的实参不必加“&”符
2. 在被调函数中不必在参数前加“*”符

引用作为其它变量的别名而存在，因此在一些场合可以代替指针。C++主张用引用传递取代地址传递的方式，因为引用语法容易且不易出错。

引用做返回值

1. 不能返回局部变量的引用。
2. 函数当左值，必须返回引用。

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

//返回局部变量引用
int& TestFun01(){
	int a = 10; //局部变量
	return a;
}
//返回静态变量引用
int& TestFunc02(){	
	static int a = 20;
	cout << "static int a : " << a << endl;
	return a;
}
int main(){
	//不能返回局部变量的引用
	int& ret01 = TestFun01();
	//如果函数做左值，那么必须返回引用
	TestFunc02();
	TestFunc02() = 100;
	TestFunc02();

	return EXIT_SUCCESS;
}

引用的本质

引用的本质在c++内部实现是一个指针常量.

1

Type& ref = val; // Type* const ref = &val;

c++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同，只是这个过程是编译器内部实现，用户不可见。

原理：

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

//发现是引用，转换为 int* const ref = &a;
void testFunc(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
	int a = 10;
	int& aRef = a; //自动转换为 int* const aRef = &a;这也能说明引用为什么必须初始化
	aRef = 20; //内部发现aRef是引用，自动帮我们转换为: *aRef = 20;
	cout << "a:" << a << endl;
	cout << "aRef:" << aRef << endl;
	testFunc(a);
	return EXIT_SUCCESS;
}

指针引用

在c语言中如果想改变一个指针的指向而不是它所指向的内容，函数声明可能这样:

1

void fun(int**);

给指针变量取一个别名。

1
2

Type* pointer = NULL;  
Type*& = pointer;

对于c++中的引用，语法清晰多了。函数参数变成指针的引用，用不着取得指针的地址。

常量引用

通俗易懂的讲解可参考此篇

1 2 3 4 5 6 7

void print(int& x) { cout << x << endl; } int main() {     print(42);        // 💥 轰！编译器炸了     double pi = 3.14;     print(pi);        // 💥 又炸了！ }

上面的编译器连这么简单的代码都无法编译,意味着引用只能引用左值

常量引用应运而生,常量应用可以引用右值

它解决了两个关键问题：

1. 可以接受右值（如字面量42）
2. 可以接受不同类型（如double转int）

为什么呢？因为：

• const引用允许绑定到临时对象
• 编译器会自动创建临时变量进行类型转换
• 临时对象的生命周期会延长到引用作用域结束

常量引用的定义格式:

1

const Type& ref = val;

常量引用注意：

1. 字面量不能赋给引用，但是可以赋给const引用（编译器自动给创建临时空间）
2. const修饰的引用，不能修改。

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

void test01(){
	int a = 100;
	const int& aRef = a; //此时aRef就是a
	//aRef = 200; 不能修改aRef的值
	a = 200; //OK
	cout << "a:" << a << endl;
	cout << "aRef:" << aRef << endl;
}
void test02(){
	//不能把一个字面量赋给引用
	//int& ref = 100;
	//但是可以把一个字面量赋给常引用（编译器自动给创建临时空间）
	const int& ref = 100; //int temp = 200; const int& ret = temp;
    //常引用可以通过指针间接修改
    int* p=(int*)&ref;
    *p=200;//OK
    //把上面引用的修改流程改成指针参考如下：
    int temp=100;
    const int* const pp=&temp;
    int* ppp=pp;
    *ppp=200;
    
}

[const引用使用场景]

常量引用主要用在函数的形参，尤其是类的拷贝/复制构造函数。

将函数的形参定义为常量引用的好处:

• 引用不产生新的变量，减少形参与实参传递时的开销。
• 由于引用可能导致实参随形参改变而改变，将其定义为常量引用可以消除这种副作用。

1
2
3
4

//const int& param防止函数中意外修改数据
void ShowVal(const int& param){
	cout << "param:" << param << endl;
}

如果希望实参随着形参的改变而改变，那么使用一般的引用，如果不希望实参随着形参改变，那么使用常引用。

对于非常量引用，必须将其绑定到一个具有持久性的左值，而不是一个临时值。这是因为非常量引用是为了能够修改引用的对象，而临时值是没有持久性的，无法被修改。

原因如下:

1. 生命周期问题：临时值是暂时创建的，它们没有持久性，只在表达式求值时存在。一旦表达式结束，临时值就会被销毁。因此，在使用非常量引用时，我们需要确保引用的对象在引用的整个生命周期内是有效的，而不是在临时值消失后引用一个已销毁的对象。
2. 修改限制：非常量引用的目的是允许对引用的对象进行修改。然而，临时值是常量对象，它们的值是不可修改的。因此，将非常量引用绑定到临时值上是没有意义的，因为我们无法通过引用修改临时值。

简单理解:

1 2 3 4 5 6 7 8 9 10 11

//对于这样的函数(常引用参数) int maxProfit(const vector<int>& prices); int res=s.maxProfit(vector<int>({7,1,5,3,6,4})); //↑是允许的 //但是对于这样的函数(非常引用参数) int maxProfit(vector<int>& prices); int res=s.maxProfit(vector<int>({7,1,5,3,6,4}));//不允许 //只能这样: vector<int> prices = {7,1,5,3,6,4}; s.maxProfit(prices);

引用和指针使用场景

• 如果这段关系”可能不存在” → 选指针(T*)
• 如果是”一定要在一起” → 选引用(T&)

虽然可以强行给引用安排一个无效对象(Customer* p = nullptr; Customer& r = *p;),但这样做会把关系搞得一团糟(未定义行为)。要尊重引用的专一本性!

内联函数(inline function)

内联函数的引出

c++从c中继承的一个重要特征就是效率。假如c++的效率明显低于c的效率，那么就会有很大的一批程序员不去使用c++了。

在c中我们经常把一些短并且执行频繁的计算写成宏，而不是函数，这样做的理由是为了执行效率，宏可以避免函数调用的开销，这些都由预处理来完成。

但是在c++出现之后，使用预处理宏会出现两个问题：

• 第一个在c中也会出现，宏看起来像一个函数调用，但是会有隐藏一些难以发现的错误。
• 第二个问题是c++特有的，预处理器不允许访问类的成员，也就是说预处理器宏不能用作类类的成员函数。

1
2
3
4
5
6
7
8
9
10

#define COMPARE(x,y) ((x) < (y) ? (x) : (y))
int Compare(int x,int y){
	return x < y ? x : y;
}
void test02(){
	int a = 1;
	int b = 3;
	//cout << "COMPARE(++a, b):" << COMPARE(++a, b) << endl; // 3 因为展开成了((++a) < (b) ? (++a) : (b)),a自加了两次
	cout << "Compare(int x,int y):" << Compare(++a, b) << endl; //2
}

为了保持预处理宏的效率又增加安全性，而且还能像一般成员函数那样可以在类里访问自如，c++引入了内联函数(inline function).

内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，可以进行参数，返回值类型的安全检查，又可以作为成员函数。

注意: 编译器将会检查函数参数列表使用是否正确，并返回值(进行必要的转换)。这些事预处理器无法完成的。

内联函数基本概念

在c++中，预定义宏的概念是用内联函数来实现的，而内联函数本身也是一个真正的函数。内联函数具有普通函数的所有行为。唯一不同之处在于内联函数会在适当的地方像预定义宏一样展开，所以不需要函数调用的开销。因此应该不使用宏，使用内联函数。

在开启了优化选项后，编译器可能不会为一个内联甚至非内联的函数生成[[C语言入门#栈区（stack）|栈框架(汇编层面的调用栈)]]，编译器可能使用很多优化技术消除这个构造

在普通函数(非成员函数)函数前面加上inline关键字使之成为内联函数。但是必须注意必须函数体和声明结合在一起，否则编译器将它作为普通函数来对待。（即在函数声明和实现同时加入关键字inline才被称为内联）

1
2
3
4
5
6
7
8

//下面不是内联
inline void func(int a);
void func(int a){};
//下面是内联
inline int func(int a){return ++;}
//下面是内联
inline void func(int a);
inline void func(int a){};

内联函数的确占用空间，但是内联函数相对于普通函数的优势只是省去了函数调用时候的压栈，跳转，返回的开销。我们可以理解为内联函数是以空间换时间。

任何在类内部定义的函数自动成为内联函数。

内联函数和编译器

内联函数并不是何时何地都有效，为了理解内联函数何时有效，应该要知道编译器碰到内联函数会怎么处理？

对于任何类型的函数，编译器会将函数类型(包括函数名字，参数类型，返回值类型)放入到符号表中。同样，当编译器看到内联函数，并且对内联函数体进行分析没有发现错误时，也会将内联函数放入符号表。

当调用一个内联函数的时候，编译器首先确保传入参数类型是正确匹配的，或者如果类型不正完全匹配，但是可以将其转换为正确类型，并且返回值在目标表达式里匹配正确类型，或者可以转换为目标类型，内联函数就会直接替换函数调用，这就消除了函数调用的开销。假如内联函数是成员函数，对象this指针也会被放入合适位置。

类型检查和类型转换、包括在合适位置放入对象this指针这些都是预处理器不能完成的。

但是c++内联编译会有一些限制，以下情况编译器可能考虑不会将函数进行内联编译：

• 不能存在任何形式的循环语句
• 不能存在过多的条件判断语句
• 函数体不能过于庞大
• 不能对函数进行取址操作

内联仅仅只是给编译器一个建议，编译器不一定会接受这种建议，如果你没有将函数声明为内联函数，那么编译器也可能将此函数做内联编译。一个好的编译器将会内联小的、简单的函数。

函数的默认参数

c++在声明函数原型的时可为一个或者多个参数指定默认(缺省)的参数值，当函数调用的时候如果没有指定这个值，编译器会自动用默认值代替。

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

void TestFunc01(int a = 10, int b = 20){
	cout << "a + b  = " << a + b << endl;
}
//注意点:
//1. 形参b设置默认参数值，那么后面位置的形参c也需要设置默认参数
void TestFunc02(int a,int b = 10,int c = 10){}
//2. 如果函数声明和函数定义分开，函数声明设置了默认参数，函数定义不能再设置默认参数
//如下情况编译报错
//void TestFunc04(int a,int b = 10,int c = 10);//声明
//void TestFunc04(int a,int b = 10,int c = 10){};//定义
void TestFunc03(int a = 0,int b = 0);
void TestFunc03(int a, int b){}

int main(){
	//1.如果没有传参数，那么使用默认参数
	TestFunc01();
	//2. 如果传一个参数，那么第二个参数使用默认参数
	TestFunc01(100);
	//3. 如果传入两个参数，那么两个参数都使用我们传入的参数
	TestFunc01(100, 200);

	return EXIT_SUCCESS;
}

注意点：

• 函数的默认参数从左向右，如果一个参数设置了默认参数，那么这个参数之后的参数都必须设置默认参数。
• 如果函数声明和函数定义分开写，函数声明和函数定义不能同时设置默认参数（和上面内联知识点正好相反，内联要求声明和定义都要加inline）。

函数的占位参数

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

void TestFunc01(int a,int b,int){
	//函数内部无法使用占位参数
	cout << "a + b = " << a + b << endl;
}
//占位参数也可以设置默认值
void TestFunc02(int a, int b, int = 20){
	//函数内部依旧无法使用占位参数
	cout << "a + b = " << a + b << endl;
}
int main(){

	//错误调用，占位参数也是参数，必须传参数
	//TestFunc01(10,20); 
	//正确调用
	TestFunc01(10,20,30);
	//正确调用
	TestFunc02(10,20);
	//正确调用
	TestFunc02(10, 20, 30);

	return EXIT_SUCCESS;
}

c++在声明函数时，可以设置占位参数。占位参数只有参数类型声明，而没有参数名声明。一般情况下，在函数体内部无法使用占位参数。

**占位符功能作用:**暂时基本没用，什么时候用，在后面我们要讲的操作符重载的后置++要用到这个.

函数重载(overload)

$$
能使名字方便使用，是任何程序设计语言的一个重要特征！
$$

同一个函数名在不同场景下可以具有不同的含义。

在传统c语言中，函数名必须是唯一的，程序中不允许出现同名的函数。在c++中是允许出现同名的函数，这种现象称为函数重载。

函数重载的目的就是为了方便的使用函数名。

函数重载并不复杂，等大家学完就会明白什么时候需要用到他们，以及是如何编译，链接的。

函数重载基本语法

实现函数重载的条件：

• 同一个作用域
• 参数个数不同
• 参数类型不同
• 参数顺序不同

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

//1. 函数重载条件
namespace A{
	void MyFunc(){ cout << "无参数!" << endl; }
	void MyFunc(int a){ cout << "a: " << a << endl; }
	void MyFunc(string b){ cout << "b: " << b << endl; }
	void MyFunc(int a, string b){ cout << "a: " << a << " b:" << b << endl;}
    void MyFunc(string b, int a){cout << "a: " << a << " b:" << b << endl;}
}
//2.返回值不作为函数重载依据
namespace B{
	void MyFunc(string b, int a){}
	//int MyFunc(string b, int a){} //无法重载仅按返回值区分的函数
}

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

void myFunc(int a)
{
	cout<<"myFunc(int a)"<<endl;
}
void myFunc(int& a)
{
	cout<<"myFunc(int a)"<<endl;
}
void myFunc(const int& a)
{
	cout<<"myFunc(int a)"<<endl;
}
void main()
{
    int a=0;
    //myFunc(a);//虽然上面三个函数可以作为重载同时存在，但这里调用会产生二义性，因此会报错。
}

注意: 函数重载和默认参数一起使用，需要额外注意二义性问题的产生。

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

void MyFunc(string b){
	cout << "b: " << b << endl;
}
//函数重载碰上默认参数
void MyFunc(string b, int a = 10){
	cout << "a: " << a << " b:" << b << endl;
}

int main(){
	MyFunc("hello"); //这时，两个函数都能匹配调用，产生二义性，这是尤其要注意的！！！
	return 0;
}

为什么函数返回值不作为重载条件呢？

当编译器能从上下文中确定唯一的函数的时，如int ret = func(),这个当然是没有问题的。然而，我们在编写程序过程中可以忽略他的返回值。那么这个时候,一个函数为

void func(int x);另一个为int func(int x); 当我们直接调用func(10),这个时候编译器就不确定调用那个函数。所以在c++中禁止使用返回值作为重载的条件。

函数重载实现原理

编译器为了实现函数重载，也是默认为我们做了一些幕后的工作，编译器用不同的参数类型来修饰不同的函数名，比如void func(); 编译器可能会将函数名修饰成_func，当编译器碰到void func(int x),编译器可能将函数名修饰为_func_int,当编译器碰到void func(int x,char c),编译器可能会将函数名修饰为_func_int_char我这里使用”可能”这个字眼是因为编译器如何修饰重载的函数名称并没有一个统一的标准，所以不同的编译器可能会产生不同的内部名。

以下三个函数在linux下生成的编译之后的函数名为:

1
2
3
4
5
6

void func(){}
void func(int x){}
void func(int x,char y){}
_Z4funcv //v 代表void,无参数
_Z4funci //i 代表参数为int类型
_Z4funcic //i 代表第一个参数为int类型，第二个参数为char类型

extern “C”浅析

在linux下测试

1
2

c函数: void MyFunc(){} ,被编译成函数: MyFunc
c++函数: void MyFunc(){},被编译成函数: _Z6Myfuncv

通过这个测试，由于c++中需要支持函数重载，所以c和c++中对同一个函数经过编译后生成的函数名是不相同的，这就导致了一个问题，如果在c++中调用一个使用c语言编写模块中的某个函数，那么c++是根据c++的名称修饰方式来查找并链接这个函数，那么就会发生链接错误，以上例，c++中调用MyFunc函数，在链接阶段会去找Z6Myfuncv，结果是没有找到的，因为这个MyFunc函数是c语言编写的，生成的符号是MyFunc。

那么如果我想在c++调用c的函数怎么办？

extern “C”的主要作用就是为了实现c++代码能够调用其他c语言代码。加上extern “C”后，这部分代码编译器按c语言的方式进行编译和链接，而不是按c++的方式。

例如如下情况，C++需要调用c语言函数：

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

//test.h--头文件
void show();//解决方案2：将这句替换为extern "C" void show();

//test.c--c语言源文件
#include "test.h"
#include <stdio.h>
void show()
{
    printf("你好\r\n");
}
//main.cpp--c++源文件
#include <iostream>
using namespace std;
#include "test.h"//解决方案1：将这句替换为extern "C" void show();
void main()
{
    show();//F5报错显示:未解析的外部命令。
}

终极解决方案：

作用：能区分C和C++的调用针对性加或不加extern “C”，并且省去每个函数都要加extern “C”的麻烦

MyModule.h

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

#ifndef MYMODULE_H
#define MYMODULE_H

#include<stdio.h>

#if __cplusplus//这句的意思是"如果是C++引入的话"（这句的目的是为了让该c文件头文件中的函数在C++也能跑起来）
extern "C"{
#endif

	void func1();
	int func2(int a,int b);

#if __cplusplus
}
#endif

#endif

MyModule.c

1
2
3
4
5
6
7
8

#include"MyModule.h"

void func1(){
	printf("hello world!");
}
int func2(int a, int b){
	return a + b;
}

类和对象

C和C++中struct区别

• c语言struct只有变量，而c++语言struct 既有变量，也有函数
• c语言中struct中的成员变量不能赋初值，C++中的struct中的成员变量可以

类的封装

把事物的属性和行为表示出来，那么就可以抽象出来这个事物。

封装:

1. 把变量（属性）和函数（操作）合成一个整体，封装在一个类中
2. 对变量和函数进行访问控制

访问权限

1. 在类的内部(作用域范围内)，没有访问权限之分，所有成员可以相互访问
2. 在类的外部(作用域范围外)，访问权限才有意义：public，private，protected
3. 在类的外部，只有public修饰的成员才能被访问，在没有涉及继承与派生时， private和protected是同等级的，外部不允许访问

[C++中struct和class的区别?]

class默认访问权限为private,struct默认访问权限为public.

尽量将成员变量设置为private

1. 可赋予客户端访问数据的一致性。

如果成员变量不是public，客户端唯一能够访问对象的方法就是通过成员函数。如果类中所有public权限的成员都是函数，客户在访问类成员时只会默认访问函数，不需要考虑访问的成员需不需要添加(),这就省下了许多搔首弄耳的时间。

2. 可细微划分访问控制

使用成员函数可使得我们对变量的控制处理更加精细。如果我们让所有的成员变量为public，每个人都可以读写它。如果我们设置为private，我们可以实现“不准访问”、“只读访问”、“读写访问”，甚至你可以写出“只写访问”。

对象的构造和析构

构造函数和析构函数，这两个函数将会被编译器自动调用，完成对象初始化和对象清理工作。

无论你是否喜欢，对象的初始化和清理工作是编译器强制我们要做的事情，即使你不提供初始化操作和清理操作，编译器也会给你增加默认的操作，只是这个默认初始化操作不会做任何事，所以编写类就应该顺便提供初始化函数。

构造函数和析构函数

构造函数主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

析构函数主要用于对象销毁前系统自动调用，执行一些清理工作(例如成员变量有存堆区指针，那么堆区空间由析构函数中释放最合适了)。

构造函数语法：

• 构造函数函数名和类名相同，没有返回值，不能有void，但可以有参数,可以重载。
• ClassName(){}

析构函数语法：

• 析构函数函数名是在类名前面加”~”组成,没有返回值，不能有void,不能有参数，不能重载。
• ~ClassName(){}

构造函数的分类及调用

• 按参数类型：
  1. 无参构造函数
  2. 有参构造函数
• 按类型分类：
  1. 普通构造函数
  2. 拷贝构造函数(复制构造函数)

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

class Person{
public:
	Person(){
		cout << "no param constructor!" << endl;
		mAge = 0;
	}
	//有参构造函数
	Person(int age){
		cout << "1 param constructor!" << endl;
		mAge = age;
	}
	//拷贝构造函数(复制构造函数) 使用另一个对象初始化本对象
	Person(const Person& person){
		cout << "copy constructor!" << endl;
		mAge = person.mAge;
	}
	//打印年龄
	void PrintPerson(){
		cout << "Age:" << mAge << endl;
	}
private:
	int mAge;
};

无参构造调用方式注意点：（重点）

• 正确方式：Person person1;
• 错误方式：Person person1();//会被误认为是函数声明

引申出来的情况如下:(当使用父类指针指向子类对象的时候)

1
2
3
4
5
6
7

//举个例子:ITestOutput是纯虚类(接口),也是TestOutput的父类
//这样是正确的   
TestOutput testObj;
ITestOutput* i = &testObj;

//这样是错误的
ITestOutput* i = &TestOutput();

有参构造调用方法

1. Person person01(100);
2. Person person02(person01);
3. Person person03 = Person(300);
4. Person person04 = 100;(不推荐)
5. Person person05 = person04;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//1. 无参构造调用方式
void test01(){
	
	//调用无参构造函数
	Person person1; 
	person1.PrintPerson();

	//无参构造函数错误调用方式
	//Person person2();！原因是会被编译器看成返回值为Person的名为person2的函数声明。！
	//person2.PrintPerson();
}
//2. 调用有参构造函数
void test02(){
	
	//第一种 括号法，最常用
	Person person01(100);
	person01.PrintPerson();

	//调用拷贝构造函数
	Person person02(person01);
	person02.PrintPerson();

	//第二种 匿名对象(显示调用构造函数)
	Person(200); //匿名对象，没有名字的对象

	Person person03 = Person(300);
	person03.PrintPerson();

	//注意: 使用匿名对象初始化判断调用哪一个构造函数，要看匿名对象的参数类型
	Person person06(Person(400)); //等价于 Person person06 = Person(400);
	person06.PrintPerson();

	//第三种 =号法 隐式转换
	Person person04 = 100; //Person person04 =  Person(100)
	person04.PrintPerson();

	//调用拷贝构造
	Person person05 = person04; //Person person05 =  Person(person04)
	person05.PrintPerson();
}

[注意事项1]

除了匿名构造外，其他情况析构都是在作用域尾执行。

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

//匿名构造情况
{
	Person(19);//构造函数中打印调用构造函数
	cout<<分割线<<endl;
}
/*以上输出为:
调用构造函数
调用析构函数
分割线
*/
//原因为:编译器看到Person(19);这种情况的时候，执行完构造后会立即调用析构函数。
//其他情况
{
    Person p=Person(19);
    cout<<分割线<<endl;
}
/*以上输出为:
调用构造函数
分割线
调用析构函数
*/

[注意事项2]

b为A的实例化对象,A a = A(b) 和 A(b)的区别？

当A(b) 有变量来接的时候，那么编译器认为他是一个匿名对象，当没有变量来接的时候，编译器认为你A(b) 等价于 A b.

拷贝构造函数初始化匿名对象汇编层面上实际并没有调用拷贝构造函数，而是调用的无参构造函数。（避免这种用法）

1
2

Person p;//正常调用无参构造函数的方法
Person(p);//上下这两行含义完全相等,若上下同时存在会产生编译错误:p重定义

[注意事项3]

不存在参数类实例本身的构造函数，即不存在如下构造函数：

1
2
3
4
5

Person(Person person)
	{
		m_age = person.m_age;
		cout << "Person构造成功" << endl;
	}

报错显示:”Person” 的复制构造函数不能带有 “Person” 类型的参数

从理解上来看，上面代码段中的参数传参为值传递，而在C++中，类对象的值传递本质上调用的就是拷贝构造函数，则会产生一个无限递归，因此必须要报错。(下面调用时机处是对这个理解的更深理解)

析构函数的调用时机

• 对象在栈上，生命周期结束的时候系统会自动调用析构函数。
• 对象在堆上，系统不会自动调用析构函数，必须见到delete。

1. 对象生命周期结束，被销毁时；
2. 主动调用delete ；
3. 对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。

如果是new的对象，即使离开了作用域也会一直存在，必须主动delete，否则只有在结束程序时才会执行析构。(虽然离开了作用域，但用new动态开辟空间的对象是不会析构的，你可以观察任务管理器，看到内存一直在上升。但你在其他地方确无法使用a所开辟的空间，因为a这个指针是保存在栈上的，当离开作用域后就自动析构(或者说自动消失了)，但它所在分配空间是分配在堆上的，只有主动析构或程序结束，才会释放空间，也就是丢失了这块空间的地址，无法操作这块空间了 。)

对不是new的对象的析构函数和return打断点，可以发现是先返回值后调用析构函数。

显示调用析构函数不但不会带来任何好处，还会造成很多奇怪、难以分析的问题

1. 手动析构 == 调用函数
2. 自动析构 == 调用函数同时销毁本身，后一个行为由系统完成，用户不能参与

我们构造对象，往往都是在一段语句体中，比如函数，判断，循环，还有就直接被一对“{}”包含的语句体。这个对象在语句体中被创建，在语句体结束的时候被销毁。问题就在于，这样的对象在生命周期中是存在于栈上的。也就是说，如何管理，是系统完成而程序员不能控制的。所以，即使我们调用了析构，在对象生命周期结束后，系统仍然会再调用一次析构函数，将其在栈上销毁，实现真正的析构。所以，如果我们在析构函数中有清除堆数据的语句，调用两次意味着第二次会试图清理已经被清理过了的，根本不再存在的数据！这是件会导致运行时错误的问题，并且在编译的时候不会告诉你！

显示调用析构带来的后果

1. 显式调用的时候，析构函数相当于的一个普通的成员函数；
2. 编译器隐式调用析构函数，如分配了堆内存，显式调用析构的话引起重复释放堆内存的异常；
3. 把一个对象看作占用了部分栈内存，占用了部分堆内存（如果申请了的话），这样便于理解这个问题，系统隐式调用析构函数的时候，会加入释放栈内存的动作（而堆内存则由用户手工的释放）；用户显式调用析构函数的时候，只是单纯执行析构函数内的语句，不会释放栈内存，也不会摧毁对象。

拷贝构造函数的调用时机

• 对象以值传递的方式传给函数参数
• 函数局部对象以值传递的方式从函数返回(vs debug模式下调用一次拷贝构造，[[qt]]不调用任何构造)
• 用一个对象初始化另一个对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Person{
public:
	Person(){
		cout << "no param contructor!" << endl;
		mAge = 10;
	}
	Person(int age){
		cout << "param constructor!" << endl;
		mAge = age;
	}
	Person(const Person& person){
		cout << "copy constructor!" << endl;
		mAge = person.mAge;
	}
	~Person(){
		cout << "destructor!" << endl;
	}
public:
	int mAge;
};
//1. 旧对象初始化新对象
void main(){

	Person p(10);
	Person p3 = p; // 相当于Person p3 = Person(p);
}

1
2
3
4
5
6
7

//2. 传递的参数是普通对象，函数参数也是普通对象，传递将会调用拷贝构造
void doBussiness(Person p){}

void main(){
	Person p(10);
	doBussiness(p);
}

输出结果:

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

//3. 函数返回局部对象
Person MyBusiness(){
	Person p(10);
	cout << "局部p:" << (int*)&p << endl;
	return p;
}
void main(){
	//vs release、qt下没有调用拷贝构造函数
	//vs debug下调用一次拷贝构造函数
	Person p = MyBusiness();
	cout << "局部p:" << (int*)&p << endl;
}

debug下生成：

release下生成：

[上面结果说明:]

编译器存在一种对返回值的优化技术,RVO(Return Value Optimization).在vs debug模式下并没有进行这种优化，所以函数MyBusiness中创建p对象，调用了一次构造函数，当编译器发现你要返回这个局部的对象时，编译器通过调用拷贝构造生成一个临时Person对象返回，然后调用p的析构函数。

我们从常理来分析的话，这个匿名对象和这个局部的p对象是相同的两个对象，那么如果能直接返回p对象，就会省去一个拷贝构造和一个析构函数的开销，在程序中一个对象的拷贝也是非常耗时的，如果减少这种拷贝和析构的次数，那么从另一个角度来说，也是编译器对程序执行效率上进行了优化。

所以在这里，编译器偷偷帮我们做了一层优化：

当我们这样去调用: Person p = MyBusiness();

编译器偷偷将我们的代码更改为:

1
2
3
4
5
6
7
8
9

 void MyBussiness(Person& _result){
       _result.X:X(); //调用Person默认构造函数
       //.....对_result进行处理
       return;
   }
int main(){
   Person p; //这里只分配空间，不初始化
   MyBussiness(p);
}

理解上就是编译器编译发布版本的时候直接改成了类对象的引用传递

【重点理解】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include"iostream"
using namespace std;

/*
结论1：函数的返回值是一个匿名对象时，会调用匿名对象的拷贝函数
结论2：有关匿名对象的去和留：
如果用匿名对象 初始化 另一个同类型的对象 匿名对象被接收				   不会调用析构函数
如果用匿名对象 赋值给 另一个同类型的对象（已经初始化：默认或者有参数） 匿名对象被析构
*/

class Test06
{
public:
	Test06() {
		a = b = 0;
		cout << "默认构造函数" << endl;
	}

	Test06(int a, int b) {
		this->a = a;
		this->b = b;
		cout << "有参数构造函数" << endl;
	}

	Test06(const Test06& obj) {//拷贝/复制构造函数：用一个对象初始化另一个对象			
		a = obj.a; b = obj.b;
		cout << "拷贝/复制构造函数" << endl;
	}

	~Test06() {
		cout << "析构函数" << endl;
	}
public:
	Test06& operator=(const Test06& obj) {
		a = obj.a; b = obj.b;
		cout << "重载=操作符" << endl;
		return *this;
	}
	void printT() {
		cout << "a = " << a << endl;
		cout << "b = " << b << endl;
	}
protected:
private:
	int a;
	int b;
};

//如果函数返回值是一个对象，建议用对象直接接收
Test06 getTest() {
	Test06 c(1, 2);		//有参构造函数
	return c;			//拷贝构造函数
						//析构c	
}

void objectShow06() {
	//匿名对象被接收，t1不调用默认构造函数 ,不调用析构，节约内存，提高速度
	Test06 t1 = getTest();//t1如何被构造的呢？？？===》函数返回值的拷贝构造

	Test06 t2;		//默认构造函数
	t2 = getTest(); //匿名对象赋值给新对象，析构匿名对象
					//重载=操作符
	t1.printT();
	t2.printT();
	//析构t2
	//析构t1
}

int main() {

	objectShow06();

	system("pause");
	return 0;
}

输出结果为:

构造函数自动生成规则

• 默认情况下，c++编译器至少为我们写的类增加4个函数
  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对类中非静态成员属性简单值拷贝
  4. 赋值运算符重载，operator=()函数。(定义时的=运算符调用的是拷贝构造之外，之后的=运算符调用的都是operator=()函数)
• 如果用户定义拷贝构造函数，c++不会再提供任何默认构造函数
• 如果用户定义了普通构造(非拷贝)，c++不在提供默认无参构造，但是会提供默认拷贝构造

深拷贝和浅拷贝

浅拷贝

同一类型的对象之间可以赋值，使得两个对象的成员变量的值相同，两个对象仍然是独立的两个对象，这种情况被称为浅拷贝.

一般情况下，浅拷贝没有任何副作用，但是当类中有指针，并且指针指向动态分配的内存空间，析构函数做了动态内存释放的处理，会导致内存问题。

深拷贝

当类中有指针，并且此指针有动态分配空间，析构函数做了释放处理，往往需要自定义拷贝构造函数，自行给指针动态分配空间，深拷贝。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class Person{
public:
	Person(char* name,int age){
		pName = (char*)malloc(strlen(name) + 1);
		strcpy(pName,name);
		mAge = age;
	}
	//增加拷贝构造函数
	Person(const Person& person){
		pName = (char*)malloc(strlen(person.pName) + 1);
		strcpy(pName, person.pName);
		mAge = person.mAge;
	}
	~Person(){
		if (pName != NULL){
			free(pName);
		}
	}
private:
	char* pName;
	int mAge;
};

void test(){
	Person p1("Edward",30);
	//用对象p1初始化对象p2,调用c++提供的默认拷贝构造函数
	Person p2 = p1;
}

explicit关键字

c++提供了关键字explicit(字面意思：更清晰的)，禁止通过构造函数的隐式转换方式来构造对象。

• explicit常用于修饰构造函数,防止隐式转化调用构造函数产生的误解。
• 常针对单参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造)而言。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Test
{
public:
	char ch;
	int num=0;
	explicit  Test(char ch)
	{
		this->ch = ch;
		num = 1;
	}
};
void main() {
	//Test test1='b';//这里报错显示：不存在从char转换到Test的适当构造函数。
    Test test1('b');//没问题
}

上面例子可看出：explicit就是禁止用隐式方式来构造对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class Test
{
public:
	char ch;
	int num=0;

	Test(char ch)
	{
		this->ch = ch;
		num = 1;
	}
	Test(int num)
	{
		this->num = num;
		ch = 'a';
	}
};

void main() {
	cout << "...情况" << endl;
	Test test1='b';
	cout << test1.ch <<"  "<< test1.num << endl;
	Test test2=65;
	cout << test2.ch << "  " << test2.num << endl;
	Test test3 ('c');
	cout << test3.ch << "  " << test3.num << endl;
	Test test4 (66);
	cout << test4.ch << "  " << test4.num << endl;
}

各种情况的输出效果：

初始化列表

构造函数和其他函数不同，除了有名字，参数列表，函数体之外还有初始化列表。

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

class Person{
public:
#if 0
	//传统方式初始化
	Person(int a,int b,int c){
		mA = a;
		mB = b;
		mC = c;
	}
#endif
	//初始化列表方式初始化
	Person(int a, int b, int c):mA(a),mB(b),mC(c){}
private:
	int mA;
	int mB;
	int mC;
};

注意：初始化成员列表(参数列表)只能在构造函数使用。

类对象作为成员

在类中定义的数据成员一般都是基本的数据类型。但是类中的成员也可以是对象，叫做对象成员。

C++中对对象的初始化是非常重要的操作，当创建一个对象的时候，c++编译器必须确保调用了所有子对象的构造函数。如果所有的子对象有默认构造函数，编译器可以自动调用他们。但是如果子对象没有默认的构造函数，或者想指定调用某个构造函数怎么办？

那么是否可以在类的构造函数直接调用子类的属性完成初始化呢？但是如果子类的成员属性是私有的，我们是没有办法访问并完成初始化的。

解决办法非常简单：对于子类调用构造函数，c++为此提供了专门的语法，即构造函数初始化列表。

当调用构造函数时，首先按各对象成员在类定义中的顺序（和参数列表的顺序无关）依次调用它们的构造函数，对这些对象初始化，最后再调用本身的函数体。也就是说，先调用对象成员的构造函数，再调用本身的构造函数。

析构函数和构造函数调用顺序相反，先构造，后析构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//汽车类
class Car{
public:
	Car(){
		cout << "Car 默认构造函数!" << endl;
		mName = "大众汽车";
	}
	Car(string name){
		cout << "Car 带参数构造函数!" << endl;
		mName = name;
	}
	~Car(){
		cout << "Car 析构函数!" << endl;
	}
public:
	string mName;
};

//拖拉机
class Tractor{
public:
	Tractor(){
		cout << "Tractor 默认构造函数!" << endl;
		mName = "爬土坡专用拖拉机";
	}
	Tractor(string name){
		cout << "Tractor 带参数构造函数!" << endl;
		mName = name;
	}
	~Tractor(){
		cout << "Tractor 析构函数!" << endl;
	}
public:
	string mName;
};

//人类
class Person{
public:
#if 1
	//类mCar不存在合适的构造函数
	Person(string name){
		mName = name;
	}
#else
	//初始化列表可以指定调用构造函数
	Person(string carName, string tracName, string name) : mTractor(tracName), mCar(carName), mName(name){
		cout << "Person 构造函数!" << endl;
	}
#endif
	
	void GoWorkByCar(){
		cout << mName << "开着" << mCar.mName << "去上班!" << endl;
	}
	void GoWorkByTractor(){
		cout << mName << "开着" << mTractor.mName << "去上班!" << endl;
	}
	~Person(){
		cout << "Person 析构函数!" << endl;
	}
private:
	string mName;
	Car mCar;
	Tractor mTractor;
};

void test(){
	//Person person("宝马", "东风拖拉机", "赵四");
	Person person("刘能");
	person.GoWorkByCar();
	person.GoWorkByTractor();
}

输出结果:

动态对象创建

当创建一个c++对象时会发生两件事:

1. 为对象分配内存
2. 调用构造函数来初始化那块内存

第一步我们能保证实现，需要我们确保第二步一定能发生。c++强迫我们这么做是因为使用未初始化的对象是程序出错的一个重要原因。

C动态分配内存方法

为了在运行时动态分配内存，c在他的标准库中提供了一些函数,malloc以及它的变种calloc和realloc,释放内存的free,这些函数是有效的、但是原始的，需要程序员理解和小心使用。为了使用c的动态内存分配函数在堆上创建一个类的实例，我们必须这样做:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class Person{
public:
	Person(){
		mAge = 20;
		pName = (char*)malloc(strlen("john")+1);
		strcpy(pName, "john");
	}
	void Init(){
		mAge = 20;
		pName = (char*)malloc(strlen("john")+1);
		strcpy(pName, "john");
	}
	void Clean(){
		if (pName != NULL){
			free(pName);
		}
	}
public:
	int mAge;
	char* pName;
};
int main(){

	//分配内存
	Person* person = (Person*)malloc(sizeof(Person));
	if(person == NULL){
		return 0;
	}
	//调用初始化函数
	person->Init();
	//清理对象
	person->Clean();
	//释放person对象
	free(person);

	return EXIT_SUCCESS;
}

问题在于：

1. 程序员必须确定对象的长度。
2. malloc返回一个void指针，c++不允许将void赋值给其他任何指针，必须强转。
3. malloc可能申请内存失败，所以必须判断返回值来确保内存分配成功。
4. 用户在使用对象之前必须记住对他初始化，构造函数不能显示调用初始化(构造函数是由编译器调用)，用户有可能忘记调用初始化函数。

c的动态内存分配函数太复杂，容易令人混淆，是不可接受的，c++中我们推荐使用运算符new 和 delete.

new operator

C++中解决动态内存分配的方案是把创建一个对象所需要的操作都结合在一个称为new的运算符里。当用new创建一个对象时，它就在堆里为对象分配内存并调用构造函数完成初始化。

1
2
3
4
5
6
7

Person* person = new Person;
//相当于:
Person* person = (Person*)malloc(sizeof(Person));
	if(person == NULL){
		return 0;
	}
person->Init(); //构造函数

New操作符能确定在调用构造函数初始化之前内存分配是成功的，所有不用显式确定调用是否成功。

现在我们发现在堆里创建对象的过程变得简单了，只需要一个简单的表达式，它带有内置的长度计算、类型转换和安全检查。这样在堆创建一个对象和在栈里创建对象一样简单。

malloc和new的区别

1. malloc和free属于库函数，new和delete属于运算符
2. malloc不会调用构造函数，new会调用构造函数
3. malloc返回void* C++下要强转，new返回创建的对象的指针

placement new机制

一般来说，使用new申请空间时，是从系统的“堆”（heap）中分配空间。申请所得的空间的位置是根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在已分配的特定内存创建对象，这就是所谓的“定位放置new”（placement new）操作。

定位放置new操作的语法形式不同于普通的new操作。例如，一般都用如下语句A* p=new A;申请空间，而定位放置new操作则使用如下语句A* p=new (ptr)A;申请空间，其中ptr就是程序员指定的内存首地址。

• 用定位放置new操作，既可以在栈(stack)上生成对象，也可以在堆（heap）上生成对象。取决于ptr地址是指向哪里
• 使用语句A* p=new (mem) A;定位生成对象时，指针p和数组名mem指向同一片存储区。所以，与其说定位放置new操作是申请空间，还不如说是利用已经请好的空间，真正的申请空间的工作是在此之前完成的。
• 使用语句A *p=new (mem) A;定位生成对象时，会自动调用类A的构造函数，但是由于对象的空间不会自动释放（对象实际上是借用别人的空间），所以必须显示的调用类的析构函数，如本例中的p->~A()。

如果有这样一个场景，我们需要大量的申请一块类似的内存空间，然后又释放掉，比如在在一个server中对于客户端的请求，每个客户端的每一次上行数据我们都需要为此申请一块内存，当我们处理完请求给客户端下行回复时释放掉该内存，表面上看者符合c++的内存管理要求，没有什么错误，但是仔细想想很不合理，为什么我们每个请求都要重新申请一块内存呢，要知道每一次内从的申请，系统都要在内存中找到一块合适大小的连续的内存空间，这个过程是很慢的（相对而言)，极端情况下，如果当前系统中有大量的内存碎片，并且我们申请的空间很大，甚至有可能失败。为什么我们不能共用一块我们事先准备好的内存呢？可以的，我们可以使用placement new来构造对象，那么就会在我们指定的内存空间中构造对象。

这种方式存在的根本原因是因为内存申请是个耗时操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
using namespace std;
 
class A
{
public:
	A()
	{
		cout << "A's constructor" << endl;
	}
 
 
	~A()
	{
		cout << "A's destructor" << endl;
	}
	
	void show()
	{
		cout << "num:" << num << endl;
	}
	
private:
	int num;
};
 
int main()
{
	char mem[100];
	mem[0] = 'A';
	mem[1] = '\0';
	mem[2] = '\0';
	mem[3] = '\0';
	cout << (void*)mem << endl;
	A* p = new (mem)A;//将A对象分配到了栈上
	cout << p << endl;
	p->show();
	p->~A();
	getchar();
}

delete operator

new表达式的反面是delete表达式。delete表达式先调用析构函数，然后释放内存。正如new表达式返回一个指向对象的指针一样，delete需要一个对象的地址。

delete只适用于由new创建的对象。

如果使用一个由malloc或者calloc或者realloc创建的对象使用delete,这个行为是未定义的。因为大多数new和delete的实现机制都使用了malloc和free,所以很可能没有调用析构函数就释放了内存。

如果正在删除的对象的指针是NULL,将不发生任何事，因此建议在删除指针后，立即把指针赋值为NULL，以免对它删除两次，对一些对象删除两次可能会产生某些问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class Person{
public:
	Person(){
		cout << "无参构造函数!" << endl;
		pName = (char*)malloc(strlen("undefined") + 1);
		strcpy(pName, "undefined");
		mAge = 0;
	}
	Person(char* name, int age){
		cout << "有参构造函数!" << endl;
		pName = (char*)malloc(strlen(name) + 1);
		strcpy(pName, name);
		mAge = age;
	}
	void ShowPerson(){
		cout << "Name:" << pName << " Age:" << mAge << endl;
	}
	~Person(){
		cout << "析构函数!" << endl;
		if (pName != NULL){
			delete pName;
			pName = NULL;
		}
	}
public:
	char* pName;
	int mAge;
};

void test(){
	Person* person1 = new Person;
	Person* person2 = new Person("John",33);

	person1->ShowPerson();
	person2->ShowPerson();

	delete person1;
    person1=NULL;//delete不会置空指针
	delete person2;
     person2=NULL;
}

用于数组的new和delete

使用new和delete在堆上创建数组非常容易。

1
2
3
4
5
6
7
8
9
10
11

//创建字符数组
char* pStr = new char[100];
//创建整型数组
int* pArr1 = new int[100]; 
//创建整型数组并初始化
int* pArr2 = new int[10]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

//释放数组内存
delete[] pStr;
delete[] pArr1;
delete[] pArr2;

当创建一个对象数组的时候，必须对数组中的每一个对象调用构造函数，一般来说除了在栈上可以聚合初始化，必须提供一个默认的构造函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class Person{
public:
	Person(){
		pName = (char*)malloc(strlen("undefined") + 1);
		strcpy(pName, "undefined");
		mAge = 0;
	}
	Person(char* name, int age){
		pName = (char*)malloc(sizeof(name));
		strcpy(pName, name);
		mAge = age;
	}
	~Person(){
		if (pName != NULL){
			delete pName;
		}
	}
public:
	char* pName;
	int mAge;
};

void test(){
	//栈聚合初始化
	Person person[] = { Person("john", 20), Person("Smith", 22) };
	cout << person[1].pName << endl;
    //创建堆上对象调用有参构造函数
    Test* test1 = new Test('a');
    //创建堆上对象调用无参构造函数
    Test* test1 = new Test();
    //创建堆上对象数组必须提供默认构造函数
	Person* workers = new Person[20];
}

以下代码可以不强制在堆中生成数组对象时候类必须有默认构造函数（即不能是自己实现了有参数构造函数却没实现无参构造函数的情况）。

1

Person* workers = new Person[2]{Person("john", 20), Person("Smith", 22)};

但是以上代码在部分编译器不支持（VS2015支持）。所以为了兼容性，最好提供一个默认构造函数，并且不使用上面语法。

[注意]

delete void*可能会出错

如果对一个void指针执行delete操作，*这将可能成为一个程序错误，除非指针指向的内容是非常简单的，因为它将不执行析构函数.以下代码未调用析构函数，导致可用内存减少。

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

class Person{
public:
	Person(char* name, int age){
		pName = (char*)malloc(sizeof(name));
		strcpy(pName,name);
		mAge = age;
	}
	~Person(){
		if (pName != NULL){
			delete pName;
		}
	}
public:
	char* pName;
	int mAge;
};

void test(){
	void* person = new Person("john",20);//这里写void*将导致下面的delete不执行析构函数
	delete person;
}

因此，不要用void*去接受new出来的对象，利用void*无法调用析构函数。

使用new和delete采用相同形式

1
2

Person* person = new Person[10];
delete person;

以上代码有什么问题吗？(vs下直接中断、qt下析构函数调用一次)

使用了new也搭配使用了delete，问题在于Person有10个对象，那么其他9个对象可能没有调用析构函数，也就是说其他9个对象可能删除不完全，因为它们的析构函数没有被调用。

我们现在清楚使用new的时候发生了两件事: 一、分配内存；二、调用构造函数，那么调用delete的时候也有两件事：一、析构函数；二、释放内存。

那么刚才我们那段代码最大的问题在于：person指针指向的内存中到底有多少个对象，因为这个决定应该有多少个析构函数应该被调用。换句话说，person指针指向的是一个单一的对象还是一个数组对象，由于单一对象和数组对象的内存布局是不同的。更明确的说，数组所用的内存通常还包括“数组大小记录”，使得delete的时候知道应该调用几次析构函数。单一对象的话就没有这个记录。单一对象和数组对象的内存布局可理解为下图:

本图只是为了说明，编译器不一定如此实现，但是很多编译器是这样做的。

当我们使用一个delete的时候，我们必须让delete知道指针指向的内存空间中是否存在一个“数组大小记录”的办法就是我们告诉它。当我们使用delete[]，那么delete就知道是一个对象数组，从而清楚应该调用几次析构函数。

结论:

如果在new表达式中使用[]，必须在相应的delete表达式中也使用[].如果在new表达式中不使用[], 一定不要在相应的delete表达式中使用[].

嵌套类和局部类

1. 嵌套类（在一个类中定义另一个类）：

   在C++语言中，嵌套类（nested class）其实与外围类没有什么太强的依赖关系 ，往往是因为外围类需要使用嵌套类对象作为底层实现，并且该嵌套类只用于外围类的实现，且同时可以对用户隐藏该底层实现时才使用嵌套类。（即作用总结：访问控制，限定嵌套类只能由这个类访问。）

2. 局部类：在一个函数中定义另一个类

静态成员（static）

对static静态的理解

术语“static”有一段不同寻常的历史。起初，C引入关键字static是为了表示退出一个块后依然存在的局部变量。在这种情况下，术语”static”是有意义的：变量一直存在，当再次进入该块时仍然存在。随后，static在C中有了第二种含义，表示不能被其他文件访问的全局变量和函数。为了避免引入一个新的关键字，关键字static被重用了。最后，C++第三次重用了这个关键字，与前面赋予的含义完全不一样，这里将其解释为：属于类且不属于类对象的变量和函数。这个含义和Java相同。

静态成员变量

在一个类中，若将一个成员变量声明为static，这种成员称为静态成员变量。与一般的数据成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝。静态成员变量，属于某个类，所有对象共享。

静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。

• 静态非常量成员变量必须在类中声明，在类外定义。(静态常量成员可以在类内一次性完成声明和定义)
• 静态数据成员不属于某个对象，编译阶段就分配内存，在为对象分配空间中不包括静态成员所占空间。
• 静态数据成员可以通过类名或者对象名来引用（两种访问方式）。
• 也有访问权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class Person{
public:
	//类的静态成员属性
	static int sNum;
private:
	static int sOther;
};

//类外初始化，初始化时不加static
int Person::sNum = 0;//这种类外定义方式看起来是在类外，但其实还是算类内，即这种可无视private权限
int Person::sOther = 0;
int main(){


	//1. 通过类名直接访问
	Person::sNum = 100;
	cout << "Person::sNum:" << Person::sNum << endl;

	//2. 通过对象访问
	Person p1, p2;
	p1.sNum = 200;

	cout << "p1.sNum:" << p1.sNum << endl;
	cout << "p2.sNum:" << p2.sNum << endl;

	//3. 静态成员也有访问权限，类外不能访问私有成员
	//cout << "Person::sOther:" << Person::sOther << endl;
	Person p3;
	//cout << "p3.sOther:" << p3.sOther << endl;

	system("pause");
	return EXIT_SUCCESS;
}