从C语言到C++_22(继承)多继承与菱形继承+笔试选择题（中）

#include <iostream>
using namespace std;
 
class Person 
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }
 
    Person(const Person& p)
        : _name(p._name)
    {
        cout << "Person(const Person& p)" << endl;
    }
protected:
    string _name;
};
 
class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)
        , _num(num)
    {
        cout << "Student()" << endl;
    }
 
    Student(const Student& s)
        : Person(s)     // 子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
        , _num(s._num)
    {
        cout << "Student(const Student& s)" << endl;
    }
protected:
    int _num;   // 学号
};
 
int main() 
{
    Student s1("GR", 19);
    Student s2(s1);
 
    return 0;
}

#include <iostream>
using namespace std;
 
class Person 
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }
 
    Person& operator=(const Person& p) 
    {
        cout << "Person& operator=(const Person& p)" << endl;
        if (this != &p) {
            _name = p._name;
        }
        return *this;
    }
 
protected:
    string _name;
};
 
class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)
        , _num(num)
    {
        cout << "Student()" << endl;
    }
    Student& operator=(const Student& s) 
    {
        cout << "Student& operator=(const Student& s)" << endl;
        if (this != &s)
        {
            // 子类的 operator= 必须要调用父类的 operator= 完成父类的复制
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }
 
protected:
    int _num;   // 学号
};
 
int main() 
{
    Student s1("GR", 19);
    Student s2("RL", 17);
    s1 = s2;
    return 0;
}

#include <iostream>
using namespace std;
 
class Person
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }
    ~Person() 
    {
        cout << "~Person()" << endl;
    }
 
protected:
    string _name;
};
 
class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)  // 父类成员，调用自己的构造完成初始化
        , _num(num)
    {
        cout << "Student()" << endl;
    }
 
    ~Student() 
    {
        cout << "~Student()" << endl;
 
        //Person::~Person();  
        // 因为要先析构子类，所以不需要显示调用，编译器自动调用父类析构函数
    }
 
protected:
    int _num;   // 学号
};
 
int main() 
{
    Student s1("GR", 19);
 
    return 0;
}

#include<iostream>
using namespace std;
 
class Student;
class Person 
{
public:
  friend void Display(const Person& p, const Student& s);
protected:
  string _name; // 姓名
};
 
class Student : public Person 
{
protected:
  int _stuNum; // 学号
};
 
void Display(const Person& p, const Student& s)
{
  cout << p._name << endl;
  cout << s._stuNum << endl; // 错误  C2248 “Student::_stuNum”: 无法访问 protected 成员(在“Student”类中声明)
}
 
void main()
{
  Person p;
  Student s;
  Display(p, s);
}

#include <iostream>
using namespace std;
 
class Person
{
public:
  Person() 
  {
    ++_count;
  }
protected:
  string _name; // 姓名
public:
  static int _count; // 统计人的个数
};
 
int Person::_count = 0;
class Student : public Person
{
protected:
  int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
  string _seminarCourse;
};
 
int main()
{
  Student s1;
  Student s2;
  Student s3;
  Graduate s4;
  Person s5;
 
  cout << "大家都可以访问：(创建了多少个对象)" << endl;
  cout << "人数：" << Person::_count << endl;
  cout << "人数：" << Student::_count << endl;
  cout << "人数：" << s4._count << endl;
 
  cout << "顺便一个类把静态成员改变：" << endl;
  s3._count = 0;
  cout << "人数：" << Person::_count << endl;
 
  cout << "并且他们的地址也都是一样的，因为所有继承体系中只有一个" << endl;
  cout << "人数：" << &Person::_count << endl;
  cout << "人数：" << &Student::_count << endl;
  cout << "人数：" << &s4._count << endl;
 
  return 0;
}

#include <iostream>
using namespace std;
 
class Person 
{
public:
  string _name; // 姓名
};
 
class Student : public Person 
{
protected:
  int _num; //学号
};
 
class Teacher : public Person 
{
protected:
  int _id; // 职工编号
};
 
class Assistant : public Student, public Teacher
{
protected:
  string _majorCourse; // 主修课程
};
 
int main()
{
  // 这样会有二义性无法明确知道访问的是哪一个
  Assistant a;
  //a._name = "peter"; // 错误  C2385 对“_name”的访问不明确
 
  // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
  a.Student::_name = "GR";
  a.Teacher::_name = "RL";
 
  return 0;
}

class Person 
{
public:
  string _name;
  int _arr[1000];
};
 
// 虚继承
class Student : virtual public Person 
{
protected:
  int _num;
};
 
// 虚继承
class Teacher : virtual public Person 
{
protected:
  int _id;
};
 
class Assistant : public Student, public Teacher 
{
protected:
  string _majorCourse;
};