【C++基础语法】

命名空间

C语言中命名冲突问题

int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决
int main()
{
printf("%d\n", rand);
return 0;
}
// 编译后后报错：error : “rand”: 重定义；以前的定义是“函数

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

1. 命名空间中可以定义变量/函数/类型

namespace csd
{
//一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

	int rand = 10;
	int Add(int left, int right)
	{
	return left + right;
	}
	struct Node
	{
	struct Node* next;
	int val;
	};
}

2.命名空间可以嵌套

3.同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中

如何使用命名空间？
命名空间的使用方法有三种。
1.加命名空间名称及作用域限定符

namespace N
{
	int a = 10;
}
int main()
{
	printf("%d\n", N::a);
	return 0;
}

2.使用using将命名空间某个成员引入

	using N::b;
int main()
{
	printf("%d\n", b);
	return 0;
}

3.使用using namespace 命名空间名称 ,将命名空间展开
但是需要注意的是，将命名空间展开 ，可能会造成名字冲突等问题，
所以比较好的使用命名空间的方法是 指定命名空间访问+展开常用

namespace N
{
	int a = 10;
	int b = 20;
}
using namespce N;
int main()
{
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
1.全缺省参数
全缺省时，实参传递给形参是从左往右传递的。

void Func(int a = 10, int b = 20, int c = 30)
{
	cout<<"a = "<<a<<endl;
	cout<<"b = "<<b<<endl;
	cout<<"c = "<<c<<endl;
}

2.半缺省参数

void Func(int a, int b = 10, int c = 20)
{
	cout<<"a = "<<a<<endl;
	cout<<"b = "<<b<<endl;
	cout<<"c = "<<c<<endl;
}

注意：

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;
}

C++支持函数重载的原理–名字修饰
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
假设当a.cpp中调用了b.cpp中定义的Add函数，在编译后链接前，每个.cpp文件会生成.o文件，当a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。（若也未找到则会报链接错误）
gcc的函数修饰后名字不变，而g++的函数修饰后变成【_Z+函数长度+函数名+类
型首字母】。
在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变，直接将函数名放入符号表中。
在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中，
所以对于相同的函数名，再被修饰后，会有不同的名字，此时链接器就可以在符号表中区分。

引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
引用特性
1.引用在定义时必须初始化。
2. 一个变量可以有多个引用。
3. 引用一旦引用一个实体，再不能引用其他实体。

引用做返回值
先来了解传值返回

当函数调用结束，返回n时，会产生一个n的拷贝，赋值给ret，因为n在函数栈帧销毁后也会一起销毁。
传引用返回

返回的还是Count栈帧中n这块空间上的值。其实此处的程序是不对的，下面的例子可以看出。

第一次调用printf函数后，因为建立printf函数的栈帧，ret引用的这块空间会被重置为随机值，所以在第二次打印ret时，就会出现随机值。
综上，引用在做返回值时要注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

常引用

用double& rdd 不能作为ii的引用，不是因为类型不同，而是因为当类型发生转换时，会产生临时变量，rdd是做为临时变量的引用，而临时变量又具有常性，所以要用常引用。

引用和指针的区别
（但从汇编的角度，引用的底层还是用指针实现的）

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型
   实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占
   4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

总结：指针更强大，更危险，更复杂，引用相对局限，更简单，更放便。

extern “C”

由于C和C++编译器对函数名字修饰规则的不同，在有些场景下可能就会出问题
在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译
但是如果只用extern “C”来限定一个函数的编译规则，对于C++来说，可以识别，但对于C语言来说，识别不了，所以在用extern “C”时就要加上C++中的一个宏__cplusplus

#ifdef __cplusplus
extern "C"
{
#endif
	int Add(int left, int right);
	int Sub(int left, int right);
#ifdef __cplusplus
}
#endif

__cplusplus:是C++编译器中定义的宏，即用该宏来检测是C工程还是C++工程
作用：如果是C++工程，编译器已经定义_cplusplus宏，编译时该宏是可以被识别的，被声明的函数就被extern "C"修饰了，
此时C++编译就知道，静态库中的函数是按照C的方式编译的，这样在链接时就会按照C的方式找函数名字
如果是C工程，编译器未定义_cplusplus宏，编译时该宏无法被识别，则条件编译就无效，函数就不会被extern "C"修饰