向大佬学习
目录
2.4同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
一、C++关键字(C++98)
C++总计63个关键字，C语言32个关键字
下面是C++的关键字总结：
其中画圈的是C语言的关键字。
这里要注意了：false和true并不是C语言的关键字。
二、命名空间
2.1 定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
2.2 作用
2.2.1 避免命名冲突
以非关键字rand为例：
#include <stdio.h> int rand = 0; int main() { printf("%d\n", rand); return 0; }运行结果：
引入rand的库函数stdlib.h以后：
#include <stdio.h> #include <stdlib.h> int rand = 0; int main() { printf("%d\n", rand); return 0; }运行结果：
使用namespace定义一个命名空间域：
#include <stdio.h> #include <stdlib.h> //命名空间域 namespace bit { int rand = 0; } int main() { printf("%d\n", rand); return 0; }运行结果：
我滴个乖乖，虽然不报错了，但咋输出这么个怪胚？
因为被namespace修饰后的rand打印的是其地址（该处的rand是打印的其全局域的地址，而不是命名空间域的地址），你用%d肯定得不到地址，要改成%p
打印用%p:
#include <stdio.h> #include <stdlib.h> //命名空间域 namespace bit { int rand = 0; } int main() { printf("%p\n", rand); return 0; }运行结果：
打印rand对应的值：
#include <stdio.h> #include <stdlib.h> //命名空间域 namespace bit { int rand = 0; } int main() { printf("%d\n", bit::rand);//告诉编译器去找命名空间域中的rand return 0; }运行结果：
2.2.2 解决作用域的问题
全局域与局部域的问题：
#include <stdio.h> int a = 0; int main() { int a = 1; printf("%d\n",a); }运行结果：
namespace修饰后，写出其全名可以避免全局域和局部域的争夺
#include <stdio.h> namespace bit { int a = 0; } int main() { int a = 1; printf("%d\n", a); printf("%d\n",bit::a); }运行结果：
：：修饰，代表全局域
#include <stdio.h> int a = 0; int main() { int a = 1; printf("%d\n", a); //：：域作用限定符 printf("%d\n",::a); }运行结果：
bit::修饰的变量打印的地址是对应的命名空间域内的
#include <stdio.h> #include <stdlib.h> //命名空间域 namespace bit { int rand = 0; } int main() { printf("%p\n", rand); printf("%p\n", bit::rand); return 0; }运行结果：
C++标准库的问题：
#include <iostream> int rand = 0; int main() { printf("%d\n", rand); return 0; }运行结果：
分析原因：rand在打印时，编译器先找局部域中找，发现不存在。于是去全局域中找,发现有两个，一个是iostreamd头文件中的库函数，一个是现在定义的变量(int rand=0)。故发生了紊乱
#include <iostream> namespace qkj { int rand = 0; } int main() { printf("%d\n", rand); return 0; }运行结果：
#include <iostream> namespace qkj { int rand = 0; } int main() { printf("%d\n", qkj::rand); return 0; }运行结果：
#include <iostream> namespace qkj { int rand = 0; } using namespace qkj;//把qkj这个空间域中的变量都展示出来 int main() { printf("%d\n", rand); return 0; }运行结果：
分析原因：using namespace 把qkj这个空间域中的rand暴露出来了，与iostream内的rand相冲突了
故我们得出以下经验：
- 项目中，尽量不要使用using namespace std;
- 日常练习用这个using namespace std;
- 项目中指定命名空间访问，或者展开常用的
指定命名空间访问 #include <iostream> int main() { std::cout << "hello world" << std::endl;//指定命名空间访问，std::是指定编译器在标准库中访问 return 0; }展开常用的 #include <iostream> //不展开整个标准库，只展开标准库中的cout和endl using std::cout; using std::endl; int main() { cout << "hello world" << endl;//cout和endl已展开 return 0; }运行结果：
-
2.2.3 隔离作用
#include <stdio.h> #include <stdlib.h> namespace bit { int rand = 0; void func() { printf("fun()\n"); } struct TreeNode { struct TreeNode* left; struct TreeNode* right; int val; }; } int main() { printf("%p\n", rand); printf("%p\n", bit::rand); bit::func(); struct bit::TreeNode node; }注:命名空间域内定义的变量、函数、结构体。。。在使用时都必须用命名空间名称（这里是bit）修饰
2.3嵌套
#include <stdio.h> #include <stdlib.h> namespace qkj { int a = 0; namespace bit { int rand = 0; void func() { printf("fun()\n"); } struct TreeNode { struct TreeNode* left; struct TreeNode* right; int val; }; } } int main() { printf("%d\n", qkj::a); printf("%p\n", rand); printf("%p\n", qkj::bit::rand); qkj::bit::func(); struct qkj::bit::TreeNode node; }
2.4同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
我们在一个工程中，我们可以将函数声明和定义分开来写，如下：
//在List.h头文件中只写声明 namespace xnh { int rand; struct ListNode { //... }; void ListInit(); void ListPushBack(struct ListNode* phead, int x); } //在List.cpp源文件中写定义 namespace xnh { void ListInit() { // ... } void ListPushBack(struct ListNode* phead, int x) { //... } } //在test.cpp源文件中使用 int main() { struct xnh::ListNode ln; xnh::ListPushBack(NULL, 1); return 0; }虽然将
xnh这个命名空间分开写在了List.h和List.cpp两个文件中，但最后会合成同一个命名空间中。
2.5 using namespace 命名空间名称
using namespace 命名空间名称;这句代码的意思就是把整个命名空间展开，这样当我们使用命名空间下的变量、函数等等就不需要加作用域限定符了，用起来方便，但隔离失效了。
日常练习，小程序，这么用可以，项目最好不要这么用。
例如：#include <stdio.h> namespace qkj { int a = 10; } using namespace qkj; int main() { //先去全局域中找，如果没有还会在带展开的qkj域中去找 printf("%d\n", a);//访问的是qkj这个命名空间中的a变量 return 0; }运行结果：
会发生如下的情况：
这样容易造成命名冲突问题，为了解决这个问题，出现了第三种引入方法。
2.6使用using将命名空间中成员引入：
第三种方法就是指定展开–把常用的展开，自己在定义的时候避免跟常用重名即可
例如：
#include <stdio.h>
#include <stdlib.h>
namespace qkj
{
int rand = 0;
int a = 10;
}
using qkj::a;
int main()
{
//先去全局域中找，如果没有还会在带展开的qkj域中去找
printf("%d\n", a);//访问的是qkj这个命名空间中的a变量
printf("%d\n", qkj::rand);
return 0;
}运行结果：
这种方法可以防止命名冲突的问题，因为它只引入了一部分。
三、C++输入与输出
cout ：输出
cin ：输入我们初学一门语言，输出Hello world是必不可少的，C++输出方法如下：
#include<iostream> using namespace std; int main() { cout<<"hello world!"<<endl; return 0; }对以上程序有几点解释：
首先是iostream头文件，是标准输入/输出文件，可以支持使用cout和cin等函数，分别代替printf和scanf；
其次是using namespace std，就是我们上文讲到的命名空间，std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
#include<iostream> //using namespace std; int main() { std::cout<<"hello world!"<<std::endl; return 0; }还有就是c++特有的输入输出,cout，cin，都有与之对应的符号，如下：
<< ：流插入操作符。与cout配合使用，可以将所有你需要输出的变量或者字符串流入到cout中，让cout负责输出。我们将cout相当于控制台就好理解了
#include <iostream> int main() { // << 是流插入运算符 std::cout << "hello world" << std::endl; std::cout << "hello world" << "\n"; //自动识别类型 int i = 11; double d = 11.11; printf("printf打印的：%d,%f\n", i, d); std::cout << i << "," << d << std::endl; }运行结果：
注：如果要控制打印的精度，则没必要学习C ++那一套，反正C++兼容C,咱们就用C语言的就行了。
#include <iostream> int main() { //自动识别类型 int i = 11; double d = 11.110000; printf("printf打印的：%d,%.2lf\n", i, d); }运行结果：
>> ：流提取操作符。与cin配合使用，可以将你输入的值流入到某变量中。
就相当于把你在屏幕上输入的数据或字符串通过>>符号流入到所需的某变量中。我们可以将cin相当于键盘#include <iostream> int main() { // >> 流提取 int i = 11; double d = 11.11; scanf("%d%lf", &i, &d); printf("%d,%lf\n", i, d); std::cin >> i >> d; std::cout << i << "," << d << std::endl; }还有就是 endl与"\n"（换行符）等价，都是进行换行的意思。
注意：使用 cout标准输出(控制台) 和 cin标准输入(键盘) 时，必须包含< iostream >头文件以及std标准命名空间。
cout、cin：可以自动识别变量的类型
使用示例：
int a = 10; char arr[] = "abcdef"; double b = 1.11; float c = 0.0; cin>>c; cout<<a<<endl; cout<<arr<<endl; cout<<c<<endl;
向大佬学习
四、缺省参数
定义：
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。
正常情况下调参：
#include <iostream> using namespace std; void Func(int a) { cout << a << endl; } int main() { Func(1); Func(2); Func(3); return 0; }运行结果：
缺省调参：
#include <iostream> using namespace std; void Func(int a = 0)这儿的 0 就相当于缺省参数，如果实参什么都没传过来，缺省参数就赋值给a。 { cout << a << endl; } int main() { Func(1); Func(2); Func(3); Func();//在c语言中这样写肯定是不行的，但是在c++中有了缺省参数，如果你什么都不传，只要你前面有缺省参数的存在，就能过。 return 0; }运行结果：
4.1 缺省参数分类：
4.1.1全缺省参数
全缺省参数就是为函数的所有参数都设置一个默认参数，例如：
void Func(int a = 10, int b = 20, int c = 30) { cout<<"a = "<<a<<endl; cout<<"b = "<<b<<endl; cout<<"c = "<<c<<endl; }我们调用此函数时，有以下几种方法：
Func(); Func(1); Func(1,2); Func(1,2,3);传进去的实参必须是从左向右传的，而且必须连续的。比如以下传参方法就是错误的
Func(,10,);//错误，传参必须是从左往右，连续传参Func(,,10);//错误
4.1.2半缺省参数
半缺省参数就是将函数的参数部分初始化，例如：
void Func(int a, int b = 10, int c = 20) { cout<<"a = "<<a<<endl; cout<<"b = "<<b<<endl; cout<<"c = "<<c<<endl; }注意：
1.半缺省参数必须只能从右向左依次给出，而且必须连续，不能间隔着给。
例如以下方式就是不行的int Func(int a,int b=10,int c);//错误，不连续 int Func(int a=10,int b=20,int c);//错误，不是从右往左给出2.缺省参数不能在函数声明和定义中同时出现，推荐在声明中给
//a.h void Func(int a = 10); // a.c void Func(int a = 20) { //..... } // 注意:如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。3.缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）
4.2缺省参数的使用场景
以栈的初始化为例：
struct Stack { int* a; int top; int capacity; }; void StackInit(struct Stack* ps, int capacity = 4) { //... ps->a = (int*)malloc(sizeof(int) * capacity); //... ps->top = 0; ps->capacity = 0; } int main() { struct Stack st1; StackInit(&st1, 100);//明确知道需要插入100个数据，就可以显示传参数100。提前开好空间，插入数据避免扩容 StackInit(&st1);//不知道有多少空间，咱就开4个 }
五、函数重载
重载的意思是具有多重含义，那么函数重载即是一个函数具有多种功能，也就是对同一个函数名的不同的“解释”。
定义：
C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，即参数个数，参数顺序，参数类型三者有一个不同即可。常用来处理实现功能类似数据类型不同的问题比如：
//参数类型不同 int Add(int a, int b) { return a+b; } double Add(double a, double b) { return a+b; } //参数个数不同 int Func(int a); int Func(int a,int b); //参数顺序不同 -- 顺序不同指的是，形参类型的顺序不同 int Sub(int a, char b); int Sub(char b, int a);注：返回值类型不同不构成重载，因为调用时函数前没有类型，无法区分
//返回值类型不同，不构成重载 short Add(short left, short right) { return left + right; } int Add(short left, short right) { return left + right; } int main() { short a=1,b=2; //函数调用 Add(left,right); }
5.1使用场景
在C语言中交换两种类型的数据：
void Swapi(int* p1, int* p2) { int* tmp = *p1; *p1 = *p2; *p2 = tmp; } void Swapd(double* p1, double* p2) { int* tmp = *p1; *p1 = *p2; *p2 = tmp; } int main() { int a = 1, b = 2; double c = 1.1, d = 2.2; Swapi(&a, &b); Swapd(&c, &d); return 0; }既要在定义函数时取不同的名字，又要在调用时考虑清楚调哪个函数，很麻烦。
在C++中用函数重载后：
void Swap(int* p1, int* p2) { int* tmp = *p1; *p1 = *p2; *p2 = tmp; } void Swap(double* p1, double* p2) { int* tmp = *p1; *p1 = *p2; *p2 = tmp; } int main() { int a = 1, b = 2; double c = 1.1, d = 2.2; Swap(&a, &b); Swap(&c, &d); return 0; }函数重载的意义就是让用起来很方便，就像用同一个函数一样
5.2函数重载的原理
为什么C++支持函数重载而C语言却不支持呢？
在C/C++中，一个程序要运行起来，C/C++的源文件都是需要进行预处理，编译，汇编，链接，最后生成可执行程序的。和C的源文件一样，都是源文件先单独编译生成目标文件合到一起链接成可执行程序。实际我们的项目通常是由多个头文件和多个源文件构成，函数的声明和定义分离会使编译器在编译源文件时暂时找不到函数的地址，那么其查找函数的规则则会在链接时体现。所以将函数的声明和实现放到两个文件中，更方便观察C++和C对于函数名字修饰规则的不同。
由于Windows下vs的修饰规则过于复杂，而Linux下gcc的修饰规则简单易懂，下面我们使用了gcc演示了这个修饰后的名字。
采用C语言编译器编译后结果:
结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。采用C++编译器编译后结果:
结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。通过这里就可以理解C语言无法支持重载了，因为c++会根据函数的参数对函数名进行修饰，只要参数不同，修饰出来的名字就不一样，就支持了重载，而C对函数名却不会修饰，所以没办法支持重载，因为同名函数没办法区分。
函数名不相同，其生成的函数地址也不会相同，所以在调用的时候也不会产生冲突
我们看完 函数重载 的定义后，可能会产生一个疑问，如：
返回值不同，构成重载吗？？为什么呢？？ 请看下面调用函数：
//两者返回值不同 int f(int a, int b) { cout << "f(int a,char b)" << endl; return 0; } char f(int a, int b) { cout << "f(int a,char b)" << endl; return 'A'; } int main() { f(1, 1); f(2, 2); //这里调用会存在二义性，因为调用时不指定返回类型，所以他不知道该调用哪个函数 return 0; }返回值不同，不构成重载原因，并不是函数名修饰规则
真正原因是调用时的二义性，无法区分，
因为调用时不指定返回值类型
六、引用
引用是C++中一个重要的语法，在后期应用非常广泛。相较于指针，它更加方便也更好理解。
定义：
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
通俗来讲，就是为一个变量取一个别名。就如同家人为你取一个小名，两个名字都代表着同一个人。
引用的基本使用：
①类型+& +引用变量名(对象名) = 引用实体;
void func() { int a = 10; int& b = a;//为a取别名叫b，此时b就是a，没有额外开辟空间 b = 20; int& c = b; //为b取别名叫c c = 30; }
从这里可以看出这里分别给a取了两个别名，并且别名值的改变也会影响变量a，因为别名本身代表的就是a，同时，这三个变量的地址都是同一地址，所以证明引用实体和引用变量共用同一块内存空间。
② cout<<+&+变量名+<<endl = 打印变量地址
#include <iostream> using namespace std; int main() { int a = 0; int& b = a; cout << &a << endl; cout << &b << endl; }运行结果：
6.1 引用的特性
6.1.1 引用在定义时必须初始化
void func()
{
int a = 10;
//int& b; //err，定义引用必须初始化
int &b = a;//正确处理
}
6.1.2 一个变量可以有多个引用
void func() { int a = 10; int& b = a;//正确处理 int& c = a; int& d = a; int& e = d;//给别名取别名 }一个人有多个外号怎么啦？？？
我还给别名取别名呢！！！
6.1.3 引用一旦引用了一个实体，就不能再引用其他实体
int a = 10; int& b = a; int c = 20; b = c;//这里是把c的值赋给b,并不是让b变为c的别名
6.2 引用的使用场景
6.2.1 引用做参数——输出型参数
①Swap函数：
void Swap(int& rx, int& ry) 此时的形参就是实参的别名 { //传引用 int tmp = rx; rx = ry; ry = tmp; } int main() { int x = 0, y = 1; Swap(x, y); cout << x << " " << y << endl; return 0; }但引用做参数时，在一些情况下会产生歧义，例如：
void Swap(int x, int y) { //传值 int tmp = x; x = y; y = tmp; } void Swap(int* px, int* py) { //传址 int tmp = *px; *px = *py; *py = tmp; } void Swap(int& rx, int& ry) { //传引用 int tmp = rx; rx = ry; ry = tmp; } int main() { int x = 0, y = 1; Swap(&x, &y);//这里调用没问题，是进行传址调用 cout << x << " " << y << endl; Swap(x, y);//err,这里就会产生错误，编译器将不会知道是调用传值还是传引用，所以会产生歧义 cout << x << " " << y << endl; return 0; }三者参数列表分别为整型、指针类型和引用类型，虽构成了函数重载，但调用时仍会有歧义。
②链表
过去写二级指针：
现在写引用：
此时phead就是plist的别名，改变phead也就改变了plist
变态的写法：
问：PSLTNode是个啥？
答：定义PSLTNode那里等价于typedef struct SListNode* PSLTNode,也就意味着PSLTNode是一个指针，类似于int* a=地址中的a,不过PSLTNode存储的是结构体类型SListNode的地址。跟struct SListNode* 等价
那在PSLTNode的情况下怎么写？咱来打个样：
//尾插 void SListPushBack(PSLTNode& phead, SLTDataType x) { if (phead == NULL) { phead = (SLTNode*)malloc(sizeof(SLTNode)); } }
6.2.2 引用做参数--大对象传参，提高效率
①Swap函数：
void Swap(int& rx, int& ry) //此时的形参只是实参的别名，不是拷贝，没有额外开辟空间，故效率更高 { //传引用 int tmp = rx; rx = ry; ry = tmp; } int main() { int x = 0, y = 1; Swap(x, y); cout << x << " " << y << endl; return 0; }
②传值与传引用效率对比
#include <iostream> #include <time.h> using namespace std; struct A { int a[10000]; }; void TestFunc1(A a) {} void TestFunc2(A& a) {} void TestRefAndValue() { A a; // 以值作为函数参数 size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc1(a); size_t end1 = clock(); // 以引用作为函数参数 size_t begin2 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc2(a); size_t end2 = clock(); // 分别计算两个函数运行结束后的时间 cout << "TestFunc1(A)-time:" << end1 - begin1 << endl; cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; } int main() { TestRefAndValue(); return 0; }运行结果：
可见，传引用几乎不消耗时间，而传值要消耗更多的时间。可以这么想：传值传参要拷贝4万个字节给，而传引用传过去的就是它自己（其实形参和实参的a不一样，因为他俩在不同的作用域），故没有拷贝
6.2.3 引用做返回值--减少拷贝
点击这里去看别人博客相关的内容。我的断网没保存，不想写第二遍了
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; return 0; }运行结果：
注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用 引用返回，如果已经还给系统了，则必须使用传值返回。
点击这里去看别人博客相关的内容。我的断网没保存，不想写第二遍了
6.2.4 引用做返回值--输出型返回对象，调用者可以修改
#include <iostream> #include <assert.h> typedef struct SeqList { int* a; int size; int capacity; }SL; void SLInit(SL& s, int capacity = 4) { s.a = (int*)malloc(sizeof(int) * capacity);//看解释1 assert(s.a); //... s.size = 0; s.capacity = capacity; } void SLPushBack(SL& s, int x) { if (s.size == s.capacity) { //... } s.a[s.size++] = x; } //修改顺序数据的函数 void SLModity(SL& s, int pos, int x);//过去的写法 int& SLAt(SL& s, int pos)//看解释1 { assert(pos >= 0 && pos <= s.size); return s.a[pos]; } using namespace std; int main() { SL sl; SLInit(sl); SLPushBack(sl, 1); SLPushBack(sl, 2); SLPushBack(sl, 3); SLPushBack(sl, 4); for (int i = 0; i < sl.size; i++) { cout << SLAt(sl, i) << endl; } //修改数据 SLAt(sl, 0)++;//把链表第一个节点的数据加1 SLAt(sl, 0) = 10; //把链表第一个节点的数据改为10 for (int i = 0; i < sl.size; i++) { cout << SLAt(sl, i) << endl; } }①malloc创建的地址存放在堆区，故调用SLAt函数返回时，出了函数返回对象还在。将返回对象的数据修改时不需要担心栈的销毁
6.3 常引用
定义：被const修饰的引用就是常引用。
常引用会涉及到权限的问题，如：
权限平移：
int a = 10; int& b = a;a是int类型，是可以修改的。a的别名是b，b对应的也是int类型，也是可以修改的。故它们的权限一样，称为权限平移
权限扩大：
const int c = 20; int& d = c;//errorc对应的类型是const int 不可被修改。d是c的别名，对应的类型是int，可以被修改。故而从c到d,权限扩大了。
改进为权限相同：
const int c = 20; const int& d = c; d = 10;//error,d对应的类型是const int,不能被修改
权限缩小：
int e = 30; const int& f = e;e可修改，f不可修改，故可以
注：权限放大是不被允许的，只能权限平移或缩小
类型转换
double d = 1.11; int i = d; double d = 1.11; int& i = d;//error const int& i = d;分析：
将浮点型变量d赋值给整型变量i时会发生隐式类型转换，中间会产生一个临时变量，将d的数据截断放入临时变量中再将临时变量赋值给i。类似于不同整型数据进行比较会发生整型提升，其实就是将各自产生的临时变量进行整型提升再进行比较，这也是二者的值不会发生改变的原因。
这样的临时变量是个右值，具有常属性，所以只有常引用才能引用这样的临时变量。也就使得const Type&的引用类型可以引用任意类型的变量。
不用const修饰而失败的本质原因是：权限放大
注：隐式类型转换和强制类型转换都会产生临时变量，类型转换不会改变变量的值也不会改变变量的类型
另类的玩法：给常数做别名
const int& x = 10;
传值传参：
void func1(int n) { //... } int main() { int a = 10; const int b = 20; func1(a); func1(b); func1(30); }注：传值传参不考虑权限问题,因为形参是实参的临时拷贝，形参的改变不影响实参
传址传参：
void func2(int& n) { //... } int main() { int a = 10; const int b = 20; func2(a);//ok,n变成a的别名 func2(b);//error,权限放大 func2(30);//error，30是常量，形参要的是地址 }
const引用传参：
void func3(const int& n) { //... } int main() { int a = 10; const int b = 20; func3(a); func3(b); func3(30); func3(1.11); double d=2.22; func3(d); }注：如果使用引用传参，函数内如果不改变n，那么建议尽量用const引用传参
6.4 引用与指针的区别
引用和指针的用途基本是相似的，你指针能用，我引用往往也能用
引用与指针的不同点：
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
- 指针更强大，更危险，更复杂。引用相对局限一些，更安全，更简单
语法层：
指针和引用是完全不同的概念，指针是开辟空间，存储变量的地址，引用不用开辟空间，仅仅是对变量取别名。底层汇编时：
从下图汇编代码可以看出，引用是用指针实现的。int main() { int a = 10; int& ra = a; ra = 20; int* pa = &a; *pa = 20; return 0; }
类似于你在拼多多买的一双椰子鞋，花了199。和你在豪华商城买的售价一万的椰子鞋。表面上看感觉上不一样，其实阿都是一个工厂生产的，没啥区别。
七 内联函数
概念：
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调 用建立栈帧的开销，内联函数提升程序运行的效率。
注：我们知道，函数的调用，会建立栈帧。栈帧内存储的是函数运行期间的局部变量，栈帧结束，这些局部变量也就销毁了。所以说这些局部变量是跟着函数走的，函数开始执行，它就创建出来了，函数执行结束，它就销毁了（因为它们是存储在栈帧里面的）。而内联函数是在调用的地方展开，也就没有建立函数栈帧。
假如现在某个项目（堆排或快排，排序10万个数据）中要用到一个短小的函数（1-10行）Swap,频繁调用次数达10万+，C与C++中分别怎么处理？C :宏函数
C++:内联函数
已经有了宏还要创造内联函数，说明宏是有缺点的。
宏的优点：a.宏常数可维护性强（改一处就改全部）b.宏函数提高了效率，减少了栈帧的建立（宏也是替换）
宏的缺点：a.可读性差 b.没有类型安全的检查 c.不方便调试（宏在预处理阶段就替换掉了）
内联函数：几乎解决了宏函数的缺点，同时兼具了它的优点
注：C++中尽量不要使用宏，而是选择const（常量定义）、enum、inline（函数定义）去替代宏
底层观察：
如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。
这时就没有调用ADD函数，而是运行到此语句时，将函数进行了展开，这样就提升了程序的效率。
注：内联函数只在release模式下起作用，若想在Debug模式下查看需要配置项目属性。
特性：
- inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
- 内联函数仅是对编译器的一种建议，编译器自动优化，如果定义为inline的函数体内的实现代码指令长度很长（10行左右，不同编译器不同）/递归等等，编译器会放弃优化。
拿函数Func()举例，了解函数内部实现代码指令过长时的，编译器放弃优化的原因 - 内联函数不建议声明和定义分离，内联函数不会调用就没有函数地址分离会导致链接失败。
宏的优点是可以增强代码的复用性，提高性能，缺点是无法调试，可维护性差，没有类型检查。C++出台内联函数就是推荐使用内联函数。
八、auto关键字（c++11）
在早期的C/C++中auto的含义是：使用auto修饰的变量是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
在C++11中，标准委员会赋予了auto全新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。注：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型
可能光看这一句话，你不一定能懂，下面我们举几个例子。
#include <iostream> int TestAuto() { return 10; } using namespace std; int main() { int a = 10; auto b = a;//智能识别指针类型 auto c = 'a'; auto d = TestAuto(); cout << typeid(a).name() << endl; cout << typeid(b).name() << endl; cout << typeid(c).name() << endl; cout << typeid(d).name() << endl; //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化 return 0； }运行结果：
8.1 auto的使用
8.1.1 auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
#include <iostream> using namespace std; int main() { int a = 10; auto b = &a; //自动推导出b的类型为int* auto* c = &a; //自动推导出c的类型为int*，强调右边传过来的一定是指针否则编译不通过 auto& d = a; //自动推导出d的类型为int，情调d只是引用，是a的别名 //打印变量b,c,d的类型 cout << typeid(b).name() << endl;//打印结果为int* cout << typeid(c).name() << endl;//打印结果为int* cout << typeid(d).name() << endl;//打印结果为int return 0; }注意：用auto声明引用时必须加&，否则创建的只是与实体类型相同的普通变量，只不过将其换了个姓名而已。
8.1.2 在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto() { auto a = 1, b = 2; auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同 }
8.2 auto不能推导的场景
8.2.1 auto做为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导 void TestAuto(auto a)//err {}
8.2.2 auto不能直接用来声明数组
void TestAuto() { int a[] = {1,2,3}; auto b[] = {4，5，6};//err }
注：
-
为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
-
auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。
九、 基于范围的for循环（c++11）
9.1 范围for的语法
对于一个有范围的集合仍需说明它的范围，这无疑是多余的，因此C++11引入范围for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
:前是循环变量，后面是循环范围
//C for (int i = 0; i < sz; i++) { cout << arr[i] << endl; } //C++ for (auto e : arr) //1.自动依次抓取a的数据，赋值给e 2.自动迭代，自动判断结束 { cout << e << endl; }注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
范围 for 循环返回的对象是数组元素值的拷贝，所以若要写入数组元素(改变数字元素)的话，需要使用引用。
for (int i = 0; i < sz; i++) { arr[i] *= 2; } for (auto& e : arr) //此时的e是数组arr的别名 { e *= 2; }
9.2 范围for的使用条件
9.2.1 for循环迭代的范围必须是确定的
对于数组而言，就是一个数组中第元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
//注意：以下代码就有问题，因为for的范围不确定 void TestFor(int arr[]) { for (auto& e : arr) //此时的arr是个指针，就不能这么搞了 { cout << e << endl; } }数组传参本质就是指针，所以不知道数组的具体范围，因此是错误的。
9.2.2 迭代的对象要实现++和==的操作
十、指针空值nullptr(C++11)
C++98中的指针空值
在良好的C/C++编程习惯中，在声明一个变量的同时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误。比如未初始化的指针，如果一个指针没有合法的指向，我们基本都是按如下方式对其进行初始化：
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*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
#include <iostream> using namespace std; void Fun(int p) { cout << "Fun(int)" << endl; } void Fun(int* p) { cout << "Fun(int*)" << endl; } int main() { int* p=NULL; Fun(0); //打印结果为 Fun(int) Fun(NULL); //打印结果为 Fun(int) Fun((int*)NULL); //打印结果为 Fun(int*) Fun(p); //打印结果为 Fun(int*) return 0; }程序本意本意是想通过Fun(NULL)调用指针版本的Fun(int* p)函数，但是由于NULL被定义为0，Fun(NULL)最终调用的是Fun(int p)函数。
注：在C++98中字面常量0，既可以是一个整型数字，也可以是无类型的指针(void*)常量，但编译器默认情况下将其看成是一个整型常量，如果要将其按照指针方式来使用，必须对其进行强制转换。
C++11中的指针空值
对于C++98中的问题，C++11引入了关键字nullptr。
1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为关键字引入的。
2.在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同，大小都为4
3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
4963
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
