目录

1.命名空间：namespace

2. 输入输出

3.缺省参数

3.函数重载

3.2 C++支持函数重载的原理--名字修饰(name Mangling)

4.引用

4.2 常引用

4.3 引用和指针的区别

4.内联函数

5. auto关键字

---

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 
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)<//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)<
	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;//X

2.auto不能作为函数的参数（建立栈帧不知道开多大）

3.auto不能直接用来声明数组

auto b[] = {4，5，6};//X

4.for循环迭代的范围必须是确定的，以下函数有问题，array是指针

void TestFor(int array[])
{
 for(auto& e : array)
 cout<< e <
}