超级详细讲解C++中的多态

class Person //成人
{
  public:
  virtual void fun()
   {
       cout << "全价票" << endl; //成人票全价
   }
};
class Student : public Person //学生
{
   public:
   virtual void fun() //子类完成对父类虚函数的重写
   {
       cout << "半价票" << endl;//学生票半价
   }
};
void BuyTicket(Person* p)
{
   p->fun();
}

int main()
{
   Student st;
   Person p;
   BuyTicket(&st);//子类对象切片过去
   BuyTicket(&p);//父类对象传地址
}

virtual void fun() //error！ 在类外面的函数不能是虚函数
{}

class Person
{
  public:
   virtual void fun()
   {
      cout << "Person->fun()" << endl;
   }
};
class Student
{
   public:
   //子类重写的虚函数可以不加virtual，因为子类继承了父类的虚函数，
   //编译器会认为你是想要重写虚函数。
   //void fun() 可以直接这样，也对，但不推荐。           
   virtual void fun()//子类重写父类虚函数
   {
     cout << "Student->fun()" << endl;
   }
};

class Person
{
  public:
   virtual Person* fun()//返回父类指针
   {
      cout << "Person->fun()" << endl;
      return nullptr;
   }
};
class Student
{
   public:
            //返回子类指针，虽然返回值不同，也构成重写
   virtual Student* fun()//子类重写父类虚函数
   {
     cout << "Student->fun()" << endl;
     return nullptr;
   }
};

class A
{};
class B : public A
{};   //B继承A
class Person
{
  public:
   virtual A* fun()//返回A类指针
   {
      return nullptr;
   }
};
class Student
{
   public:
            //返回B类指针，虽然返回值不同，也构成重写
   virtual B* fun()//子类重写父类虚函数
   {
     return nullptr;
   }
};

//B继承了A，他们的析构函数没有重写。
class A
{
  public:
  ~A()
  {
     cout << "~A()" << endl;
  }
};
class B : public A
{
  public:
  ~B()
  {
    cout << "~B()" << endl;
  }
};

 A* a = new B; //把B的对象切片给A类型的指针。
 delete a; //调用的是谁的析构函数呢？你希望调用谁的呢？

class A
{
  public:
 virtual  ~A()
  {
     cout << "~A()" << endl;
  }
};
class B : public A
{
  public:
  virtual ~B()
  {
    cout << "~B()" << endl;
  }
};

class A final //A类无法被继承
{
public:
  virtual void fun() final //fun函数无法被重写
  {}
};

class B : public A //error
{
  public:
    virtual void fun() //error
    {
     cout << endl;
    }
};

class A  
{
public:
  virtual void fun() 
  {}
};

class B : public A 
{
  public:
  //这里我想重写fun，但写成了fun1，因为有override,编译器会报错。
    virtual void fun1() override
    {
     cout << endl;
    }
};

class Car
{
 public:
    virtual void fun() = 0; //不用实现，只写接口就行。
}

class A
{
   public:
   virtual void fun(int val = 0)//父类虚函数
   {
     cout <<"A->val = "<< val << endl;
   }
   void Fun()
   {
      fun();//传过来一个子类指针调用fun()
   }
};
class B: public A
{
   public:
    virtual void fun(int val = 1)//子类虚函数
    {
       cout << "B->val = " << val << endl;
    }
};

B b;
A* a = &b;
a->Fun();

class A
{
  public:
   virtual void fun()
   {}
   protected:
   int _a;
};

class A
{
  public:
  void fun1()
  {}
  virtual void fun2()
  {}
};

A* ap = nullptr;
ap->fun1(); //调用成功，因为这是普通函数的调用
ap->fun2(); //调用失败，虚函数需要对指针操作，无法操作空指针。

class A
{
  public:
   virtual void fun1()
   {}
   virtual void fun2()
   {}
};
class B : public A
{
 public:
   virtual void fun1()//重写父类虚函数
   {}
   virtual void fun3()
   {}
};
A a;
B b; //我们通过调试看看对象a和b的内存模型。

class Person //成人
{
  public:
  virtual void fun()
   {
       cout << "全价票" << endl; //成人票全价
   }
};
class Student : public Person //学生
{
   public:
   virtual void fun() //子类完成对父类虚函数的重写
   {
       cout << "半价票" << endl;//学生票半价
   }
};
void BuyTicket(Person* p)
{
   p->fun();
}

#include <iOStream>
using namespace std;

class Base {
public:
	virtual void func() {
		cout << "Base func\n";
	}
};

class Son : public Base {
public:
	void func() {
		Base::func();
		cout << "Son func\n";
	}
};

int main()
{
	Son b;
	b.func();
	return 0;
}

class BV
{
public:
	virtual void Fun1()
	{
		cout << "BV->Fun1()" << endl;
	}
	virtual void Fun2()
	{
		cout << "BV->Fun2()" << endl;
	}
};
class DV : public BV
{
public:
	virtual void Fun1()
	{
		cout << "DV->Fun1()" << endl;
	}
	virtual void Fun3()
	{
		cout << "DV->Fun3()" << endl;
	}
	virtual void Fun4()
	{
		cout << "DV->Fun4()" << endl;
	}
};

typedef void(*V_PTR)(); //typedef一下函数指针，相当于把返回值为void型的
//函数指针定义成 V_PTR.
void PrintPFTable(V_PTR* table)//打印虚函数表
{  //因为虚表最后一个为nllptr，我们可以利用这个打印虚表。
	for (size_t i = 0; table[i] != nullptr; ++i)
	{
		printf("table[%d] : %p->", i, table[i]);
		V_PTR f = table[i];
		f();
		cout << endl;
	}
}

BV b;
DV d;
	      // 取出b、d对象的前四个字节，就是虚表的指针，
	      //前面我们说了虚函数表本质是一个存虚函数指针的指针数组，
	      //这个数组最后面放了一个nullptr
     // 1.先取b的地址，强转成一个int*的指针
     // 2.再解引用取值，就取到了b对象前4个字节的值，这个值就是指向虚表的指针
     // 3.再强转成V_PTR*,这是我们打印虚表函数的类型。
     // 4.虚表指针传给PrintPFTable函数，打印虚表
     // 5,有时候编译器资源释放不完全，我们需要清理一下，不然会打印多余结果。
	PrintPFTable((V_PTR*)(*(int*)&b));
	PrintPFTable((V_PTR*)(*(int*)&d));

class A
{
public:
 virtual void fun1()
 {
   cout << "A->fun1()" << endl;
 }
 protected:
 int _a;
};
class B
{
public:
 virtual void fun1()
 {
   cout << "B->fun1()" << endl;
 } 
 protected:
  int _b;
};
class C : public A, public B
{
  public:
  virtual void fun1()
  {
    cout << "C->fun1()" << endl;
  }
  protected:
  int _c;
};

C c;
//sizeof(c) 是多少呢？

//Derive继承Base1和Base2
class Base1
{
public:
	virtual void fun1()
	{
		cout << "Base1->fun1()" << endl;
	}
	virtual void fun2()
	{
		cout << "Base1->fun2()" << endl;
	}
};
class Base2
{
public:
	virtual void fun1()
	{
		cout << "Base2->fun1()" << endl;
	}
	virtual void fun2()
	{
		cout << "Base2->fun2()" << endl;
	}
};
class Derive : public Base1, public Base2
{
public:
	virtual void fun1()
	{
		cout << "Derive->fun1()" << endl;
	}
	virtual void fun3()
	{
		cout << "Derive->fun3()" << endl;
	}
};

Derive d;
	PrintPFTable((V_PTR*)(*(int*)&d));
	PrintPFTable((V_PTR*)(*(int*)((char*)&d+sizeof(Base2))));