C++编程基础

Hello, world!

 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

#include <iostream>
#include <stdlib.h>  //使用atexit()
using namespace std;

void show1(void) {
    cout << "first exit main()" << endl;
}

void show2(void) {
    cout << "second exit main()" << endl;
}

int main(int argc, char* argv[]) {
    atexit(show1);
    atexit(show2);
    cout << "Hello, world!" << endl;

    system("pause");
    return 0;
}
/*打印
Hello, world!
second exit main()
first exit main()  
*/

main 函数前面的数据类型 int 与 void

main 函数的返回值是返回给主调进程，使主调进程得知被调用程序的运行结果。

标准规范中规定 main 函数的返回值为 int，一般约定返回 0 值时代表程序运行无错误，其它值均为错误号，但该约定并非强制。

如果程序的运行结果不需要返回给主调进程，或程序开发人员确认该状态并不重要，比如所有出错信息均在程序中有明确提示的情况下，可以不写 main 函数的返回值。在一些检查不是很严格的编译器中，比如 VC, VS 等，void 类型的 main 是允许的。不过在一些检查严格的编译器下，比如 g++, 则要求 main 函数的返回值必须为 int 型。

所以在编程时，区分程序运行结果并以 int 型返回，是一个良好的编程习惯。

main 函数执行完后执行其他语句

有时候需要在程序退出时做一些诸如释放资源的操作。我们可以用 atexit() 函数来注册程序正常终止时要被调用的函数。

atexit() 在一个程序中最多可以注册32个处理函数，这些处理函数的调用顺序与注册顺序相反，即后注册的函数先被调用。

有必要补充一下，main函数执行之前会做什么？全局对象的构造函数会在main函数之前执行。例

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

class C
{
public:
    C() { std::cout << "call C()" << std::endl; };
};

C c0; //全局变量

int main()
{
    std::cout << "main() start" << std::endl;
    C c1; // call C()
    return 0;
}
/**
call C()
main() start
call C()
*/

main函数之前执行的操作

main函数执行之前，主要就是初始化系统相关资源：

• 设置栈指针
• 初始化静态static变量和global全局变量，即.data段的内容
• 将未初始化部分的全局变量赋初值：数值型short，int，long等为0，bool为FALSE，指针为NULL等等，即.bss段的内容
• 全局对象初始化，在main之前调用构造函数
• 将main函数的参数argc，argv等传递给main函数，然后才真正运行main函数

“\n” 与 endl 的区别

在 C++ 中，终端输出换行时，用cout<<......<< endl 与"\n" 都可以，这是初级的认识。但二者有小小的区别，用 endl 时会刷新缓冲区，使得栈中的东西刷新一次，但用 “\n” 不会刷新，它只会换行，栈内数据没有变化。但一般情况，二者的区别是很小的，建议用 endl 来换行。

1

std::cout << std::endl;

相当于:

1

std::cout << '\n' << std::flush;

或者

1

std::cout << '\n'; std::fflush(stdout);

endl 除了写 '\n' 之外，还调用 flush 函数，刷新缓冲区，把缓冲区里的数据写入文件或屏幕。考虑效率就用 '\n'。

一般情况下，不加endl大多数情况下，也能正常输出，是因为在系统较为空闲时候，会查看缓存区的内容，如果发现新的内容，便进行输出。但是你并不清楚，系统什么时候输出，什么时候不输出，与系统自身的运行状况有关。而刷新缓存区，是强制性的，绝对性的输出，不取决于系统运行状况。所以正如《C++ Primer》书中所写，为了避免出现没有刷新输出流的情况发生，在使用打印语句来调试程序时，一定要加入 endl或 flush 操纵符。

这里可能会想到，以后遇到这类问题，干脆直接都使用 endl，不用 \n 不就好了吗？

也不是，要知道，endl会不停地刷新输出流，频繁的操作会降低程序的运行效率，这也是C++标准库对流的输入/输出操作使用缓冲区的原因。没有必要刷新输出流的时候应尽量使用 \n，比如对于无缓冲的流 cerr，就可以直接使用 \n。

头文件里的 " " 与 < >

<> 默认去系统目录中找头文件。像标准的 C 头文件 stdio.h、stdlib.h 和 C++ 头文件 iostream、string 等用这个方法。 " " 首先在当前目录下寻找，如果找不到，再到系统目录中寻找。 这个用于 include 自定义的头文件，让系统优先使用当前目录中定义的。

命名空间 std

所谓名称空间它是一种将库函数封装起来的方法。通过这种方法，可以避免和应用程序发生命名冲突的问题。

如果想要使用 cin，cout 这两个 iostream对象，不仅要包含 <iostream> 头文件，还得让命名空间std内的名称曝光，即 using namespace std;

真正的开发过程中， 尽量避免使用 using namespace std; 等直接引入整个命名空间，否则会因为命名空间污染导致很多不必要的问题， 比如自己写的某个函数，名称正好和 std 中的一样， 编译器会不知道使用哪一个， 引起编译报错， 建议使用由命名空间组合起来的全称： std::cout << "Hello World" << std::endl;

system(“pause”)

包含头文件 stdlib.h，并在主程序中加入 system("pause"); 可以在程序运行完以后使黑框暂停显示，等待输入，而不是闪退。linux环境下运行该程序需去掉该语句。

cout 与 printf()

cout 流速度较慢，如果速度过慢可以用 <stdio.h> 库中的 printf() 格式化输出函数，不需要 using namespace std;。但注意 printf() 中不能使用 endl。printf 是函数。cout是ostream对象，和 « 配合使用。如果 printf 碰到不认识的类型就没办法了，而cout可以重载进行扩展。

main函数与命令行参数

一个程序的main()函数可以包括两个参数

• 第一个参数的类型为int型；
• 第二个参数为字符串数组。

通常情况下，将第一个参数命名为argc，第二个参数为argv（当然参数名字可以换）。由于字符串数组有两种表达方式，因此，main函数存在两种书写方法：

1
2
3

int main(int argc, char* argv[])//这里使用char* argv[]

int main(int argc, char** argv)//这里使用char **argv

int argc：表示字符串的数量，操作系统会自动根据第二个参数传入数字，程序员不用管，只需要正确使用即可。若用户输入N个字符串，那么argc= N + 1；因为 argv[0] 为程序的路径。

char* argv[]：字符串数组，即多个字符串。为用户输入的一系列字符串，字符串之间以空格间隔，形式为：str1 str2 str3 在linux下，若存在可执行文件a.out，则运行该程序命令为：

1

./a.out str1 str2 str3

预处理、编译与链接

• 预处理： 预处理也称为预编译，它为编译做准备工作，主要进行代码文本的替换，用于处理#开头的指令 。

• 编译：编译是将编译好的源程序*.cpp文件翻译成二进制目标代码的过程。编译过程是使用C++提供的编译程序完成的，该过程会检查程序语法错误、函数变量的声明是否正确。正确的源程序文件经过编译在磁盘上生成目标文件（windows上是*.obj，linux上是*.o）。

• 链接：链接将编译生成的各个目标程序模块（一个或者多个）及系统或者第三方提供的库函数*.lib链接在一起，生成可以在操作系统上直接运行的可执行文件（windows上的*.exe）

安装 g++

1

sudo apt-get install g++ build-essential

将源文件hello.cpp编译成可执行文件hello

1

g++ hello.cpp -o hello

运行可执行文件

1

./hello

如果省略-o hello也是没问题的。由于命令行中未指定可执行程序的文件名，编译器采用默认的 a.out。程序可以这样来运行：

1

./a.out

如果是多个 C++代码文件，如f1.cpp，f2.cpp，编译命令如下：

1

g++ f1.cpp f2.cpp -o myexec

则会生成一个名为myexec的可执行文件。

静态链接和动态链接

要生成可执行文件，必须经历两个阶段，即编译、链接。

在链接过程中，静态链接和动态链接就出现了区别。静态链接的过程就已经把要链接的内容已经链接到了生成的可执行文件中，就算你在去把静态库删除也不会影响可执行程序的执行；而动态链接这个过程却没有把内容链接进去，而是在执行的过程中，再去找要链接的内容，生成的可执行文件中并没有要链接的内容，所以当你删除动态库时，可执行程序就不能运行。所以动态链接生成的可执行文件要比静态链接生成的文件要小一些。

各自的优缺点：

• 静态链接库执行速度比动态链接库快。（执行过程不需要找链接的内容）

• 动态链接库更节省内存。（未写入要链接的内容）

深入浅出静态链接和动态链接

iostream

标准输入流 cin

1
2
3
4
5
6

char name[50];
short age;
cout << "请输入您的名称与年龄： ";
cin >> name >> age;
//C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。
//流提取运算符 >> 在一个语句中可以多次使用

标准输出流 cout

1
2

char str[] = "Hello C++";
cout << "Value of str is : " << str << endl;

标准错误流 cerr

cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

1
2

char str[] = "Unable to read....";
cerr << "Error message : " << str << endl;

标准日志流 clog

clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲在，直到缓冲填满或者缓冲区刷新时才会输出。

1
2

char str[] = "Unable to read....";
clog << "Error message : " << str << endl;

1
2
3
4
5
6
7
8

#include <iostream>
using namespace std;
int main()
{
    cout << "cout" << endl;
    cerr << "cerr" << endl;
    return 0;
}

linux下命令行输入：

1
2

g++ main.cpp -o a
./a >> test.log

终端输出“cerr”，
打开test.log，里面只有一行字符串“cout”。

• cout默认情况下是在终端显示器输出，cout流在内存中开辟了一个缓冲区，用来存放流中的数据，当向cout流插入一个endl，不论缓冲区是否满了，都立即输出流中所有数据，然后插入一个换行符。cout可以被重定向到文件。

• cerr不经过缓冲而直接输出，一般用于迅速输出出错信息，是标准错误，默认情况下被关联到标准输出流，但它不被缓冲，也就说错误消息可以直接发送到显示器，而无需等到缓冲区或者新的换行符时，才被显示。不被重定向。

  • 有时程序调用导致栈被用完了，此时如果使用cout 会导致无内存输出。使用cerr 会在任何情况下输出错误信息。
  • 不被缓冲就是你打一个字符就马上在显示器显示，而不是等到endl才打印。

• clog流也是标准错误流，作用和cerr一样，区别在于cerr不经过缓冲区，直接向显示器输出信息，而clog中的信息存放在缓冲区，缓冲区满或者遇到endl时才输出。clog用的少。

变量

勿混用带符号类型和无符号类型

一个算术表达式中既有无符号又有有符号时，如int，那个int就会转换为无符号数

1
2
3
4

unsigned u = 10;
int i = -42;
std::cout << i + i << std::endl; // 输出-84
std::cout << u + i << std::endl; // 如果int占32位，输出4294967264

无符号数不会小于0这一事实关系到循环的写法

【PRIMER 34】

1
2
3

// WRONG: u can never be less than 0; the condition will always succeed
for (unsigned u = 10; u >= 0; --u)
    std::cout << u << std::endl;

当u等于0时，–u的结果将会是4294967295。一种解决办法是用while语句来代替for语句，前者可以在输出变量前先减去1。

1
2
3
4
5
6

unsigned u = 11;    // start the loop one past the first element we want to print
while (u > 0)
{
    --u;    // decrement first, so that the last iteration will print 0
    std::cout << u << std::endl;
}

初始化

初始化不等于赋值（assignment）。初始化的含义是创建变量时赋予其一个初始值，而赋值的含义是把对象的当前值擦除，再用一个新值来替代。【PRIMER 39】

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

int a(5);  // 构造函数语法，比如复数需要初始化两个值
complex<double> purei(0, 7);
int b = 6;  // C 风格的运算符（=）初始化

//关于指针
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr; // 合法，数组名即首地址
cout << p[1] << endl;

// 如果要对数组求址，就需要定义一个数组指针，指向一个包含5个元素的数组
int(*pa)[5] = &arr; 
cout << "arr[0] = " << **pa << ", arr[2] = " << (*pa)[2] << endl;
cout << "p[1] - [p0] = " << pa[1] - pa[0] << endl; 
// 输出：
// arr[0] = 1, arr[2] = 3
// p[1] - [p0] = 5，表明数组指针包含 5 个元素

vector<int> vec(arr, arr + 5);
vector<int> *pv = &vec;  // 合法
//而 vector<int> *pv = vec;  不合法，因为 vec 是 vector 型对象，它的名字不是首地址
cout << vec[1] << endl;  // 注意与数组的差别

new 与 vector 定义多维变长数组并初始化，查看code

 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

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
	int row = 2;
	int col = 3;
	int **p = new int*[row];
	for (int i = 0; i < row; ++i)
	{
		p[i] = new int[col];
		for (int j = 0; j < col; ++j)
		{
			p[i][j] = i * col + j;
		}
	}
	for (int i = 0; i < row; ++i)
		for (int j = 0; j < col; ++j)
			printf("p[%d][%d] = %d\n", i, j, p[i][j]);


	cout << "--------------------" << endl;
	int *p1 = new int[5];  // 未初始化， p 指向含 5 的整数的堆内存空间的首地址
	cout << p1[0] << " " << p1[1] << " " << *p1 << endl;
	int *p2 = new int(5);   // 初始化一个值，p 指向一个数
	cout << p2[0] << " " << p2[1] << " " << *p2 << endl;


	cout << "----------------------" << endl;
	int a = 2, b = 2, c = 3;
	vector<vector<vector<int> > > v(a, vector<vector<int> >(b, vector<int>(c, 5)));
	for (int i = 0; i < v.size(); ++i)
		for (int j = 0; j < v[0].size(); ++j)
			for (int k = 0; k < v[0][0].size(); ++k)
				printf("v[%d][%d][%d] = %d\n", i, j, k, v[i][j][k]);

	cout << "-------------------------" << endl;
	vector<int> v1(c, 6);
	vector<vector<int> >v2(b, v1);
	vector<vector<vector<int> > >v3(a, v2);
	for (int i = 0; i < v.size(); ++i)
		for (int j = 0; j < v[0].size(); ++j)
			for (int k = 0; k < v[0][0].size(); ++k)
				printf("v3[%d][%d][%d] = %d\n", i, j, k, v3[i][j][k]);

	cout << "-------------------------" << endl;
	int* pmalloc = (int *)malloc(sizeof(int) * row * col);
	for (int i = 0; i < row; ++i)
		for (int j = 0; j < col; ++j)
			pmalloc[i * col + j] = i * col + j;
	for (int i = 0; i < row; ++i)
		for (int j = 0; j < col; ++j)
			printf("pmalloc[%d * %d + %d] = %d\n", i, col, j, pmalloc[i * col + j]);
	free(pmalloc);
}

逗号表达式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 【例 1】
cout << a_string << (cnt % line_size ? ' ' : '\n');
// 若某一行计数不超过 line_size，就打印空格，否则换行。用来限制某一行字符打印的个数
//【ESS 11】

// 【例 2】
fun(f2(v1,v2),(v3,v4,v5),(v6,max(v7,v8)));
// fun 函数的实参个数有几个？
// 答：三个。
// 第一个是 f2 的返回值，第二个是逗号表达式(v3,v4,v5)的值，第三个是逗号表达式(v6,max(v7,v8))的值。

指针

如果指针不指向任何对象，则【提领】操作（也可称为【解引用】，即取指针指向的内容）会导致未知的执行结果。这意味着在使用指针时，必须在提领前确定它的确指向某对象。

一个未指向任何对象的指针，其地址为0，也被称为 nullptr 指针。我们可以在定义阶段便初始化指针，令其值为 0.

1
2
3
4
5

int *p = 0;  // 初始化指针地址为0
if (p && *p != 1024)  // 如果 p 地址不为零，才能有 *p 操作
    *p = 1024;
// 当 p 的地址为 0，直接提领，会报错
//【ESS 28】

野指针

指的是没有被初始化过的指针。指针变量未初始化时不会自动成为 nullptr，而是一个随机值。

1
2
3
4
5

int main() { 
    int* p;     // 未初始化
    std::cout<< *p << std::endl; // 未初始化就被使用
    return 0;
}

因此，为了防止出错，对于指针初始化时都是赋值为 nullptr，这样在使用时编译器就会直接报错，产生非法内存访问。

悬空指针

悬空指针，指针最初指向的内存已经被释放了的一种指针。（指针操作超越变量的作用域，比如函数返回栈内存的指针或引用）

1
2
3
4
5
6

int main() { 
    int * p = nullptr;
    int* p2 = new int;
    p = p2;
    delete p2;
}

此时 p和p2就是悬空指针，指向的内存已经被释放。继续使用这两个指针，行为不可预料。需要设置为p=p2=nullptr。此时再使用，编译器会直接保错。

野指针和悬空指针，无法通过简单地判断是否为 nullptr 避免，所以要习惯在初始化时赋值或析构时赋为nullptr。

void*是一种特殊的指针类型，可以存放任意对象的地址，但不能直接操作void*指针所指的对象。

指针与数组名的区别

• 修改内容上的差别：

  1 2 3 4

  char a[] = "hello"; a[0] = 'H'; char *p = "world"; // p 指向常量字符串，该字符串存储在文字常量区，不可更改 // p[0] = "W" // 所以这个赋值有问题

  1 2 3 4 5 6 7 8 9 10

  int main() { char a[] = "hello"; char *p = a; // 这样让指针指向数组 a，而非常量字符串，就可以修改了 p[0] = 'H'; a[1] = 'E'; printf("%d", sizeof(p)); // 64 位机器 std::cout << p << std::endl; return 0; } //输出：8HEllo

• sizeof

  1 2 3 4 5 6 7 8

  sizeof(a); // 输出6，包含 '\0' sizeof(p); // 64 位机器输出 8 /* 指针类型对象占用内存为一个机器字的长度： 这意味着在16位cpu上是16位 = 2字节 32位cpu上是32位 = 4字节 64位cpu上就是64位也就是8字节了 */

数组指针与指针数组

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

type (*p)[]; // 数组指针
/*
type a[]，a 是一个数组，数组内元素都是 type 类型，将 a 换成 (*p)，
可以理解为 （*p）是一个数组，数组内元素都是 type 类型，那么 p 就是指向这样的数组的指针，即数组指针。
*/

type *p[]; // 指针数组
/*
type *p[]即(type *)p[]，则 p 是一个 type* 类型的数组(类比int a[10]，a 是 int 型数组）
即 p 是一个数组，数组内元素都是指针（ type *）
*/

// 在后文的介绍中使用右左法则，更容易理解

稍微复杂一些的指针数组：

1
2
3
4
5
6
7
8
9

const int seq_cnt = 6;
vector<int> *seq_addrs[seq_cnt] = {
    &fibonacci, &lucas, &pell,
    &triangular, &square, &pentagonal
};
// seq_addrs 是一个数组，存储 vector<int> * 型的指针，
// seq_addrs[0] 的内容为指针，该指针指向 fibonacci，
// 而 fibonacci 的类型为 vector<int>。
//【ESS 29】

指针函数与函数指针

指针函数：返回类型是指针的函数，如

1
2
3
4
5
6

char *StrCat(char *ptr1, char *ptr2)
{
    char *p;
    do something;
    return p;
}

函数指针：指向函数的指针，如

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

#include <stdio.h>
int max(int x, int y)
{
    return x > y? x: y;
}
int main()
{
    // int max(int x, int y);
    int (*ptr)(int, int);
    ptr = max;
    int max_num = (*ptr)(12, 18);  // int max_num = ptr(12, 18);也是对的
    printf("%d", max_num);
    return 0;
}
// 打印 18。

1
2

int (*ptr)(); // “()” 表明该指针指向函数，函数返回值为 int
int (*ptr)[3]; // “[]” 表明该指针指向一维数组，该数组里包含三个元素，每一个元素都是int类型。

数组名指向了内存中一段连续的存储区域，可以通过数组名的指针形式去访问，也可以定义一个相同类型的指针变量指向这段内存的起始地址，从而通过指针变量去引用数组元素。

每一个函数占用一段内存区域，而函数名就是指向函数所占内存区的起始地址的函数指针（地址常量），故函数指针解引用与不解引用没有区别 。通过引用函数名这个函数指针让正在运行的程序转向该入口地址执行函数的函数体，也可以把函数的入口地址赋给一个指针变量，使该指针变量指向该函数。

复杂指针声明

函数指针数组

1
2
3
4

const vector<int>* (*seq_array[])(int) = {
    fibon_seq, lucas_seq, pell_seq,
    triang_seq, square_seq, pent_seq
};

seq_array 是一个可以持有六个函数指针的指针数组，第一个元素指向函数 fibon_seq()，该函数原型为 const vector<int> *fibon_seq(int);。

【ESS 62】

解读复杂指针使用右左法则：首先从未定义的标识符所在的圆括号看起，然后往右看，再往左看。每当遇到圆括号就调转阅读方向。一旦解析完圆括号里的东西，就跳出圆括号。重复这个过程，直到整个声明解析完毕。

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

int (*func)(int *p, int (*f)(int*));
// func左边有一个*表明func是一个指针，跳出圆括号看右边，右边有括号，说明func是一个函数指针，
// 指向的函数接收两个形参，分别是整型指针 int * 和函数指针 int (*f)(int*)，返回值为 int。

int (*func[5])(int *p);
// func 是一个数组，含5个元素，左边*号，表明 func 是一个指针数组（由于[]优先级高于*，func先跟[]结合，然后*修饰func[5]，故该数组的元素都是指针）。
//再往右看，是括号，说明 func 里的指针是函数指针，函数指针所指向的函数接收 int * 型参数并返回 int。

int (*(*func)[5])(int *p);
// func 是一个指针，指向含有 5 个元素的数组，数组里的元素都是指针，而且都是函数指针，
// 函数指针指向的函数接收 int * 型形参并返回 int。

int (*(*func)(int *p))[5];
// func 是一个指针，该指针指向一个函数，该函数接收 int * 型参数返回一个指针，
// 返回的指针指向一个数组，该数组含有 5 个元素，每一个元素都是 int 型。

指针(pointer)与引用(reference)

1
2
3

int ival = 1024;
int *pi = &ival;  // pointer
int &rval = ival;  // reference

• 引用是别名，而指针是地址。指针可以被赋值，以指向另一个不同的对象，而引用只能在定义时被初始化一次，以后不能修改，但引用的那个对象内容却可以改变。可以把引用理解为指针常量，而普通指针为指针变量。

• 引用不能为空，指针可以为空。故在使用上，指针可能（也可能不）指向一个对象，提领时一定要先确定其值非 0。而引用，则必定会代表某个对象，所以不需要作此检查。

• 从内存分配上来看，程序为指针变量分配内存区域，而不为引用分配内存区域。

• 引用使用时无需解引用(*)，指针需要解引用；

• 引用没有 const，指针有 const；

• “sizeof 引用” 得到的是所指向的变量(对象)的大小，而 “sizeof 指针” 得到的是指针本身的大小；

• 指针可以有多级，但是引用只能是一级（int **p；合法 而 int &&a是不合法的）

• 指针和引用的自增(++)运算意义不一样；

  1 2 3 4 5 6

  int a = 0; int &b = a; int *p = &a; b++; // 相当于 a++; b 只是 a 的一个别名，和 a 一样使用。 p++; // p 指向 a 后面的内存 (*p)++; // 相当于 a++

（在二进制层面，引用一般是通过指针来实现的，只不过编译器帮我们完成了转换。总的来说，引用既具有指针的效率，又具有变量使用的方便性和直观性。）

【ESS 46，47】

引用作为函数参数

• 传递引用给函数与传递指针给函数的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

• 使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配临时存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

• 使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用 “*指针变量名” 的形式进行运算，这很容易产生错误且程序的可读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

常引用作为函数参数

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用

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

void foo(const string &s) {
    cout << s << endl;
}  

// 如果形参里的 const 去掉，程序就报错，
// 因为 ss 与 "world!" 都是常量，你不能把一个 const 类型转换成非 const 类型。
// 所以 foo() 形参必定要用 const 修饰。

int main() {
    const string ss("hello ");
    foo(ss);
    foo("world!");
}

对于常量类型的变量，其引用也必须是常量类型的；对于非常量类型的变量，其引用可以是非常量的，也可以是常量的。但是要注意，无论什么情况都不能使用常量引用修改其引用的变量的值。

函数返回引用与返回值

返回引用的好处：在内存中不产生被返回值的副本。

同时注意，正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生 runtime error!

【注意】

• 最好不要返回局部变量的引用；
• 最好不要返回函数内部 new 分配的内存的引用；
• 流操作符重载返回值应为引用；
• 全局变量和局部静态变量的返回值可以是引用；
• 可以返回类成员的引用；

指针运算

*&p和&*p

• &：取出变量的存储地址。对指针变量 p，&p 取指针变量 p 所占用内存的地址，可以说是二级指针。
• *：引用指针所指向单元的内容。

1
2
3
4

1、*&p 等价于*(&p)
2、&*p 等价于&(*p)
p 是 int 变量，那么 *&p = p，而 &*p 是非法的。因为 *p 非法
p 是 int* 变量，那么 *&p = p，&*p = p，都是 p

p+(或-)n

指针加减一个数，是指该指针上移或下移n个数据之后的内存地址。即：

1

p +(或-) n * sizeof(type);

*p++，*(p++)， (*p)++，*++p，++*p

• *p++ 和 *(p++) 没有区别，因为 ++ 在变量之后，运算得先用再自增，所以先执行*p，p再自增。这又与 (*p)++ 有区别，这里面先 *p，*p 再自增而不是 p 自增。

  1 2 3 4 5

  // 一个 ++ 在变量后，先用再自增的例子。 int a = 3; int b = 3; printf("%d",a++); //打印3,但a值已经变成4了。先用a，a再自增，所以就是先打印3,打印完再自增。 printf("%d",++b); //先自增，自增完，再用。

• *++p 等价于 *(++p)，p 先自增，自增完后再取 *p 的值，即取下一个元素的值，而不是当前元素。
  ++*p，*p自增。

i++ 与 ++i 的效率

• 对于内置数据类型，两者差别不大；
• 对于自定义数据类型（如类），++i 返回对象的引用，而 i++ 返回对象的值，导致较大的复制开销，因此效率低。

前缀++和后缀++的原型为：【PRIMER 501】

1
2
3

// class C;
C& C::operator++(); // 前缀运算符返回递增或递减后对象的引用
C C::operator++(int);  // 后缀运算符返回对象的值。为了与前缀运算符作区分，后缀版本接受一个（不被使用，编译器默认设为0）int类型的形参。

sizeof

sizeof 计算普通变量与指针所占空间的大小

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 在32 位操作系统上，用 sizeof 计算下列变量所占空间的大小
// 32位，char:1，short:2, int:4，long:4
char str[] = "hello";  		// 6
char *p = str;         		// 4
int n = 10;            		// 4
void fun(char str[100])
{
    sizeof(str);			// 4，函数形参对传入的数组是按照指针处理的，在函数体内可以通过修改 str 修改函数外的数组
}
void *p = malloc(100);		// 4, p 指向 100 个字节的堆内存，但本质上还是指针。

sizeof 计算空类的大小

1
2
3

class A {};
cout << sizeof(A) << endl;	// 1
// 空类不包含任何信息，本来求 sizeof 的时候应该是 0，但是当我们声明该类型的实例的时候，它必须在内存中占用空间，否则无法使用。至于占多少空间由编译器来决定，使用 gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04) 编译打印 1。

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

class A
{
public:
	A() {};
	~A() {};
	// virtual void f() {};  //【1】
  // static int a; // 【2】
};
cout << sizeof(A) << endl;
// 注释【1】【2】，无虚函数，依旧占用空间 1 字节
// 只注释【1】，因为 static 变量不属于类，且无虚函数，依旧占用空间 1 字节
// 如果去掉【1】处注释，含虚函数，得占用内存 4。有虚函数时，默认有一个指针指向虚函数表。该指针占 4 字节。
// 普通成员函数不占用类的空间。类的函数是该类所有实例共享的，调用时通过隐藏的 this 指针和类的实例相关联，
// 普通成员函数代码编译后存储在程序代码区，根本就不在类实例中，所以不占实例空间。

sizeof 计算类对象与结构体、联合体所占空间的大小

在 32 位操作系统上，占用空间 char:1，short:2, int:4，long:4

 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

class A				// 1
{
public:
	char ch;
};

class B				// 4 + 2 + 填充2 = 8
{
public:
	int i;
	short j;
};

class C				// 4 + 2 + 1 + 1 = 8
{
public:
    int i;
    short j;
    char c1;
    char c2;
};

class D				// 1 + 填充3 + 4 + 1 + 填充1 + 2 = 12
{
public:
    char c1;
    int i;
    char c2;
    short j;
};
// 【注意】类 C，D 的区别在于变量定义的顺序不一样
D d;
printf("%x, %x, %x, %x, %x\n", &d, &d.c1, &d.i, &d.c2, &d.j);
// 输出：12ffed4, 12ffed4, 12ffed8, 12ffedc, 12ffede

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

// 注意 S1 与 S2 也就是成员变量定义时顺序不一样而已
struct S1			// 4 + 1 + 1 + 填充2 = 8
{
	int a1;
	char c1;
	char c2;
};

struct S2			// 1 + 填充3 + 4 + 1 + 填充3 = 12
{
	char c1;
	int a1;
	char c2;
};

S2 s2;
printf("%x, %x, %x, %x\n", &s2, &s2.c1, &s2.a1, &s2.c2);
// 输出：10ff794, 10ff794, 10ff798, 10ff79c

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

union u1			// 8
{
	double a;
	int b;
};

union u2			// 13，对齐方式是1，13 是 1 的整数倍
{
	char a[13];
	char b;
};

union u3			// 16，对齐方式是 4，16 是 4 的整数倍
{
	char a[13];
	int b;
}；

这一切都与字节对齐有关：

• 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
• 结构体每一个成员相对于结构体首地址的偏移量都是成员大小的整数倍，如有需要，编译器会在成员之间加上填充字节；
• 结构体的总大小为结构体最宽基本数据类型成员大小的整数倍，如有需要，编译器会在最末一个成员之后加上填充字节。

联合体（共用体），类同理。

sizeof 与 strlen 区别

• sizeof 是操作符，strlen 是函数；

• 数组做 sizeof 参数不退化，传递给 strlen 就退化成指针（函数的形参将数组按指针处理）；

  1 2 3 4 5 6 7 8 9 10

  char *s = "hello"; char str[20] = "hello"; cout << sizeof(s) << ' ' << sizeof(str) << endl; // sizeof 对字符指针和字符数组的处理不同 // cout << sizeof s << ' ' << sizeof str << endl; // sizeof 后面不加括号也正确，因为 sizeof 是运算符不是函数，但用 sizeof 求类型大小，必须加括号，比如 sizeof(int) cout << strlen(s) << ' ' << strlen(str) << endl; /* 打印 4 20 5 5 */

• sizeof 在编译阶段就计算出来了，所以可以定义数组的维度，而strlen是在运行时候才计算出来；

strcpy 与 memcpy 区别

• 复制的内容不同。strcpy 只能复制字符串，而 memcpy 可以复制任意内容，例如字符数组、整型、结构体、类等。
• 复制的方法不同。strcpy 不需要指定长度，它遇到被复制字符的结束符 “\0” 才结束，所以容易溢出。memcpy 则是根据其第 3 个参数决定复制的长度。
• 用途不同。通常在复制字符串时用 strcpy，而需要复制其他类型数据时则一般用 memcpy 。

作用域与生存周期

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

// 花括号可以看作是作用域标识符，除了在写函数时候用到，它还有一个作用是表示变量的作用域：
{ 					// 外花括号
    int a = 0;
    {				// 内花括号
        int b = 0;
        a = 1;  	//【1】正确，对外花括号内的 a 重新赋值
    }
    // b = 1;   	// 错误，b 已经被销毁了
    cout << a << endl;
    /*
    输出为 1。如果将【1】处 a = 1； 改成 int a = 1；此时输出为 0。
    因为前者 a = 1 表明修改的是外花括号内的 a，而后者表明定义一个局部变量 a 并初始化，
    内花括号的 a 屏蔽了外花括号的 a，而 cout 打印的是外花括号的 a
    */
}

// 对于 if, while, for 在花括号里定义的变量，出了花括号就被释放了，
    int a = 1;
    for (int a = 2; a == 2; ++a)
    {
        cout << a << endl; //for 中定义的 a 作用域在花括号内，屏蔽 for 外定义的 a
    }
    cout << a << endl; // 打印外花括号的 a
/* 打印
2
1
*/

【PRIMER 44】

作用域中一旦声明了某个名字，在它所嵌套着的所有作用域中都能访问该名字。同时，允许在内层作用域中重新定义外层作用域已有的名字，此时内层作用域中新定义的名字将屏蔽外层作用域的名字。

可以用作用域操作符::来覆盖默认的作用域规则。因为全局作用域本身并没有名字，所以当作用域操作符的左侧为空时，会向全局作用域发出请求获取作用域操作符右侧名字对应的变量。

内存分配

一个程序将操作系统分配给其运行的内存块分为 5 个区域：

• 静态区（全局区）：存放程序的全局变量和静态变量。初始化的全局变量和静态变量在一个区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。（在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。）

• 堆区：存放程序的动态数据。

• 栈区：存放程序的局部数据，即各个函数的参数和局部变量等。函数结束，自动释放。

• （文字）常量区：常量字符串存放的区域，程序结束后由系统释放。

• 代码区：存放程序的代码，即程序中的各个函数代码块。

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

int a = 0; // 全局初始化区
char *p1;  // 全局未初始化区
int main() {
    int b;    // 栈
    char s[] = "abc"; // 栈
    char *p2; // 栈
    char *p3 = "123456";  // 字符常量 “123456\0” 在常量区，p3 在栈上。
    static int c = 0;  // 全局（静态）初始化区
    p1 = (char *)malloc(10);
    p2 = (char *)malloc(20);  // 分配得来的 10 和 20 字节的区域在堆区。
    strcpy(p1, "123456");  // “123456\0” 放在文字常量区，编译器可能会将它与 p3 所指向的 "123456\0" 优化成一个地方
}

局部变量和全局变量

局部变量也称为内部变量，它是在函数内定义的。其作用域仅限于函数内，离开该函数后再使用这种变量是非法的。

全局变量也称为外部变量，它是在函数外部定义的变量。它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。在函数内部，局部变量可以屏蔽全局变量。如果一个全局变量用 static 修饰，它就是静态全局变量，它的作用域是该文件范围（称为文件作用域，即其它文件不能使用它）

操作系统和编译器是怎么变量是全局还是局部

操作系统和编译器，可能是通过内存分配的位置来知道的，全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面。

静态存储与动态存储

变量的生存周期只与变量的存储位置（存储类别）有关。可以分为：

• 静态存储方式（在程序运行期间，系统对变量分配固定的存储空间）
• 动态存储方式（在程序运行期间，系统对变量动态（不固定）的分配存储空间）

而变量的存储类别可以分为静态存储和动态存储

• auto 自动变量(动态存储方式)
• static 静态变量(静态存储方式)
• register 寄存器变量(动态存储方式)
• extern 外部变量(静态存储方式)

C++变量保存在堆还是栈？

• 如果对象是函数内的非静态局部变量，则对象，对象的成员变量保存在栈区。
• 如果对象是全局变量，则对象，对象的成员变量保存在静态区。
• 如果对象是函数内的静态局部变量，则对象，对象的成员变量保存在静态区。
• 如果对象是 new 出来的，则对象，对象的成员变量保存在堆区。

1
2
3
4
5
6

void foo() {
    int* p = new int[5]; 
}
// 在栈内存中存放了一个指向一块堆内存的指针 p
// 程序会先确定在堆中分配内存的大小，然后调用 operator new 分配内存
// 然后返回这块内存的首地址，存入栈中

堆与栈的效率

栈是程序启动的时候，系统分好了给你的，你自己用，系统不干预。

堆是用的时候才向系统申请的，用完了还回去，这个申请和交还的过程开销相对就比较大了。

堆相对于栈，效率低，多次分配（malloc/new）容易产生碎片，使用时最好结合相关操作系统（Linux、Windows、RTOS ）使用，因为系统针对内存管理有专门的优化算法，减少内存碎片。堆虽然有一定的缺点，但其最大的优点是使用灵活，而且堆容量大，一般需要申请比较大的内存块时，都会从堆中申请。

new 与 delete

堆内存（空闲空间）里的内存分配通过 new 表达式来完成，释放通过 delete 表达式来完成。堆内存由程序员自行管理。

1
2
3
4
5
6
7

int *p1 = new int;  // 未初始化
int *p2 = new int(1024); // 指定初值, p2 指向一个 int 对象，其值为 1024
int *p3 = new int[1024]; // 从 heap 中分配一个数组，含有1024个元素，p3 指向数组第一个元素
delete p1;
delete p2;  
delete [] p3  // new[] 与 delete[] 要一一对应
// 如果不使用 delete，由 heap 分配而来的对象就永远不会被释放，这被称之为内存泄漏。

【ESS 49，50】

new/delete 与 malloc/free 关系

malloc/free 是 C/C++ 的标准库函数，new/delete 是 C++ 的运算符。它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用 malloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于 malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于 malloc/free（malloc 只能申请内存，不能在申请内存的时候对所申请的内存进行初始化工作，而构造函数可以。free 只能释放内存，而如果析构函数设计得好的话，在释放内存的同时还可以完成额外的其他工作）。因此 C++ 语言需要一个能完成动态内存分配和初始化工作的运算符 new ，以及一个能完成清理与释放内存工作的运算符 delete 。

• new / new[]：完成两件事，先底层调用 malloc 分配内存，然后调用构造函数（创建对象）。
• delete/delete[]：也完成两件事，先调用析构函数（清理资源），然后底层调用 free 释放空间。
• new 在申请内存时会自动计算所需字节数，而 malloc 则需我们自己输入申请内存空间的字节数。

malloc/free 的使用

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

#include <iostream>
using namespace std;
int main() {
    int *score, num;
    cin >> num;
    if ((score = (int *)malloc(sizeof(int) * num)) == nullptr)
        cerr << "fail" << endl;
    else {
        do something;
        free(score); // 释放内存
    }
}

malloc、calloc、realloc的区别

• malloc与calloc的区别为1块与n块的区别

• realloc将 ptr 指向的内存的大小增大到 size，新增加的内存块没有初始化。

1
2
3

(type *)malloc(sizeof(type));	// 分配一个长度为 sizeof(type) 的连续空间，且未初始化，是随机数
(type *)calloc(n, sizeof(type)); // 分配 n 块 长度为 sizeof(type) 的连续空间，初始化，均为 0。
(type *)realloc(ptr, size)       // 将ptr指向的空间增大到size，新增加的内存块没有初始化。

宏

1
2
3

#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define POW(x) ((x) * (x))
// 为什么用括号？因为宏只是简单的字符替换

头文件

• 头文件的扩展名习惯上是.h，标准库例外。
• 函数的定义只能有一份，倒是可以有多份声明。我们不能把函数的定义放在头文件，因为一个程序的多个代码文件可能都会包含这个头文件。但只定义一份的规则有一个例外，内联函数。为了能够扩展内联函数的内容，以便在每个调用点上，编译器都取得其定义，必须将内联函数的定义放在头文件中，而不是放在各个不同程序代码文件中（如果两个函数在定义时函数名和参数列表都一样(返回类型可以不一样)，则会出错，因为重载要保证参数列表不一样）。
• 一个对象和变量同函数一样，也只能在程序中定义一次，因此也应该将定义放在程序代码文件中，而不是头文件中。一般地，加上 extern 就可以放在头文件中作为声明了。

1
2
3

// 如果想声明一个变量而非定义它，就在变量名前添加 extern 关键字，而且不要显式地初始化变量
extern int x;  // 声明 x 而非定义
int y;         // 声明并定义 y

• const int a = 6;就可以放入头文件中，因为 const object 就和 inline 函数一样，是”一次定义“规则下的例外。因为 const 定义一出文件外便不可见（文件作用域），这意味着可以在多个不同的文件中加以定义。

• 头文件用 <> 表明此文件被认为是标准的或项目专属的头文件，编译器搜索此文件时，会先在系统默认的磁盘目录下寻找；头文件用 ” “ 表明此文件被认为是用户提供的头文件，会先在包含此文件的磁盘目录开始寻找，找不到再去系统默认的目录下寻找。

【ESS 63，64】

#ifndef/#define/#endif作用

防止头文件的重复包含和编译

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

#ifndef A_H // 意思是 if not define a.h"  如果不存在a.h
#define A_H // 就引入 a.h
#include <math.h> // 引用标准库的头文件 
… 
#include “header.h” // 引用非标准库的头文件 
… 
void Function1(…); // 全局函数声明 
… 
class Box // 类结构声明 
{ 
… 
}; 
#endif  // 最后一句应该写 #endif，它的作用相当于 if 的反花括号 '}'

extern “C”

作为C语言的扩展，C++ 保留了一部分过程式语言的特点，因而它可以定义不属于任何类的全局变量和函数。但是，C++ 毕竟是一种面向对象的设计语言，为了支持函数的重载，C++ 对全局函数的处理方式有着明显的不同。

首先看一下 C++ 对类似C的函数是怎样编译的：

作为面向对象的语言，C++ 为了支持函数重载，函数在被 C++ 编译后在符号库中的名字与 C 语言的不同。假如某个函数的原型为 void foo(int x, int y);，该函数被 C 编译器编译后在符号库中的名字为 _foo，而 C++ 编译器则会产生 _foo_int_int 之类的名字。_foo_int_int 这样的名字是包含了函数名以及形参，C++就是靠这种机制来实现函数重载的。 如果在 C 中连接 C++ 编译的符号时，就会因找不到符号问题而发生连接错误。

被 extern “C” 修饰的函数或者变量是按照 C 语言方式编译和链接的，所以可以用一句话来概括 extern “C” 的真实目的：实现 C++ 与 C 的混合编程。

typedef 声明

可以使用 typedef 为一个已有的类型取一个新的名字。

typedef 可以声明各种类型名，但不能用来定义变量。用 typedef 可以声明数组类型、字符串类型，使用比较方便。

用 typedef 只是对已经存在的类型增加一个类型名，而没有创造新的类型。

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

typedef int feet;		// 告诉编译器，feet 是 int 的另一个名称：可以理解 feet 为 int 的别名
feet distance;			// 它创建了一个整型变量 distance

typedef int A[];		// 定义了数组类型，数组大小由初始化时候决定
typedef int B[9];		// 定义了大小为9的数组类型，用 B 定义并初始化数组时，元素个数不应超过9
A arra = { 0, 1, 2, 3, 4 };			// arra 长度为 5
cout << arra[3] << ' ' << sizeof arra/sizeof arra[0] << endl; // 打印 3 5
B arrb = { 0, 1, 2, 3, 4 };  		// 实际是 {0， 1， 2， 3， 4， 0， 0， 0， 0}
cout << arrb[8] << ' ' << sizeof arrb / sizeof arrb[0] << endl; // 打印 0 9

typedef int (*pfun)(int x, int y);  // 定义一个 pfun 类型，表明一个函数指针类型
int fun(int x, int y);
pfun p = fun;						// 定义了一个 pfun 类型的函数指针，并指向函数 fun
int ret = p(2, 3);

typedef struct Student				// 定义了一个 ST 类型的结构体，下次定义结构体可直接用 ST 定义，
{									// ST Lux = { 123, 'F' };
	int id;
	char sex;
}ST;

decltype 类型指示符

【PRIMER 62】

C++11新增decltype类型指示符，作用是选择并返回操作数的数据类型，此过程中编译器不实际计算表达式的值。

1

decltype(f()) sum = x;  // sum has whatever type f returns

decltype处理顶层const和引用的方式与auto有些不同，如果decltype使用的表达式是一个变量，则decltype返回该变量的类型（包括顶层const和引用）。

1
2
3
4

const int ci = 0, &cj = ci;
decltype(ci) x = 0;     // x has type const int
decltype(cj) y = x;     // y has type const int& and is bound to x
decltype(cj) z;     // error: z is a reference and must be initialized

如果decltype使用的表达式不是一个变量，则decltype返回表达式结果对应的类型。如果表达式的内容是解引用操作，则decltype将得到引用类型。如果decltype使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，则decltype会得到引用类型，因为变量是一种可以作为赋值语句左值的特殊表达式。

decltype((var))的结果永远是引用，而decltype(var)的结果只有当var本身是一个引用时才会是引用。

1
2
3

int i = 42;
decltype((i)) d1 = i; // d1 has type int&
decltype(i) d2 = i;   // d2 has type int

枚举类型

如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。每个枚举元素在声明时被分配一个整型值，默认从 0 开始，逐个加 1。也可以在声明时将枚举元素的值一一列举出来。

注意

• 枚举元素是常量，除了初始化时不可给它赋值。
• 枚举变量的值只可取列举的枚举元素值。

1
2
3
4
5
6

enum 枚举名{ 
     标识符[=整型常数], 
     标识符[=整型常数], 
... 
     标识符[=整型常数]
} 枚举变量;

如果枚举没有初始化,，即省掉 “=整型常数” 时，则从第一个标识符开始。

1
2
3
4
5

enum color { red, green, blue } c;
c = blue; // c 为枚举变量，把枚举元素 blue 赋给 c，此时 c = 2
// 若直接这样赋值 c = 2；就会报错！你只能把{ red, green, blue }赋值给 c。
// blue = 2；报错！blue 是常量而不是变量。
// 未初始化默认 red = 0, green = 1, blue = 2

若给某一个标识符赋值如 green = 5

1
2
3
4
5
6

enum color { red, green = 5, blue } c;
c = blue;	// 6
color d;	// d 也为枚举变量
d = red;	// d = 0
// 部分值初始化，要满足后面的值比前面值大 1，此时 red 默认为 0
// green 初始化为 5 ，blue 要满足比 green 大 1 即 blue = 6

C结构体、C++结构体、C++类的区别

C 结构体与 C++ 结构体

• C 语言中的结构体不能为空，否则会报错
• C 语言中的结构体只涉及到数据结构，而不涉及到算法，也就是说在 C 中数据结构和算法是分离的。换句话说就是 C 语言中的结构体只能定义成员变量，但是不能定义成员函数（虽然可以定义函数指针，但毕竟是指针而不是函数）。然而 C++ 中结构体既可以定义成员变量又可以定义成员函数， C++ 中的结构体和类体现了数据结构和算法的结合。

C++ 中结构体与类

• 相同之处： 结构体中也可以包含函数；也可以定义 public、private、protected 数据成员；定义了结构体之后，可以用结构体名来创建对象。也就是说在 C++ 当中，结构体中可以有成员变量，可以有成员函数，可以从别的类继承，也可以被别的类继承，可以有虚函数。总的一句话：class 和 struct 的语法基本相同，从声明到使用，都很相似。
• 区别：对于成员访问权限和继承方式，class 中默认的是 private，而 struct 中则是 public。class 还可以用于表示模板类型，struct 则不行。

实际上C++中保留struct关键字是为了使C++编译器能够兼容C语言开发的程序

结构体与联合体（共用体）的区别

• 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构体的所有成员都存在（不同成员的存放地址不同）。 （在 struct 中，各成员都占有自己的内存空间，它们是同时存在的。一个 struct 变量的总长度等于所有成员长度之和。在 Union 中，所有成员不能同时占用它的内存空间，它们不能同时存在。Union 变量的长度等于最长的成员的长度。）
• 对联合体不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

类型转换

【PRIMER 142-146】

无须程序员介入，会自动执行的类型转换叫做隐式转换（implicit conversions）。

算术转换

（Integral Promotions）

把一种算术类型转换成另一种算术类型叫做算术转换。

整型提升（integral promotions）负责把小整数类型转换成较大的整数类型。

其他隐式类型转换

（Other Implicit Conversions）

在大多数表达式中，数组名字自动转换成指向数组首元素的指针。

常量整数值0或字面值nullptr能转换成任意指针类型；指向任意非常量的指针能转换成void*；指向任意对象的指针能转换成const void*。

任意一种算术类型或指针类型都能转换成布尔类型。如果指针或算术类型的值为0，转换结果是false，否则是true。

指向非常量类型的指针能转换成指向相应的常量类型的指针。

显式转换

（Explicit Conversions）

显式类型转换也叫做强制类型转换（cast）。虽然有时不得不使用强制类型转换，但这种方法本质上是非常危险的。建议尽量避免强制类型转换。

命名的强制类型转换（named cast）形式如下：

1

cast-name<type>(expression);

其中type是转换的目标类型，expression是要转换的值。如果type是引用类型，则转换结果是左值。cast-name是static_cast、dynamic_cast、const_cast和reinterpret_cast中的一种，用来指定转换的方式。

• dynamic_cast支持运行时类型识别。
• 任何具有明确定义的类型转换，只要不包含底层const，都能使用static_cast。
• const_cast只能改变运算对象的底层const，不能改变表达式的类型。同时也只有const_cast能改变表达式的常量属性。const_cast常常用于函数重载。
• reinterpret_cast通常为运算对象的位模式提供底层上的重新解释。

早期版本的C++语言中，显式类型转换包含两种形式：

1
2

type (expression);    // function-style cast notation
(type) expression;    // C-language-style cast notation

类型安全

类型安全是指同一段内存在不同的地方，会被强制要求使用相同的办法来解释(内存中的数据是用类型来解释的)。

Java 语言是类型安全的，除非强制类型转换。

C 语言不是类型安全的，因为同一段内存可以用不同的数据类型来解释，比如 1 用 int 来解释就是 1，用 boolean来解释就是 true。

C++ 也不是绝对类型安全的，但使用得当，它将远比 C 更有类型安全性。

C++提供了一些新的机制保障类型安全：

• 操作符 new 返回的指针类型严格与对象匹配，而不是 void
• C 中很多以 void* 为参数的函数可以改写为 C++ 模板函数，而模板是支持类型检查的；
• 引入 const 关键字代替 #define constants，它是有类型、有作用域的，而 #define constants 只是简单的文本替换；
• 一些 #define 宏可被改写为 inline 函数，结合函数的重载，可在类型安全的前提下支持多种类型，当然改写为模板也能保证类型安全；
• C++ 提供了 dynamic_cast 关键字，使得转换过程更加安全，因为 dynamic_cast 比 static_cast 涉及更多具体的类型检查。

try语句块和异常处理

【PRIMER 172】

异常（exception）是指程序运行时的反常行为，这些行为超出了函数正常功能的范围。当程序的某一部分检测到一个它无法处理的问题时，需要使用异常处理（exception handling）。

异常处理机制包括throw表达式（throw expression）、try语句块（try block）和异常类（exception class）。

• 异常检测部分使用throw表达式表示它遇到了无法处理的问题（throw引发了异常）。
• 异常处理部分使用try语句块处理异常。try语句块以关键字try开始，并以一个或多个catch子句（catch clause）结束。try语句块中代码抛出的异常通常会被某个catch子句处理，catch子句也被称作异常处理代码（exception handler）。
• 异常类用于在throw表达式和相关的catch子句之间传递异常的具体信息。

throw表达式

throw表达式包含关键字throw和紧随其后的一个表达式，其中表达式的类型就是抛出的异常类型。

try语句块

try语句块的通用形式：

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

try
{
    program-statements
}
catch (exception-declaration)
{
    handler-statements
}
catch (exception-declaration)
{
    handler-statements
} // . . .

try语句块中的program-statements组成程序的正常逻辑，其内部声明的变量在块外无法访问，即使在catch子句中也不行。catch子句包含关键字catch、括号内一个对象的声明（异常声明，exception declaration）和一个块。当选中了某个catch子句处理异常后，执行与之对应的块。catch一旦完成，程序会跳过剩余的所有catch子句，继续执行后面的语句。

如果最终没能找到与异常相匹配的catch子句，程序会执行名为terminate的标准库函数。该函数的行为与系统有关，一般情况下，执行该函数将导致程序非正常退出。类似的，如果一段程序没有try语句块且发生了异常，系统也会调用terminate函数并终止当前程序的执行。

标准异常

异常类分别定义在4个头文件中：

• 头文件exception定义了最通用的异常类exception。它只报告异常的发生，不提供任何额外信息。

• 头文件stdexcept定义了几种常用的异常类。

  

• 头文件new定义了bad_alloc异常类。

• 头文件type_info定义了bad_cast异常类。

标准库异常类的继承体系：

只能以默认初始化的方式初始化exception、bad_alloc和bad_cast对象，不允许为这些对象提供初始值。其他异常类的对象在初始化时必须提供一个string或一个C风格字符串，通常表示异常信息。what成员函数可以返回该字符串的string副本。

类 & 对象

类包含对象所需的数据，以及描述用户与数据交互所需的操作。

成员函数可以定义在类内部，或者单独使用范围解析运算符（域区分符） :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即使没有使用 inline 标识符。

类的成员名和方法的参数名不能相同，建议成员名加上 ’m’ 前缀或者末尾加上 ‘_’。

【PLUS 353】

类对象声明

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

class C
{
public:
    C() { std::cout << "call C()" << std::endl; };
    C(int _m) : m(_m) { std::cout << "call C(int m)" << std::endl; };

private:
    int m;
};

int main()
{
    C c1;    // call C()
    C c2();  // 仅仅声明了一个函数 c2，它返回 C 类型，所以不要乱加括号
    C c3(1); // call C(int m)

    return 0;
}

类访问修饰符

• public：公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值。
• private：私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员（派生类也不能访问）。
• protected：保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

封装继承多态

封装

封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（称之为类）。

封装的意义在于保护或者防止代码（数据）被无意中破坏。

继承

继承主要实现代码重用，节省开发时间。子类可以继承父类的一些东西。

有 public, protected, private 三种继承方式，它们相应地改变了派生类的用户以及派生类的派生类的访问权限。

• public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private

• protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private

• private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：

• private 成员只能被本类成员（类内，不是实例化的对象）和友元访问，不能被派生类访问；
• protected 成员可以被派生类（类内，不是实例化的对象）访问。

私有继承的作用

私有继承时，编译器一般不会将派生类对象转换成基类对象。且派生类与基类不是 is a 的关系，而是意味着“is implement in terms of”（以……实现）的关系。如果类D私有继承于B，这样做，只是因为D想使用B中的某些代码，而不是因为类D的对象与类B的对象之间右什么概念上的关系。因此，私有继承在软件“设计”过程中毫无意义，只是在软件“实现”时才有用。

私有继承与组合的不同

• 组合是has a关系，如果需要使用一个对象的某些方法，可以用组合，也可以私有继承。选择它们的原则是尽可能使用组合，万不得已才使用继承。继承最大的问题就在于：继承层次过深、继承关系过于复杂会影响到代码的可读性和可维护性（继承了无用或者有害的方法，代码膨胀等，还有，在继承时，基类之间或基类与派生类之间发生成员同名时，将出现对成员访问的不确定性，即同名二义性）。
• 私有继承中派生类能访问基类的protected成员，并且可以重写基类的虚函数，甚至当基类是抽象类的情况。组合不具有这样的功能。

多态

同一个方法在派生类和基类中的行为是不同的，即方法的行为取决于调用该方法的对象。有两种重要的机制可以实现多态公有继承：

• 在派生类中重新定义基类的方法
• 使用虚方法

【注意】在派生类中重新定义基类的方法，会导致基类方法被隐藏（函数隐藏），这不是重载，重载是一个类中的方法与另一个方法同名，但是参数表不同，这种方法称之为重载方法。

重载与重写

• 重写（overried，覆盖、覆写）：是指子类重新定义父类虚函数的方法。与多态有关。

• 重载（overload）：是指允许存在多个同名函数，而这些函数的参数列表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）返回值类型随意。与多态无关。

  • C++中 const 用于函数重载。常成员函数不能更新类的成员变量，也不能调用该类中没有用const修饰的成员函数，只能调用常成员函数。非常量对象可以调用常成员函数和非常成员函数，但是如果有重载的非常成员函数则会调用非常成员函数。

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

    class C { public: C(int v) : mValue(v){}; void fun() const { std::cout << "void fun() const" << std::endl; }; void fun() { std::cout << "void fun()" << std::endl; }; private: int mValue; }; int main() { const C c1(1); C c2(2); c1.fun(); c2.fun(); return 0; } /* 打印 void fun() const void fun() **/

  • 顶层const是不支持重载的，因为函数调用的时候，存在形实结合的过程，所以不管有没有const都不会改变实参的值。

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

    void fun(char *s) { std::cout << "non-const fun() " << s << std::endl; } void fun(char *const s) // 顶层 const 不支持重载 { std::cout << "const fun() " << s << std::endl; } /** 编译出错 test.cpp:21:6: error: redefinition of ‘void fun(char*)’ void fun(char *const s) ^~~ test.cpp:16:6: note: ‘void fun(char*)’ previously defined here void fun(char *s) ^~~ */

  • ​ 底层const支持重载

    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

    void fun(char *s) { std::cout << "non-const fun() " << s << std::endl; } void fun(const char *s) // 底层 const 支持重载 { std::cout << "const fun() " << s << std::endl; } int main() { char *ptr1 = "hello"; const char *ptr2 = "world"; fun(ptr1); fun(ptr2); return 0; } /** non-const fun() hello const fun() world */ // 对于引用也是同样的道理，如 // void fun(int &i) 和 void fun(const int &i) 也是可以重载的。 // 原因是第一个 i 引用的是一个变量，而第二个 i 引用的是一个常量，两者是不一样的，类似于上面的指向变量的指针和指向常量的指针。

构造函数与析构函数

 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

class Line
{
	private:
	double length;
	
	public:
		void setLength(double len);
		Line(double len); 	// 构造函数的名称与类的名称完全相同。不会返回任何类型，也不会返回 void，常用于赋初值
		~Line();  			// 析构函数，函数名与类完全相同，只是在前面加了一个波浪号（~）作为前缀，它不会返回任何值，也不会返回void，也不能带有任何参数（所以不可以被重载）。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
		double Line::getLength(void)  //方法可以定义在类中
        {
			return length;
		}
};

Line::Line(double len) // 方法也可以通过范围解析运算符定义在类外，这是构造函数的具体实现，注意函数前无类型
{
	cout << "Object is being created, length = " << len << endl;
	length = len; //初始化属性
}

Line::~Line(void)
{
	cout << "Object is being deleted" << endl;
}

也可以使用初始化列表来初始属性

1
2
3
4

Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

1
2
3
4
5
6

// 同时初始化多个值
Person::Person( double name, double age, double job): Name(name), Age(age), Job(job)  
// 将参数 name, age, job 初始化给属性 Name, Age, Job
{
  ....
}

构造函数不同于类方法，因为它创建新的对象，而其他类对象只是被现有的类调用。这是构造函数不能被继承的原因之一。 继承意味着派生类继承基类的成员函数和成员变量，然而，在构造函数完成其工作之前，对象并不存在。

一定要使用显式析构函数来释放类构造函数使用 new 分配的所有内存，并完成类对象所需的任何特殊的清理工作。对于基类即使它不需要析构函数，也应提供一个虚析构函数。

初始化派生类把基类中所有的成员继承过来，除了构造函数和析构函数。友元函数不属于类，它只是给类开了一个后门，自然不能被继承。子类继承父类，那么默认的，就是继承了父类的成员函数和成员变量。

初始化子类时，会先自动调用父类的构造函数，然后才调用子类的构造函数。

析构时，按相反顺序进行。

构造从类层次的最根处开始，在每一层中，首先调用基类的构造函数，然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编译器将无法自动执行析构过程。

【PLUS 524，525，527】

不同于其他函数，构造函数不能被声明为const。当我们创建类的一个const对象时，直到构造函数完成初始化过程，对象才真正取得其常量属性。因此，构造函数在const对象的构造过程中可以向其写值。

【PRIMER 235】

构造函数可以被重载，析构函数不可以被重载。因为析构函数只能有一个且不带参数。

委托构造函数

C++11扩展了构造函数初始值功能，可以定义委托构造函数。委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程。【PRIMER 261】

= default和= delete

在C++中，声明自定义的类型之后，编译器会默认生成一些成员函数，这些函数被称为默认函数。其中包括：

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

class A
{
    // C++03
    A();                     // 默认构造函数
    A(const A &);            // 拷贝构造函数
    ~A();                    // 析构函数
    A &operator=(const A &); // 拷贝赋值运算符

    // C++11 新增
    A(A &&);            // 移动构造函数
    A &operator=(A &&); // 移动赋值运算符
};

这6个函数的实现例子，以string为例，查看实现

另外，编译器还会默认生成一些操作符函数，包括：

（7）operator ,

（8）operator &，有两个，const版本和非const版本

1
2

A* operator&();                 //取址运算符
const A* operator&() const;     //取址运算符(const版本)

（9）operator &&

（10）operator *

（11）operator ->

（12）operator ->*

（13）operator new

（14）operator delete

= default 显示缺省函数

只有当类没有声明任何构造函数时，编译器才会自动生成默认构造函数。一旦类定义了其他构造函数，那么除非再显式地定义一个默认的构造函数，否则类将没有默认构造函数。【PRIMER 236】

在C++11中，如果类需要默认的函数行为，可以通过在参数列表后面添加=default来要求编译器生成构造函数。其中=default既可以和函数声明一起出现在类的内部，也可以作为定义出现在类的外部。和其他函数一样，如果=default在类的内部，则默认构造函数是内联的。

1

Sales_data() = default;

= delete 显示删除函数

另一方面，有时候可能需要限制一些默认函数的生成。

例如：需要禁止拷贝构造函数的使用。以前通过把拷贝构造函数声明为private访问权限，这样一旦使用编译器就会报错。

而在 C++11 中，只要在函数的定义或者声明后面加上= delete就能实现这样的效果。这种方式不容易犯错，且更容易理解。

在C ++ 11之前，操作符delete 只有一个目的，即释放已动态分配的内存。而C ++ 11标准引入了此操作符的另一种用法，即：禁用成员函数的使用。这是通过附加= delete说明符到该函数声明的结尾。

拷贝（复制）构造函数

 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

class Line
{
    public:
    	Line(int len);  //构造函数
    	Line(const Line &obj);  //拷贝构造函数
    	~Line();  //  析构函数
    
    private:
    	int *ptr;
};

// 成员函数定义，包括构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}
 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}
 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}

什么情况使用拷贝构造函数

 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

class Test
{
public:
	int a;
	Test(int x) : a(x) { cout << "Test(int x)" << endl; }
	Test(const Test& t)
	{
		cout << "copy constructor" << endl;
		a = t.a;
	}
};

void fun1(Test test)
{
	cout << "fun1()" << endl;
}

Test fun2()
{
	Test t(2);
	cout << "fun2()" << endl;
	return t;
}

int main(int argc, char* argv[]) {
	Test t1(1);
	cout << "-------\n";
	Test t2(t1);					// 通过使用另一个同类型的对象来初始化新创建的对象。
	cout << "-------\n";
	fun1(t1);						// 复制对象把它作为参数传递给函数。
	cout << "-------\n";
	fun2();							// 复制对象，并从函数返回这个对象，返回对象时调用拷贝构造函数。
	//Test t3 = fun2();
    
	getchar();
	return 0;
}
/* 打印
Test(int x)
-------
copy constructor
-------
copy constructor
fun1()
-------
Test(int x)
fun2()
copy constructor
*/

**类的对象需要拷贝时，拷贝构造函数将会被调用。**以下情况都会调用拷贝构造函数：

• 通过使用另一个同类型的对象来初始化新创建的对象。
• 复制对象，把它作为参数传递给函数。
• 复制对象，并从函数返回这个对象。

浅复制与深复制

如果在类中没有显式地声明一个复制构造函数，那么，编译器将会自动生成一个默认的复制构造函数，该构造函数完成对象之间的浅复制。

自定义复制构造函数是一种良好的编程风格，它可以阻止编译器形成默认的复制构造函数，提高源码效率。

所谓浅复制，直接为数据成员赋值即可。比如一个实类 c1 里的数据成员里有一个指针 c1.p 指向字符数组 str[] = “hello”，使用浅复制来初始化类 c2，则赋值为 c2.p = c1.p，那么通过 c1.p 改变了 str，c2.p 指向的内容也会改变。

而深复制要创建新的对象，要为对象的数据成员分配存储空间，直接赋值就将值保存在相应的空间中。比如

1
2
3

// c1, c2 均是类
c2.p = new char[strlen(c1.p) + 1]; 
strcpy(c2.p, c1.p); 

让 c2.p 指向 new 出来的空间，这时 c1.p 里的内容改变了也不会影响 c2.p。

编译器与默认的 copy constructor

• 如果用户定义了一个构造函数（不是拷贝构造函数），且此时在代码中用到了拷贝构造函数，那么编译器会生成默认的拷贝构造函数；如果没有使用，编译器就不会生成默认的拷贝构造函数；
• 如果用户定义了拷贝构造函数，则编译器就不会再生成拷贝构造函数。

为什么复制构造函数可以访问参数对象的私有成员

封装是编译期的概念，是针对类型而非对象的，在类的成员函数中可以访问同类型实例对象的私有成员变量。

参考：https://blog.csdn.net/ganwenbo2011/article/details/100919900

拷贝构造函数与赋值函数的区别

1
2

A (const A&other) // 拷贝构造函数重载声明
A& operator = (const A& other) // 赋值函数重载声明

• 一般来说在数据成员包含指针对象的时候，需要考虑两种不同的处理需求：一种是复制指针对象，另一种是引用指针对象。拷贝构造函数大多数情况下是复制，而赋值函数是引用对象。

• 拷贝构造函数是一个对象初始化一块内存区域，这块内存就是新对象的内存区。赋值构造函数则是把一个对象赋值给一个原有的对象，所以，对于赋值函数，如果原来的对象中有内存分配，就要先把内存释放掉，而且还要检查一下两个对象是不是同一个对象，如果是的话就不做任何检测。

1
2
3
4
5
6

class A;
A a;
A b = a;   // 调用拷贝构造函数（b 不存在）
A c(a) ;   // 调用拷贝构造函数
A d;
d = a;     // 调用赋值函数（d 已初始化）

以字符串的为例子，理解拷贝构造函数和赋值函数

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

String::String(const String &other) //拷贝构造函数
{
    cout << "copy construct" << endl;
    m_string = new char[strlen(other.m_string) + 1]; //分配空间并拷贝
    strcpy(m_string, other.m_string);
}

String &String::operator=(const String &other) //赋值运算符
{
    cout << "operator =funtion" << endl;
    if (this == &other) //如果对象和other是用一个对象，直接返回本身
    {
        return *this;
    }
    delete[] m_string; //先释放原来的内存
    m_string = new char[strlen(other.m_string) + 1];
    strcpy(m_string, other.m_string);
    return *this;
}

临时对象的复制与析构

 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
77

class C
{
public:
    C() : mValue(0)
    {
        std::cout << "default constructor, value = " << mValue << std::endl;
    };
    C(const C &c)
    {
        mValue = c.mValue;
        std::cout << "copy constructor, value = " << mValue << ", this = " << std::hex << this << std::endl;
    };
    C &operator=(const C &c)
    {
        if (this == &c)
            return *this;
        mValue = c.mValue;
        std::cout << "assignment function, value = " << mValue << ", this = " << std::hex << this << std::endl;
        return *this;
    };
    C(int v) : mValue(v)
    {
        std::cout << "constructed by parameter: " << std::dec << mValue << ", this = " << std::hex << this << std::endl;
    };
    virtual ~C()
    {
        std::cout << "destructor, value = " << mValue << ", this = " << std::hex << this << std::endl;
    };

private:
    int mValue;
};

C create(C c)
{
    std::cout << "start creat" << std::endl;
    return c;
}

int main()
{
    C c1 = create(5);
    std::cout << "finish creat c1" << std::endl;
    C c2 = create(c1);
    std::cout << "finish creat c2" << std::endl;
    C c3 = create(8);
    std::cout << "finish creat c3" << std::endl;
    C c4 = 12;
    std::cout << "finish creat c4" << std::endl;
    c4 = c1;
    return 0;
}
// g++ test.cpp -o test -std=c++11 -m32
/* 打印
constructed by parameter: 5, this = 0xffb5a528 // create 函数值传递，调用带参数的构造函数，生成临时对象
start creat
copy constructor, value = 5, this = 0xffb5a520 // return 值，调用拷贝构造函数，生成临时对象
destructor, value = 5, this = 0xffb5a528       // 析构值传递所产生的临时对象（形参）
finish creat c1
copy constructor, value = 5, this = 0xffb5a530 // create 函数值传递，调用拷贝构造函数，生成临时对象
start creat
copy constructor, value = 5, this = 0xffb5a518 // return 值，调用拷贝构造函数，生成临时对象
destructor, value = 5, this = 0xffb5a530       // 析构值传递所产生的临时对象（形参）
finish creat c2
constructed by parameter: 8, this = 0xffb5a538 // create 函数值传递，调用带参数的构造函数，生成临时对象
start creat
copy constructor, value = 8, this = 0xffb5a510 // return 值，调用拷贝构造函数，生成临时对象
destructor, value = 8, this = 0xffb5a538       // 析构值传递所产生的临时对象（形参）
finish creat c3
constructed by parameter: 12, this = 0xffb5a508 // 隐式转换，调用带参数的构造函数
finish creat c4
assignment function, value = 5, this = 0xffb5a508 // 调用赋值函数，将 c1 赋给 c4
destructor, value = 5, this = 0xffb5a508 // c4 析构
destructor, value = 8, this = 0xffb5a510 // c3 析构
destructor, value = 5, this = 0xffb5a518 // c2 析构
destructor, value = 5, this = 0xffb5a520 // c1 析构
*/