文章目录
我们知道C++语言是在C语言的基础上建立的，所以在C语言中没有的语法，C++中却可以有新的语法，这是为了弥补C语言中的一些缺陷，分析如下：
一、命名空间
在C语言中我们知道在同一作用域下命名是不能有相同的，比如在全局作用域中变量名字sum就只能存在一个不能存在多个。但是我就想多用这个名字怎么办呢？
在C++中为我们带来了新的语法，引入了命名空间这个概念。
并且在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace（命名空间）关键字的出现就是针对这种问题的。
1. 命名空间定义
定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对{}即可，{} 中即为命名空间的成员，比如：
namespace N // N为命名空间的名称
{
// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int b;
int Add(int x, int y)
{
return x + y;
}
//命名空间还可以嵌套
namespace N2
{
int c;
int d;
}
}
这样子一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
2.命名空间的使用
命名空间的使用有三种方式:
①加命名空间名称及作用域限定符：
namespace N // N为命名空间的名称
{
// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int b;
int Add(int x, int y)
{
return x + y;
}
}
int main()
{
N::a = 2; //为命名空间N中的a进行赋值，这里::为作用域限定符
return 0;
}
②使用using将命名空间中成员引入：
namespace N // N为命名空间的名称
{
// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int b;
int Add(int x, int y)
{
return x + y;
}
}
using N::a; //释放命名空间N中的a，后面就可以直接使用了
int main()
{
a = 2;
return 0;
}
③使用using namespace 命名空间名称引入：
namespace N // N为命名空间的名称
{
// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int b;
int Add(int x, int y)
{
return x + y;
}
//命名空间还可以嵌套
namespace N2
{
int c;
int d;
}
}
using namespace N; //对命名空间N中的全部成员进行释放，后面都可以直接使用
int main()
{
a = 2;
b = 3;
return 0;
}
有了这三中使用方式，我们就可以很好的控制命名空间了，然后也可以解释为什么在学C++的时候要 using namespace std;
#include <iostream>
using namespace std;
//因为C++中的输入cin和输出cout都在命名空间std中
//要释放才能使用
int main()
{
a = 2;
b = 3;
cout << a << endl; //流插入运算符<<
cin >> b; //流提取运算符>>
return 0;
}
二、缺省参数
1.缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。
2.缺省参数分类
①全缺省参数 ：
int Add(int x = 0, int y = 0,int z=0)
{
cout << x + y + z << endl;
return x + y + z;
}
int main()
{
Add();
Add(5 + 8 + 9);
return 0;
}
②半缺省参数
int Add(int x , int y = 0,int z=0)
{
cout << x + y + z << endl;
return x + y + z;
}
int main()
{
Add(5 + 8 + 9);
return 0;
}
注意：
1.半缺省参数必须从右往左依次来给出，不能间隔着给。
2.缺省参数不能在函数声明和定义中同时出现。
3. 缺省值必须是常量或者全局变量。
4. C语言不支持。
三、函数重载
1.函数重载概念
函数重载: 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。
//下面三个函数就构成了重载
void fun(int x, int y)
{
cout << x << y << endl;
}
void fun(double x,double y)
{
cout << x << y << endl;
}
void fun(char x, char y)
{
cout << x << y << endl;
}
但是要注意的是函数名相同，返回值不同却不能构成重载，比如：
//下面两个函数就不是重载函数，返回值不同不能构成重载
int Add(int x, int y)
{
return x + y;
}
short Add(int x, int y)
{
return x + y;
}
2.函数重载的分析
为什么在C++中支持函数重载，而C语言不支持函数重载呢？
我们先了解一下程序要运行起来，需要经历这几个阶段：预处理、编译、汇编、链接。
而在链接的过程中C语言的编译器和C++的编译器就不同了，在链接时，面对函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则；但是C语言和C++比较起来就简单 ，函数修饰后名字不变。而C++编译器的函数修饰规则复杂，所以才能令函数名相同但是参数不同就能构成重载。
通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
我们也理解了，为什么函数重载要求参数不同，而跟返回值没关系。
3.函数重载的歧义
对于函数重载来说是不是构成了函数重载，程序就能运行成功呢？
我们以下面的重载函数进行分析：
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
void Swap(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
//对于上面两个函数虽然构成重载，但是如果调用Swap(3,7),
//就会造成歧义性，不知道要调用哪一个，程序也不会运行成功
四、引用
1.引用的概念和特性
概念： 引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
格式： 类型& 引用变量名(对象名) = 引用实体；
我们经过它们的地址进行对比，发现它们的地址是一样的，证明了它和它引用的变量共用同一块内存空间，还有引用类型必须和引用实体是同种类型的。
引用的特性：
① 引用在定义时必须初始化。
② 一个变量可以有多个引用。
③引用一旦引用一个实体，再不能引用其他实体。
int main()
{
int a = 0;
//int& c; //该语句会报错，因为引用没有初始化
int& d = a;
int& f = a;
int& g = a; //一个变量可以有多个引用
return 0;
}
2.引用的使用场景
①做参数：
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
②做返回值：
int& fun(int* p,int i)
{
p[i] = 0;
return p[i];
}
但是我们要特别注意使用做返回值的场景，一定要看返回对象是否出了函数作用域；
如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
3.传值和引用的效率比较
我们先来分析做参数的情况下，传值和传引用的时间对比：
struct N
{
int a[5000];
};
//构造一个足够大的自定义类型，这样才能区别出时间
void fun1(struct N tmp)
{
}
void fun2(struct N& a)
{
}
int main()
{
struct N a;
int start1 = clock();
for (int i = 0; i < 1000000; i++)
{
fun1(a);
//以传值的方式实现
}
int end1 = clock();
int start2 = clock();
for (int i = 0; i < 1000000; i++)
{
fun2(a);
//以传引用的方式实现
}
int end2 = clock();
cout <<"传值方式的时间为："<< end1 - start1 << endl;
cout <<"传引用方式的时间为："<< end2 - start2 << end2;
}
我们再来看看做返回值的情况，返回值和返回引用的时间对比：
struct N
{
int a[5000];
};
struct N a;
struct N fun1()
{
return a;
}
struct N& fun2()
{
return a;
}
int main()
{
int start1 = clock();
for (int i = 0; i < 1000000; i++)
{
fun1();
//返回值的方式实现
}
int end1 = clock();
int start2 = clock();
for (int i = 0; i < 1000000; i++)
{
fun2();
//返回引用的方式实现
}
int end2 = clock();
cout <<"返回值方式的时间为："<< end1 - start1 << endl;
cout <<"返回引用方式的时间为："<< end2 - start2 << end2;
}
通过上面的比较，传值和指针在作为传参以及返回值类型上效率相差很大。
4.引用和指针的区别
语法概念上： 引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
底层实现上： 实际是有空间的，因为引用是按照指针方式来实现的。
int main()
{
int c = 0;
int& rc = c;
rc = 30;
int* pc = &c;
*pc = 30;
return 0;
}
反汇编代码如下：
引用和指针的不同点:
① 引用在定义时必须初始化，指针没有要求。
② 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
③ 没有NULL引用，但有NULL指针。
④ 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
⑤ 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
⑥ 有多级指针，但是没有多级引用。
⑦ 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
⑧引用比指针使用起来相对更安全。
五、内联函数
1.内联函数概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率.
如果不是内联函数那么调用函数时就会压栈处理：
如果在Add函数前面加上inline 时就变成了内联函数：
2.内联函数特性
① inline内联函数是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
② inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
③ inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
3.关于宏和内联函数
宏的优点：
1.增强代码的复用性。
2.提高性能。
宏的缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查 。
C++中替代宏的方法：
1.常量定义 换用const
2.函数定义 换用内联函数