C++基础知识点

一、命名空间

在C++中，我们可以使用关键字 namespace 加命名空间名字再加花括号来创建一个新的命名空间，一个命名空间相当与一个新的作用域，在该命名空间下的所有成员都仅局限于这个命名空间中。而且命名空间 namespace 可以嵌套使用。
我们来看一段代码：

namespace N1
{
	int a = 10;
	int b = 20;
	int c = a + b;
	namespace N2
	{
		int d = 40;
	}
}
int main()
{
	cout << a << endl;
    return 0;
}

上述代码编译器会报错，a 是未声明的标识符。也就是说，a 只能在命名空间 N1 中使用。
那么我们如何去使用命名空间中的成员呢。
一共有三种方法可以使用某个命名空间中的成员
1. 使用命名空间名称加作用域限定符
 

namespace N1
{
	int a = 10;
	int b = 20;
	int c = a + b;
	namespace N2
	{
		int d = 40;
	}
}
int main()
{
	cout << N1::a << endl;
}

2. 使用关键字 using 引入命名空间中的成员。
 

namespace N1
{
	int a = 10;
	int b = 20;
	int c = a + b;
	namespace N2
	{
		int d = 40;
	}
}
using N1::a
int main()
{
	cout << a << endl;
}

3. 使用 using namespace 将整个命名空间展开，可以使用整个命名空间的所有成员。
 

namespace N1
{
	int a = 10;
	int b = 20;
	int c = a + b;
	namespace N2
	{
		int d = 40;
	}
}
using namespace N1;
int main()
{
	cout << a << endl;
}

 二、缺省参数

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

void TestFunc(int a = 0)
{
 cout<

缺省参数分为两种：全缺省参数和半缺省参数。
1.全缺省参数,即所有参数都设定一个缺省值，函数调用时，没有指定的参数则使用缺省值。

void TestFunc(int a = 10, int b = 20, int c = 30)
{
 cout<<"a = "<void TestFunc(int a = 10, int b = 20, int c)
{
 cout<<"a = "<//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{}
// 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个
缺省值

另外，缺省值必须是全局变量或者常量。  C语言不支持缺省值。

三、函数重载

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

namespace N1
{
	int add(int a, int b)
	{
		return a + b;
	}
	double add(double a, double b)
	{
		return a + b;
	}
}
using namespace N1;
int main()
{
	cout << add(1, 2) << endl;
	cout << add(1.1, 2.2) << endl;
}

上述代码执行后会出现输出结果
3
3.3
达到了我们预期的要求，那么，编译器是怎么知道我们具体想要调用的是哪个函数呢？
我们知道一个程序需要经过预处理，编译，汇编，链接这几个过程。编译器的进行编译过程中，会将函数根据函数名和参数（类型，数量，顺序）来重新修饰为一个在全局上唯一的函数名。这样，我们在调用重载函数时，不管我们调用的是哪一个同名的重载函数，在编译器那里都是一个唯一的名字，所以就会调用我们想要的重载函数。
那么是什么样的修饰规则呢？
对于C语言来说，在编译时，会对函数名前面加一个下划线 _ ，所以，在C语言中是不支持函数重载的。
而支持函数重载，所以修饰规则会非常复杂，需要根据函数名，以及参数列表来重新修饰函数名，这也就是为什么，函数重载时，必须要有不同的参数列表。因为要保证编译器在修饰后的函数名在全局上是唯一的。

我们在使用C++编译程序时，可以在函数前加上 extern "C"  表示使用C语言规则来编译。
列如：
 

extern "C" int Add(int left, int right);  //只有声明没有定义，程序在链接时会报错
int main()
{
 Add(1,2);
 return 0;
}

程序在链接时会报错：error LNK2019: 无法解析的外部符号_Add，该符号在函数 _main 中被引用。 我们可以看到，编译器已经将函数名修饰为 _Add 也就是说，使用了C语言的编译规则。

我们来看下面两个函数是否属于重载
 

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

答案是不属于，只改变了返回值，而返回值不作为编译器重新修饰函数名的因素。

四、引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。相当于给被引用的变量起了一个别名。
类型& 引用变量名(对象名) = 引用实体；
 

void TestRef()
{
 int a = 10;
 int& ra = a;//<====定义引用类型
 
 printf("%p\n", &a);
 printf("%p\n", &ra);
}
int main()
{
 TestRef();
}

程序运行结果：

我们可以看到，变量 a 和变量 a 的引用 ra 的地址都是一样的。
1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体
4.引用类型必须和引用实体是同一种类型。

常引用

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;

我们来看一段代码：
 

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 <

上述代码运行结果会是什么？答案是 7 。为什么呢？
如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能用栈上的空间作为引用类型返回。如果以引用类型返回，返回值的生命周期必须不受函数的限制(即比函数生命周期长)。否则就不会达到预期的值。
上述代码可以这样改：
 

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

输出结果为 3 。

值、指针和引用作为参数和返回值的效率比较：
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实
参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返
回值类型非常大时，效率就更低 。
那么指针和引用来比较呢？
引用和指针在作为传参以及返回值类型上效率几乎相同（不作证明）。

指针和引用的区别：

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

五、内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，
内联函数提升程序运行的效率。inline关键字必须和函数体定义放在一起才可以实现内联，仅仅将inline放在函数声明之前不起任何作用。inline是一个用于实现的关键字而不是一个用于声明的关键字。

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜
使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等
等，编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会无法找到。

说到内联，我们可以简单的说一下宏。宏的优点是：挺高代码复用性，增强性能。缺点是： 1.不方便调试宏。（因为预编译阶段进行了替换）2.导致代码可读性差，可维护性差，容易误用。 3.没有类型安全的检查。
那么我们在C++中，有一些技术可以代替宏：常量定义——换用const ； 函数定义——换用内联。

六、auto 关键字

auto 一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();

	cout << typeid(b).name() << endl;  //typeid(变量名).name() 可以输出变量的类型
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;

	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}

程序运行结果：

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

2. 在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对
第一个类型进行推导，然后用推导出来的类型定义其他变量。
 

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

不能使用 auto 的场景
1. auto 不能作为函数参数。
2. auto 不能用来声明数组。
3. auto 不能定义类的非静态成员变量。
4. 实例化模板时不能使用 auto 作为模板参数。

基于 auto C++11 还给出了一种新的循环的方式。
 

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

上述代码运行结果为： 1 2 3 4 5
我们再来看一个代码：
 

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

}
int main()
{
	TestFor();
	return 0;
}

我们会发现程序运行结果还是 1 2 3 4 5
如果我们想利用 auto 这种方式来去改变变量 e 的内容 我们需要用到引用，即在 auto 后面加上 & 。
 

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

}
int main()
{
	TestFor();
	return 0;
}

该程序运行结果就是我们想要的 2 4 6 8 10

七、nullptr

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
 

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

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
 

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
 

void f(int)
{
 cout<<"f(int)"<

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
程序运行结果如下：

为了考虑兼容性，C++11并没有消除常量0的二义性，C++11给出了全新的 nullptr 表示空值指针，即：nullptr代表一个指针空值常量。
nullptr是有类型的，其类型为nullptr_t，仅仅可以被隐式转化为指针类型，nullptr_t被定义在头文件中：
typedef decltype(nullptr) nullptr_t;

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr