从基础入门到学穿C++

前言知识

C++简介

C++是一门什么样的语言，它与C语言有着什么样的关系？

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。

1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

C++与C语言之间的关系

C++兼容C语言的语法。

C++补充C语言语法的不足，对C语言设计不合理的地方进行优化，比如：作用 域方面、IO方面、函数方面、指针方面、宏方面等

学习环境

开发环境：VS2022 , centos7/8

学习网站：cplusplus , MSDN

---

C++基本语法

C++的头文件

#include//输入输出流
using namespace std;//标准的命名空间
1
2

cout、cin、endl

cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

**<<是流插入运算符，>>**是流提取运算符。依靠cout和cin我们可以控制控制台的打印输出。实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这里只是简单学习他们的使用。

使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。

示例输出hello C++

#include
using namespace std;
int main()
{
	cout << "hello C++" << endl;
	return 0;
}
1
2
3
4
5
6
7

我们还可以用下面的方式进行使用cout和cin

#include
int main()
{
	std::cout << "hello C++" << std::endl;
	return 0;
}
1
2
3
4
5
6

如何合理使用std命名空间？

• 在日常中，直接展开使用using namespace std即可。
• 在大的工程之中，因为涉及到的变量和类等繁杂，为了避免命名冲突，我们一般使用std::cout这种方式进行使用标准库中的功能。

---

namespace关键字

namespace的作用

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

比如说我们在写一般的代码时，包含了std(standard)的命名空间，那么我们就不能再把cout等等定义为变量或者函数名，但是如果不包含这个头文件，我们可以无限制的使用这些名称。

#include 
using namespace std;

int main() {
    int cout = 10; // 错误！与标准库的对象冲突
    cout << "Hello, world!" << endl;
    return 0;
}
1
2
3
4
5
6
7
8

上述的代码表明，编译器会将cout解释为你定义的变量，而不是标准库中的对象，从而导致编译错误。因此，在使用using namespace std;时，应避免定义与标准库名称相同的变量，以免造成命名冲突。

namespace的使用

1.我们可以采用指定类域的方式进行访问该命名空间的成员，这也是我们最常使用的方式

namespace test_space
{
	int _st = 10;
}
int main()
{
	cout << test_space::_st << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9

2.使用using将命名空间的某个成员引入(如果有多个成员的话，这种方法过于繁琐，我们只作为了解)

#include"namespace.h"
using test_space::_st;
int main()
{
	cout << _st << endl;
	return 0;
}
1
2
3
4
5
6
7

---

缺省参数

C++提供了缺省参数的功能，缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。也就是说如果我们给定了参数就用我们传递的参数，如果没有给定，那么就使用默认值。

• 全缺省

void Func(int a = 10, int b = 20, int c = 30)
{
    cout<< a+b+c <<endl;
}
1
2
3
4

• 半缺省

void Func(int a, int b = 20, int c = 30)
{
    cout<< a+b+c <<endl;
}
1
2
3
4

注意：缺省必须从右往左依次缺省。

因为我们在调用函数传递参数的时候，都是从左往右依次传递的，所以如果不是全缺省，就要从右往左依次缺省。另外，缺省值必须是常量或者全局变量。

---

引用

前言知识：缺省参数，函数重载，引用

函数重载，函数名相同，参数不同(类型/个数/顺序不同)

引用的形式

类型& 引用变量名(对象名)  = 引用实体
1

引用必须要进行初始化，不能单独定义

int main()
{
    const int a  = 0;
    int& b = a;//b的类型是int
    return 0;
}
1
2
3
4
5
6

这个地方编译不通过，因为变量a是只读的，b的类型是int，也就是可读可写的，这里属于权限的放大。

如果就是想要让变量b作为变量a的别名，可以在int前面同样加上const

int main()
{
    int c = 0;
    const int& e = c;
}
1
2
3
4
5

这里编译可以通过，c是可读可写的，e是c的别名，变成了只读的，属于权限的缩小。

总结：引用取别名时，变量取别名时，变量访问的权限可以缩小，不能放大。需要注意的是，变量之间赋值没有权限缩小和放大的关系。因为赋值的双方是两块独立的空间，一个的改变不会影响另外一个。

int i = 0;
double b = i;//隐式类型转换，中间赋值的时候产生了一个double的临时变量
const double& rb = i;
1
2
3

下面这里的rb引用的其实不是i，而是中间产生的临时变量，临时变量具有常性，所以需要加上const

权限的缩小和放大规则：适用于引用和指针间。

引用的使用场景

引用做参数

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
1
2
3
4
5
6

引用做返回值—可以提高程序的效率

int Count1()//传值返回
{
    static int n =  0;
    n++;
    return n;
}
int& Count2()//传引用返回
{
    static int n = 0;
    n++;
    return n;
}
int main()
{
    int& r1 = Count1();//编译不通过
    int& r2 = Count2();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里需要说明的是，传值调用都会产生一个临时变量，而临时变量具有常性，所以子啊前面加上const即可成功编译。

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;
}
1
2
3
4
5
6
7
8
9
10
11

这里打印出来的结果是7.这与函数栈帧的创建和销毁有关，充分说明了有时候的引用返回是不安全的。

如果返回变量c是一个局部变量的时候，引用返回是不安全的

static修饰的变量会存储在数据段内，生命周期一直到整个函数结束

什么时候使用引用？

总结：一个函数要使用引用返回，返回变量出了这个函数的作用域还存在，就可以使用引用返回，否则就不安全

使用引用返回的好处：少创建一个拷贝的临时对象，可以提高函数的执行效率（并不是节省空间的占用）

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但其实在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 在sizeof中含义不同**：引用结果为引用类型的大小**，但指针始终是地址空间，所占字节个数为32/64个字节
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

---

内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提高程序运行的效率。简单来说，内联函数就是以空间换时间的做法。

一般内联函数适用于小函数，小于20行，其次，递归或者比较长的都不适宜内联。

内联函数没有地址，因此内联函数不能声明和定义分离，分离会导致链接不上*

C语言中的宏#define N 10用const int N = 10来替代

宏函数用内联函数来替代

1.在release模式下，查看编译器生成的汇编代码中是否存在call Add

2.在debug模式下，需要对编译器进行设置，否则不会展开,因为debug模式下，编译器默认不会对代码进行优化,这里需要自己去设置

设置方式：配置 – > C/C++ --> 常规 --> 优化 --> 内联函数扩展

注意：设置内联函数只是向编译器发出一个请求，采用不采用还是看编译器本身。

---

auto关键字

C++支持auto关键字：auto关键字可以推导出变量的类型

auto a = 1;//这里auto可以推导出a的类型是int
1

随着程序越来越复杂，程序中用到的类型也越来越复杂，类型难于拼写，这时候就体现出了auto关键字的重要作用。

如果在同一行定义多个变量，使用auto关键字进行推导时，要注意这些变量必须是相同的类型。

auto不能用来使用的场景

1.auto不能作为函数的形参

2.auto不能用来声明数组

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}
1
2
3
4
5

auto在范围for循环中的应用

C++11支持了范围for循环

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    for(auto e : arr)
    {
        cout << e <<" ";
    }
    return 0;
}
1
2
3
4
5
6
7
8
9

for循环后的括号由冒号分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

范围for的使用场景

使用范围for要提供精确的范围对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围（底层基于迭代器实现）。

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

上面代码的循环条件不确定，就会出现问题。

---

函数重载

C++支持重载，C语言为什么不支持

1、预处理：头文件的展开、宏替换、条件编译、去掉注释 list.i test.i

2、编译：检查语法，生成汇编代码 list.s test.s

3、汇编：汇编代码转换成二进制的机器码 list.o test.o

4、链接：将两个目标文件链接到一起

两者不同的原因是在进行链接的过程中。因为我们在一个比较大的工程中会拆分成几个不同的文件，比如list.c,list.h,test.c，其中test.c在编译到test.o阶段时，函数的声明部分需要等待链接后找到函数的地址，此时我们只有声明，没有定义所以无法找到它的地址。在链接阶段，到其他目标文件符号表中区去找到这个函数的地址。

在Linux系统下，我们采用gcc编译test的obj文件时，使用objdump -S命令可以查看反汇编，我们发现其在链接过程中，链接的函数名就是原理函数名。而在g++环境中编译时，添加了函数名修饰的功能，比如说一个函数void Test(int a , double x)，其函数名在调用时，被修饰成了<_Z4Testid>，由此我们可以理解，为什么C++的语法支持函数重载。

objdump -S executable_file
1

可以使用上面的命令进行反汇编二进制目标文件的命令

##nullptr(空指针)

在C++中，我们在表示空指针的时候要把C语言中惯用的NULL换成nullptr，因为NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。