问题：
1.命名空间是什么？
2.函数重载是什么？为什么C语言没有函数重载而C++有函数重载？
3.传值和引用的效率哪个更高？
4.引用和指针哪个效率更高呢？引用和指针的区别？
5.宏的优缺点有哪些？
6.auto关键字的使用
7.NULL和nullptr的比较，到底该用用NULL还是用nullptr呢？
目录
>>3.使用using namespace 命名空间名称引入
5.2为什么C++支持函数重载而C语言不支持呢？因为它们对函数名称的修饰规则的不同
由上面的两个结果可知，传引用的效率明显比传值的效率高很多。那么这是为什么呢？
6.6既然引用效率这么高，那肯定比指针的效率要高吧？答案是否定的。
1.C++关键字
2.C++命名空间
在C语言中，你是否会会因为变量的起名字而苦恼呢？
当我们和别人一起开发一个项目的时候，自己负责自己的模块，互不干扰，但最后将代码进行整合，这时候就会出现问题了，有可能你定义的变量，别人已经定义过了，那么这时就需要进行逐个修改，很麻烦，为了解决这种问题，我们的命名空间就出现了。
2.1命名空间的定义
定义命名空间，需要使用到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 Sub(int left, int right)
{
return left - right;
}
}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace N1
{
int Mul(int left, int right)
{
return left * right;
}
}注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
2.2命名空间的使用
命名空间有三种方式：
>>1.加命名空间名称及作用域限定符
int main()
{
printf("%d\n", N::a);
return 0;
}>>2.使用using将命名空间中成员引入
using N::b;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
return 0;
}>>3.使用using namespace 命名空间名称引入
using namespce N;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
Add(10, 20);
return 0;
}2.3标准命名空间
为了解决C++标准库中的标识符与程序中的全局标识符之间以及不同库中的标识符之间的同名冲突，应该将不同库的标识符在不同的命名空间中定义(或声明)。标准C++库的所有的标识符都是在一个名为std的命名空间中定义的，或者说标准头文件(如iostream)中函数、类、对象和类模板是在命名空间 std中定义的。std是standard(标准)的缩写，表示这是存放标准库的有关内容的命名空间，含义请楚，不必死记。
这样，在程序中用到C++标准库时，需要使用std作为限定。如
std::cout<<”OK．”;
3.C++输入输出
大家在使用C语言的时候，在输出的时候，需要自己增加数据格式控制，比如：整形--%d, 字符--%c
这很麻烦，有时写错了格式控制符就会输出错误的答案，甚至是代码无法通过编译
C++就为我们解决了这个问题：它的输入和输出不再需要我们自己添加格式控制符
#include <iostream>
using namespace std;
int main()
{
int a;
double b; 12345678 12345678 1234567
char c;
cin>>a;
cin>>b>>c;
cout<<a<<endl;
cout<<b<<" "<<c<<endl;
return 0;
}注意： 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。
4.缺省参数
4.1缺省参数的概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。
void TestFunc(int a = 0) {
cout<<a<<endl;
}
int main()
{
TestFunc(); // 没有传参时，使用参数的默认值
TestFunc(10); // 传参时，使用指定的实参
}4.2缺省参数的分类
>>1全缺省参数
void TestFunc(int a = 10, int b = 20, int c = 30) {
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}>>2.半缺省参数
void TestFunc(int a, int b = 10, int c = 20) {
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}注意：1.半缺省参数必须是从右往左依次给出，不能间隔着给
2.缺省参数不能在函数声明和定义中同时出现
//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那
个缺省值。3.缺省值必须是常量或者全局变量
4.C语言不支持（编译器不支持）
5.函数重载
5.1函数重载的概念
函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须
不同，常用来处理实现功能类似数据类型不同的问题
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;
}5.2为什么C++支持函数重载而C语言不支持呢？因为它们对函数名称的修饰规则的不同
这里因为windows下vs的修饰规则过于复杂，而linux下的较为简单，所以我们采取linux进行测试
gcc编译：如下图，我们会发现函数名字的修饰没有发生改变。
g++编译：如下图，我们发现了它的函数名修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。这里也可以看出，修饰信息中没有返回值的信息，所以我们也可以知道，函数的重载与返回值的类型是否相同无关。
很明显，修改后的名称也很好理解：_Z + 原函数名的长度 + 原函数名 + 参数的类型
总结：C语言没办法支持函数重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持重载。
注意：C++支持函数重载，同名函数的形参列表（参数个数 或 类型 或 顺序）必须不同，与返回值的类型是否相同无关。
5.3extern "C"
我们在C++工程中有可能需要将某些函数按照C的风格来编译，那我们岂不是要重新写一份C++的代码？
这代价也实在太大了，所以我们就有了extern这个关键字，在函数前面加上extern "C"，意思就是告诉编译器，将该函数按照C语言规则来编译。
6.引用
6.1引用的概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
类型& 引用变量名(对象名) = 引用实体；
void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}注意：引用类型必须和引用实体是同种类型的
6.2引用特性
1.引用在定义时必须初始化
2.一个变量可以有多个引用
3.引用一旦引用一个实体，再不能引用其他实体
void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;
printf("%p %p %p\n", &a, &ra, &rra);
}6.3常引用
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;
}6.4使用场景
1.做参数
void Swap(int& left, int& right) {
int temp = left;
left = right;
right = temp;
}2.做返回值
int& Count()
{
static int n = 0；
n++;
// ...
return n;
}6.5那么传值和引用的效率哪个更高？
参数的引用与传值比较：
#include <time.h>
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; }
返回值的引用与传值比较：
#include <time.h>
struct A{ int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2(){ return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
} 
由上面的两个结果可知，传引用的效率明显比传值的效率高很多。那么这是为什么呢？
这是因为，以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而且传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是十分低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
6.6既然引用效率这么高，那肯定比指针的效率要高吧？答案是否定的。
我们发现他们的时间效率是一样的（如果不一样，那么可以多运行几次，他们所用时间几乎是一样的），那么这又是为什么呢？
我们通过查看以下代码的反汇编：我们发现了指针和引用在底层的实现上完全是一样的。所以我们可以知道引用的底层是用指针实现的。
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
既然底层代码都一样那么指针和引用是完全一样的吗？当然不是
6.7引用和指针的不同点：
- 引用在定义的时候必须初始化，指针没有要求
- 引用在初始化引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用，但有NULL指针
- 引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下4个字节）
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显示解引用，引用编译器自己处理
- 引用比指针使用起来更加安全
7.内敛函数
7.1概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率
通过上图我们知道，通过查看反汇编我们发现，当执行到139行代码的时候，有一个call Add的函数压榨过程，这就增加了我们的开销。而我们使用内联函数的时候。
注意：对于内联函数我们的查看方式有两种
1.在release模式下，查看编译器生成的汇编代码中是否存在call Add
2.在debug模式下，需要对编译器进行设置，否则不会展开（因为debug模式下，编译器默认不会对代码进行优化，一下的测试均是在vs2013下进行的）
我们首先的编译器进行设置：
第一步：
第二步：
此时我们查看它的反汇编，我们发现：
如上图，此时的call Add已经不在了。
7.2特性
- inline是一种空间换取时间的做法，省去调用函数的开销。所以代码很长或者有递归循环/循环的函数不适宜使用作为内联函数。
- inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内敛。
- inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会报错
// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i) {
cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
f(10);
return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?
f@@YAXH@Z)，该符号在函数 _main 中被引用7.3宏的优缺点
优点：1.增强代码的复用性
2.提高性能
缺点：1.不方便调试宏（因为在编译阶段就进行了替换）
2.导致代码可读性差，可维护性差，容易误用
3.没有类型安全检查
7.4C++有哪些技术替代宏
1.常量定义换用const
2.函数定义换用内敛函数
8.auto关键字（C++11）
8.1概念：
注意：
8.2auto的使用细则
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的初始化表达式类型不同
}// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}2.auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}3.为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4.auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配和使用
9.基于范围的for循环(C++11)
9.1范围for的语法
void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
array[i] *= 2;
for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
cout << *p << endl; }对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由“ ：”分为两部分：第一部分是范围用于迭代的变量，第二部分则表示迭代的范围。
void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
e *= 2;
for(auto e : array)
cout << e << " ";
return 0;
}9.2范围for的使用条件
void TestFor(int array[])
{
for(auto& e : array)
cout<< e <<endl;
}10.指针空值--nullptr（C++11）
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
#endifvoid f(int) {
cout << "f(int)" << endl;
}
void f(int*) {
cout << "f(int*)" << endl;
}
int main()
{
f(0);
f(NULL);
f((int*)NULL);
return 0;
}
我们第192行本来是想要调用参数为int*（指针）类型的f函数，结果他却调用了参数为int类型的函数，与我们的初衷不同。
这是因为什么呢？
在 C++98 中，字面常量 0 既可以是一个整形数字，也可以是无类型的指针 (void*) 常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转 (void *)0 。
注意：
- 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
- 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
- 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。