目录
3.2 C++支持函数重载的原理--名字修饰(name Mangling)
1.命名空间：namespace
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。(命名空间对于编译器而言是寻找的规则)
printf是ppp命名空间域中的局部域，与正常的打印关键字不同。
namespace ppp
{
int printf = 2;
}
int main()
{
printf("%d ",ppp::printf);
return 0;
}变量首先访问局部域，再访问全局域；其中：：代表访问全局域(域作用限定符)
int k = 0;
int main()
{
int k = 1;
printf("%d ",k);//1
printf("%d ",::k);//0
return 0;
}命名空间中可以定义变量/函数/类型
namespace ppp
{
int printf = 2;
void print()
{
cout << "Hello world!!!" << endl;
}
struct Stack
{
int* a;
int capacity;
};
}
int main()
{
ppp::print();
struct ppp::Stack st;
return 0;
}命名空间可以嵌套
namespace pp
{
int w = 2;
namespace ppp
{
int printf = 2;
void print()
{
cout << "Hello world!!!" << endl;
}
struct Stack
{
int* a;
int capacity;
};
}
}
int main()
{
pp::ppp::print();
struct pp::ppp::Stack st;
return 0;
}相同/不同文件允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
多次使用命名空间ppp::十分麻烦，我们可以使用
using namespace ppp;变量先去全局域找，如果没有还会到展开的命名域去找（std是标准命名库空间）,我们也可以只展开一部分命名空间
using std::cout;
using std::cin;2. 输入输出
#include <iostream>
using namespace std;
int main()
{
int i = 0;
cout << "Hello,World" << endl;
cin >> i;
return 0;
}1.cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出
2.<<是流插入运算符,>>是流提取运算符
3.使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
3.缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。
实参传递时，形参缺省值不起作用
在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
void fun(int a = 3)
{
cout << a << endl;
}
int main()
{
fun(1);//打印1
fun();//打印3
return 0;
}全缺省参数
void fun(int a = 10, int b = 20, int c = 30)
{
cout << a << endl;
cout << b << endl;
cout << c << endl;
}
int main()
{
fun();//10 20 30
fun(1);//1 20 30 从左往右传
return 0;
}半缺省参数
半缺省参数必须从右往左连续缺省，不能间隔；传参是从左往右传
void Halffun(int a, int b = 20, int c = 30)
{
cout << a << endl;
cout << b << endl;
cout << c << endl;
}
int main()
{
Halffun();//不能不传参数，至少传一个参数
Halffun(1);//1 20 30
return 0;
}缺省参数不能在函数声明和定义中同时出现
原因在于编译器不知道使用哪个缺省值，最好在声明中给缺省参数，不可以声明不给定义给（以声明为准），同时缺省值必须是常量或者全局变量
3.函数重载
函数重载：是函数的一种特殊情况，C++允许在同一作用域（命名空间也是域，不能在不同命名空间）中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数；类型；类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
int Add(int a, int b)
{
return a + b;
}
double Add(double a, double b)
{
return a + b;
}
int main()
{
cout<<Add(1,2)<<endl; //3
cout << Add(1.1, 2.2) << endl; //3.3
return 0;
}以下函数不构成函数重载（与返回值无关）
int Add(int a, int b)
{
return a + b;
}
double Add(int a, int b)
{
return a + b;
}
int main()
{
cout<<Add(1,2)<<endl;
cout << Add(1.1, 2.2) << endl;
return 0;
}3.2 C++支持函数重载的原理--名字修饰(name Mangling)
为什么C++支持函数重载，而C语言不支持函数重载呢？
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
C语言拯救者（程序的预处理、编译、链接与宏- -15）_北方留意尘的博客-CSDN博客
在符号表中，C语言同名函数修饰规则没有发生改变，相同函数在符号表之间冲突，编译器不知道使用哪个
而在C++中函数名修饰规则变成【_Z+函数长度+函数名+类型首字母】，编译器将函数参数类型信息添加到修改后的名字，放入符号表中。
这样就就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。所以如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。
4.引用
引用不是新定义一个变量，而是给已存在变量取别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
int main()
{
int a = 1;
int& b = a;//单独用在变量前才是取地址
b = 3;
cout << a << endl;//打印3
return 0;
}引用注意事项：
1.引用类型必须和引用实体是同种类型的
2.引用在定义时必须初始化
3.一个变量可以有多个引用（别名也可以取别名）
int main()
{
int a = 1;
int& b = a;//单独用在变量前才是取地址
int& c = b;
int& d = c;
cout << a << endl;//bcd都是变量a的别名
return 0;
}4.引用一旦引用一个实体，再不能引用其他实体
使用场景1:做输出型参数（输入型指传入参数使用，输出型是传入后内部改变，外部拿到改变值）
void Swap(int& a,int &b)
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
int a = 1;
int b = 2;
Swap(a, b);
cout << a << endl;//2
cout << b << endl;//1
return 0;
}使用场景2:做参数--大对象传参，提高效率
使用场景3:做返回值
普通的传值返回，并不是用返回对象进行返回，而是生成临时拷贝，再把拷贝值返回ret
加了static修饰后，n存在静态区不销毁，但是还是传值返回，编译器还是采用临时变量去做返回值
做返回值-- 传引用返回：做输出型返回对象，调用者可以修改返回对象
传值返回 “返回对象”的别名:生成拷贝，传引用返回n的别名，但是栈帧已经被销毁，越界
int& Count()
{
int n = 0;
n++;
// ...
return n;
}
int main()
{
int ret = Count();
cout << ret << endl;
return 0;
}第二次打印变成随机值，原因在于
int& Count()
{
int n = 0;
n++;
return n;
}
int main()
{
int& ret = Count();
cout << ret << endl;//1
cout << ret << endl;//随机值
return 0;
}总结：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回； 如果已经还给系统了，则必须使用传值返回
额外例子：SLAt函数直接充当顺序表中可读，可修改的函数
int& SLAt(SL& s, int pos)
{
assert(pos >= 0 && pos <= s.size);
return s.a[pos];
}4.2 常引用
void TestConst()
{
const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量 ,权限放大出错
const int& b = a;//正常
int k = 0;
const int& kk = k;//正常，权限缩小
const int& ra = a;
// int& b = 10; // 该语句编译时会出错，b为常量
double d = 12.34;
//int& rd = d; // 该语句编译时会出错，类型不同，原因在于rd引用的根本就不是d，而是引用临时变量（强转/隐式类型转换），临时变量具有常性（类似const修饰），所以是权限放大，出错
const int& rd = d;//类型转换会产生临时变量，临时变量也是常性，权限平移，正常
const int& x = 10;//引用常量，变成常量别名也可以
}
其中，所有的类型转换都不是对原变量进行转换，并不会改变原变量类型，所有的提升/截断都是产生一个临时变量
如果使用引用传参，函数内不改变参数，尽量使用const修饰参数（其中权限放大和缩小只针对引用/指针）
void fun(int a)
{}
int main()
{
const int a = 0;
fun(a);//可以
}4.3 引用和指针的区别
1.指针和引用的用途相似，引用能用的地方指针基本也能用
2.引用必须初始化，指针不用
3.引用初始化后不能再引用其他实体，指针可以任意指向
4.没有NULL引用，有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全
4.内联函数
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
当函数汇编指令行数小时，而且如果被频繁调用可以使用内联函数（例如堆排，快排Swap函数），C语言面对这个场景可以使用宏函数解决
宏优点：1.宏函数减少栈帧开销 2.复用性变强（宏常量）
缺点：1.可读性差（宏函数） 2.没有安全类型检查 3.不方便调试
C++中尽量使用const enum inline替换宏
特性：
1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
3. inline不建议声明和定义分离（多文件分离），分离会导致链接错误。因为inline被展开（内联函数不会被放进符号表，一般不会有人会去调用内联函数，因为默认认为在调用的地方已经被展开），就没有函数地址了，链接就会找不到。声明和定义分离时，内联加在声明中
5. auto关键字
作用：1.自动推导类型，例如很长的类型
2.范围for
int main()
{
int i[] = { 1,2,3,4,5 };
for(auto e:i)//自动取i的值赋值给e
{
cout << e << " ";//1 2 3 4 5
}
return 0;
}3.范围for加上&便可以修改数组内容，但是没法用指针（取i中每个数据的值赋值过去int类型）
int x = 10;
auto a = &x;
auto* b = &x;//强调传过来的是指针，类型还是int*
auto& c = x;//强调c是引用注意：
1.auto不能连续推导，编译器实际只对第一个类型进行推导
auto c = 3, d = 4.0;//X2.auto不能作为函数的参数（建立栈帧不知道开多大）
3.auto不能直接用来声明数组
auto b[] = {4，5，6};//X
4.for循环迭代的范围必须是确定的，以下函数有问题，array是指针
void TestFor(int array[])
{
for(auto& e : array)
cout<< e <<endl;
}
3648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
