命名空间
在C/C++中，变量、函数和后⾯要学到的类都是⼤量存在的，这些变量、函数和类的名称将都存在于全
局作⽤域中，可能会导致很多冲突。使⽤命名空间的⽬的是对标识符的名称进⾏本地化，以避免命名
冲突或名字污染 。
在同一个工程中，不同文件中定义的同名namespace会被认为是同一个namespace，不会冲突。
嵌套
命名空间内可以嵌套命名空间，如示例代码：
namespace Kevin
{namespace star{string star = "Messi";}namespace sport{string sport = "Football";}
}
命名空间的使用
在使用时进行展开使用：
cout << Kevin::sport::sport << Kevin::star::star << endl;
• 指定命名空间访问，项⽬中推荐这种⽅式。
• using将命名空间中某个成员展开，项⽬中经常访问的不存在冲突的成员推荐这种⽅式。
• 展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤。
C++输⼊&输出
• 是InputOutputStream的缩写，是标准的输⼊、输出流库，定义了标准的输⼊、输
出对象。
• std::cin是istream类的对象，它主要⾯向窄字符（narrowcharacters(oftypechar)）的标准输⼊流。
• std::cout是ostream类的对象，它主要⾯向窄字符的标准输出流。
• std::endl是⼀个函数，流插⼊输出时，相当于插⼊⼀个换⾏字符加刷新缓冲区。
• <<是流插⼊运算符，>>是流提取运算符。（C语⾔还⽤这两个运算符做位运算左移/右移）
• 使⽤C++输⼊输出更⽅便，不需要像printf/scanf输⼊输出时那样，需要⼿动指定格式，C++的输⼊
输出可以⾃动识别变量类型(本质是通过函数重载实现的，这个以后会讲到)，其实最重要的是C++的流能更好的⽀持⾃定义类型对象的输⼊输出
缺省参数
缺省参数分为：全缺省，半缺省参数（默认参数）。
请注意：
- C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值 ；
- 带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参；
- 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省
值。
全缺省
全缺省就是参数部分全部给缺省值
void Func1(int a = 10, int b = 20, int c = 30)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}
可以如下使用：
Func1();
Func1(1,2,3);
半缺省参数（默认参数）
半缺省就是部分形参给缺省值
void Func2(int a, int b = 10, int c = 20)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}
可以如下使用：
Func2(1);
Func2(1,2);
Func2(1,2,3);
函数重载
C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者
类型不同。
参数类型不同
样例如下：
// 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 << "double Add(double left, double right)" << endl;return left + right;
}
参数个数不同
样例如下：
// 2、参数个数不同
void f()
{cout << "f()" << endl;
} void f(int a)
{cout << "f(int a)" << endl;
}
参数类型顺序不同
样例如下：
// 3、参数类型顺序不同
void f(int a, char b)
{cout << "f(int a,char b)" << endl;
} void f(char b, int a)
{cout << "f(char b, int a)" << endl;
}
不能构成函数重载的举例
返回值不同
当返回值不同的时候，我们在使用的时候无法识别出要使用哪一个函数，因为使用哦的时候仅仅是调用，不会显式的告诉编译器你要用哪个返回值的函数，所以返回值不同的函数不能构成重载。
// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分
void fxx()
{}int fxx()
{return 0;
}
全缺省参数与无参函数
区别于构造函数，类外的全缺省参数函数与无参函数构成的函数重载无法正常调用，存在歧义。当调用时编译器不知道应该使用哪一个函数。
void f1()
{cout << "f()" << endl;
} void f1(int a = 10)
{cout << "f(int a)" << endl;
}
引用
给变量取别名，编译器不会为引用变量开辟内存空间，它和引用的变量共用一块内存空间。也就是说，通过引用可以直接改变引用的变量。（无法直接代替指针）
使用格式：
类型& 引用别名 = 引用对象；
引用的特性
• 引⽤在定义时必须初始化
• ⼀个变量可以有多个引⽤
• 引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体
在定义时初始化
引用需要再定义的时候就进行初始化，如果执行以下代码会报错：
int& ra;
ra = a;
正确格式：
int& ra = a;
一个变量可以有多个引用
int& ra = a;
int& aa = a;
int& ba = a;
可以根据上述代码进行多个引用别名引用同一个变量，通过修改ra,aa,ba都可以改变a的值。
定义后不能改变引用实体
int& ra = a;
int& ra = b; //error
当已经在定义的时候引用一个实体变量后，在后续这个别名就不能再引用别的变量了。
为什么引用无法直接代替指针？
在链表中，节点就是指针，无法用指针替代。
我们使用链表的尾插进行讲解，代码如下：
#include <stdlib.h>typedef struct LTNode {int val;struct LTNode* next;
} LTNode;typedef struct LTNode* PNode;void ListPushBack(PNode** phead, int x) {// 动态分配内存给新节点PNode newnode = (PNode)malloc(sizeof(LTNode));if (newnode == NULL) {// 内存分配失败的处理return;}newnode->val = x; // 设置新节点的值newnode->next = NULL; // 新节点的next指针初始化为NULL// 如果链表为空，新节点即为头节点if (*phead == NULL) {*phead = newnode; // 将头指针指向新节点} else {// 如果链表不为空，找到链表的最后一个节点PNode current = *phead;while (current->next != NULL) {current = current->next;}// 将最后一个节点的next指针指向新节点current->next = newnode;}
}
为什么要用二级指针？
- 指针变量的值：指针变量存储的是另一个变量的内存地址。当你有一个指针PNode* p，p的值是另一个LTNode对象的地址。当解引用时：*p则代表着直接操作LTNode对象。
- 间接修改：如果你有一个指针的引用（即二级指针），比如PNode** pp，你可以修改*pp的值，即改变pp所指向的指针变量的值。这相当于间接修改了指针变量本身。因为我们要改变头指针的指向，所以用**p来接收头结点（修改一级指针的指向），然后再函数中就可以通过解引用进行修改头指针指向。而对于修改next指向本身是不用二级指针接收的。
当用C++风格修改后的函数：
void ListPushBack(PNode*& pheadRef, int x) {// 动态分配内存给新节点PNode newnode = (PNode)malloc(sizeof(LTNode));if (newnode == NULL) {// 内存分配失败的处理return;}newnode->val = x;newnode->next = NULL;// 如果链表为空，新节点即为头节点if (pheadRef == NULL) {pheadRef = newnode; // 使用引用直接修改头指针} else {// 如果链表不为空，找到链表的最后一个节点PNode current = pheadRef;while (current->next != NULL) {current = current->next;}// 将最后一个节点的next指针指向新节点current->next = newnode;}
}
当使用PNode*&的时候与int&类似，表示一个结构体指针的引用。在函数中直接通过修改phead的值就可以修改头结点的指向，而不需要像二级指针一样需要解引用才可以改变一级指针指向 。
引用返回值
例如想要改变栈顶元素：
int STTop(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top - 1];
}int main()
{STTop(st1) = 3;
}
该代码运行会报错：
必须为左值元素（可修改，赋值变量）
原因
当该返回值为int时，返回的临时变量STTop(st1)为常量，常量无法修改。
解决措施
用引用来解决该问题。
当用引用做返回值，就是返回rs.a[rs.top - 1]的引用。此时当再用STTop(st1) = 3;修改栈顶数据即可完成。
const引用
代码书写可能会有以下错误：
const int a = 10;
int& ra = a; // error
当使用
int&来接收const int类型的值时，对于int&来说相当于把权限放大了，而权限放大时不允许的。因为原来的a是一个不可修改的int常量，而如果要用int&接收的话，int&本身是要对所引用的对象进行修改等操作的，如此即违规了。
但是如下代码相反：
int a = 10;
const int& ra = a; // yes
原因如上述的相反结论，即缩小了权限，权限的缩小是被允许的。
常量的延伸
（表达式1 + 表达式2）在赋值时也会产生临时对象
- 注意：临时对象具有常性！
如下：
const int a = 10;
int b = 20;int& rab = (a + b); // error
与上述类似：int&如果接受一个常量会将权限放大，不允许。
const int a = 10;
int b = 20;int rab = (a + b); // yes
但当使用一个整型变量接收的话会直接对临时对象进行拷贝，拷贝不涉及权限的放大缩小，仅仅是数据上的拷贝！int&是为了取别名对引用对象进行操作，而拷贝只是进行数据的拷贝。
指针和引用的关系
• 语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。
• 引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。
• 引⽤可以直接访问指向对象，指针需要解引⽤才是访问指向对象。
• sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下
占4个字节，64位下是8byte)
• 指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些
inline
inline对于编译器⽽⾔只是⼀个建议 ，用inline修饰的函数也叫内联函数，编译的时候C++编译器会在调用的地方将函数内的代码全部展开，这样调用内联函数就不用寄哪里栈帧了，从而提高效率。
格式一般如下：
inline int Add(int x, int y)
{int ret = x + y;ret += 1;ret += 1;ret += 1;return ret;
}
注意：
- vs编译器debug版本下⾯默认是不展开inline的，这样⽅便调试，debug版本想展开需要设置⼀下
以下两个地⽅- inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地
址，链接时会出现报错。
内联函数比较于宏
宏的回顾
#define ADD(a, b) ((a) + (b))
// 为什么不能加分号?
// 为什么要加外⾯的括号?
// 为什么要加⾥⾯的括号?
- 为什么不能加分号？
- 在调用宏的时候必须保证调用时写的与定义的宏函数格式一样，如果多加了分号的话那在调用的时候就会因为缺少分号而报错；
- 为什么要加外面的括号？
- 例如在使用宏函数进行运算
cout << 3 * ADD( 1 , 2 ) << endl;时就会因为运算符优先级的问题而计算错误。所以在定义宏函数的时候将括号写准确有利于后续程序的稳定。
- 为什么要加里面的分号？
- 如果使用宏 ADD(a++, b)，没有括号的情况下，宏会展开成 a++ + b，这将导致 a 被递增两次：一次是因为宏展开，另一次是因为 a++ 本身。但加上括号后，宏展开为 ((a)++) + b，这在大多数编译器中是不允许的，因为不允许对括号内的表达式进行递增操作，从而避免了这种错误。
nullptr
void f(int x)
{cout << "f(int x)" << endl;
} void f(int* ptr)
{cout << "f(int* ptr)" << endl;
}
C++中NULL可能被定义为字⾯常量0，或者C中被定义为⽆类型指针(void*)的常量。 由于在C++中NULL被定义成了0，所以例如：调⽤了
f(int x)，因此与程序的初衷相悖。f((void*)NULL);调⽤会报错。
其他关于C++的知识：
类和对象：构造、析构、拷贝构造
