初识C++

一、C++的由来

C++的起源可以追溯到1979年，当时Bjarne Stroustrup(本贾尼·斯特劳斯特卢普，这个翻译的名字不同的地方可能有差异)在贝尔实验室从事计算机科学和软件工程的研究工作。面对项目中复杂的软件开发任务，特别是模拟和操作系统的开发⼯作，他感受到了现有语言（如C语⾔）在表达能力、可维护性和可扩展性方面的不足。

1983年，Bjarne Stroustrup在C语⾔的基础上添加了面向对象编程的特性，设计出了C++语⾔的雏形，此时的C++已经有了类、封装、继承等核⼼概念，为后来的面向对象编程奠定了基础。这⼀年该语言被正式命名为C++。

二、命名空间

1、命名空间的意义

我们先看一段代码：

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

这段代码没有问题，打印结果就是10。我们接着往下看：

#include <stdio.h>
#include <stdlib.h>   //添加了一个头文件
int rand = 10;
int main()
{printf("%d\n",rand);return 0;
}

我们在此基础上添加一个头文件，在vs2019下会产生一个这样的错误：

原因很简单，因为新加的头文件中含有rand函数，在编译过程中会展开头文件，这样就出现了命名冲突的问题，这在日常写代码中是非常常见的，比如，你写了上万行代码，加了一个头文件，导致出现许多命名冲突，再比如，在大项目中往往会遇到分工问题，你写一份，他写一份，在合并时，就容易出现命名冲突，这样改起来就比较麻烦。

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

2、命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量。
C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的⽣命周期，命名空间域和类域不影响变量⽣命周期。
namespace只能定义在全局，当然它还可以嵌套定义。
项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。
C++标准库都放在⼀个叫std(standard)的命名空间中。

根据命名空间的定义，上述代码可以这样修改：

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

这样代码在编译过程中就会去hah这个命名空间中去找rand，而不会去全局寻找rand。
其中，::是域作用限定符，是各种域性质的实体（比如类（不是对象）、命名空间等）调用其成员专用的。(如果有个局部变量与全局变量同名（假设都是int a;），默认调用的 a 是局部变量，如果要访问全局变量a，就要这么写“::a”。使用域作用符来加以区别；前面没写具体的域名，就是指默认域)。

#include <stdio.h>
int a = 0;
int main()
{int a = 10;printf("%d\n",a); //这里的a默认是打印局部变量的areturn 0;
}

如果我只想访问全局变量的a，就可以这样改：

#include <stdio.h>
int a = 0;
int main()
{int a = 10;printf("%d\n",::a); //这里的a是全局变量的areturn 0;
}

编译器遇到陌生的标识符时，它会从局部先找，若没找到，再去全局找，若还没找到，就报错。

在命名空间中可以定义变量/函数/类型等。

#include <stdio.h>
namespace blue
{int k = 10;int Add(int a, int b){return a + b;}struct Node {int val;struct Node* next;};
}
int main()
{printf("%d\n",blue::k);printf("%d\n",blue::Add(1,1));blue::Node p1;return 0;
}

namespace只能定义在全局，定义在局部是不被允许的，但它可以嵌套定义，比如这样：

#include <stdio.h>namespace blue
{namespace blue1{int rand = 10;int Add(int a, int b){return a + b;}}namespace blue2{int rand = 20;int Add(int a, int b){return a + b;}}
}int main()
{printf("%d\n",blue::blue1::rand);printf("%d\n",blue::blue2::rand);return 0;
}

嵌套定义有什么用处呢？
比如，分工时，你写一个项目用的命名空间是blue，另一个人写的项目命名空间也应是blue，项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。但你们在blue这个命名空间下定义相同的变量，合并时同样会发生命名冲突，所以这时候就可以在blue这个命名空间下，在添加各自的命名空间，合并时就避免了命名冲突，同时也符合语法，语法允许嵌套定义命名空间。

3、命名空间的使用

我们要使用命名空间中定义的变量/函数，有三种方式：

指定命名空间访问，项目中推荐这种方式。
using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

我们可以想象命名空间就是一堵围墙，所谓“展开”的意思就是，将围墙拆开，将其中的变量/函数/类型等变为全局的，访问时直接访问，不需要加::

第一种方式就是不展开，第二种方式就是部分展开，第三种方式就是全部展开。

//方式一，不展开
#include <stdio.h>
namespace blue
{int a = 10;int b = 20;
}
int main()
{printf("%d\n",blue::a);//访问a时，必须加::printf("%d\n",blue::b);//访问b时，必须加::return 0;
}

//方式二，部分展开
#include <stdio.h>
namespace blue
{int a = 10;int b = 20;
}
using blue::a;
int main()
{printf("%d\n",a);//访问a时，不需要加::printf("%d\n",blue::b);//访问b时，必须加::，因为b没有展开return 0;
}

//方式三，全部展开
#include <stdio.h>
namespace blue
{int a = 10;int b = 20;
}
using namespace blue;
int main()
{printf("%d\n",a);//访问a时，不需要加::printf("%d\n",b);//访问b时，不需要加::return 0;
}

一旦展开就会有命名冲突的风险，所以大项目中，一般采用方式一或方式二，而方式三一般练习时(代码量小)，会采用。

三、C++输入和输出

<iostream>是Input Output Stream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
std::cin是istream类的对象，它主要面向窄字符（narrow characters(of type char)）的标准输入流。
std::cout是ostream类的对象，它主要面向窄字符的标准输出流。
std::endl是⼀个函数，流插入输出时，相当于插入⼀个换行字符加刷新缓冲区。
<<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
IO流涉及类和对象，运算符重载、继承等很多面向对象的知识，这里我们简单认识⼀下C++IO流的用法。
cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用它们。

#include <iostream>
int main()
{int i = 123;std::cout << i << std::endl;return 0;
}

⼀般日常练习中我们可以using namespace std，实际项目开发中不建议使用using namespace std。

#include <iostream>
using namespace std;
int main()
{int i = 123;cout << i << endl;return 0;
}

四、缺省参数

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。(有些地方把缺省参数也叫默认参数)。
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

#include <iostream>
using namespace std;
void Func(int a = 0)
{cout << a << endl;
}
// 全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}
// 半缺省
void Func2(int a, int b = 10, int c = 20)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}
int main()
{Func(); // 没有传参时，使⽤参数的默认值Func(10); // 传参时，使⽤指定的实参Func1(); //10 20 30Func1(1); //1 20 30Func1(1, 2); //1 2 30Func1(1, 2, 3); //1 2 3Func2(100); //100 10 20Func2(100, 200); //100 200 20Func2(100, 200, 300); //100 200 300return 0;
}

五、函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。

构成函数重载有两种情况，参数类型不同，参数个数不同。

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

还有一种特殊情况，请看代码：


void f1()
{cout << "f1()" << endl;
}
void f1(int a = 10)
{cout << "f1(int a = 10)" << endl;
}

这两个函数构成重载，但无参调用时会发生错误，因为编译器不知道要调用哪一个。所以我们尽量不要这样写。

单单返回值不同不能构成重载。因为调用时也无法区分。

//返回值不同不能作为重载条件，因为调用时无法区分
void f2()
{}
int f2()
{return 0;
}

六、引用

1、引用的概念和定义

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

它的格式是：类型& 引用别名=引用对象；

C++中为了避免引入太多的运算符，会复用C语言的⼀些符号，比如前面的<<和>>，这里引用也和取地址使用了同⼀个符号&，大家注意使用方法角度区分就可以。

//引用
int main()
{int a = -1;int& b = a; //这里给a取了一个别名bint& c = a; //这里给a取了一个别名cint& d = b; //这里给b取了一个别名d++d; //d加1，则a，b，c也加1，因为它们是同一个空间，只是名字不同cout << &a << endl;cout << &b << endl;cout << &c << endl;cout << &d << endl;return 0;
}

在vs2019下调用结果如下：

2、引用的特性

引用在定义时必须初始化
⼀个变量可以有多个引用
引用一旦引用⼀个实体，再不能引用其他实体

//引用在定义时必须初始化
int main()
{int a = 10;int& ra;//errint& rra = a;//okreturn 0;
}

//⼀个变量可以有多个引用
int main()
{int a = 10;int& k = a;int& p = a;int& q = a;return 0;
}

//引用一旦引用⼀个实体，再不能引用其他实体
int main()
{int a = 10;int& b = a;int c = 20;b = c;//这里并非让b引用c，因为C++引用不能改变指向，这里是一个赋值return 0;
}

//给引用起别名
int main()
{int a = 10;int& b = a;int& c = b; //可以给引用起别名，a,b,c是同一个空间return 0;
}

3、引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。

void SwapC(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}
void SwapCPP(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}
int main()
{int x = 1, y = 2;cout << x << " " << y << endl;//SwapC(&x, &y);SwapCPP(x, y);cout << x << " " << y << endl;return 0;
}

相比之下，引用传参更加方便。

引用做返回值的情况如下：

int& func(int arr[])
{return arr[0];
}
int main()
{int arr[] = { 1,2,3,4,5 };func(arr) = 100;return 0;
}

这段代码可以将arr数组中的第一个元素修改为100，当然，直接修改也是更方便，但我们这里主要演示引用做返回值的基本用法。

不是任何地方都可以用引用做返回值的，比如下面代码：


int& func()
{int a = 0;return a;
}

当你调用func后，变量a虽然被返回了，但a这块空间已经不属于我们了，返回给操作系统了，我们如果强行使用a这块空间就会发生非法占用内存空间，这是不行的。所以这段代码是错误的。

4、const引用

可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访
问权限在引用过程中可以缩小，但是不能放大。

int main()
{const int a = 10; //只读权限//int& ra = a; // 这里的引用是对a访问权限的放大，这里的ra即可读可写const int& ra = a; //这里才可以，这里的ra只读int b = 20; //可读可写const int& rb = b;// 这里的引用是对b访问权限的缩小，这里的rb只读return 0;
}

我们可以简单的理解它，一个变量只读，引用后，权限最大也是只读，不能放大权限，一个变量可读可写，引用后，我们可以缩小权限。

	int a=1,b=2;const int& rc = 30;  //这里也必须使用常引用const int& rd = a + b;//临时对象具有常性

需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，也就是说，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里如果不用常引用就触发了权限放大，必须要用常引用才可以。

所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，
C++中把这个未命名对象叫做临时对象。

	double d = 12.33;int i = d;//int& ri = d; //err  类型转换会产生临时变量，必须用常引用const int& ri = d;

5、指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

语法概念上引用是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。
引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
引用可以直接访问指向对象，指针需要解引用才能访问指向对象。
sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下占8个字节)。
指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些。

int main()
{int a = 10;int* pa = &a;*pa = 1;int& ra = a;ra = 5;return 0;
}

引用底层逻辑其实是指针。

七、inline

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。

内联函数的出现主要是针对宏函数的。

因为写宏函数时往往会出现许多问题，比如，写一个具有加法功能的宏函数：

// 实现⼀个ADD宏函数的常⻅问题
#define ADD(int a, int b) return a + b;
#define ADD(a, b) a + b;
#define ADD(a, b) (a + b)

以上三种都是常见的问题，正确的写法是：

// 正确的宏实现
#define ADD(a, b) ((a) + (b))

那么随之而来就会有许多疑问：

为什么不能加分号?
为什么要加外面的括号?
为什么要加里面的括号?

我们用代码来解释这些疑问：

int main()
{int ret = ADD(1, 2);cout << ADD(1, 2) << endl; //如果加了分号，则这句打印代码就会出现问题//cout << ADD(1, 2); << endl; 出现语法错误cout << ADD(1, 2)*5 << endl;//如果去掉外面的括号，代码会变成(1)+(2)*5==11 而不是我们想要的结果15int x = 1, y = 2;ADD(x & y, x | y); // -> (x&y+x|y)//如果去掉里面的括号，代码会变成(1&2+1|2),+的优先级更高，也会出现不是我们想要的结果return 0;
}

故使用宏会导致我们需要注意的点特别多，为了避免这些问题，就出现了内联函数。

inline对于编译器而言只是⼀个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展
开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁
调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调
试，C++设计了inline目的就是替代C语言的宏函数。

vs编译器debug版本下面默认是不展开inline的，这样方便调试。inline不建议声明和定义分离到两个文件，分离会导致链接错误。

八、nullptr

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

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

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

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

本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(int x)，因此与程序的初衷相悖。

f((void*)NULL);调用会报错。因为与C语言相反在C++中，void类型的指针不能隐式转换为其他指针，也就是说 void* p1 = NULL; int* p2 = p1;这两句代码在C++中是编译不过去的，必须强制类型转换 void* p1 = NULL; int* p2 = (int*)p1;才可以。

C++11中引入nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字面量，它可以转换
成任意其他类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被
隐式地转换为指针类型，而不能被转换为整数类型。这就解决了上述问题。

void f(int x)
{cout << "f(int x)" << endl;
} 
void f(int* ptr)
{cout << "f(int* ptr)" << endl;
} 
int main()
{f(0);f(NULL);f(nullptr);return 0;
}

我们只需传nullptr就可以调用void f(int* ptr)这个函数了，因为nullptr可以隐式转换成任意其他类型的指针类型。当遇到一个指针变量不知道赋什么值时就可以给nullptr，这一点与C语言进行区分。

九、总结

以上就是本篇的全部内容，希望大家有所收获，有不足的地方烦请大家多多指正，祝大家天天开心！