命名空间、缺省参数、函数重载、引用

 
 
 

1.命名空间：

一个命名空间就定义了一个新的作用域，其内的所有内容全部局限于该命名空间。

这样做的目的：避免命名冲突或名字污染。

命名空间的定义方式：

1. 常见的：

namespace N
{
	int a;
	int ADD(int left, int right)
	{
		return left + right;
	}
}

2. 嵌套定义：

namespace N
{
	int a;
	int ADD(int left, int right)
	{
		return left + right;
	}
	namespace N1
	{
		int a;
		int ADD(int left, int right)
		{
			return left + right;
		}
	}
}

3. 在同一个文件中，存在多个相同名称的命名空间，编译器最终会合并为一个命名空间

namespace N
{
	int a;
	int ADD(int left, int right)
	{
		return left + right;
	}
}
namespace N
{
	int c;
	int d;
}

注意： 第三种方式是同一个命名空间，写在了不同的位置，最终会进行合并，不能有相同的变量或者函数名(参数类型完全一致)。否则会发生重定义。

命名空间的使用：

1. 采用作用域运算符：：： ，N：：变量/函数
   如：N::c;
2. 使用 using N(命名空间名)：： 变量/函数
   这种情况适合某命名空间中的某些变量或函数经常用到，就可以直接这样使用。这样就相当于在当前文件中，该变量成为了 “全局变量” ,函数在整个工程中可以直接调用。
   如：

using N::ADD;// ②
using N::a;

int main()
{
	N::c;//①
	return 0;
}

3. 使用 using namespace N(命名空间);
   该命名空间中的变量或函数都能经常用到。则将该命名空间中的所有成员作用域当成该文件的全局作用。

 
 
 

2.缺省参数：

缺省参数是在声明或定义函数时为参数指定一个默认值。在函数调用的时候，若没有指定实参则使用默认值，否则使用指定的实参。

缺省参数类型：

1. 全缺省参数：所有的函数参数都有默认值。

int ADD(int first = 1, int second = 2, int third = 3)
{
	return first + second + third;
}

2. 半缺省参数：只有部分函数参数有默认值。

int ADD(int first, int second, int third = 3)
{
	return first + second + third;
}

注意：

1. 半缺省参数必须从右往左给出。
2. 缺省参数不能同时在函数声明和定义中出现。
3. 缺省值必须是常量或者全局变量

单独在函数声明和定义中都可以给出。若重复出现，会出现重定义默认参数。

一般建议缺省参数默认值在函数声明中给出。

3.函数重载：

函数重载：在C++中，同一个作用域声明几个功能类似的同名函数。这些同名函数的形参列表(参数类型，参数个数，参数顺序)不同。

参数列表的不同体现：

1. 参数个数不同： 下面这两个同名函数，不同参数个数，构成了函数重载。

int ADD(int right, int left)
{
	return right + left;
}

int ADD()
{
	return 10;
}

2. 参数类型不同：下面两个同名函数，其参数类型不一样，构成了函数重载。

int ADD(int right, int left)
{
	return right + left;
}

double ADD(double right,double left)
{
	return right + left;
}

3. 参数类型顺序不同：下面两个同名函数,参数类型的顺序不一样，构成了函数重载。

double ADD(int right, double left)
{
	return right + left;
}

double ADD(double right, int left)
{
	return right + left;
}

这样一份代码：

int ADD(int right, int left)
{
	return right + left;
}

double ADD(double right, double left)
{
	return right + left;
}

int main()
{
	ADD(1, 2.2);
	return 0;
}

在这份代码中，会出现怎样的错误呢？

在函数调用过程中，会进行形参实例化，但都没有完全匹配的类型。则会发生隐式类型转换。int->double 或者double->int 类型，但是在上述调用中，会发现，两种转换都可以进行。而编译器并不知道选择哪一个。就会产生错误。

VS2017中的报错：

这样产生的错误叫做二义性 | 歧义。

函数重载调用原理： 在编译阶段确定调用什么函数

1. 在编译阶段，编译器对类型进行推演，根据推演的结果寻找类型匹配的函数进行调用。
2. 若有类型完全匹配的函数，则直接进行调用。
3. 若没有类型完全匹配的函数，则进行隐式类型转换。
4. 若隐式类型转换后有对应的函数(没有产生二义性)则进行调用。
5. 若没有或产生了二义性，进行报错。

所以在执行ADD(1，2.2)的时候，产生了二义性，多重转换，编译器报错。

函数的返回值类型不一样，不构成函数重载。

int ADD(int right, int left)
{
	return right + left;
}

double ADD(int right, int left)
{
	return right + left;
}

这样是不构成函数重载的。

C语言为什么不支持函数重载？而C++支持函数重载呢？

在VS环境中看一下：

int ADD(int right, int left);

int main()
{
	ADD(1, 2);
	return 0;
}

没有函数定义，进行报错。
在C++中，报错为：

在C语言中，报错为：

上述代码是一样的，但是编译器在编译的时候，在底层使用的名字是不一样的。

C语言：仅仅对函数名字前加了一个_
C++：对函数名解释为？ADD@@YAHHH@Z。
若在C++中，返回值类型为double，参数类型都为double，其函数名是什么呢？

 
 
 
再看一下Linux环境中是怎样的：
C++：

C语言：

可以看到在C语言中，对函数修饰的比较简单。而C++对函数修饰的比较具体，在Linux中，包含了函数名的长度，函数参数的类型第一个字母。

所以，C语言不支持函数重载，因为它对函数修饰的比较简单，如果有重名函数，就会发生重定义。而在C++中，对函数参数类型也进行了修饰，同名函数不同的参数列表，其底层描述是不一样的。

 
 
 

C语言和C++函数的区别？

1. 返回值类型：

C语言中：函数没有返回值类型，系统默认返回int类型。
C++中：需要带上返回值类型。否则程序报错。

2. 函数参数：

C语言中：函数无参数，但调用时，传递了参数，编译器可以编译通过。
C++中，函数无参数，调用时，传递了参数，编译器无法编译通过。

3. C++函数参数可以带默认值：即缺省参数
4. 函数命名规则不同：C++中支持函数重载，而C语言不支持

C++编译器比C语言编译器语法检测更加严格。
 
 
 
 

4.引用：

引用是对当前的已存在变量取一个别名，编译器不会对该引用开辟空间，而是和被引用的变量共用一块内存空间。

引用和被引用变量共用一个内存空间。
引用发生了数据更改，被引用的变量也会发生变化。

引用类型要和变量的类型保持一致。

引用的注意事项：

1. 在定义时必须初始化。即指定要引用的变量。
2. 一个变量可以有多个引用。即一个实体有多个别名。
3. 引用一个实体之后，不能再引用其它实体。

引用一个常量时，也要加上const，不能通过引用来修改实体。

int main()
{
	double d = 12.56;
	const int& rd = d;
	return 0;
}

上述代码的引用是可以引用成功的。但是会有问题：

这是为什么呢？
引用变量会与引用实体的类型要一致。double与int之间发生了隐式类型转换，double转化为了int。
rd引用d，编译器创建了一个临时空间作为过渡，让rd去引用这个临时空间。
但是这个空间的地址，在一般情况下是不知道的，则无法修改。所以这个空间具有了常性 (常量特性)。
rd相当于就引用了一个常量。则必须加上一个const。

 
 
引用的应用场景：

1. 使代码简洁。
2. 做函数参数。
3. 做函数返回值。

做函数返回值时要注意：

1. 若返回对象已经归还给系统，不能用引用返回。否则返回的是一块非法区域。
2. 若返回对象未归还给系统，可以使用引用返回。

对函数传值和传引用的比较：传引用比传值效率快的多，因为传引用没有形参实例化的过程，形参只是实体的一个别名，减少了参数压栈带来的开销，所以效率快的多。

函数传指针和传引用的比较：两者的效率是差不多的。

void Swap(int& right, int& left)
{
	int tmp = right;
	right = left;
	left = tmp;
}

void Swap(int *right, int *left)
{
	int tmp = *right;
	*right = *left;
	*left = tmp;
}

int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);

	Swap(&a, &b);
	return 0;
}

对其反汇编：

发现，两个代码进行的操作是一样的。引用按照指针的方式进行了操作。

引用在底层的操作和指针的方式实现的。

引用和指针的区别：

1. 从概念上看：
   引用：是一个变量的别名，编译器不会对其开辟空间。引用和实体共用一块空间。
   指针：编译器会对其分配空间，指针指向的是地址。
2. 从底层上看：引用和指针没有什么区别----引用就是指针
3. 从特性上看：

1.引用必须初始化，指针没有要求
2.引用实体之后，不能再引用其它实体。指针可以指向任意同意类型的地址
3.没有NULL引用，但有NULL指针
4.sizeof中，引用结果为其引用类型的大小，而指针在32位平台下，始终是4个字节
5.引用自加1为实体加1，指针自加1，为加上其类型的大小
6.有多级指针，但没有多级引用
7.访问实体时，指针需要解引用，引用能直接使用
8.引用比指针相对来说更安全