C++基础知识

一、命名空间
使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。
namespace关键字就是针对这种问题，起隔离的作用。
（1）普通的命名空间

namespace N1  //N1为命名空间的名称
{
	//命名空间的内容即可以定义变量，也可以定义函数
	int a;
	int Add(int left, int right)
	{
		return left + right;
	}
}

（2）命名空间可以嵌套使用

namespace N2
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N3
	{
		int c;
		int d;
		int Add(int left, int right)
		{
			return left - right;
		}
	}
}

（3）同一个工程中允许存在多个相同名称的命名空间

1、命名空间的使用

namespace bit
{
	const int N = 10;
}

（1）加命名空间名称及作用域限定符

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

（2）使用using将命名空间中成员引用

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

（3）使用using namespace命名空间名称引用

using namespace bit;
int main()
{
	printf("%d\n", N);
}

二、C++的输入和输出
cout标准输出，cin标准输入，endl为换行
注：不需要增加数据格式控制，比如：整性–%d，字符–%c

#include<iostream>
using namespace std;  //std为C++标准库的命名空间

int main()
{
	int a;
	double b;
	char c;
	cin >> a;
	cin >> b >> c;
	cout << a << endl;
	cout << b << " " << c << endl;
	return 0;
}

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

void TestFunc(int a = 0)
{
	cout << a << endl;
}

int main()
{
	TestFunc();    //没有传参时，使用参数的默认值
	TestFunc(10);   //传参时，使用指定的实参
	return 0;
}

1、缺省参数的分类
（1）全缺省参数

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

int main()
{
	TestFunc();           //10  20  30
	TestFunc(1);          //1   20  30
	TestFunc(1, 2);       //1   2   30
	TestFunc(1, 2, 3);    //1   2   3
	return 0;
}

（2）半缺省参数

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

int main()
{
	TestFunc(1);          //1   10  20
	TestFunc(1, 2);       //1   2   20
	TestFunc(1, 2, 3);    //1   2   3
	return 0;
}

注：1、半缺省参数必须从右往左依次来给出，不能间隔着给
2、缺省参数不能在函数声明和定义中同时出现，一般放在声明中
3、缺省值必须时常量或全局变量

四、函数重载
1、函数重载：同名函数的形参列表（参数的个数或类型或顺序）必须不同。

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

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

long Add(long left, long right)
{
	return left + right;
}

int main()
{
	Add(10, 20);
	Add(10.0, 20.0);
	Add(10L, 20L);
	return 0;
}

2、名字修饰
C/C++中，一个程序运行起来，需经历：预处理、编译、汇编、链接。
预处理：展开头文件、宏替换、条件编译、去掉注释…
编译：检查语法错误、生成汇编代码
汇编：把汇编代码转成二进制机器码
链接：链接到一起，生成可执行程序

名字修饰是在编译过程中将函数、变量的名称重新改编
而在C中，名字修饰规则特别简单，只是在函数名字前添加了下划线。
因此当工程中存在相同函数名的函数时，会发生链接错误，就会产生冲突。故C中不适合函数重载。

3、extern “C”
当工程中需要将某些函数按照C的风格来编译，在函数前加extern “C”

五、引用
给已存在变量取了一个别名，与其引用的变量共用一块内存空间
类型& 引用变量名（对象名）= 引用实体

void TeatRef()
{
	int a = 10;
	int& b = a;
	printf("%p\n", &a);
	printf("%p\n", &b);
}

1、引用特性：
（1）引用在定义时必须初始化
（2）一个变量可以有多个引用
（3）一旦引用一个实体，再不能引用其他实体

void TestConstRef()
{
	const int a = 10;
	//int& ra = a;    //该语句编译时会出错，a为常量，是不可改变的
	const int& ra = a;
	double d = 12.34;
	//int& rd = d;    //该语句编译时会出错,类型不同
	const int& rd = d;  //可行，在类型转换中产生了一个临时变量，这个临时变量是不可变的，即为const类型
}

2、使用场景
（1）做参数

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

（2）做返回值

int TestRefReturn(int& a)
{
    	a += 10;
    	return a;
}//当函数返回时，a所在的栈帧被销毁，a创建了一个临时空间，放在寄存器中保存，即传递了实参或返回变量的一份临时拷贝
int& TestRefReturn(int& a)
{
	a += 10;
	return a;
}//当函数返回时，返回的对象不用拷贝

注：1.返回对象是一个当前函数的局部变量，不能用引用返回
2.返回对象出了当前函数的作用域依旧存在，可以用引用返回
3.对象很大时尽量不要传值返回，使用传引用减少拷贝

3、引用和指针的区别
引用和指针的不同点：
1）引用在定义时必须初始化，指针没有要求
2）引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3）没有NULL引用，但有NULL指针
4）在sizeof中含义不同：引用结果为引用类型大小，但指针始终是地址空间所占字节个数
5）引用自加即引用的实体加1，指针自加即指针向后偏移一个类型的大小
6）有多级指针，但没有多级引用
7）访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
引用在语法概念上是没有独立空间的，和其引用实体共用同一块空间。但在底层实现上实际是有空间的，因为指针是按照指针方式来实现的。
8）引用比指针使用起来相对更安全

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

inline int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int ret = 0;
	ret = Add(1, 2);
	return 0;
}

inline是一种时间换空间的做法

C语言中使用宏函数
宏函数
优点：增强代码的复用性；提高性能
缺点：不方便调试宏；导致代码可读性差，可维护性差，容易误用；没有类型安全的检查

#define ADD(a, b) ((a) + (b))
#define SWAP(a, b) {int tmp;\
	tmp = a;  \
    a = b;    \
    b = tmp; }
#define SWAP(a, b) (a = (a) + (b), b = (a) - (b), a = (a) - (b));
#define SWAP(a, b)\
do
{
	int tmp = a; \
		a = b;   \
		b = tmp; \
} while (false)

七、auto关键字
auto作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

int TestAuto()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a;   //int
	auto c = 'a';   //char
	auto d = TestAuto();   //int
	auto& e = a;      //int
	auto* f = &a;    //int*

	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(e).name() << endl;
	cout << typeid(f).name() << endl;
	return 0;
}

1、auto使用细则
（1）auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时必须加&

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	*a = 20;
	*b = 30;
	c = 40;
	return 0;
}

（2）在同一行定义多个变量（这些变量必须是相同类型的）

void TestAuto()
{
	auto a = 1, b = 2;
	auto c = 3, d = 4.0;  //该行代码会编译失败，因为c和d的初始化表达类型不同
}

2、auto不能推导的场景
（1）auto不能作为函数的参数
此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导

void TestAuto()
{}

（2）auto不能直接用来声明数组

void TestAuto()
{
	int a[] = { 1, 2, 3 };
	auto b[3] = a;
}

八、基于范围的for循环

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array)
	{
		e *= 2;
	}
	for (auto& e : array)
	{
		cout << e << " ";
	}
}

注：for循环迭代的范围必须是确定的。对于数组而言，就是数组中第一个元素和最后一个数组的范围。

九、指针空值nullptr

void TestPtr()
{
	int* p1 = NULL;
	int* p2 = 0;
}

NULL可能被定义为字面常量0，或者被定义为无指针类型(void*)常量。
故为避免混淆，用nullptr代表一个指针空值常量