C++-面向对象(六)

虚析构函数

• 含有虚函数的类，应该将析构函数声明为虚函数（虚析构函数）

• delete父类指针时，才会调用子类的析构函数，保证析构的完整性

#include <iostream>
using namespace std;

class Animal {
public:
  int m_age;
  virtual void speak() {
    cout << "Animal::speak()" << endl;
  }
  virtual void run() {
    cout << "Animal::run()" << endl;
  }
  virtual ~Animal() {
    cout << "~Animal()" << endl;
  }
};

class Cat : public Animal {
public:
  int m_life;
  Cat() :m_life(0) {}
  void speak() {
    cout << "Cat::speak()" << endl;
  }
  void run() {
    cout << "Cat::run()" << endl;
  }
  ~Cat() {
    cout << "~Cat()" << endl;
  }
};


int main() {
  Animal *cat1 = new Cat();
  cat1->speak();
  cat1->run();

  delete cat1;

  getchar();
  return 0;
}

纯虚函数

• • 
    
• 纯虚函数：没有函数体且初始化为0的虚函数，用来定义接口规范
• 抽象类（Abstract Class） 含有纯虚函数的类，不可以实例化（不可以创建对象）

• • 
    
• 抽象类也可以包含非纯虚函数
• 如果父类是抽象类，子类没有完全实现纯虚函数，那么这个子类依然是抽象类
  • 
    

#include <iostream>
using namespace std;

// 类似于Java中接口、抽象类
// 类似于OC中的协议protocol

// Animal是个抽象类
class Animal {
public:
  virtual void speak() = 0;
  virtual void run() = 0;
};

class Cat : public Animal {
public:
  void run() {

  }
};

class WhiteCat : public Cat {
public:
  void speak() {

  }
  void run() {

  }
};

int main() {
  Cat *cat = new WhiteCat();

  getchar();
  return 0;
}

多继承

• C++允许一个类可以有多个父类（不建议使用，会增加程序设计复杂度）

#include <iostream>
using namespace std;

class Student {
public:
  int m_score;
  Student(int score = 0) :m_score(score) { }
  void study() {
    cout << "Student::study() - score = " << m_score << endl;
  }
  ~Student() {
    cout << "~Student" << endl;
  }
};

class Worker {
public:
  int m_salary;
  Worker(int salary = 0) :m_salary(salary) { }
  void work() {
    cout << "Worker::work() - salary = " << m_salary << endl;
  }
  ~Worker() {
    cout << "~Worker" << endl;
  }
};

class Undergraduate : public Student, public Worker {
public:
  int m_grade;
  Undergraduate(
    int score = 0, 
    int salary = 0, 
    int grade = 0) :Student(score), Worker(salary), m_grade(grade) {

  }
  void play() {
    cout << "Undergraduate::play() - grade = " << m_grade << endl;
  }
  ~Undergraduate() {
    cout << "~Undergraduate" << endl;
  }
};

int main() {
  {
    Undergraduate ug;
    ug.m_score = 100;
    ug.m_salary = 2000;
    ug.m_grade = 4;
    ug.study();
    ug.work();
    ug.play(); 
  }

  cout << sizeof(Undergraduate) << endl;

  getchar();
  return 0;
}

多继承体系下的构造函数调用

#include <iostream>
using namespace std;

class Student {
public:
  virtual void study() {
    cout << "Student::study()" << endl;
  }
};

class Worker {
public:
  virtual void work() {
    cout << "Worker::work()" << endl;
  }
};

class Undergraduate : public Student, public Worker {
public:
  void study() {
    cout << "Undergraduate::study()" << endl;
  }
  void work() {
    cout << "Undergraduate::work()" << endl;
  }
  void play() {
    cout << "Undergraduate::play()" << endl;
  }
};

int main() {
  /*Undergraduate ug;
  ug.study();
  ug.work();
  ug.play();*/

  Student *stu = new Undergraduate();
  stu->study();

  Worker *worker = new Undergraduate();
  worker->work();

  cout << sizeof(Undergraduate) << endl;

  getchar();
  return 0;
}

多继承-虚函数

• 如果子类继承的多个父类都有虚函数，那么子类对象就会产生对应的多张虚表

同名函数

#include <iostream>
using namespace std;

class Student {
public:
  int m_age;
};

class Worker {
public:
  int m_age;
};

class Undergraduate : public Student, public Worker {
public:
  int m_age;
};

int main() {
  Undergraduate ug;
  ug.m_age = 10;
  ug.Student::m_age = 20;
  ug.Worker::m_age = 30;
  ug.Undergraduate::m_age = 40;

  cout << sizeof(Undergraduate) << endl;

  getchar();
  return 0;
}

//class Student {
//public:
//  void eat() {
//    cout << "Student::eat()" << endl;
//  }
//};
//
//class Worker {
//public:
//  void eat() {
//    cout << "Worker::eat()" << endl;
//  }
//};
//
//class Undergraduate : public Student, public Worker {
//public:
//  void eat() {
//    cout << "Undergraduate::eat()" << endl;
//  }
//};
//
//int main() {
//  Undergraduate ug;
//  ug.eat();
//  ug.Worker::eat();
//  ug.Student::eat();
//  ug.Undergraduate::eat();
//
//  getchar();
//  return 0;
//}

菱形继承

• 菱形继承带来的问题
• 
  
  • • 
      
  • 最底下子类从基类继承的成员变量冗余、重复
  • 最底下子类无法访问基类的成员，有二义性
    
    • 
      
• 
  

#include <iostream>
using namespace std;

// 非虚继承：(10 + 10 + 3) * 4 = 23 * 4
// 虚继承：(10 + 2 + 2 + 1) * 4 = 15 * 4
class Person {
public:
  int m_age;
  int m_age1;
  int m_age2;
  int m_age3;
  int m_age4;
  int m_age5;
  int m_age6;
  int m_age7;
  int m_age8;
  int m_age9;
};

class Student : virtual public Person {
public:
  int m_score;
};

class Worker : virtual public Person {
public:
  int m_salary;
};

class Undergraduate : public Student, public Worker {
public:
  int m_grade;
};

int main() {
  /*Undergraduate ug;
  ug.m_grade = 10;
  ug.m_score = 20;
  ug.m_salary = 20;*/

  cout << sizeof(Student) << endl;

  getchar();
  return 0;
}

虚继承

• 虚继承可以解决菱形继承带来的问题

#include <iostream>
using namespace std;

// 多继承：增加程序的复杂度

// 多继承有一个很好的用途：
// 一个类实现多个接口（Java）
// 一个类遵守多份协议（OC）
// 一个类继承多个抽象类（C++）

class JobBaomu {
  virtual void clean() = 0;
  virtual void cook() = 0;
};

class JobTeacher {
  virtual void playBaseball() = 0;
  virtual void playFootball() = 0;
};

class SalesMan : public JobBaomu {
  void clean() {

  }

  void cook() {

  }
};

class Student : public JobBaomu, public JobTeacher {
  void clean() {

  }

  void cook() {

  }

  void playBaseball() {

  }

  void playFootball() {

  }
};

int main() {
  // 兼职中心
  // 招聘一些人来做兼职
  // 兼职的岗位很多种（保姆、老师、开挖掘机）
  // 应聘的人种类也很多（学生、XXX）

  getchar();
  return 0;
}