『C++』基础知识点

一、基础知识

1、C++编译流程

以Unix系统编译中间文件为说明：

.cpp—（编译预处理）—>.ii—（编译）—>.s—（汇编）—>.o—（ld，连接）—>.out

2、#include

作用于编译预处理阶段，将被include文件抄送在include所在位置，并会在相应位置写出调用栈，生成中间文件.ii，该中间文件可读

include文件加引号表示先从当前目录寻找索引，加尖括号表示从编译器指定根目录索引，Unix默认为"~//usr/include"目录

3、定义、声明、头文件

.h头文件中只应存放三种代码：

函数声明：没有大括号，形如void fun()

变量声明：extern 变量名

class、结构体定义

extern表示声明一个全局变量

声明只是提示编译器，存在这个东西，并没有定义出实体，不定义直接调用会报错。

4、标准头文件结构

#ifndef HEADER_FLAG

#define HEADER_FLAG

/*头文件*/

#endif

这是为了防止多次include同一个头文件时，每次都抄送到预编译文件中，造成文件过大、循环导入或者结构体定义重复以致报错（声明重复问题不大）。

5、默认参数

在声明中写默认参数，不在定义中给默认参数。

6、调用函数过程

本地变量进入堆栈（未必初始化）

函数参数进入堆栈

返回地址计入堆栈

返回值进入寄存器（运行函数）

pop掉参数

返回值进入堆栈（返回地址，所以要pop掉参数，堆栈先进后出）

7、内联函数

在编译阶段优化，省略上一小结中复杂的堆栈操作，效果如下，

汇编（伪）优化如下，

注意，inline 函数名实际是一个声明，而非定义所以不需要额外声明。实际上以空间换时间（编译会将函数插入调用位置），编译器如果发现函数递归或者过于巨大，可能会拒绝inline操作，函数较小可能被自动inline，建议就是小函数inline（2-3行），超过20行的就不要inline了。

相比于宏，inline可以做类型检查，给出debug提示，下图中C++会提示double的f(a)和%d不匹配，C会直接给出一个奇怪的值，

 8、const

初始化之后不可修改，值得注意的是下图这种，指针和const，到底是地址（指针）还是地址中的内容（对象）是const

重点在于const和*的位置顺序，下述代码中2、3两句等价，

且const变量不能传给其他非const的指针（因为这样有可能造成修改），

函数和const

函数虚参加const表示函数内部不可修改该变量，对输入无要求

return const 对接收函数返回的类型无要求

class和const

const 对象，此时我们不能保证class方法是否修改成员变量，又不能限制函数不能使用（class就没有意义了）

const 对象 or 成员变量是const，要求成员变量必须有初始值，因为事后无法赋值

main文件（编译时可以感知类声明文件），类声明文件，类定义文件：声明、定义（两个位置都需要添加）函数时后面添加const关键字如，int fun() const。

下图运行结果为"f() const"，

实际构成了重载，

void f(A* this)

void f(const A* this)

 9、字符串

char *s = "Hello World";  // 将代码段的字符串地址直接付给指针，所以后面尝试修改会报错（代码段不可修改），

　　　　　　　　　　   // 应该在开头改写为const char *s

char s[] = "Hello World";  // 数组被写入堆栈，将代码段的字符串拷贝到堆栈

10、引用

char& r = c;  // 引用可以做左值

相当于给c取了一个别名，此时c、r绑定到同一实体。

int x;int y;

int& a = x;

int& b = y;

a = b;  // 等价x=y

注意，引用无法取地址，即 int&* r 的写法是错误的，不过相对的，int*& p 是没问题的，指针可以被引用。

class的成员变量是引用时

此时只能使用initializer list的方式初始化引用对应的变量，如果在{}中使用m_y=a则表示将a复制给m_y对应的变量。

函数返回引用时

return一个全局变量，

这个引用表示变量，不表示值，所以最后一句表示赋值。

11、中间结果

相当于Python中的“_”，i*3这样的结果会作为const int类型临时保存。

二、class入门

1、变量

Field，成员变量，作用域为class的对象，类的函数中可以直接使用；class本身不能拥有变量，理解为声明一个变量（函数和变量不同，函数属于class而不是对象）；

parameters，函数参数；

local variables，本地变量，作用域为本函数；

 后两者完全相同，本地存储，出来作用域则不存在该变量。

关键字 this：一个指针，为当前对象的指针（指该次调用成员函数的对象的指针），

经由指针this区分调用成员函数的不同实例，其原理如下：使用'实例对象.成员函数'来调用等价于直接调用该函数并将对象指针作为首个参数输入，即：成员函数(this)，原理和python一致，成员函数实际上有一个默认存在的参数输入，接收实例指针

2、构造和析构

在C++中，class实例化时成员变量不会初始化，仅仅寻找到一块足够大的地址（java会清空地址内数据）。VS会在debug时为未初始化空间填充0xcd，用于排查（0xcd0xcd在国标码中为‘烫’）。

constructor：构造函数，初始化对象时自动执行（相当于python中的__init__）

函数名和class名相同

没有返回类型

destructor：析构函数，退出对象所在scope时自动执行

函数名为'~'加构造函数名

没有返回类型

不可以有参数

有关‘{}’，表示scope，如下代码中，进入‘{’后会执行Tree的构造函数，退出‘}’前，本scope内资源回收，会自动执行析构函数

数组、结构体、使用构建函数的class初始化方式对比：

Y经由构建函数Y()间接将f、i赋值，顺便一提，数组b后面未指定元素会被初始化为0

default constructor：无参数构建函数，见下右的第二行会报错，因为构建y2有两个元素，而第二个元素会调用default constructor，但实际上constructor需要参数，所以会报错：

:

3、scope和存储空间

编译器在‘{}’开始的位置会分配好空间，而在运行到相关定义时才会真正的运行构造函数。

如下图，某些情况下编译会出错，因为一旦goto成功，则x1不会被构建，相应的退出‘{}’时，析构函数执行会失败。

4、动态分配空间

new：制造对象，类似malloc；分配空间、调用构造函数（对于class），返回地址

使用一张表，记录下每次申请的内存大小和对应的地址：

delete：收回空间，类似free；析构对象（对于class）、回收空间；它有两种用法，如下：

delete p ：普通用法

delete[] p ：一般来说new p[]时，需要使用这个，会将所有对象的析构函数分别调用，否则回收内存正常，但只调用指针直接指向的对象的析构

5、访问控制

public：任何人可以访问

private：成员函数可以访问 ，注意对class来讲，同一个class不同对象可以互相访问私有变量，如下代码，p[0]是可以访问b的私有变量的

friends：声名一个函数/class等，使之可以访问自己（本class的任何实例）的私有变量

下面代码涉及两个知识点：1、friends声明在class内部；2、结构体可以前向声明（开头的X），用于在结构体Y定义中占位。

 

protected：自己及子类可以访问

6、struct vs class

未指定访问控制属性的变量、函数，class默认为private，struct默认public

7、初始化list

初始化后才执行构造函数（大括号中语句）

在大括号中赋值的话会先默认初始化变量，然后赋值；初始化list的方式直接用目标值初始化变量

8、成员函数和inline

在class内部给出了body的成员函数，视为内联函数。

三、父类子类

1、组合和继承

组合：已有类作为新的类的成员

继承：改造类，class B: public A {}，意为B类为A类子类 

　　   父类的private，在子类中存在，但是不能直接访问（需要使用父类的public方法），需要使用protected声明。

另一点值得注意的是，由于构造函数不可以直接调用， 调用父类的构造函数方式需要使用初始化list方法，而且必须最先构造父类（如果父类构造函数有参数），构造先父后子，析构先子后父：

2、覆盖（override）、重载（overload）、隐藏

overload

在同一作用域中，函数名相同，参数列表不同，返回值可同可不同的函数，编译器会根据传入参数决定调用哪个函数，注意仅返回值不同不能构成overload关系。

override

又叫覆盖，是指不在同一个作用域中（分别在父类和子类中），函数名，参数个数，参数类型，返回值类型都相同，并且父类函数必须有virtual关键字的函数，就构成了重写（协变除外）。协变：协变也是一种重写，只是父类和子类中的函数的返回值不同，父类的函数返回父类的指针或者引用，子类函数返回子类的指针或者引用。

virtual：子类的同名同参函数之间有联系（继承树中某一个函数是virtual的，子类的该方法都是virtual的）。

重定义

又叫隐藏，是指在不同的作用域中（分别在父类和子类中），函数名相同，不能构成重写的都是重定义（重定义的不光是函数，还可以是成员变量），隐藏和覆盖不同，被隐藏的父类成员可以通过子类.父类::成员的方式调用。

3、向上造型upcasting

子类对象可以被传给父类对象指针，如下图所示，

这是由于C++的class类似于C的结构体，实际上是一个指针指向一块有特定内容排列顺序的内存，子类只会在父类的内存规划上向后扩充，不会更改父类已经规划好的部分。如果有子类方法隐藏了父类方法，向上造型后会隐藏失效，此时的对象指针仅能识别父类原有的模块。

类似地，也有向下造型，不过可能会出错。

 

Employee是Manager的父类

4、多态

本小节摘抄自文章：C++ 多态的实现及原理

想要理解多态，需要区分函数和虚函数的区别（内存上的位置差异），并要理解向上造型的概念，了解了前面两点，就了解了动态绑定、静态绑定的区别，对于多态产生的种种现象就能够从机理上给出自己的解释。

virtual虚函数内存机制

上面提到过，virtual是让子类与父类之间的同名函数有联系，这就是多态性，实现动态绑定。

任何类若是有虚函数就会比正常类大一点，所有有virtual的类的对象里面最头上会自动加上一个隐藏的，不让我知道的指针，它指向一张表，注意，该表对于同一个class的不同对象是同一个，不同class（指父类子类）的表不同。这张表叫做vtable（虚表），vtable里是所有virtual函数的地址，对于下面代码，

class Shape {
public:
    Shape();
    virtual  ~Shape();
    virtual void render();
    void move(const pos&);
    virtual void resize();
protected:
    pos center;
};

 其内存分布如下：

我们看一下其子类的内存分布：

class Ellipse : public Shape{
public:
    Ellipse (float majr, float minr);
    virtual void render();

protected:
    float major_axis;
    float minor_axis;
};

 

这里的resize沿用了shape的成员函数。

多态实现逻辑

看如下代码，

#include "stdafx.h"
#include <iostream> 
#include <stdlib.h>
using namespace std; 

class Father
{
public:
    void Face()
    {
        cout << "Father's face" << endl;
    }

    void Say()
    {
        cout << "Father say hello" << endl;
    }
};


class Son:public Father
{
public:     
    void Say()
    {
        cout << "Son say hello" << endl;
    }
};

void main()
{
    Son son;
    Father *pFather=&son; // 隐式类型转换
    pFather->Say();
}

输出的结果为:

我们在main()函数中首先定义了一个Son类的对象son，接着定义了一个指向Father类的指针变量pFather，然后利用该变量调用pFather->Say().估计很多人往往将这种情况和c++的多态性搞混淆，认为son实际上是Son类的对象，应该是调用Son类的Say，输出"Son say hello",然而结果却不是.

从编译的角度来看:

c++编译器在编译的时候，要确定每个对象调用的函数（非虚函数）的地址，这称为早期绑定，当我们将Son类的对象son的地址赋给pFather时，c++编译器进行了类型转换，此时c++编译器认为变量pFather保存的就是Father对象的地址，当在main函数中执行pFather->Say(),调用的当然就是Father对象的Say函数

从内存角度看：

　　　　

Son类对象的内存模型如上图

我们构造Son类的对象时，首先要调用Father类的构造函数去构造Father类的对象，然后才调用Son类的构造函数完成自身部分的构造，从而拼接出一个完整的Son类对象。当我们将Son类对象转换为Father类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是上图中“Father的对象所占内存”，那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法，因此，输出“Father Say hello”，也就顺理成章了。

正如很多人那么认为，在上面的代码中，我们知道pFather实际上指向的是Son类的对象，我们希望输出的结果是son类的Say方法，那么想到达到这种结果，就要用到虚函数了。

前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用晚绑定，当编译器使用晚绑定时候，就会在运行时再去确定对象的类型以及正确的调用函数，而要让编译器采用晚绑定，就要在基类中声明函数时使用virtual关键字，这样的函数我们就称之为虚函数，一旦某个函数在基类中声明为virtual，那么在所有的派生类中该函数都是virtual，而不需要再显式地声明为virtual。

代码稍微改动一下，看一下运行结果

#include "stdafx.h"
#include <iostream> 
#include <stdlib.h>
using namespace std; 

class Father
{
public:
    void Face()
    {
        cout << "Father's face" << endl;
    }

    virtual void Say()
    {
        cout << "Father say hello" << endl;
    }
};


class Son:public Father
{
public:     
    void Say()
    {
        cout << "Son say hello" << endl;
    }
};

void main()
{
    Son son;
    Father *pFather=&son; // 隐式类型转换
    pFather->Say();
}

我们发现结果是"Son say hello"也就是根据对象的类型调用了正确的函数，那么当我们将Say()声明为virtual时，背后发生了什么。

编译器在编译的时候，发现Father类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表(即 vtable)，该表是一个一维数组，在这个数组中存放每个虚函数的地址，

那么如何定位虚表呢？编译器另外还为每个对象提供了一个虚表指针(即vptr)，这个指针指向了对象所属类的虚表，在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向了所属类的虚表，从而在调用虚函数的时候，能够找到正确的函数，对于第二段代码程序，由于pFather实际指向的对象类型是Son，因此vptr指向的Son类的vtable，当调用pFather->Son()时，根据虚表中的函数地址找到的就是Son类的Say()函数.

正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的，换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数，那么虚表指针是在什么时候，或者什么地方初始化呢？

答案是在构造函数中进行虚表的创建和虚表指针的初始化，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表，当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。