C++ 多态

比如Student继承了 Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person
{
public:
	// 重写/覆盖
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);

	return 0;
}

2、虚函数

class Person {
public:
    virtual void BuyTicket()
    { 
        cout << "买票-全价" << endl;
    }
};

3、虚函数的重写

接下来我们看看满足和不满足多态的两种情况：?

1、满足多态 ? -- 看指向的对象的类型，调用这个类型的成员函数?

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

2、不满足多态 -- 看调用者的类型，调用这个类型的成员函数?

class Person {
public:
	void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student :public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用。 （重写=接口继承+重写继承父类这个函数的实现）

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

?

?父类的析构函数加virtual，子类不加也够成多态。

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }

	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Student : public Person {
public:
	void BuyTicket() { cout << "买票-半价" << endl; }

	~Student()
	{
		cout << "~Student()" << endl;
	}
};


void Func(Person* p)
{
	p->BuyTicket();
	delete p;
}

int main()
{
	Func(new Person);
	Func(new Student);

	return 0;
}

两个例外：

• 协变返回值可以不同，必须是父子关系指针或者引用
• 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。?

class A {};
class B : public A {};
class Person {
public:
	virtual A* f() { return new A; }
};
class Student : public Person {
public:
	virtual B* f() { return new B; }
};

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

4、例题

下面程序的输出结果是什么呢

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

• 在这段代码中，类A和类B之间存在继承关系。类A中有两个成员函数：func和test。func函数有一个默认参数val，默认值为1。test函数调用了func函数。
• 类B继承自类A，并且重写了func函数。在类B中，func函数也有一个默认参数val，默认值为0。
• 在main函数中，创建了一个指向类B对象的指针p，然后调用了p->test()。
• 由于test函数在类A中被声明为虚函数，因此在运行时会根据实际对象的类型(*this)来确定调用的函数。在这里，p指向的是类B的对象，所以调用的是类B中的test函数。
• 在类B的test函数中，调用了func函数，但没有提供参数。由于func函数在类B中被重写，因此会调用类B中的func函数。
• 然而，由于默认参数的值是在编译时确定的，而不是在运行时确定的，所以在调用func函数时，默认参数的值是根据函数声明的类型来确定的。在这里，函数声明的类型是类A中的func函数，所以默认参数的值为1。
• 因此，当调用p->test()时，输出的结果是"B->1"。

?test()函数在类B中调用，输出结果是什么呢？

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
	virtual void test() { func(); }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

这里没有通过基类的指针或引用调用test()函数，是通过类B的指针p的this指针来调用test函数。

5、C++11 override 和 final

class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car {
public:
	void Drive() { cout << "Benz-速度快" << endl; }
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
	Car p;
	p.Drive();
	Benz q;
	q.Drive();

	return 0;
}

?

6、重载、覆盖(重写)、隐藏(重定义)的对比

二. 抽象类

1、概念

?

class Car
{
public:
	// 纯虚函数  -- 抽象类 -- 不能实例化出对象
	virtual void Drive() = 0;
};

int main()
{
	Car car;
	return 0;
}

2、接口继承和实现继承

• 普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
• 虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

三、多态的原理

1、虚函数表(虚表)

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

?接下来观察下面代码：

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
cout << "Derive::Func1()" << endl;
 }
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚 表指针也就是存在部分的另一部分是自己的成员。
2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表 中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数 的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外，基类中的Func2被继承下来后仍然是虚函数，所以它也被放入了派生类的虚表中。Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，通常在数组的最后放置一个nullptr指针（vs系列编译器有，g++没有）。
5. 总结一下派生类的虚表生成过程： a. 首先将基类中的虚表内容拷贝一份到派生类的虚表中。 b. 如果派生类重写了基类中的某个虚函数，就用派生类自己的虚函数地址覆盖虚表中基类的虚函数地址。 c. 派生类自己新增加的虚函数按照在派生类中的声明顺序增加到派生类虚表的最后。
6. 需要注意的是，虚函数本身是存在代码段中的，而虚表存储的是虚函数指针。对象中存储的是虚表指针，而不是虚表本身。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的。

同类型对象共用一个虚表 ：

int main()
{
	Base b1;
	Base b2;
	Base b3;
	Derive d;
	return 0;
}

?

???2、多态的原理

?

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
	return 0;
}

class Base
{
public:
	Base()
		:_b(10)
	{
		++_b;
	}

	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}

	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}

private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}

	virtual void Func4()
	{
		cout << "Derive::Func4()" << endl;
	}
private:
	int _d = 2;
};

typedef void(*VF_PTR)();
void PrintVFTable(VF_PTR table[])
{
	for (int i = 0; table[i] != nullptr; i++) {
		printf("[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

int main()
{
	Base b;
	Derive d;
	//32位
	//PrintVFTable((VF_PTR*)*(int*)&b);
	//PrintVFTable((VF_PTR*)*(int*)&d);

	//64位
	//PrintVFTable((VF_PTR*)*(long long*)&b);
	//PrintVFTable((VF_PTR*)*(long long*)&d);

	//32位/64位均可
	PrintVFTable(*(VF_PTR**)&b);
	PrintVFTable(*(VF_PTR**)&d);

	return 0;
}

?

对象中虚表指针什么时候初始化的？ -- 构造函数的初始化列表

?接下来跳转到构造函数

构造函数结束，虚表指针初始化完成，

虚表存储在哪？—常量区（数据段）

int main()
{
	Base b;
	Derive d;

	int x = 0;
	static int y = 0;
	int* z = new int;
	const char* p = "xxxxxxxxxxxxxxxxxx";

	printf("栈对象：%p\n", &x);
	printf("堆对象：%p\n", z);
	printf("静态区对象：%p\n", &y);
	printf("常量区对象：%p\n", p);
	printf("b对象虚表：%p\n", *((int*)&b));
	printf("d对象虚表：%p\n", *((int*)&d));
	return 0;
}

3、多继承中的虚函数表

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

typedef void(*VF_PTR)();
//void PrintVFTable(VF_PTR table[])
void PrintVFTable(VF_PTR* table)
{
	for (int i = 0; table[i] != nullptr; i++) {
		printf("[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

int main()
{
	Derive d;
	PrintVFTable((VF_PTR*)(*(int*)&d));
	//PrintVFTable((VF_PTR*)(*(int*)((char*)&d+sizeof(Base1))));
	Base2* ptr2 = &d;
	PrintVFTable((VF_PTR*)(*(int*)(ptr2)));

	return 0;
}

在C++中，每个具有虚函数的类都有一个虚函数表（vtable），但是这个表是类级别的，而不是对象级别的。也就是说，所有同一类型的对象共享同一个虚函数表，而不是每个对象都有自己的虚函数表。

• 在上面的代码中，Derive类继承自Base1和Base2，并且覆盖了Base1和Base2的func1函数。因此，Derive类的虚函数表将包含指向Derive::func1、Base1::func2、Base2::func1、Base2::func2和Derive::func3的指针。
• 当创建一个Derive对象d时，d的内存布局中将包含两个虚函数表指针（vptr），一个指Base1的虚函数表，一个指向Base2的虚函数表。这是因为Derive类从两个基类继承，每个基类都有自己的虚函数表。
• 在上面的代码中，通过将d的地址转换为int指针，然后解引用它来获取虚函数表的地址。这实际上获取的是d的第一个虚函数表指针，也就是指向Base1的虚函数表的指针。如果想获取d的第二个虚函数表指针，也就是指向Base2的虚函数表的指针，需要将d的地址加上Base1的大小，或者使用Base2指针指向d的地址进行切片，切出d中Base2的部分，然后再进行转换和解引用。

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

• 如果Derive类只从Base1或Base2单继承，那么Derive类会有自己的虚函数表。这个虚函数表会包含Derive类自己定义或覆盖的虚函数，以及从基类继承的所有虚函数。
• 例如，如果Derive类只从Base1继承，那么Derive类的虚函数表会包含func1()和func2()，因为这两个函数在Base1类中被声明为虚函数。如果Derive类覆盖了这些函数，那么虚函数表中对应的条目会被更新为指向Derive类的函数版本。

4、动态绑定与静态绑定

四、例题

下面说法正确的是()?

class Base1 { public: ?int _b1; };
class Base2 { public: ?int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() {
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

答：C?

下面程序的输出结果（）

#include <iostream>

class A {
public:
    A() : m_iVal(0) { test(); }
    virtual void func() { std::cout << m_iVal << ' '; }
    void test() { func(); }
public:
    int m_iVal;
};

class B : public A {
public:
    B() { test(); }
    virtual void func() {
        ++m_iVal;
        std::cout << m_iVal << ' ';
    }
};

int main(int argc, char* argv[]) {
    A* p = new B;
    p->test();
    delete p;
    return 0;
}

这是一个关于C++中的继承和虚函数的例子。在这个例子中，我们有两个类，A和B，其中B是A的子类。这两个类都有一个名为func的函数，但在B中，这个函数被重写了。同时，这两个类都有一个名为test的函数，它调用了func函数。在类A的构造函数中，调用了test函数。

现在，让我们逐步解析这个程序的执行过程：

1. 在main函数中，我们创建了一个指向B类对象的A类指针p。这是通过new B实现的。

2. 创建B类对象时，首先会调用其基类A的构造函数。在A的构造函数中，m_iVal被初始化为0，然后调用test函数。

3. test函数调用func函数。这里需要注意的是，虽然此时正在创建B类对象，但是因为在A的构造函数中调用的func，所以此时的func是A类的func，而不是B类的func。因此，此时输出的是0。

4. A类的构造函数执行完毕后，开始执行B类的构造函数。在B类的构造函数中，也调用了test函数。

5. 但是此时，因为B类对象已经创建完毕，所以调用的func是B类的func。在B类的func中，m_iVal被增加1，然后输出。因此，此时输出的是1。

6. B类的构造函数执行完毕后，回到main函数。在main函数中，通过A类指针p调用test函数。

7. 因为p实际指向的是B类对象，所以此时调用的func是B类的func。因此，m_iVal再次被增加1，然后输出。此时输出的是2。

8. 最后，删除p指向的对象，并返回0。

所以，这个程序的输出应该是 "0 1 2 "。

下面程序的输出结果（）

class A
{
public:
    virtual void f()
    {
        cout << "A::f()" << endl;
    }
};


class B : public A
{
private:
    virtual void f()
    {
        cout << "B::f()" << endl;
    }
};

int main() {
    A* pa = (A*)new B;

    pa->f();
}

这是一个关于C++中的继承、虚函数和访问控制的例子。在这个例子中，我们有两个类，A和B，其中B是A的子类。这两个类都有一个名为f的函数，但在B中，这个函数被重写了。同时，B类中的f函数被声明为私有的。

现在，让我们逐步解析这个程序的执行过程：

1. 在main函数中，我们创建了一个指向B类对象的A类指针pa。这是通过new B实现的。

2. 然后，我们通过A类指针pa调用f函数。在C++中，如果一个函数被声明为虚函数，那么在通过指针或引用调用这个函数时，会根据指针或引用实际指向的对象类型来决定调用哪个函数。这就是所谓的动态绑定或运行时多态。

3. 在你的代码中，虽然pa是一个A类指针，但它实际指向的是一个B类对象。所以，pa->f()实际上调用的是B类的f函数。

4. 但是，B类的f函数被声明为私有的，这意味着它不能被类的外部访问，包括其子类和父类。所以，尽管pa实际指向的是一个B类对象，但是在main函数中，我们无法通过pa调用B类的f函数。这将导致编译错误。

所以，这个程序在编译时会报错，因为试图访问一个私有成员函数。如果你想让这个程序能够正确运行，你需要将B类的f函数声明为公有的或保护的。