什么是C++

1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表示该语言与C语言的渊源关系，将其命名为C++。因此，C++是基于C语言产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
现在C++比较主流的两个版本还是C++98和C++11。

C++98：C++标准的第一个版本，绝大多数编译器都支持，以模板方式重写C++标准库，引入了STL(标准模板库)
C++11：增加了许多特性，使得C++更像一种新语言。比如：正则表达式、基于范围的for循环，auto关键字、新容器、列表初始化、标准线程库等。

命名空间

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

#include <stdio.h>
#include <stdlib.h>int rand = 0;int main()
{printf("%d\n", rand);return 0;
}

C语言没有办法解决上述类似的命名冲突问题，所以C++提出了namespace来解决。
命名空间中可以定义变量/函数/类型，可以嵌套。同一个工程中是允许存在多个相同名称的命名空间的，这些命名空间中的内容最后会合并到一起。
定义一个命名空间就定义一个新的作用域，命名空间中的所有内容都局限于该命名空间。

int a = 0;namespace zs
{int a = 1;
}/** 命名空间展开* 先到全局域中去找，如果没有还会在展开的zs域中去找*/
using namespace zs;int main()
{int a = 2;printf("%d\n", a);// 2printf("%d\n", ::a);// 0printf("%d\n", zs::a);// 1return 0;
}

所以，std作为C++标准库的命名空间，很多时候C++程序中的using namespace std将标准库中的东西都暴露出来，在实际开发中并不是好的做法。那如何合理使用std命名空间呢？
可以通过指定命名空间 + 展开常用的库对象/类型等方式来解决。

命名空间的三种使用方式

• 加命名空间名称及作用域限定符
• 使用using将命名空间中某个成员引入
• 使用using namespace 命名空间名称引入

C++的输入和输出

• 使用cout标准输出对象和cin标准输入对象时，必须包含<iostream>头文件，并按命名空间使用方法使用std。
• <<是流插入运算符，>>是流提取运算符。
• 使用C++输入输出可以自动识别变量类型。

#include <iostream>
using namespace std;int main()
{int i = 0;float f = 0;char c = 0;cin >> i >> f >> c;cout << i << ' ' << f << ' ' << c << endl;return 0;
}

缺省参数

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

缺省参数分类

• 全缺省参数

void Cout(int a = 1, int b = 2, int c = 3)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}int main()
{Cout();Cout(10); // 从左往右传值Cout(10, 20);Cout(10, 20, 30);return 0;
}

• 半缺省参数

// 从右往左连续缺省，不能间隔
void Cout(int a, int b = 2, int c = 3)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}int main()
{Cout(10);Cout(10, 20);Cout(10, 20, 30);return 0;
}

缺省参数不能在函数声明和定义中同时出现。声明和定义都有的时候声明中给缺省参数。

缺省值必须是常量或者全局变量。

函数重载

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

void CppSwap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}void CppSwap(float* a, float* b)
{float tmp = *a;*a = *b;*b = tmp;
}int main()
{int i1 = 1;int i2 = 2;float f1 = 1.1f;float f2 = 2.2f;CppSwap(&i1, &i2);CppSwap(&f1, &f2);cout << "i1 = " << i1 << endl;cout << "i2 = " << i2 << endl;cout << "f1 = " << f1 << endl;cout << "f2 = " << f2 << endl;return 0;
}

但是C语言并不支持函数重载，如果C语言想要实现上面的交换就需要定义不同的函数来完成了。

void CSwapi(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}void CSwapf(float* a, float* b)
{float tmp = *a;*a = *b;*b = tmp;
}int main()
{int i1 = 1;int i2 = 2;float f1 = 1.1f;float f2 = 2.2f;CSwapi(&i1, &i2);CSwapf(&f1, &f2);printf(" i1 = %d\n i2 = %d\n", i1, i2);printf(" f1 = %.1f\n f2 = %.1f\n", f1, f2);return 0;
}

这里就可以初步认识到函数重载的意义：让用的地方很方便，就像用同一个函数一样。
那为什么C++支持函数重载，而C语言不支持呢？C++又是如何支持函数重载的呢？
这里通过程序编译链接的过程来进行解释。

有3个文件：func.h，func.c，test.c，编译链接过程如下：

但是，如果是用gcc编译，会报错：

用g++编译，能够正常输出：

通过查看汇编下的代码可以发现，两个func函数的命名并不相同：<_Z4funcid>和<_Z4funcdi>【_Z+函数长度+函数名+类型首字母】，对应的函数地址自然不相同。

但是C语言对于函数的命名规则是直接使用函数名，这就导致如果两个函数重名，C语言编译器就无法区分。
所以，就可以知道C++通过函数名修饰规则来进行同名函数的区分来达到重载，C语言因为不能对同名函数进行区分也就不能支持函数重载了。

引用

引用就是给已经存在的变量取一个别名。编译器不会为引用变量开辟内存空间，而是和被引用的变量共用一块内存空间。
引用变量的定义形式：类型& 引用变量名(对象名) = 引用实体
注意：引用类型必须和引用实体是同种类型的
引用特性：

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用了一个实体，在不能引用其它实体
   

引用的使用场景

1. 引用做参数

void Swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}int main()
{int a = 1;int b = 2;Swap(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;return 0;
}

引用可以用作输出型参数。例如交换两个变量的值，可以避开使用指针来完成。
引用还可以对大对象进行传参，提高效率。
2. 引用做返回值
使用引用做返回值，必须确保出了函数作用域，返回对象仍不会被销毁。否则只能选择传值返回。

int& RetRef()
{//int count = 0;// 只能传值返回static int count = 0;// 可以传引用返回++count;//...return count;
}

引用返回的语法含义就是返回 返回对象 的别名。所以如果用普通变量接收，得到的是引用变量中存储的值；如果用引用变量接收，得到的就是这个引用变量。

同时，引用返回也可以减少拷贝，提高效率。

常引用

const int i = 1;
int& ii = i;// error

由const int到int权限被放大了，会报错。所以只能选择权限平移const int& ii = i;。

int i = 1;
const int& ii = i;

由int到const int权限被缩小了，这样是可以的。这时i有读和写的权限，而ii只有读的权限了。

const int& i = 10;

常量10只具有读的属性，所以需要用const修饰。

int i = 1;
double& rd = i;//error
const double& rd = i;//correct

引用类型和引用实体必须是同种类型的，否则会报错。但是经过const修饰后，又不再报错了，这时为什么呢？

变量i在给到rd之前，是会在中间发生隐式类型转换的。将int类型的值转换成double类型的值，给到临时变量tmp，而rd实际上只是临时变量tmp的引用变量。

所以有时候在使用函数调用的时候，如果使用引用传参，并且函数内如果不改变引用参数，那么就建议尽量用const引用传参。

void func(const int& n)
{//...
}int main()
{int a = 10;const int b = 20;func(a);//权限缩小func(b);func(30);return 0;
}

指针和引用的区别

在语法概念上，引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
但在底层实现上，引用是按照指针的方式来实现的，是开辟了空间的。
引用和指针的汇编代码对比：

引用和指针的不同点：

1. 概念上引用是一个变量的别名；指针是一个变量的地址。
2. 引用在定义时必须初始化；指针没有要求
3. 引用在引用一个实体后，就不能再引用其它实体了；指针可以更改指向。
4. 没有NULL引用；但有NULL指针。
5. sizeof的含义不同：引用结果是引用类型的大小；指针始终是 4 or 8 byte。
6. 引用自加是引用的实体+1；指针自加是指针向后偏移一个类型的大小。
7. 有多级指针；但没有多级引用。
8. 指针访问实体需要显式解引用；引用编译器自己处理。
9. 指针更强大，也更危险，更复杂；引用相对局限一些，但更安全，更简单

auto关键字

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11就给auto赋予了新的含义。
C++11中，标准委员会赋予了auto全新的含义：作为一个新的类型指示符来指示编译器(为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法)。auto声明的变量必须由编译器在编译时期推导而得，因此使用auto定义变量时必须对其进行初始化。
所以auto并非是一种“类型”的声明，而是一个类型声明的“占位符”，编译器在编译期间会将auto替换为变量实际的类型。

auto使用细则

1. 用auto声明指针类型时，使用auto和auto*没有任何区别；但用auto声明引用类型时则必须加&。
2. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错。因为编译器实际只会对第一个类型进行推导，然后用推导出来的类型定义其它的变量。

auto a = 1, b = 2;
auto c = 3, d = 4.4; // error

auto不能推导的场景

1. auto不能用于函数的参数中

//编译器无法对a的类型进行推导
void TestAuto(auto a)
{}

2. auto不能直接用于声明数组

int a[] = {1, 2, 3};
auto b[] = {4, 5, 6}; // error

基于范围的for循环

对于一个有范围的集合，由程序员来说明其范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。
for循环后的括号由冒号:分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

范围for的使用条件

for循环迭代的范围必须是确定的。
对于数组而言，就是数组中第一个元素到最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

指针空值nullptr

在良好的C/C++变成习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误。比如未初始化的指针。
而这里要说的是，用于初始化指针的NULL实际是一个宏。在传统的C头文件中，可以看到如下的定义：

可以看到，NULL在C++环境中可能被定义为字面常量0，这就可能就会导致一些程序上的错误和麻烦。

void func(int)
{cout << "int" << endl;
}void func(int*)
{cout << "int*" << endl;
}int main()
{func(0);func(NULL);func((int*)NULL);return 0;
}

上面程序本意是想通过func(NULL)调用func(int*)函数，但是由于NULL被定义为了0，就与预想的执行结果相悖了。
所以如果想按照指针的方式来使用，必须对其进行强转(int*)0。
但是为了更好地解决上面的问题，C++11引入了nullptr作为关键字，表示指针空值，而且在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同。