#include <iostream>
using namespace std;
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(*VFPTR) ();
typedef void(*p)();
void PrintVFTbale(p vft[])//打印虚表
{
  for (int i = 0; vft[i] != nullptr; i++)
  {
    printf("[%d]:%p->", i, vft[i]);
    vft[i]();
  }
}
int main()
{
  Base1 b1;
  Base2 b2;
  PrintVFTbale((p*)(*(void**)&b1));
  PrintVFTbale((p*)(*(void**)&b2));
  Derive d;
  PrintVFTbale((p*)(*(void**)&d));//d有两个虚表
  PrintVFTbale((p*)(*(void**)((char*)/*不强转就不是+1跳过一个字节了*/ &d + sizeof(Base1))));//想要打印第二个虚表就要跳过第一个虚表的地址
  return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
  virtual void func1(){}
  int _a;
};
class B : public A
//class B : virtual public A
{
public:
  virtual void func1() {}
  int _b;
};
class C : public A
//class C : virtual public A
{
public:
  virtual void func1() {}
  int _c;
};
class D : public B, public C
{
public:
  int _d;
};
int main()
{
  D d;
  d.B::_a = 1;
  d.C::_a = 2;
  d._b = 3;
  d._c = 4;
  d._d = 5;
  return 0;
}

#include<iostream>
using namespace std;
class A {
public:
  A(const char* s) { cout << s << endl; }
  ~A() {}
};
class B :virtual public A
{
public:
  B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class C :virtual public A
{
public:
  C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C
{
public:
  D(const char* s1, const char* s2, const char* s3, const char* s4) :B(s1, s2),C(s1, s3),A(s1)
  {
    cout << s4 << endl;
  }
};
int main() {
  D* p = new D("class A", "class B", "class C", "class D");
  delete p;
  return 0;
}

#include<iostream>
using namespace std;
class A {
public:
  A(const char* s) { cout << s << endl; }
  ~A() {}
};
class B :public A
{
public:
  B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class C :public A
{
public:
  C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C
{
public:
  D(const char* s1, const char* s2, const char* s3, const char* s4) :B(s1, s2),C(s1, s3)//这里就不用初始化A了，因为有两份A，在B和C中，B和C就会去调用A的初始化
  {
    cout << s4 << endl;
  }
};
int main() {
  D* p = new D("class A", "class B", "class C", "class D");
  delete p;
  return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
  virtual void add() { cout << "A：add" << endl; }
  int _a;
};
class B :public A
{
public:
  virtual void add() { cout << "B：add" << endl; }
  int _b;
};
void app(A a)//这里传过来的如果是B类的对象，顶多是切片过来的A类一部分，不可能是拷贝过来所有的内容
{
  a.add();//这里就是静态绑定，普通调用
}
int main()
{
  A a;
  B b;
  app(a);
  app(b);//如果拷贝到A a中，里面的内容就乱套了，所以只能用引用或者是指针才能指向子类对象完成多态的调用
  return 0;
}