①.【命名空间】
在C/C++中，变量，函数和类都是大量存在的，而这些变量，函数，和类的名称都将存在全局作用域中，这样可能就回引起很多冲突：比如命名冲突。
- 命名冲突
1.我们跟库冲突
2.我们互相之间冲突
而我们使用命名空间的目的就是为了解决C语言大多缺陷<命名冲突>。
使用命名空间可以对标识符的名称进行本地化，从而避免命名冲突或名字污染。
1.编译器访问域顺序 --局部域>全局域–>展开命名空间域or指令访问命名空间域。
2.命名空间展开就是展开到全局里来，是编译器是否会到命名空间域中访问搜索。
#include <stdio.h> #include <stdlib.h> int rand = 10; int main() { printf("%d\n", rand); return 0; } //比如我们在这里定义一个全局变量rand，想要打印rand。 //但是编译器会报错，因为显示重定义。 为什么呢？因为引用了头文件后，头文件里就有rand函数的定义，在头文件里rand定义为函数，而在这里又被定义为全局变量，所以产生了命名冲突。
由于在C语言中该类问题无法解决，所以在C++中提出了使用namespace来解决
1.命名空间定义
库里的名称我们无法改变，那我们可以将自己定义的名称放在命名空间里，当需要时指令访问即可。
那怎么定义命名空间呢？
定义命名空间，需要使用关键字namespace，后面跟着命名空间名子，然后再接着一个{}即可。
{}里即为命名空间的成员，可以是变量，函数，类。
namespace定义的命名空间就相当于定义一个域–可以与其他域隔离。也就是将自己定义的变量，函数，类，划到一个新的域中，让全局域找不到自己。
常见域：
1.类域
2.命名空间域
3.局部域
4.全局域
Ⅰ.正常定义命名空间
namespace wei { int a = 10;//可以定义变量 int Add(int x, int y)//可以定义函数 { return x + y; } struct Node//可以定义类 { int data; struct Node* next; }; }
Ⅱ.嵌套定义命名空间
命名空间是可以嵌套的
比如C++库名字就叫std里面就嵌套着许多命名空间。
namespace tao1 { int a = 10; int b = 20; namespace tao2 { int a = 1; int b = 2; namespace tao3 { int a = 3; int b = 4; } } }
Ⅲ.合并命名空间
在不同的头文件里，最后同名的命名空间会合并成一个。
也就是在同一个工程中允许多个相同名称的命名空间，编译器最后会合成同一个命名空间中的
//test.cpp文件 namespace tao1 { int a = 10; int b = 20; namespace tao2 { int a = 1; int b = 2; namespace tao3 { int a = 3; int b = 4; } } } //test.h文件 namespace tao1 { int max; int min; int a = 10; int b=30; }
2.命名空间的使用
定义好命名空间后，我们可以在命名空间里定义我们想要定义的变量，函数，类，并且不需要担心和库里函数发生命名冲突。
不过当我们要使用这些命名空间里的成员时，该如何使用呢？
::域作用限定符
Ⅰ.+命名空间名称及域作用限定符
namespace wei { int a = 10;//可以定义变量 int Add(int x, int y)//可以定义函数 { return x + y; } struct Node//可以定义类 { int data; struct Node* next; }; } int main() { printf("%d", wei::a);//加命名空间名称与域作用限定符 return 0; }
Ⅱ.using成员引入
namespace wei { int a = 10;//可以定义变量 int Add(int x, int y)//可以定义函数 { return x + y; } struct Node//可以定义类 { int data; struct Node* next; }; } using wei::Add;//使用using将命名空间中某个成员引入。 int main() { printf("%d\n", wei::a); printf("%d\n", Add(2, 5)); return 0; }
Ⅲ.using namespace名称全部引入
namespace wei { int a = 10;//可以定义变量 int Add(int x, int y)//可以定义函数 { return x + y; } struct Node//可以定义类 { int data; struct Node* next; }; } using namespace wei;//使用using namespace命名空间名称将命名空间内容全部展开。 int main() { printf("%d\n", wei::a); printf("%d\n", Add(2, 5)); struct Node n; return 0; }
但这种做法是有风险的。
3.注意事项
当我们使用第三种方法来访问命名空间里的成员时，会存在风险，因为命名空间全部展开到全局域中，就又会出现命名冲突的风险。比如如果全部展开C++标准库就会存在风险。
- using namespace std；
1.直接展开会有风险：当我们定义如果和库重名那就会报错
2.建议项目里面不要直接展开，建议日常练习可以直接展开
3.项目中建议指定展开，不要轻易展开命名空间。
不过我们还可以这样：
如果有重复多使用的可以【部分展开】：【指定展开】：【把常用的展开】
using std::cout;//将常用的成员展开使用 using std::end1;//将常用的成员展开使用
Ⅰ.概念
当声明或定义函数时，为函数的参数指定一个缺省值，也叫做默认值。
规则：
当调用该函数时，如何没有没有指定实参则采用改形参的默认值。
当调用该函数时，指定实参，那就使用传过来的实参。
通俗的说就是：
没有传参时，使用参数的默认值
传参时，使用指定的实参
void fun(int n=10) { cout << n << endl; } int main() { fun();//没有指定实参，则使用缺省参数 fun(20);//指定实参 }
1.全缺省参数
全缺省参数，即函数形参都被指定为缺省值
using namespace std; void fun(int a=1,int b=2,int c=3) { cout << a<< endl; cout << b << endl; cout << c << endl; } int main() { fun();//全缺省参数，形参全部指定为缺省值，不传实参 }
2.半缺省参数
半缺省参数，即函数形参部分被指定为缺省值
void fun(int a,int b=2,int c=3) { cout << a<< endl; cout << b << endl; cout << c << endl; } void fun2(int a,int b, int c = 9) { cout << a << endl; cout << b << endl; cout << c << endl; } int main() { fun(2);//部分缺省，部分形参指定为缺省值 fun2(5, 6); }
3.使用规则
- 1.传参是从左向右传，不能隔着传。
- 2.而缺省参数是从右到左缺省。
- 3.声明和定义不能同时给缺省
为什么声明和定义不能同时给缺省呢？？？
因为会出现这样的场景：当声明和定义的缺省参数不一致时，那编译器到底该用哪个缺省值呢？
- 4.准确的来说，只能在声明函数的时候来给缺省，定义时候不能给。
- 5.缺省值必须是常量或者全局变量
- 6.默认参数也叫缺省参数
4.应用场景再现
比如顺序表中有静态顺序表和动态顺序表。我们知道静态顺序表，写死了固定大小，很不好使，但动态顺序表又需要不断的扩容，扩容操作是需要消耗效率的。所以我们可以利用缺省参数，来对顺序表的默认大小进行缺省，当我们知道要插入多少数据时，则指定传相对的大小，那顺序表一开始就会开辟那么大的空间，就不需要从一小块不断扩容了。而当我们不知道要插入的数据时，那么就按照给定的默认值(缺省值)来进行开辟空间。
typedef struct SQList { int* a; int size; int capacity; }SQList; void SQInit(SQList *s,int defalutCapacity=4) { s->a = (int*)malloc(sizeof(SQList) * defalutCapacity); if (s->a == NULL) { perror("malloc"); } } int main() { SQList s; SQInit(&s);//如果不知道要插入多少数据，那就按照默认值4来 SQInit(&s, 100);//如果知道要插入多少数据，那么直接就开辟这么大的空间，不需要不断的扩容到100 }
②.函数重载
C语言不允许存在同名函数，但C++允许存在同名函数，这么做的原因是用来处理实现功能类似数据类型不同的问题。
那C++是如何做到让同名函数同时存在的呢？
Ⅰ.概念
函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参( |参数个数|或类型|或类型顺序|)不同。
1.参数个数不同
//参数个数不同 int Add2(int left, int mid,int right)//3个参数 { return left+mid + right; } int Add(int left, int right)//2个参数 { return left + right; } int main() { printf("%d\n", Add(1, 1));//编译器会自动识别使用哪一个函数的 printf("%d\n", Add2(1,2,3)); }
参数个数不同：
void f() { cout << "f()" << endl; } void f(int a) { cout << "f(int a)" << endl; }
不过要注意的是下面这个例子
void f() { cout << "f()" << endl; } void f(int a=0) { cout << "f(int a)" << endl; }
你觉得它构成函数重载吗？
从定义的角度来说，它确实是一个没有参数，一个有一个参数，它们参数个数不同，函数名相同，所以是构成函数重载的。但有没有什么问题呢？
你看，第二个函数的参数被缺省了，也就是相当于当函数传参时，传不传都无所谓，传参数，那就使用这个实参，如果不传，那就使用缺省参数。那么问题来了，如果我们不传参数，到底调用的是第一个函数，还是调用第二个函数呢？
第一个函数没有参数，如果我们不传参正常来说就应该调用第一个，但第二个同名函数的参数被缺省了。所以就会出现
调用不明确问题。
2.参数类型不同
//参数类型不同 int Add(int left, int right)//int 类型 { return left + right; } double Add(double left, double right)//double 类型--注意这里返回值是double ，不需要管返回值类型 { return left + right; } int main() { printf("%d\n", Add(1, 1)); printf("%f\n", Add(1.1, 1.1));//编译器会自动识别数据类型，并且使用相应的函数 }
3.参数类型顺序不同
void fun1(int a, char c) { cout << a << " " << c << endl; } void fun1(char c, int a) { cout << c << " " << a << endl; } int main() { fun1(1,'x'); fun1('w', 6); }
要明确注意的是这里是类型顺序，而不是变量顺序。
比如下面这个坑
void fun1(int a, char c) { cout << a << " " << c << endl; } void fun1(int c, int a) { cout << c << " " << a << endl; }
你觉得构成重载吗？
当然不构成了，我们要严格按照定义，是类型顺序不同如果是上面这个例子，那我要传fun1(1,'x');到底调用的是哪一个函数呢，是上面的还是下面的呢？所以是有歧义的。
c++虽然允许同名函数并且会自动识别变量类型
但要严格遵守函数重载的规则才可以。
4.对返回值没有要求
函数重载对函数的返回值是没有要求的。
返回值没有要求，但是当后面的要求不符合是，仍然不能构成重载(函数参数类型不同，函数参数的个数不同，函数类型顺序不同)
返回值没有要求 --不构成重载 —无法使用
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; }
比如这样，两个同名函数符合参数类型不同，所以构成重载。虽然它们返回值不同，但函数重载对返回值没有要求。
③.函数名修饰规则
为什么C语言不支持函数重载，而C++支持重载呢？
C++又是如何支持的呢？
这其中就要涉及程序的【编译与链接过程】与【函数名修饰规则】
假设一个工程里有三个文件，一个是专门声明各函数的文件，一个是专门定义各函数的文件，一个是用来测试这些函数功能的文件。
我们知道一个程序要通过预编译，编译，汇编，链接四个部分才可以生成可执行程序。
而各个阶段的处理也不相同。
大体是就是在预编译阶段，在声明和定义的两个文件里包含的头文件会被展开，宏会被替换，还有注释会被去掉。
然后各生成一个带 .i的文件。在编译阶段会进行检查语法，生成汇编代码，并生成一个带.s的文件。
汇编阶段会进行将汇编代码转化为机器指令，生成一个符号表，并生成一个带.o的文件，最后在链接阶段，会将符号表合并和重定位，将两个带.o文件链接成一个可执行程序。
根据函数栈帧的创建和销毁，我们知道当调用一个函数时，会执行一个call的汇编代码。call后面就是函数的地址。然后就会使用jump跳进调用的函数里。
而在实际的项目中通常是由多个头文件和多个源文件。
比如在test.c文件里调用了定义.c文件里的函数A，在链接之前，test.o文件里是没有函数A的地址的，因为函数A的地址在定义.c文件里。
那么test.c程序如何执行呢？
在链接阶段会解决这个问题，链接器看到test.o调用函数A，但是又没有函数A的地址，它就会到定义.o符号表中去找函数A的地址，然后重定位到一起。
我们可以这样比喻：将在.h头文件里声明的看成一种承诺
test.c想要买房，还差钱，向好兄弟.h文件借钱，好兄弟.h满口答应。给定了test.c承诺。
test.c有了承诺，它就敢买房了，这个过程是合法的。所以不会报错的。
但要真正的买到房，还需要.h兑现承诺，而如果.h找到定义的文件就可以兑现承诺了。
所以test.c要执行起来就需要找到定义来兑现承诺。
链接的作用就是：找到定义(兑现承诺)。
那还有一个问题，链接器是如何找定义的呢？是找哪个定义的呢？
是使用哪个名字定义的呢？
在不同的编译器有不同的函数名修饰规则。
Ⅰ.C/C++的不同
我们举例gcc和g++的例子。
- 1.C语言编译器编译结果：
我们发现gcc的函数修饰后名字是不改变的。
- 2.C++编译器编译器结果：
而在g++的函数修饰后变成了【_Z+函数长度+函数名+类型首字母】
- 3.结论：采用C语言编译器编译后，函数名没有改变，而采用C++编译器编译后，函数名经过函数修饰发生改变，并且跟函数的参数类型，参数个数等有关。
- 4.通过这里我们就可以理解C语言没有办法支持重载了，因为C编译器，在编译后，同名函数没有办法区分，而C++经过函数修饰规则，根据函数参数的类型，参数的个数不同而改变函数的名字进行区分，只要参数不同，修饰后的函数名就不一样，这样就支持重载了。
- 5.如果两个函数函数名和参数都是一样的，但是函数返回值不一样，这是不构成重载的，因为重载的定义没不包括返回值。编译器没有办法区分。
【C++入门必备知识：|引用| +|auto关键字| + |范围for|】
在这里插入图片描述
④.引用
Ⅰ.引用概念
引用不是新定义一个变量，而是给已经存在的变量取别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存区间。
比如水浒传里的李逵
小名叫铁牛，江湖人称黑旋风。这些都是他，只不过名字不同。
Ⅱ.引用使用
类型& 引用变量名=引用实体
int main() { int a = 10; int& ra = a;//给变量a取别名为ra int& rra = ra;//又给变量rra取别名为rra ，其实本质上都是a printf("%p\n", a); printf("%p\n", ra); printf("%p\n", rra); }
从语法上我们看，就是给a取别名，并没有开辟空间。
注意：引用类型必须和引用实体是同种类型的。
Ⅲ.引用特性
1.一个变量可以有多个引用
2.引用在定义时必须初始化
3.引用一旦引用一个实体，再不能引用其他实体。 C++的引用不能改指向
1.一个变量可以有多个引用
就像李逵可以有多个别名一样。
int main() { int a = 10; int& ra = a; int& rra = a; printf("%p\n", a); printf("%p\n", ra); printf("%p\n", rra);//它们的本质都是a }
2.引用在定义时必须初始化
你要取别名，倒是说给谁取别名呀，你不说谁知道这个名字是谁的。
int main() { int a=10; int&ra;//这样是不可以的，编译器会报错。 //引用在定义时必须要初始化。 }
3.引用一旦引用一个实体，再不能引用其他实体。
int main() { int a = 10; int&ra=a; int b=20; ra=b;//这里ra=b是将b的值赋给ra，而不是让ra变成b的别名。C++的引用不能改指向。ra仍然是a的别名 }
注意：
同一个域不能同名引用，不能域里可以同名，但在不同域里是可以同名的，是可以区分的。
Ⅳ.使用场景
引用第一使用场景：
1.做函数参数
void Swap(int*a, int* b) { int tmp = a; a = b; b = tmp; } //引用 void Swap(int& a, int& b) { int tmp = a; a = b; b = tmp; }
意义：
1.引用做参数–【输出型参数】
什么叫输出型参数呢？就是传进去使用还要带出来
这里利用形参就是实参的变名，改变形参就改变了实参
不同于传指针参数。
2.引用做参数—【提高效率】
对于/大对象/深度拷贝的数据是可以提高效率的。
因为是引用不开空间
#include <time.h> 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(); }
虽然指针也能做到上面的功能。
但是引用更方便。
引用第二大使用场景：
2.做函数返回值
int fun()//返回值就用int来接受 { int n = 0; n++; return n; } int main() { int ret = fun();//最后将返回值返回ret printf("%d ", ret); }
没有毛病吧。根据函数栈帧的创建和销毁我们知道，在函数调用完时，函数栈帧会销毁，而这个返回值将会保存在一个寄存器中，相当于一个临时变量。操作系统会开辟一个临时变量来保存这个返回值，如何再将临时变量赋给ret。最后ret得到了函数的返回值。
而这个过程需要需要创建临时变量，那么就需要开销。
其实只要看函数返回值，只要是传值返回的
不管怎么样编译器都会生成临时变量。
但是当用引用作为返回值时，最后就不需要创建临时变量了。
也就是传引用返回就不会生成临时变量。
int& fun()//用引用作为返回值 { static int n = 0; n++; return n;//最后函数返回的是n的别名，不需要创建临时变量保存，因为别名不需要开辟空间 } int main() { int ret = fun();//fun的返回值就是n的别名，别名不需要开辟空间，中间没有临时变量，直接就赋值会ret了。 printf("%d ", ret); }
那我们是不是以后函数返回值都用引用呢？
当然不行了，上面的案例也是特殊的，因为static修饰的变量在静态区，当函数栈帧销毁时，并不影响变量a，所有当引用取别名时可以找到它。
所以这里打印的ret的值是不确定的。
如果fun函数结束，栈帧销毁，没有清理栈帧，那么ret的结果是侥幸是正确的。
如果fun函数结束，栈帧销毁，清理栈帧，那么ret的结果是随机值。
意义：
1.减少拷贝，提高效率
但要记住并不是任何地方都可以引用返回值
当函数 返回值为局部变量时，这种是不行的。
因为返回局部对象引用很危险。最后的结果取决于函数调用完栈帧销毁不销毁
当返回值为静态变量时不危险，函数调用结束，函数栈帧销毁不影响静态变量的存在。
不会有随机值的问题。静态变量还在，那么取别名就合法。
传引用返回–没有创建临时变量，只是取别名。别名==变量。
返回变量的别名，没有临时变量，也没有拷贝。所以可以提高效率。
传值返回–需要开辟临时变量-再拷贝回去。
引用返回门槛：不能随意引用传参返回
1.基本任何场景都可以用引用传参
2.但要谨慎用引用返回，出了函数作用域，对象不在， 就不能用引用返回，还在就能用。
2.查改返回值
引用做返回值，可以修改返回值，和获取返回值。
因为返回值就是这个要修改或者要返回变量的别名，对别名修改或者获取。就是修改该变量。
Ⅵ.常引用
1.引用过程中，权限不能放大
int main() { 1.//引用过程中，权限不能放大 const int a = 0;//表示a不能修改 int& b = a;//不能通过引用别名来修改a，这种方法是错误的。 2.//引用过程中，权限是可以平移或缩小的。 int x=0; int &y=x; const int&z=x; 3.//对z这个别名进行修饰，也就是z这个别名权限缩小了。但其他别名的权限还是正常的。 ++x; }
2.不能引用带有常性的变量。
double a=1.2; int b=a; //其实在类型转化会产生临时变量，产生一个int 类型的临时变量 int&bb=a; //这个也是一样，a是double类型，别名bb是int类型，发生类型转化，然后产生一个临时变量存在着dd，这个dd就具有常性了，因为临时变量具有常性。
而带有常性的变量就不能使用引用了。
Ⅶ.引用与指针区别
1.引用在语法概念上就是一个别名，没有开辟空间，和其引用的实体共用同一块空间。
2.但在底层实现上，引用其实是有空间的，因为引用是按照指针方式来实现的。
不同点：
-1.引用概念上是定义一个变量的别名，指针是存储一个变量的的地址
-2.引用在定义时，需要初始化，指针没有要求。
-3.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在如何时候指向任何一个同类型实体。
-4.没有NULL引用概念，但有NULL指针
-5.有多级指针，但是没有多级引用。
-6.引用比指针使用起来更安全。
-8.在sizeof下含义不相同：在引用用计算的就是别名类型的大小，而指针是固定的，始终是地址空间所占字节个数。(32位下4字节)
-9.引用自加表示引用的实体加1，而指针自加，表示指针向后偏移一个类型的大小。
⑤.auto关键字
在C++11中，auto的作用是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
int a = 0; auto b = a;//auto可以自动识别a的类型 auto c = 's';//自动识别字符‘s’的类型
还有要注意在使用auto时定义变量时，必须要对其进行初始化
int a=0; auto b;//使用auto却不初始的编译器会报错 auto c ;//这样不初始化是不对的。
【注意】
在使用auto定义变量时，必须对其初始化，在编译阶段编译器需要根据初始化表达式来推到auto的实际类型，因此auto并非是一种”类型“声明，而是一个类型声明时的”占位符“，编译器在编译期会将auto替换为变量实际的类型。
1.使用规则
1.auto与指针和引用结合使用
用auto声明指针类型时，用auto和auto没有区别。*
但用auto声明引用类型时，必须加上&。
int a=0; auto pa=&a;//auto与指针和引用结合使用 auto* pa = &a; auto&ra=a;
2.在同一行定义多个变量。
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto a = 1, b = 2; auto c = 3, d = 4.0;//这样就不对了，auto一行定义多个变量虽然可以，但是要求这一行变量类型都相同才可以。d的类型与c不同
3.auto不能作为函数的参数。
void fun(auto a)//这种写法是不允许的 {}
4.auto不能直接用来声明数组
int a[]={6,5,4}; auto c={9,8,7};//这种写法是不允许的。
⑥.基于范围的for循环
如果我们想要打印一个数组，就必须遍历这个数组，而遍历这个数组就得需要知道这个数组的大小是多少。
int main() { int a[] = { 9,8,7,6,5,4,3,2,1 }; int n = sizeof(a) / sizeof(a[0]); for (int i = 0; i < n; i++) { cout << a[i] << endl; } return 0; }
而对于我们来说，这种写法有时会出现很多问题，比如数组大小计算错误，或者循环条件写错，所以C++11中引入了基于范围的for循环。
for循环后面的括号由冒号" ："分为两个部分，第一部分是范围内用于迭代的变量类型，第二部分则表示被迭代的范围。
for(auto__:__);
int arr[] = { 9,8,7,5,6,3,2,4 }; for (auto e : arr) { cout << e << endl; }
1.使用规则
1.使用于数组
2.依次取数组中的数据赋值给e（这里的e可以随便写其他，没有规定，可以是x，可以是y）
3.自动迭代，自动判断结束。
4.与普通循环类似，可以用continue来结束本次循环，也可以用break跳出整个循环。
还有如果想要利用范围for改变数组内容该任何改变呢？
如果想让数组内数据都变成2倍这样写可以吗？
int arr[] = { 9,8,7,5,6,3,2,4 }; for (auto x : arr) { x * 2; }
要注意，这里只是将arr数组内容依次赋值给x，但x改变能改变数组内的数据吗？当然不能了。
所以我们想要改动数组内的数据，只要传引用即可，每次改变的是数组数据的别名。改变别名就改变了数组数据。
int arr[] = { 9,8,7,5,6,3,2,4 }; for (auto& x : arr) { x * 2; }
【注意】
for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
