C++——入门

        C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。

1.C++关键字(C++98)

C语言有 32个关键字，而C++总计63个关键字。取变量名称时不能与关键字冲突。

2.命名空间

       C++是在C语言的基础上进行扩展的一门语言，而C语言中存在着一些不完善的地方，所以C++的一些知识旨在解决C语言留下的坑。

我们简单写一些代码

#include <stdio.h>

int rand = 100;
int main()
{
	printf("%d\n", rand);
	return 0;
}

#include <stdio.h>
#include<stdlib.h>//rand函数在里面

int main()
{
	printf("%p\n", rand);//默认会去全局搜索，是函数指针
	return 0;
}

很正常的两份代码，但如果写到一起就会报错

#include <stdio.h>
#include<stdlib.h>//rand函数在里面

int rand = 100;//全局变量
int main()
{

	printf("%d\n", rand);//报错
	return 0;
}

报错的原因是命名冲突，命名冲突在编译阶段报错，C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决命名冲突问题。

        在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称都将存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

#include <stdio.h>
#include<stdlib.h>

namespace jxy //命名空间是为了解决 命名冲突 的问题
{
	int rand = 17;
}
int main()
{
	printf("%p\n", rand);//是函数指针
	printf("rand=%d\n", jxy::rand);
	return 0;
}

这样写就解决了命名冲突问题。

2.1命名空间的定义

定义命名空间，需要使用到 namespace关键字，后面跟 命名空间的名字，然后接一对 {}即可， {}

中即为 命名空间的成员。例如：

namespace jxy
{
	int rand = 17;
}

2.1.1命名空间中可以定义变量、函数和结构体（类型）

namespace jxy
{
	//命名空间可以定义 变量 、函数、结构体(类型)

	int rand = 17;


	int Add(int x, int y)
	{
		return x + y;
	}

	struct Node
	{
		struct Node* next;
		int x;
	};

}

2.1.2 命名空间可以嵌套命名空间

namespace jxy
{
	//命名空间还可以嵌套命名空间  

    int rand=100;

	namespace xxx
	{
		int rand = 10;
	}
}

2.1.3补充

同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中，同名命名空间可以合并，但同一个命名空间（域）中不能定义同一个变量，例如：

注意： 一个命名空间就是定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

2.2命名空间的使用

命名空间的使用有三种方式：

2.2.1域作用限定符 ::

使用命名空间名称加作用域限定符

#include <stdio.h>
#include<stdlib.h>

namespace jxy 
{
	int rand = 17;

	int Add(int x, int y)
	{
		return x + y;
	}

	struct Node
	{
		struct Node* next;
		int x;
	};
	
    namespace xxx
	{
		int rand = 10;
	}
}

int main()
{
	printf("rand=%d\n", jxy::rand);
                        // ::叫做域作用限定符
	
    printf("rand=%d\n", jxy::Add(60,40));

	struct jxy::Node node;//使用命名空间中的结构体

	printf("rand=%d\n", jxy::xxx::rand);

	return 0;
}

这种写法是不对的

2.2.2部分展开（授权）

使用using将命名空间中某个成员引入，我们称之为部分展开（授权）。

namespace jxy
{

	int rand = 17;

}

using jxy::rand;
//部分展开（授权）
int main()
{
	printf("rand=%d\n",rand);//这样就不需要使用域作用限定符了
	return 0;
}

部分展开也可能再次导致命名冲突。

2.2.3全部展开（授权）

使用using namespace加命名空间名称引入，我们称之为全部展开。

using namespace jxy;//展开后该命名空间中的成员就可以直接使用了
int main()
{
	printf("rand=%d\n", rand);
	printf("rand=%d\n", jxy::rand);

	printf("rand=%d\n", Add(60,40));
	printf("rand=%d\n", jxy::Add(60, 40));

	struct Node node;
	struct jxy::Node node1;

	printf("rand=%d\n", jxy::xxx::rand);
	return 0;
}

但全部展开命名空间是很危险的事情，很容易再次导致命名冲突。

3.C++的输入&输出

3.1cout

cout：标准输出对象(控制台)，c是console（控制台），out是输出

​#include<iostream>

using namespace std;

int main()
{
	cout << "hello world" << endl;//打印hello world
	//如果不展开，要写成
	std::cout << "hello world" << std::endl;
	return 0;
}

​

3.2cin

cin：标准输入对象(键盘)，in是输入

using namespace std;

int main()
{
	int i = 0;
	cin >> i;//从控制台提取一个变量给i

	cout << i << endl;//打印i的值
	return 0;
}

3.3<<：流插入运算符

3.4>>：流提取运算符

上述两运算符比scanf、printf效率低。

3.5endl

endl表示换行输出，可以看作换行符 "\n"

using namespace std;

int main()
{
	cout << "hello world" << endl;
	cout << "hello world"<<'\n';//二者相同

	return 0;
}

3.6注意

1.使用 cout标准输出对象(控制台)和 cin标准输入对象(键盘)时，必须 包含< iostream >头文件，并且按照命名空间的使用方法使用std。

#include<iostream>
// io流  头文件中包括std命名空间
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中，避免定义冲突，避免和使用者命名冲突
namespace std
 {
  ......
 }
//使用std里的成员要展开头文件

//#include<iostream.h> 过于古老
//早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(如VC6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式。

2.cout和cin是 全局的流对象，endl是 特殊的C++符号，表示换行输出，他们都包含在<iostream >头文件中。

3.使用C++输入输出更方便，不需要像 printf 和 scanf 输入输出时那样， 需要手动控制格式。C++的输入输出可以 自动识别变量类型、自动匹配，无需去关心类型。

using namespace std;

int main()
{

    int i = 0;
	double j = 3.14;

	cin >> i;//从控制台提取一个变量给i
	cin >> j;
//另一种写法：cin>>i>>j;//先输入i的值
	
	cout << "i="<<i << endl;//打印i的值
	cout << "i的地址:"<< & i << endl;

	cout << "j="<<j << endl;
	cout << "j的地址:" << &j << endl;
	
	return 0;
}

4.想控制浮点数精度，建议使用C语言

printf("%.2lf",j);

5.cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这里只是简单地学习下如何使用它们。

6. std命名空间的使用惯例

std是C++标准库的命名空间，如何展开std使用更合理呢？

1. 在日常练习中，建议直接using namespace std即可，这样很方便。

2. using namespace std展开，标准库就全部暴露出来了，如果我们定义和库重名的类型、对

象和函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模

大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 +

using std::cout展开常用的库对象或类型等方式。

4.缺省参数

4.1概念

缺省参数是 声明或定义函数时为函数的 参数指定一个缺省值。在调用该函数时，如果没有指定实

参则采用该形参的缺省值，否则使用指定的实参。

using namespace std;

void Func(int a = 1)//a被称作缺省参数  可以通俗地看作备胎
{
	cout << "a=" << a << endl << endl;
}
int main()
{
	Func(2);//传参时，使用指定的实参      打印2
	Func();//没有传参时，使用参数的默认值  打印1
	return 0;
}

4.2分类

4.2.1全缺省参数

全缺省，指所有参数都缺省，使用时可以一个参数都不传

void Func1(int a = 0, int b = 1, int c = 2)
{
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	cout << "c=" << c << endl<<endl;
}

int main()
{

	Func1();
	Func1(1);//只能传给第一个
	Func1(1,2);//只能传给第一、二个
	Func1(1,2,3);
	//Func1(1, , 3);//不能这样传参数

	return 0;
}

注意：传参时是从左往右显示传参

4.2.2半缺省参数

半缺省，也称为部分缺省吗，使用时需要传参

注意：半缺省参数必须从右往左依次来给出，不能间隔着给

void Func2(int a , int b = 22, int c = 33)
//使用时需要给a传参，至少传一个参数
{
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	cout << "c=" << c << endl << endl;
}

4.3应用实例

比如在初始化一个栈的时候，不知道在最开始开辟多大的空间，这时就可以使用缺省参数

4.4补充

4.4.1缺省参数不能在函数声明和定义中同时出现

缺省参数不能在函数声明和定义中同时出现，当函数的声明与定义分离时，不允许缺省参数在函数声明和定义中同时出现，这样做是为了 避免二者所给值不同，如图

如果缺省值在 声明与定义的位置 同时出现，并且两个位置提供的值不同，那么编译器就 无法确定到底该用那个缺省值。

正确的写法是分离时声明给缺省值，定义不给。

4.4.1.1补充：链接冲突

然而此时发现依旧会报错，这是为什么？

       原因是发生了链接冲突。我们知道编译阶段每个源文件（.c/.cpp）都会生成一个目标文件，而图中两个源文件都包含了Stack.h这个头文件，头文件展开就是拷贝一份过来，所以两个源文件定义了同名函数，都定义了StackPush函数，定义会生成代码、一段指令，函数名和地址会进入符号表，汇编阶段两个源文件的符号表都会生成StackPush函数的相关信息，链接阶段，符号表进行合并，但两个源文件都有StackPush，就会发生重定义，就会报错，声明不会到符号表中去，所以test.cpp中的StackInit和Stack.cpp中的StackInit不会冲突。

所以多个源文件时要使得函数的声明与定义分离。

 当然，上述问题也可以使用static解决，static可以影响链接属性。全局变量在所有地方都可见，可见的意思，本质是它会进入符号表。static可以使其只在当前文件中可见，static会改变链接属性，从外部链接改成内部链接，使其只能在当前文件中使用。

4.4.2缺省值必须是常量或者全局变量

4.4.3C语言不支持（编译器不支持）

5.函数重载

重载的意思就是一词多义。自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。

正如一个笑话：中国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”。这就是重载。

5.1概念

函数重载即为一个函数有多重意思。函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。函数重载调用时也不需要关注类型，可以自动匹配。
C语言不允许存在同名函数，C++可以，但是要求构成函数重载。

5.2分类

5.2.1函数名相同，参数类型不同

int Add(int  left, int right)
{
	cout << "int Add(int  left, int right)" << endl;
	return left + right;
}

double Add(double  left, double right)
{
	cout << "int Add(double  left, double right)" << endl;
	return left + right;
}

5.2.2函数名相同，参数个数不同

int Add1(int a, int b)
{
	return a + b;
}


int Add1(int a, int b, int c)
{
	return a + b + c;
}

5.2.3函数名相同，参数类型的顺序不同

int Add2(int a, char b)
{
	return a + b;
}


int Add2(char b, int a)
{
	return a + b;
}

5.2.4注意

5.2.4.1函数重载要求在同一个作用域，不同域不构成。

namespace jxy1
{
	void func(int x)
	{

	}
}

//不构成函数重载！
namespace jxy2
{
	void func(double x)
	{

	}
}

5.2.4.2有些函数重载调用时会存在歧义

void func(int a)//参数个数不同，构成重载  但调用时存在歧义
{

}
void func(int a, int b = 1)//存在缺省参数
{

}


int main()
{
//  func(1);//调用存在歧义，编译器无法判断调用的是哪个函数
	func(1, 2);//可以正常使用，这个调用的一定是第二个函数

    return 0;
}

5.2.4.3只有函数的返回值类型不同时，不能构成重载

int Add(int  left, int right)
{
	cout << "int Add(int  left, int right)" << endl;
	return left + right;
}

//不构成重载，会报错
double Add(int  left, int right)
{
	cout << "int Add(double  left, double right)" << endl;
	return left + right;
}

6.C++支持函数重载的原理

C++支持函数重载的原理：名字修饰(name Mangling)即函数名修饰规则，不同编译器的修饰规则不尽相同

C++编译链接的过程和C语言是几乎是一样的，在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

6.1预处理

Linux环境下，源文件（如 test.cpp）经过预处理生成 test.i。

预处理阶段：头文件展开、宏替换、去掉注释、条件编译

6.2编译

test.i经过编译生成 test.s（其中为汇编代码）

编译阶段：检查语法、生成汇编代码（是指令级代码）

6.3汇编

test.s经过汇编生成 test.o（其中为二进制代码）

汇编阶段：将汇编代码生成二进制的机器码，生成符号表，符号表中是函数名（或者变量）和地址的映射

6.4链接

test.o经过链接生成可执行程序 a.out或xxx.exe

链接阶段：合并链接，生成可执行程序

合并链接：如果有多个源文件，就会有多个目标文件，将他们合并在一起，主函数调用的某个函数可能不在当前文件中，就要去其他文件中找，要在符号表中 用名字去找地址。

6.5C语言与C++ 符号表中函数名的区别

C语言会直接用函数名字去充当符号表中函数的名字，如果两个函数名字相同的话，符号表就乱了，如果查找地址，也不知道应该去哪个名字下找，所以C语言区分不清楚同名函数，因此C语言不允许重名。//？

那么C++如何解决这一问题呢？

它引入了函数名修饰规则，在C++中,符号表中的函数名字不是直接使用函数名，而是使用修饰以后的函数名，修饰后的函数名本质上相当于把类型带进名字中去了

6.6补充

6.6.1

函数只有声明没有定义就无法找到地址，函数被编译完是一串指令，函数的地址本质上可以认为是跳转指令+第一句指令的地址，函数没有定义无法生成指令，也就没有地址。函数没有实现就不能被编译成一串指令、建立栈帧，生不成地址，在符号表中拿名字去找就找不到，就会报错。

6.6.2

只有返回值不同时，为什么不能构成函数重载？

因为在函数名修饰规则中，没有将返回值类型带进符号表中的函数名里。

假设能够修改一些规则，例如将返回值也写入函数名修饰规则中，那么能做到只有返回值不同时，构成函数重载吗？

答案是不能的！ 因为哪怕使用别的特殊符号来替代返回值类型，将返回值类型也写入符号表中的函数名里，但是调用函数时是不使用返回值的！如图

除非把函数调用的规则也更改掉，比如上述函数调用改为，当然这是不可能的。

void func(1, 1.2);//意为调用返回值类型为void的那个func函数

7.引用

7.1概念

引用不是 新定义一个变量，而是 给已存在变量取了一个别名， 或者说取了一个外号，编译器不会为引用变量 开辟内存空 间，它和它引用的变量 共用同一块内存空间。

举个例子：水浒传中的 李逵，在家被称为" 铁牛"，而在江湖上人称" 黑旋风"。这就是引用。

类型& 引用变量名(对象名) = 引用实体；
注意：引用类型必须和引用实体是同种类型的

#include<iostream>

using namespace std;
int main()
{
	int a = 0;
	int& b = a;//定义引用类型
    //这里不是取址，是取别名、取外号，即引用
    //有块空间，最开始只有一个名字叫a，后来又取了个名字叫b，C++中允许同一块空间可以有多个名字
	
	//C++为了避免使用各种符号不好记忆，允许一个符号有多重意思
	//符号赋予了新的意思，但原来的意思还可以继续使用
	
//例如：cout << a;  此时 << 移位操作符用作流插入运算符

	cout << &a << endl;	//&在类型和变量中间时才叫引用，否则就是取地址
	cout << &b << endl;//这里都是取址

	b++;//二者都会变化，a、b操纵的是同一个变量
	a++;

	return 0;
}

7.2特性

7.2.1引用在定义时必须初始化

    int& b;//引用必须在定义的时候初始化，这里是错误的

7.2.2一个变量可以有多个引用

	int a = 0;
	int& b = a;//给a取别名为b
	int& c = a;
	int& d = b;//给别名取别名

7.2.3引用一旦引用一个实体，再不能引用其他实体

	int a = 0;
	int& b = a;//给a取别名为b
	int& c = a;
	int& d = b;//给别名取别名

	int x = 1;
	b = x;//这里是赋值
	//引用一旦引用一个实体，再不能引用其他实体
	//这也是C++引用与Java引用的本质区别
	//Java的引用可以改变指向，C++的引用不能改变指向
	//C++脱离不开指针
	//C++的引用是从一而终的

//  int& b=x;//这样写也是错误的，b已经定义过了，重定义了

7.3使用场景

7.3.1做参数

void Swap(int& a, int& b)//不需要传地址了
//实参传给形参，形参的改变可以影响实参
{
	int tmp = a;
	a = b;
	b = tmp;
}

还有需要做输出型参数时也很有意义

7.3.2做返回值

7.3.2.1传值返回

int Count()//传值返回
{
	int n = 0;
	n++;

	return n;
}


int main()
{
	int ret = Count();//不是把n返回给了ret
	//调用函数，函数结束的时候，n已经被销毁了
	//n在Count这个函数的栈帧里面，调用Count，Count结束了，栈帧也就销毁了
	//所以不能拿n返回
	//实际设计：中间会生成一个临时变量,临时对象具有常性，不能修改，可能用寄存器充当，也可能使用其它方式
	//一般是用寄存器（把n的值拷贝到一个寄存器），然后寄存器充当返回值，一般比较小时会这么做
	//或者在上一层的函数栈帧（即main函数）中提前开好（n比较大时）

	cout << ret << endl;
	cout << ret << endl;
	return 0;
}

7.3.2.2传引用返回，正常接收

int& Count()//传引用返回，相当于返回的是n的别名、n的引用
//为什么空间销毁了，还能返回n的别名？
//空间销毁、栈帧销毁，不是这块空间就没了，而是像退房一样，房间不用了，我退掉这个房间，但实际上房间还是存在的
// 只是这个房间有可能还空着，也有可能租出去了，房间的使用权不是我的了
// 
// 野指针就是，我把房间退了，但我还悄悄地留了一把钥匙
//这里就类似野指针，可以称作野引用（非官方），严格来说这个别名是不合法的东西
// 也因此我可以偷偷地进入退掉的房间，但这时有可能我会被抓住，也有可能没人发现，就无事发生
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int ret = Count();//Count的栈帧已经销毁
	//还去访问这块空间，有两种可能性
	//1.依旧是1
	//2.随机值

	cout << ret << endl;//这里打印的结果可能是1，也可能是随机值
	//这里取决于栈帧销毁后，这块空间会不会被置成随机值
	//有些空间释放会去置成随机值，有些不会，要看具体的环境、编译器系统
	cout << ret << endl;
	return 0;
}

7.3.2.3传引用返回，用引用接收

int& Count()
{
	int n = 0;//变量定义的太靠前，很容易被覆盖
	n++;

	return n;
}
int main()
{
	int& ret = Count();//这里的ret就是n的别名

	cout << ret << endl;//这里是一个函数调用
	cout << ret << endl;
	//cout是ostream类型的对象
	//要调用时先传参，取这个地方的值取到的还是1，然后函数调用建立栈帧
	//还是在原来Count栈帧的地方建立，那么ret就有可能被覆盖
	//第一次为什么没有覆盖？
    //因为调用函数是先传参，先传参就要先取值，然后才建立函数栈帧


	return 0;
}

下面来看段代码

int& Add(int a, int b)//所以这类型的函数是不能返回引用的
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	//如果不清栈帧的话，结果是7
	return 0;
}

所以， 当函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用

引用返回，如果返回对象已经还给系统了，则必须使用传值返回。

7.3.3总结

所以什么时候使用传引用返回呢？
当使用的是全局对象、静态对象或是在堆上动态申请的这种，出了作用域还在，这时可以使用传引用返回，来提高效率。

传引用传参（任何时候都可以用）
1、减少拷贝，提高效率
2、输出型参数（形参的修改，影响的实参）

传引用返回（出了函数作用域对象还在才可以用）
1、减少拷贝，提高效率
2、修改返回对象，如

struct SeqList
{
	int a[10];
	int size;
};
//给别人用的都可以叫接口
//C的接口设计
//读取第i个位置的值
int SLAT(struct SeqList* ps, int i)
{
	assert(i < ps->size);
	// ...
	return ps->a[i];
}
//修改第i个位置的值
void SLModify(struct SeqList* ps, int i, int x)
{
	assert(i < ps->size);

	// ...
	ps->a[i] = x;
}

struct SeqList
{
	int a[10];
	int size;
};
//CPP接口设计

//可以读也可以修改第i个位置的值

int& SLAT(struct SeqList& ps, int i)
{
	assert(i < ps.size);
	// ...
	return (ps.a[i]);
}

int main()
{
	struct SeqList s;
	s.size = 3;
	// ...
	SLAT(s, 0) = 10;
	SLAT(s, 1) = 20;
	SLAT(s, 2) = 30;
	cout << SLAT(s, 0) << endl;
	cout << SLAT(s, 1) << endl;
	cout << SLAT(s, 2) << endl;

	return 0;
}

7.4传值、传引用效率比较

以值作为参数或者 返回值类型，在 传参和返回期间，函数 不会直接传递实参或者将变量本身直

接返回，而是 传递实参或者返回变量的一份临时的拷贝，因此 用值作为参数或者返回值类型， 效

率是非常低下的，尤其是 当参数或者返回值类型非常大，传大一点的变量或者说对象（C++

叫法）时，效率就更低。

7.4.1值和引用的作为参数的性能比较

7.4.2值和引用的作为返回值类型的性能比较

通过上述代码的比较，可以知道 传值和指针在作为传参以及返回值类型上效率相差很大。

7.5常引用

//在引用的过程中，权限可以平移、缩小，但是不能放大
int main()
{
	const int a = 0;

	//int& b = a;//权限的放大

	int b = a;//赋值不受上面规则的影响，赋值是一种拷贝
	//把a的值拷贝给了b，b修改不影响a

	const int& c = a;//权限的平移

	int x = 0;
	const int& y = x;

	int i = 0;
	double d = i;//可行
	//在C/C++中有一个规则，发生类型转换时会产生一个临时变量（隐式类型转换和显式类型转换）
	//这里不是把i直接给d，而是把i给一个临时变量，临时变量是double类型
	//类型转换、提升、截断都会产生临时变量
	//double& di = i;//这里不可以是因为临时变量具有常性，它是一种权限的放大
	const double& di = i;

	return 0;
}

int func()
{
	int a = 0;
	return a;
}

int main()
{
	int ret = func();//加上引用就会报错
	//只拷贝是不涉及权限放大的问题的，ret不会影响a的大小
	//不会返回a，会返回a的拷贝
	
	//int& ret = func();
	因为临时变量具有常性，不能变成常量对象的别名

	const int& ret1 = func();
	//权限平移就可以了
	//如果用const去引用会延长这个对象的生命周期，相当于ret出了作用域，临时变量才会销毁
	
	return 0;
}

int main()
{
	const int a = 10;
	//int& ra = a;   // 该语句编译时会出错，a为常量
	const int& ra = a;
	// int& b = 10; // 该语句编译时会出错，b为常量
	const int& b = 10;
	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，类型不同
	const int& rd = d;

	return 0;
}

7.6引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

而实际上可以看到引用和指针在底层上的实现是一致的，引用在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

#include<iostream>

using namespace std;


int& Count()//实际上底层返回的是n的指针
{
	int n = 0;
	n++;

	return n;
}
int main()
{
	int a = 0;
	int* p1 = &a;//指针开空间，一个指针变量4个字节或者8个字节，开空间存a的地址
	int& ref = a;//从语法上理解（上层看到的东西），引用不开空间，认为ref是a的别名
	
	//引用本质上也是存它的地址
	//引用和指针在底层是一样的

	//代码只是上层的展示，编译完都变成汇编指令了
	//C/C++编译器看到汇编代码这一层时是没有引用的
    //在底层只有指针，没有引用，从下层的角度看，引用和指针是一样的，引用其实是化了妆的指针
	
	return 0;
}

7.6.1总结

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时 必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就 不能再引用其他实体，而指针可以在任何时候指向任何

一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同： 引用结果为 引用类型的大小，但 指针始终是 地址空间所占字节个数(32

位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同， 指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

7.7补充

//C++中的结构体已经升级成了类
#define N 10
struct SeqList
{
	//可以定义函数
	//成员函数
	int& at(int i)
	{
		assert(i < N);
		return a[i];
	}

	int& operator[](int i)//运算符重载 
	{
		assert(i < N);
		return a[i];
	}
	//成员变量
	int a[N];
};

int main()
{
	//struct SeqList s1;//兼容C的用法
	SeqList s2;

	for (int i = 0; i < N; i++)
	{
		//s2.at(i) = i;
		s2[i] = i;
		s2.operator[](i) = i;
		//编译器会转换成这样
	}
	for (int i = 0; i < N; i++)
	{
		//cout << s2.a[i] << " ";
		cout << s2[i] << " ";

	}
	cout<<endl;
	return 0;
}

8.内联函数

8.1创建内联函数的原因

创建内联函数的原因是为了去补一些C语言的坑，C语言中的宏使用起来不是很舒服。

宏分为两种：宏常量、宏函数。

宏函数的缺点：

1.容易出错，语法坑很多，代码可读性差，可维护性差，容易误用

2.不能调试，不方便调试宏是因为预编译阶段进行了替换

3.没有类型安全的检查

宏函数的优点：

1.没有类型的严格限制

2.针对频繁调用的小函数，不需要再建立栈帧，很大程度上提高了效率、提高性能

3.增强了代码的复用性。

C++使用了哪些技术替代宏？

1. 宏常量定义换用  const、enum

2. 短小函数定义 换用 内联函数

#define MAX(a,b) ((a>b)?(a):(b))
//#define ADD(a,b) ((a)+(b))


int main()
{
//#define ADD(a,b) ((a)+(b));
//	ADD(1, 2);//单给一个分号认为是空语句，虽然不需要，但编译语法是不会报错的
//	//printf("%d\n", ADD(1, 2));//但这样就会报错

#define ADD(a,b) (a+b)
	int a = 0, b = 1;
	ADD(a | b, a & b);//会直接替换为(a|b+a&b);  +号优先级更高

	return 0;
}

8.2概念

以 inline（内联）修饰的函数叫做内联函数， 编译时C++编译器会在 调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

//C++允许把一个函数定义为内联函数
inline int Add(int x, int y)//没有调用的消耗
{
	return x + y;
}

int main()
{
	int ret=Add(1, 2);
	int a = 0, b = 1;
	int ret1=Add(a | b, a & b);//这里会计算表达式，就不会出现问题了
	printf("%d\n", ret);

	//展开：不调用函数，把函数的功能放在这里直接实现
	//在release优化的情况下，会在调用的地方展开
	//默认在debug版本不展开，因为展开后就不能调试了
	//release可以展开，但不方便看汇编，而且可能会优化很多

	//call之后，跳过去执行指令，就要建立函数栈帧

	//如果一个函数很长，变成内联会导致程序变大，这是程序膨胀的问题
	//引发一个问题，编译好的代码膨胀，编译好的程序变大，会导致安装包变大，因为安装包本质就是编译好的二进制的那些程序的打包
	//所以编译器不会把inline随便开放给你

	//内联函数在符号表中没有地址
	return 0;
}

如果在函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的

调用。

查看方式：

1. 在release模式下，查看编译器生成的汇编代码中是否存在 call 函数名

2. 在debug模式下，需要对编译器进行设置，否则不会展开，因为debug模式下，编译器默认不

会对代码进行优化

8.3特性

1. inline是一种 以空间换时间的做法，如果编译器将函数当成内联函数处理，在 编译阶段，会

用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运

行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建

议：将 函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、 不

是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

《C++prime》第五版关于inline的建议：

3. inline不建议声明和定义分离在两个文件，分离会导致 链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

所以声明与定义不能分离

9.auto关键字(C++11)

9.1简介

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一

个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

//auto经常用来做一些自动推导
int main()
{
	int a = 0;
	//int b=a;
	auto b = a;//它可以根据右边的值，自动推导左边的值的类型
	auto c = &a;
	auto& d = a;

	 普通场景没有什么价值
	 类型很长，就有价值，简化代码
	std::vector<std::string> v;
	std::vector<std::string>::iterator it = v.begin();
	auto it = v.begin();

	//C++中，帮助我们看实际类型
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(it).name() << endl;

	return 0;
}

注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto

的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编

译期会将auto替换为变量实际的类型。

9.2使用细则

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

2. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

9.3注意事项

1. auto 不能作为函数的参数

2. auto 不能直接用来声明数组

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。

10. 基于范围的for循环(C++11)

10.1范围for的语法

 对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因

此C++11中引入了 基于范围的for循环。for循环后的括号由 冒号“ ：”分为两部分： 第一部分是范

围内用于迭代的变量， 第二部分则表示被迭代的范围。  

//void TestFor(int array[])//C/C++中函数的形参没有数组的概念，都退化成指针了
//{
//	for (auto& e : array)
//		cout << e << endl;
//}

// 范围for
int main()
{
	int array[] = { 1, 2, 3, 4, 5 };

	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
		array[i] *= 2;

	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
		cout << array[i] << " ";
	cout << endl;


	for (auto& x : array)//下面不会变，x不影响数组里的值，给个引用就可以了
		//但只能用引用，不能用指针，因为是把数组的值赋给x
	{
		x*=2;
	}

	// 范围for
	// 依次取数组中的数据赋值给e
	// 自动判断结束
	// 自动迭代  ++
	for (auto e : array)//这里是数组名
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

10.2 范围for的使用条件

 1. for循环迭代的范围必须是确定的  

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供

begin和end的方法，begin和end就是for循环迭代的范围。

注意：以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}

2. 迭代的对象要实现++和==的操作。  

11. 指针空值nullptr(C++11)

11.1 C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现

不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下

方式对其进行初始化：

void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
// ……
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

可以看到， NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何

种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

void f(int )//形参可以不写，不写的意思就是只去匹配
{
	cout << "f(int)" << endl;
}

void f(int* p)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);//实际上都会匹配到第一个函数，因为把NULL定义成了0
	f(nullptr);//可以认为它的值是0，但类型是void*
	f((int*)NULL);//强转了一下就可以了

	return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的

初衷相悖。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器

默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。

11.2注意

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为 新关键字引入的。

2. 在C++11中， sizeof(nullptr) 与 sizeof((void*)0)所占的 字节数相同。

3. 为了提高代码的健壮性，在 后续表示指针空值时建议最好使用 nullptr。