C++基础知识之面向对象篇1

这两期讲完基本上面试遇到的相关问题就过了一半了，后续将STL和内存相关的补充完整，C++这块的基本上就全部结束了，以后可能再也不会像现在这样在这个方向投入过多时间，且行且珍惜啊，还是跟以前一样，所有的总结都会有PDF版，如有需要自取。废话不多说，发完这期，继续整理STL去了。

1、C++函数模板

• 模板的意义：对类型也可以进行参数化了。
• 函数模板 《= 是不进行编译的，因为类型不知道。
• 模板的实例化 《= 函数调用点进行实例化。
• 模板函数 《= 才是被编译器所编译的。
• 模板类型参数。
• 模板非类型参数。
• 模板的实参推演 =》 可以根据用户传入的实参的类型，来推导模板类型。
• 模板的特例化。
• 函数模板、模板的特例化、非模板函数的重载关系。
• 模板代码是不能在一个文件中定义，在另外一个文件中使用的。
• 模板代码调用之前，一定要看到模板定义的地方，这样的话，模板才能够进行正常的实例化，产生能够被编译器编译的代码。
• 所以，模板代码都是放在头文件当中的，然后在源文件当中直接进行#includ包含。

2、泛型算法

• 泛型算法参数接收的都是迭代器！
• 泛型函数 - 全局的函数 - 给所有容器用的
• 泛型函数，有一套方式，，能够统一的遍历所有的容器的元素 - 迭代器。

3、拷贝赋值和移动赋值

1. 拷贝赋值是通过拷贝构造函数来赋值，在创建对象时，使用同一类中之前创建的对象来初始化新创建的对象。
2. 移动赋值是通过移动构造函数来赋值，二者的主要区别在于：

• 拷贝构造函数的形参是一个左值引用，而移动构造函数的形参是一个右值引用。
• 拷贝构造函数完成的是整个对象或变量的拷贝，而移动构造函数是生成一个指针指向源对象或变量的地址，接管源对象的内存，相对于大量数据的拷贝节省时间和内存空间。

4、虚函数、静态绑定、动态绑定

虚函数表位于只读数据段（.rodata） ，也就是C++内存模型中的常量区；而 虚函数则位于代码段（.text） ，也就是C++内存模型中的代码区。

一个类添加了虚函数，对这个类有什么影响？

• 如果类里面定义了虚函数，那么编译阶段，编译器给这个类类型产生一个唯一的vftable虚函数表，虚函数表中主要存储的内容就是RTTI指针和虚函数的地址。当程序运行时，每一张虚表函数都会加载到内存的 .rodata区。
• 一个类里面定义了虚函数，那么这个类定义的对象，其运行时，内存中开始部分，多存储一个vfptr虚函数指针，指向相应类型的虚函数表vftable。一个类型定义的n个对象，它们的vfptr指向的都是同一张虚函数表。
• 一个类里面虚函数的个数，不影响对象内存大小(vfptr)，影响的是虚函数表的大小
• 如果派生类中的方法，和基类继承来的某个方法，返回值、函数名、参数列表都相同，而且基类的方法是virtual虚函数，那么派生类的这个方法，自动处理成虚函数。

静态绑定和动态绑定：绑定指的是函数调用

• 静态绑定在编译时期，绑定的是普通函数的调用 指令 ：call Base::show(地址)
• 动态绑定在运行时期，绑定的一定是虚函数的调用 指令：编译的是call寄存器 运行时才知道

覆盖：基类和派生类的方法，返回值、函数名以及参数列表都相同，而且基类的方法是虚函数，那么派生类的方法就是自动处理成虚函数，他们之间成为覆盖关系。

在类内部添加一个虚拟函数表指针，该指针指向一个虚拟函数表，该虚拟函数表包含了所有的虚拟函数的入口地址，每个类的虚拟函数表都不一样，在运行阶段可以循环脉络找到自己的函数入口。纯虚函数相当于占位符，现在虚函数占一个位置由派生类实现后再把真正的函数指针填进去。

5、虚析构函数

1. 哪些函数不能实现成虚函数？

虚函数依赖：

• 虚函数能产生地址，存储在vfptr当中
• 对象必须存在(vfptr -> vftable -> 虚函数地址)

构造函数：没有虚构造函数！！！

• virtual+构造函数 NO！
• 构造函数中(调用的任何函数，都是静态绑定的)调用虚函数，也不会发生静态绑定

派生类对象构造过程：先调用的是基类的构造函数，才调用派生类的构造函数。

static静态成员方法 NO！

2. 虚析构函数 析构函数调用的时候，对象是存在的！
3. 什么时候把基类的析构函数必须实现成虚函数？

基类的指针（引用）指向堆上new出来的派生来对象的时候，delete pb（基类指针），它调用析构函数的时候，必须发生动态绑定，否则会导致派生类的析构函数无法调用

4. 虚函数和动态绑定

问题：是不是虚函数的调用一定就是动态绑定？肯定不是！

在类的构造函数当中，调用虚函数，也是静态绑定（构造函数中调用其他函数（虚），不会发生动态绑定）

静态绑定 用对象本身调用虚函数，是静态绑定

动态绑定：

• 必须由指针调用虚函数
• 必须由引用变量调用虚函数
• 虚函数通过指针或者引用的调用，才发生动态绑定

6、如何解释多态

1. 静态（编译时期）的多态：函数重载、模板（函数模板和类模板）

   bool compare(int , int) { }
   bool cpmpare(double, double) { }
   compare(10,20); call compare_int_int  在编译阶段就确定好调用的函数版本
   compare(10.5, 20.5); call compare_double_double  在编译阶段就确定好调用的函数版本
   template<typename T>
   bool compare(T a, T b) { }
   compare<int>(10,20);  => int   实例化一个compare<int>
   compare(10.5 ,20.5);  => double  实例化一个 compare<double>
   

2. 动态（运行时期）的多态：

在继承结构中，基类指针（引用）指向派生类对象，通过指针（引用）调用同名覆盖方法（虚函数），基类指针指向哪个派生类对象，就会调用哪个派生类对象的同名覆盖方法，称为多态。

pbase->show();

多态底层是通过动态绑定来实现的，pbase->访问谁的vfptr ->继续访问谁的vftable -> 当然调用的是对应的派生类对象的方法了。

7、继承

广义的继承有三种实现形式：

1. 实现继承：指使用基类的属性和方法而无需额外编码的能力。
2. 可视继承：子窗口使用父窗口的外观和实现代码。
3. 接口继承：仅使用属性和方法，实现滞后到子类

好处：

• 可以做代码的复用
• 在基类中给所有派生类提供统一的虚函数接口，让派生类重写，然后就可以使用多态了。

8、抽象类和普通类的区别

一般把什么类设计成抽象类？基类

//动物的基类 泛指 类 -> 抽象一个实体的类型

定义Animal的初衷，并不是让Animal抽象某个实体的类型

• string _name; 让所有的动物实体类通过继承Animal直接复用该属性
• 给所有的派生类保留统一的覆盖/重写接口

拥有纯虚函数的类，叫抽象类！（Animal）

Animal a; NO！！！

抽象类不能再实例化对象了，但是可以定义指针和引用变量。

class Animal
{
public:
    Animal(string name) : _name(name) { }
    virtual void bark() = 0; //纯虚函数
protected:
    string _name;
};
//以下是动物实体类
class Cat : public Animal
{
public:
    Cat(string name) : Animal(name) { }
    void bark() { cout << _name << "bark: miao miao!" << endl; }
};
class Dog :public Animal
{
public:
    Dog(string name):Animal(name) { }
    void bark() { cout << _name << "bark: wang wang!" << endl; }
};
class Pig :public Animal
{
    Pig(string name) :Animal(name) {        }
    void bark() { cout << _name << "bark: heng heng! " << endl; }
};
void bark(Animal* p)
{
    p->bark(); //Animal::bark虚函数，动态绑定了
}
int main()
{
    Cat cat("猫咪");
    Dog dog("二哈");
    Pig pig("佩奇");

    bark(&cat);
    bark(&dog);
    bark(&pig);


    return 0;
}

9、抽象类（有纯虚函数的类） / 虚基类

virtual

• 修饰成员方法的虚函数
• 可以修饰继承方式，是虚继承。被虚继承的类，称作虚基类。

class A
{
public:
    virtual void func() { cout << "call A::func" << endl; }
    void operator delete(void* ptr)
{
        cout << "operator delete p:" << ptr << endl;
        free(ptr);
    }
private:
    int ma;
};
class B :virtual public A
{
public:
    void func() { cout << "call B::func" << endl; }
    void* operator new(size_t size)
{
        void* p = malloc(size);
        cout << "operator new p:" << p << endl;
        return p;
    }
private:
    int mb;
};


A a; 4个字节
B b; ma,mb  8个字节


int main()
{
    B b;
    A* p = &b;
    cout << "main p:" << p << endl;
    p->func();
    return 0;
}

基类指针指向派生类对象，永远指向的是派生类基类部分数据的起始地址。

10、C++多继承

菱形继承的问题：派生类有多份间接基类的数据， 设计的问题

使用虚继承

好处 ：可以做更多代码的复用。

C++语言级别提供的四种类型转换方式：

• const_cast：去掉常量属性的一个类型转换。
• static_cast：提供编译器认为安全的类型转换（没有任何联系的类型之间的转换就被否定）。
• reinterpret_cast：类似于C风格的强制类型转换。
• dynamic_cast：主要用于在继承结构中，可以支持RTTI类型识别的上下转换。

11、函数对象

把有operator() 小括号运算符重载函数的对象，称作函数对象或者仿函数。

• 通过函数对象调用operator()，可以省略函数的调用开销，比通过函数指针调用函数（不能够inline内联调用）效率高。
• 因为函数对象是用类生成的，所以可以添加相关的成员变量，用来记录函数对象使用时的信息。

//函数对象
template

12、菱形继承

多重继承-菱形继承的问题：

• 好处：可以做更多代码的复用。

基类被多个派生类用就需要是虚继承，不然就会报错。

基类需要被最后的派生类初始化。