目录

一、命名空间

二、缺省参数

三、函数重载

四、引用

五、内联函数

六、异常处理

---

一、命名空间

在C/C++项目中，存在着大量的变量、函数和类，这些变量、函数和类都存在于全局作用域中，可能会导致命名冲突。

使用命名空间的目的就是对标识符进行本地化，以避免命名冲突或名字污染。

std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中。

在日常学习中，我们为了方便会直接展开std标准库的命名空间（using namespace std;），但是在一个项目中，为了避免存在命名冲突，我们会只展开std标准库中的一些常用的函数或对象，如（using std::cout;）。

#include <iostream>
using std::cout;

int main()
{
	cout << "hello world!" << std::endl;
}

二、缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实
参则采用该形参的缺省值，否则使用指定的实参。

#include <iostream>
using std::cout;

// 全缺省参数
void Func1(int num1 = 0, int num2 = 0)
{
	cout << num1 << " " << num2 << std::endl;
}

// 半缺省参数
// 半缺省参数必须从右往左依次来给出，不能间隔着给
// 缺省参数不能在函数声明和定义中同时出现
void Func2(int num1, int num2 = 0)
{
	cout << num1 << " " << num2 << std::endl;
}

int main()
{
	Func1();		// 0 0
	Func1(1);		// 1 0
	Func1(1, 2);	// 1 2

	Func2(1);		// 1 0
	Func2(1, 2);	// 1 2
}

三、函数重载

C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

对于参数类型不同的函数重载，我们可以用模板来实现，模板是减少代码复用的一种手段，是泛型编程的基础。

#include<iostream>
using namespace std;

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

int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

四、引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

void TestRef()
{
	int a = 10;
	int& ra = a;	// 定义引用类型
	// 引用类型必须和引用实体是同种类型的
	// 引用在定义时必须初始化
	// 一个变量可以有多个引用
	// 引用一旦引用一个实体，再不能引用其他实体

	printf("%p\n", &a);
	printf("%p\n", &ra);
}

// 常引用
void TestConstRef()
{
	const int a = 10;
	//int& ra = a; // 该语句编译时会出错，a为常量
	const int& ra = a;
	// int& b = 10; // 该语句编译时会出错，b为常量
	const int& b = 10;
	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，类型不同
	const int& rd = d;
}

// 做参数
// 引用传参，减少临时变量的拷贝，提高了效率
void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

// 做返回值
int& Count()
{
	static int n = 0;
	n++;
	// ...
	return n;
}

#include<iostream>
using namespace std;

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

// 结果是 ret == 7，为什么？

C++中引用和指针的区别：

1. 引用是一个变量的别名，与所引用的实体类型相同；指针存储的是一个变量的地址，是一个指针类型的变量。
2. 引用必须初始化，指针可以不初始化。
3. 引用在初始化引用一个实体后，就不能再引用其他实体；指针可以随时指向任何一个同类型实体。
4. 引用不能为空，指针可以为空。
5. 引用只有一级，指针可以有多级。
6. 引用可以直接访问和修改实体的值，指针需要解引用后才能访问和修改实体的值。
7. 引用的自增自减是修改所引用实体的值，指针的自增自减是向后或向前偏移一个相同数据类型的地址。

五、内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

六、异常处理

C语言程序遇到异常时一般会终止程序或返回错误码，但是在某些时候，我们是需要程序有一定的容错性的，也就是说遇到异常后将异常抛出并继续执行代码，于是C++引入了异常处理机制。

异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的
直接或间接的调用者处理这个错误。

• throw: 当问题出现时，程序会抛出一个异常。
• catch: 在想要处理问题的地方，通过cathc捕获异常。
• try: try 块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个 catch 块。

#include <iostream>
using namespace std;

// 有可能单个的catch不能完全处理一个异常，
// 在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，
// catch则可以通过重新抛出将异常传递给更上层的函数进行处理。

double Division(int a, int b)
{
	if (b == 0)
		throw "Division by zero condition";
	else
		return (double)a / (double)b;
}

void Func()
{
	// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
	// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。
	int* arr = new int[10]{ 0 };
	try {
		int x, y;
		cin >> x >> y;
		cout << Division(x, y) << endl;
	}
	catch (...) {
		cout << "delete[] " << arr << endl;
		delete[] arr;
		throw;
	}

	cout << "delete[] " << arr << endl;
	delete[] arr;
}

int main()
{
	try {
		Func();
	}
	catch (const char* errmsg) {
		cout << errmsg << endl;
	}
	catch (...) {
		cout << "unknown exception";
	}

	return 0;
}

C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII（智能指针）来解决以上问题。

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。

C++标准库定义的异常	描述
std::exception	所有标准C++异常的父类
std::bad_alloc	有new抛出的异常
std::logic_error	理论上可以通过读取代码来检测到的异常
std::invalid_argument	使用了无效参数抛出的异常
……	……