C ++初阶：C++入门级知识点

🍺0.前言

言C++之言，聊C++之识，以C++会友，共向远方。各位博友的各位你们好啊，这里是持续分享C++知识的小赵同学，今天要分享的C++知识是C++入门知识点，在这一章，小赵将会向大家展开聊聊C++入门知识点。✊

在上一章，我们算是初步入门了C++的基础知识，知道了C++中有命名空间，域等新东西的引入，那么这一章我们继续去学习C++的一些基础知识。

1.C++输入输出

任何一门编程语言的最开始，一般都是从HELLO WORLD开始的，象征着这门语言的诞生，而每门语言的输出HELLO WORLD的方式也是不同的，正如C语言的printf(),python的print(),java的System.out.println()，我们C++也有自己的输出方式就是cout，与之相对应的还有cin输入，这个输入输出和原本的C语言的scanf和printf有什么区别呢？

C++写HELLO WORLD

在这里我们看到我们的C++在输出的时候和C语言的输出是有着极大的不同的，不用像之前那样加括号，写这是什么类型便直接可以输出出来。与之相对应的输入也是如此。

C++的输入输出

它都会在底层为大家展开。但这里我们也要写一下头文件，就和C语言一样，C++的输入输出是在头文件的#include<iostream>里面的。同时C++在输出方面引入了新的换行符。

C++的换行endl

2.缺省参数

相比较C语言，C++做出的一大创新便是缺省参数的引入，什么叫缺省参数呢？缺省参数这个概念其实在函数中引入的。例如我们之前的函数。

int ADD(int a,int b)
{
	return a + b;
}

这里我们要调用的话就必须手动输入两个值给a和b；

而缺省参数是什么，是即使你不输入值，我也可以运行。那这是怎么做到的呢？就是你先给他值。

这个给人的感觉就有点像替补的队员，主队员不再时候，这个时候我们的替补就可以上场了。（除了这个，我一个朋友的比方也很有意思，说这个就是备胎，现在的没有了就用备用的，也是蛮有意思的一个比方）。

缺省参数有两种，一种叫全缺省，一种叫半缺省。

2.1全缺省参数

全缺省参数比较好理解就像我们上面的ADD函数一样每个值都有一个替补，随时准备上场。

int ADD(int a=1,int b=5)//全缺省参数
{
	return a+b;
}
int main()
{
	cout<<ADD(3, 5)<<endl;//输出3+5
	cout << ADD(2) << endl;//输出2+5
	cout<<ADD();//输出1+5

}

在这里要注意的是我们不能省略第一个参数的输入。

这个就像是一种规定，非要说原因，我感觉就是前面加逗号这种写法总感觉怪怪的，你们呢？

2.2半缺省参数

半缺省参数的半当然不是大家以为的一半的意思，它意思就是，有缺省参数，但不是全省参数，所以只要一个缺省参数也可以叫半缺省参数。

半缺省参数

int ADD(int a,int b=45)
{
	return a + b;
}
int main()
{
	cout << ADD(3);
}

这里要注意的一点是我们在使用缺省参数函数时，无论是全缺省参数还是半缺省参数函数，给值都要从左向右给，不能跳着给。

所以我们在写缺省参数函数时候，往往都是从右边向左边写。

从左向右写则会报错，是不被允许的，同时也不能跳着给缺省参数。

必须从右向左依次给。

缺省参数还有一个点是我们需要去注意的，就是函数的定义和函数声明不能同时有缺省参数，这里的主要原因可能也是为了防止冲突吧，比如你函数定义中的缺省参数和函数声明中的缺省参数如果给不一样的值，到底该用哪一个呢？

所以当我们的定义和函数分离时在这里一定一定要注意。

3.函数重载

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

根据上面函数重载的定义我们发现，函数重载其实就允许同名函数的诞生，但是中间又有一些小的规则，我们先来看第一种使用方式。

3.1参数类型不同

我们在使用自己ADD函数的时候，常常有一个问题就是我们写的ADD函数只能针对某一种类型的相加，遇到别的类型相加就要取别的名字去解决，有木有什么办法可以解决呢？用函数重载就可以完美化解这个问题（后面还有一种化解方法叫模板，有兴趣的可以提前了解下）

我们之前遇到的问题，只能对一种类型使用

使用函数重载

3.2参数个数不同

第二种函数重载是函数参数不同进行重载

int ADD(int a, int b)//针对两个参数相加
{
	return a + b;
}
int ADD(int a,int b, int c)//针对三个参数相加
{
	return a + b + c;
}
int main()
{
	cout << ADD(3, 5);//调用两个参数相加
	cout << ADD(3, 5,3);//调用三个参数相加
}

3.3参数类型顺序不同

第三种函数重载是参数类型顺序不同进行重载

3.4为什么C++支持，C语言不支持（底层）

为什么C++可以支持函数重载而C语言不能支持函数重载这样的操作，这一点其实主要由二者的编译器在对函数名字的修饰是不一样的。

我们用gcc（C语言编译器）去编译我们的C语言，看C语言对函数修饰后的名字：

我们明显发现它的修饰名字里面是没有里面的参数，只有名字

我们再看g++（C++编译器）去编译我们的代码时

我们明显发现多了很多东西，我们看看到底多了什么，再编译一个

通过编译我们发现，里面的函数名后面的有极大的可能就是我们的函数中的参数，所以通过这里的底层编译我们就发现了为什么我们的C++支持函数重载的原因了。

同时我们也要注意一点：如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。（这里的原因就是我们编译器里面没有给返回值一个位置，但同时也有合理性，如果支持参数相同返回值不同，那调用的时候到底该调用有返回值的还是没返回值的，又或者返回值不同呢？）

最后给大家分享：Windows下名字修饰规则可以帮助大家去看我们VS下的函数名字修饰规则（上面没用VS的主要原因也是这个确实不太容易看懂）

VS2020编译器下的编译结果

4.引用

引用可以说是C++的一个极大的创新，基本解决了我们之前的指针问题，为什么这么说呢？我们来看看吧。

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

关于这个定义，我学C++的好哥们立马就相当了一个相当不错的例子，他说他可以管他的对象叫小虞，也可以管她叫两岁，都是一个人。（好恶毒的狗粮，呜呜呜）这个可以说是一个很形象的例子，就是我给你一个别名，你可以是这个名字，也可以是名字都是你。

下面看使用：

使用方法：类型& 引用变量名(对象名) = 引用实体；

如我们这个例子，我们只要对b++，其实就是对a++。

4.1引用特性

引用特性一共有三条

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

4.1.1引用在定义时必须初始化

引用时候必须初始化，就是告诉编译器你究竟是谁的别名，你总不能谁的别名都不是吧。

4.1.2引用在定义时必须初始化

你一个对象可以有多个名字，比如我们上面说的小虞，两岁，也可以再加个别名如小虞同学，多个别名。

4.1.3.引用一旦引用一个实体，再不能引用其他实体

你既然已经是这个的别名了，那你就不能再是别人的别名了，不然你使用的时候，到底加在哪个上面呢？

4.2常引用

再开展常引用前，我们先回顾一下常量，常量一般指的是不能被修改的值，比如我们的数字10，就是一个常量。我们也可以在一个变量前加个const使它具有常性，让它变成一个常量。

为什么要说这个呢？因为我们的引用是不能去引用常量的，因为如果我们用引用去引用一个常量实际上是涉及权限的放大问题的，因为我们的引用其实是可以去改值，它对应的是变量。而如果要引用常量就只能用我们的常引用。

int main()
{
	const int a=10;//一个具有常性的变量
	10;//常量
	//int&b=a;会报错因为引用不能作为常引用的别名，不然就是权限的放大
	const int& b = a;
	const int& d = 10;
}

4.3使用场景

那么我们的引用究竟为何说能代替大部分的指针呢？首先我们看一个例子。

void swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

相信这样一个交换代码大家都写过，最开始也都头疼过这里要用指针。

但是如果我们这里用引用就可以很大程度避免这个问题了。

这样既可以大大加强我们代码的可读性，方便我们理解，也可以让我们摆脱一大部分的指针问题。但是指针的学习一定还是必要的，因为底层和软件开发中很多还是要用到我们的指针的。

除了大家在穿参的时候可以用引用在我们返回的时候也可以用引用返回；

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 <<endl;
    return 0;
}

这里可能就有人看不懂了，为什么返回也可以用引用，因为按照函数栈帧这块空间其实不是被释放了，这里就给大家补充一下知识。

而这里首先要补充的其实是我们引用的底层一直没和大家说，其实我们的引用底层还是指针，只不过它是对指针的封装，同时引用的别名和被引用的变量其实用的是一块空间，这样就能说明为什么指针如此神奇了。下面我们来解决上面的问题

从这里我们就发现了，就算函数释放了空间但其实那块空间的变量其实没变的，只是我现在没有了钥匙去打开这个空间，而引用就可以说是偷了一把钥匙。但是当我们第二次用这块空间的时候这个变量就会变了，这个我们在前面的指针里面也说过。

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了（被销毁），则必须使用传值返回。

4.4传引用和传值效率对比

在函数的时候，我们常常要传参，这时候我们可以试试用我们的传引用。为什么我们要试试传引用呢？相信我们都能猜出来，同样的参数，如果我传值其实是要拷贝一份传入，而传引用则是大家公用一块，哪个效率快一眼就能猜出来。（其实如果传普通的参数int等效率不会特别明显的提升，但如果你传一个二叉树，那就是天差地别了吧。）

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

通过代码的测试我们发现传引用是很快的，而传值就很慢。

4.5引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

这里为了向大家证明我说的是真的，我也是找到了底层的汇编代码：

可以说通过汇编代码我们发现引用的底层确实是指针。

虽然底层是指针但两者还是有一定的区别的：

引用和指针的不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全（主要是指针可以自由访问地址）

4.5加餐：不同变量的传值传引用经历了一个什么过程

4.5.1传值

先看这一段代码

int a=5;
double b = a;

在这一段代码中我们把int类型的值赋给了b，但其实这个过程不是直接给给的而是这样：

而这里要给大家补充的一点就是临时对象是具有常性的，那么我们下面的引用就要注意了。

4.5.2传引用

这也正印证我们的说法引用的不是int a,而是a创建的double类型的临时对象。

5.内联函数

内联函数其实是在对我们之前的宏定义的优化，之前我们的宏函数（如#define AREA(i) i*i）有好多好多的坑不知道大家是否还记得，各种替换演变出来各种坑，用着并不是特别好的体验，要加一堆括号。但是内联函数确可以解决宏函数的一些问题。但首先我们先来看一下宏有哪些优缺点。

小赵想了想感觉其实还有一点就是宏写函数的总感觉太长了，不太好弄。

而内联函数则是优化了这些问题，你只需要在函数前面加一个inline就可以让函数转化为内联函数了，那转化成内联有哪些好处呢？首先是在编译阶段不用函数栈帧直接在调用的地方换了，其次也可以进行调试，增加了代码的安全性。

就如这个原本是这样

编译之后就可能是这样

5.1特性：

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

这里需要注意的是像很多的递归代码内联函数是不会展开的空间太大。

下图为《C++prime》第五版关于inline的建议：

其次还要注意的是：inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

6.auto

auto其实就是一个万能的类型主要用于接收复杂的返回值后面用，像我们现在接收的返回值大部分都很简单吗，像int并不长但是到了后面这个是很香的。

int Add(int a, int b)
{
	return a + b;
}
int main()
{
	auto e = Add(3, 5);
	cout << e;
}

注意

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

其实就是以前由我们做得工作交给编译器去推导。

6.1一些注意点

1.auto可以表示指针类型，但是不能代表引用，引用还是得用auto&(感觉这个也是怕有歧义，到底是传引用还是传值)

2.不能一行定义多个变量

auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同

这里的auto只会推导一次而且就就近，那么编译之后就当于int c=3,d=4.0这就会报错。

3.auto也不能作为函数的参数去用，也不能用去定义数组。

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导

void TestAuto(auto a)
{}

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};//不允许会报错
}

其实我们大多数用auto主要是为了去接收一些复杂的类型,这个大家到后面就知道了。

7.for

好了最爽的来了，C++11引入了for的全新用法，之前我们要遍历一个数组要这样

int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
     cout<<array[i];

但C++11引入新的用法后：

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

就可以遍历这个数组了。

要改变值得话加个引用就好了。

其实它的底层还是我们第一个代码，一个一个取出来，只是我们对它进行了封装，那么这些活就交给了编译器。

8.nullptr（空指针）

为什么C++要引入新的空指针呢？以前的NULL用着不好吗？

首先我们看一下C语言的底层对NULL的定义

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。

这就会导致下面的代码出现问题：

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}

int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0;
}

这时候我们发现我们的NULL被当成数字0处理了。

而程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

所以C++11就引入了新的空指针nullptr,这样就可以化解NULL带来的问题。这里推荐大家使用nullptr防止出现上面的问题等其他问题。同时nullptr的使用是不需要头文件的，它的全新的关键字。