//C++继承和虚函数（具体见附件）


//-----------继承--inheritance：------------
//程序1：
#include<iostream>
using namespace std;
class Person{
protected:
  string name;//由于是protected类型，故在子类里面可以访问 
private:
  bool gender;
public:
  Person(const char *a,bool g=true):name(a),gender(g){}
  void show()
  {
    cout<<"大家好，我是"<<(gender?"帅哥":"美女")<<name<<endl;
    cout<<",很高兴认识大家!"<<endl;
  }
  void eat(const char *food)
  {
    cout<<"我喜欢吃"<<food<<"."<<endl;
  }
};

class Student:public Person{
  int gread;
  string major;
public:
  //公有继承父类的，可以访问它里面的公有成员以及受保护的成员
  //如果在子类构造函数里面要初始化父类里面的成员，就把相应的参数传给
//父类的构造函数 
  Student(const char *a,bool g,int G,const char *m)
  :gread(G),major(m),Person(a,g){}//注意这里对父类成员的初始化
  void show()//改写来自父类成员，隐藏父类的同名成员
  {
    cout<<"大家好，我是"<<name<<endl;
    cout<<",很高兴认识大家!"<<endl;
  }
  void details()
  {
    cout<<"我现在是大学"<<gread<<"年级学生,"<<name<<"我的专业是"<<major;
    cout<<",希望一起交流!"<<endl;
  }
};
int main()
{
  Person a("铁蛋",true);
  a.show();
  a.eat("火腿肠");
  Student b("胖妞",false,3,"信息"); 
  b.show();
  b.eat("火腿");
  b.details();
}


//----------多重继承、虚继承:------------

  
//虚继承：
//1.来自虚基类的成员合并，只保留一份到最下层子类里面
//2.虚基类构造函数的参数，由底层子类直接传递
//3.虚继承，保证虚基类的成员到最底层子类里面只保留一份
#include<iostream>
using namespace std;
class Goods{
  double price;
public:
  Goods(double p=100):price(p){cout<<"Goods()"<<endl;}
  ~Goods(){cout<<"~Goods()"<<endl;}
  //double Price()
  void Price()
  {
    //return price;
    cout<<price<<endl;
  }
};
class Camera:virtual public Goods{
public:
  Camera(double p):Goods(p){cout<<"Camera()"<<endl;}
  ~Camera(){cout<<"~Camera()"<<endl;}
  void take(const char* obj)
  {
    cout<<"给"<<obj<<"照相."<<endl;
  }
};
class MP3:virtual public Goods{
public:
  MP3(double p):Goods(p){cout<<"MP3()"<<endl;}
  ~MP3(){cout<<"~MP3()"<<endl;}
  void play(const char *song)
  {
    cout<<"播放歌曲<<"<<song<<">>"<<endl;
  }
};
class Phone:virtual public Goods{
public:
  Phone(double p):Goods(p){cout<<"Phone()"<<endl;}
  ~Phone(){cout<<"~Phone()"<<endl;}
  void dial(const char *no)
  {
    cout<<"给"<<no<<"拨打电话!"<<endl;
  }
};
//多重继承,构造函数执行的顺序是按照子类继承父类的顺序执行
//同时，子类的构造函数是最后执行(即一个类总是先调用父类的构造函数)
class ModernPhone:public Phone,public Camera,public MP3
{
  string factory;
public:
  ModernPhone(const char *f,double p):factory(f),Phone(p),Camera(p),MP3(p),Goods(p)
  {
    cout<<"ModernPhone()"<<endl;
    cout<<"手机厂商"<<factory<<endl;
  }
  ~ModernPhone(){cout<<"~ModernPhone"<<endl;}
  void visitnet(const char *url)
  {
    cout<<"访问网址"<<url<<endl;
  }
};
int main()
{
  ModernPhone mp("Apple",300);
  mp.dial("18710831610");
  mp.play("最炫民族风");
  mp.Price();
  return 0;
}

//--------虚函数、多态---(polymorphism[pɒlɪ'mɔːfɪz(ə)m])：------------
//程序1：
//通过指针调用虚函数的时候才会实现多态
#include<iostream>
using namespace std;
class Person{
protected:
  string name;
private:
  bool gender;
public:
  Person(const char *a,bool g=true):name(a),gender(g){}
  virtual void show()//虚函数
  {
    cout<<"大家好，我是"<<(gender?"帅哥":"美女")<<name<<endl;
    cout<<",很高兴认识大家!"<<endl;
  }
  void eat(const char *food)
  {
    cout<<"我喜欢吃"<<food<<"."<<endl;
  }
};

class Student:public Person{
  int gread;
  string major;
public:
  Student(const char *a,bool g,int G,const char *m)
  :gread(G),major(m),Person(a,g){}
  void show()
  {
    cout<<"大家好，我是"<<name<<endl;
    cout<<",很高兴认识大家!"<<endl;
  }
  void details()
  {
    cout<<"我现在是大学"<<gread<<"年级学生,"<<name<<"我的专业是"<<major;
    cout<<",希望一起交流!"<<endl;
  }
};
int main()
{
  Person a("铁蛋",true);
  Student b("胖妞",false,3,"信息"); 
  Person *p,*q;   //注意这里，p,q两个指针都是Person类型
  p=&a;
  q=&b;
  //会根据对象的类型来决定调用那个对象里面的成员函数
  a.show();
  b.show();
}

//程序2：
//构造函数、析构函数中没有多态
#include<iostream>
using namespace std;
class USB{
public:
  virtual void recognise()
  {
    cout<<"正在识别USB..."<<endl;
  }
  virtual void know()
  {
    cout<<"USB已经接入!"<<endl;
  }
  virtual void display()
  {
    cout<<"USB开始工作."<<endl;
  }
};
//后面的子类里面的成员函数可以不写virtual，默认加virtual
class USBCamera:public USB{
  void recognise()
  {
    cout<<"正在识别相机..."<<endl;
  }
  void know()
  {
    cout<<"相机已经接入!"<<endl;
  }
  void display()
  {
    cout<<"相机开始工作."<<endl;
  }
};
class USBMP3:public USB{
  void recognise()
  {
    cout<<"正在识别MP3..."<<endl;
  }
  void know()
  {
    cout<<"MP3已经接入!"<<endl;
  }
  void display()
  {
    cout<<"MP3开始工作."<<endl;
  }
};
class Computer{
public:
  void use(USB *p)//相当于，用父类申明一个指针,然后用改指针指向相应的成员函数
  {
    p->recognise();
    p->know();
    p->display();
  }
};
int main()
{
//由于父类的成员函数已经申明为虚函数(virtual)，所以在调用函数时，会根据相应的子类对象而调用子类里面的成员函数
  USBCamera ca;
  USBMP3 m;
  Computer c;
  c.use(&ca);
  c.use(&m);
  return 0;
}


//--------------纯虚函数：-------------
//程序1：
//只有用new创建对象，用delete释放对象，虚析构才起作用
//构造、析构函数没有纯虚函数
//子类一定是父类,所以可以将一个子类赋给父类，但父类不一定能够赋给子类
#include<iostream>
using namespace std;
class Animal{
public:
  Animal(){}
  virtual ~Animal(){}//虚析构
  //~Animal(){shout();}
  void play()
  {
    eat();
    shout();
    sleep();
  }
  //纯虚函数:提供一个接口，子类覆盖它，自己实现函数的不同功能
  //有纯虚函数的类，称为抽象类abstract class
  //补允许创建抽象类的对象
  virtual void eat()=0;
  virtual void shout()=0;
  virtual void sleep()=0;
};
class Horse:public Animal{
public:
  Horse(){cout<<"马"<<endl;}
  ~Horse(){cout<<"死马"<<endl;}
  virtual void eat(){cout<<"马吃草"<<endl;}
  virtual void shout(){cout<<"马叫"<<endl;}
  virtual void sleep(){cout<<"马睡觉"<<endl;}
};
class Tiger:public Animal{
public:
  Tiger(){cout<<"老虎"<<endl;}
  ~Tiger(){cout<<"死老虎"<<endl;}
  virtual void eat(){cout<<"老虎吃肉"<<endl;}
  virtual void shout(){cout<<"老虎叫"<<endl;}
  virtual void sleep(){cout<<"老虎睡觉"<<endl;}
};
int main()
{
  char c;
  Animal *p=NULL;
  cout<<"选择h代表马，t代表老虎:";
  cin>>c;
  if(c=='h')
    p=new Horse;
  else
    p=new Tiger;
  p->play();
  delete p;
  //Animal a;这里编译出现错误，补允许创建抽象类的对象
  return 0;
}


//程序2：
//虚函数表里存有这个类里面所有虚函数的地址
//每个类只有一个虚函数表，每个对象有一个指针指向这个虚函数表
#include<iostream>
using namespace std;
class A{
  double a;
};
class B{
  double b;
  void fun(){}
};
class C{
  double c;
  virtual void fun(){}
};
class D{
  double d;
  virtual void fun1(){}
  virtual void fun2(){}
  virtual void fun3(){}
};
int main()
{
  cout<<sizeof(A)<<endl;//8
  cout<<sizeof(B)<<endl;
  //sizeof(B)=8,函数在代码区，b在数据区，所以sizeof(b)=8
  cout<<sizeof(C)<<endl;
  //sizeof(C)=12,有虚函数的类，每个对象有一个虚指针，
  //指向一个存有所有虚函数的数组，只占4个字节，与虚函数的个数无关
  cout<<sizeof(D)<<endl;//sizeof(D)=12
  return 0;
}