#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
  void Print()
  {
    cout << "name:" << _name << endl;
    cout << "age:" << _age << endl;
  }
protected:
  string _name = "peter"; // 姓名
  int _age = 18;  // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。
//下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
  int _stuid; // 学号
};
class Teacher :public  Person
{
protected:
  int _jobid; // 工号
};
int main()
{
  //Person叫做父类或基类，Student和Teacher叫做子类或派生类
  Student s;
  Teacher t;
  s.Print();
  t.Print();
  //基类中的私有就是不想给派生类继承。
  //继承的目的就是让子类去使用基类的成员，所以一般情况下基类不会将成员设置为私有，设置为保护更常见，
  //class默认访问限定符和继承方式都是私有，struct默认访问限定符和继承方式都是公有。
  //实际当中很少使用保护继承和私有继承，公有继承最为常见。
  return 0;
}

class Person
{
protected:
    string _name; // 姓名
    string _sex;  // 性别
public:
    int _age; // 年龄
};
class Student : public Person
{
public:
    int _No; // 学号
};
int main()
{
    Person p;
    Student s;
    // 中间不存在类型转换，不产生临时变量
    p = s;
    Person& rp = s;//如果有临时变量，这里普通引用一定会报错。子类可以认为是特殊的父类
    // rp变为子类中父类那一部分的别名，所以这里有人喜欢叫做切割或切片。
    rp._age++;
    Person* ptrs = &s;
    ptrs->_age++;//这里++的都是子类中父类那部分的_age。
    int i = 1;
    double d = 2.2;
    i = d;//类型转换中间会产生临时变量,临时变量的类型是int类型
    // int& ri = d;//ri不能变成d的别名，因为中间产生的临时变量具有常性，需要用const引用
    //基类与派生类对象的赋值转换也叫做向上转换，但是不能向下转换，因为父类缺少子类中特殊的那一部分，无法进行赋值转换。
    //向上转换的过程是天然的，子可以给父，但父不可以给子。
    return 0;
}

class Person
{
protected:
    string _name = "小李子"; // 姓名
    int _num = 111;   // 身份证号
};
class Student : public Person
{
public:
    void Print()
    {
        cout << " 姓名:" << _name << endl;
        cout << " 身份证号:" << Person::_num << endl;//可以指定类域访问Person类里面的_num成员变量。
        cout << " 学号:" << _num << endl;
        //这里默认访问的是子类的成员，未指定作用域访问限定符时，编译器采用就近原则，如果自己的所在作用域有，则直接使用。
        //如果局部有，就直接用局部。局部没有，编译器才会去全局找。
    }
protected:
    int _num = 999; // 学号：同名成员变量
};
void Test1()
{
    Student s1;
    s1.Print();
};

class A
{
public:
    void fun()
    {
        cout << "func()" << endl;
    }
};
// 同名成员函数fun()构成什么关系呢？
// 重载 重写 隐藏（重定义） 编译报错
//父类和子类的同名成员函数，只要函数名相同就构成隐藏，参数列表不同也没有关系，只要函数名相同就构成隐藏。
class B : public A 
{
public:
    void fun(int i)//同名成员函数
    {
        A::fun();
        cout << "func(int i)->" << i << endl;
    }
};
void Test2()
{
    B b;
    b.fun(10);
};
class A
{
public:
    void fun()
    {
        cout << "func()" << endl;
    }
};
class B : public A
{
public:
    void fun(int i)//同名成员函数
    {
        A::fun();
        cout << "func(int i)->" << i << endl;
    }
};
void Test2()
{
    B b;
    //b.fun();//就近原则，优先去B类域去找。这里会报错。
    b.A::fun();//隐藏后，需要指定类域才能访问基类的成员函数。
};
int main()
{
    Test1();
    //当子类和父类中拥有同名成员的时候，子类会屏蔽父类对同名成员的直接访问，这样的方式叫隐藏，可以用基类:基类成员显示访问
    Test2();
}

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;
    }
    Person& operator=(const Person & p)
    {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p)
            _name = p._name;
        return *this;
    }
    ~Person()
    {
        cout << "~Person()" << endl;
    }
protected:
    string _name; // 姓名
};
//派生类中：
// 1、构造函数，父类成员会默认调用父类的构造函数完成初始化。
class Student : public Person
{
public:
    Student(const char* name, int num)
        //:_name(name)//规定死了，如果要初始化基类成员，必须调用基类的构造函数。
        //如果父类没有合适的默认构造，则必须在子类中调用有参的基类构造完成基类成员的初始化。
        :Person(name)
        ,_num(num)
    {}
    Student(const Student& s)
        :Person(s)//基类成员要拷贝，直接传派生类对象过去，会发生向上切割赋值。
        ,_num(s._num)
    {}
    Student& operator=(const Student& s)
    {
        if (this != &s)//不要自己给自己赋值
        {
            Person::operator=(s);//发生切割或切片，将子类中的父类成员进行赋值，父子类的赋值重载构成隐藏，会默认调就近的类
            _num = s._num;
        }
        return *this;
    }
    ~Student()
    {
        //Person::~Person();//编译器当作调用基类的destructor
        //1.子类析构和父类析构构成隐藏关系（由于多态的关系需求，所有的析构函数都会特殊处理成destructor函数名）
        //2.调用了一次Person的构造，两次析构，其实是因为我们显示调用了Person的析构，编译器自己会自动调用析构，所以调2次
        //  子类先析构，父类后析构。可得结论：子类析构函数不需要显示调用父类析构，依靠编译器之后的自动调用即可。
        cout << "~Student()" << endl;
        //在子类对象析构函数调用之后，编译器又会自动调用父类析构，这是编译器的默认行为。
        //构造顺序和析构顺序相反，基类成员先构造，则析构时基类就后析构。
    }
protected:
    int _num; //内置类型不处理
    string _address;//调用string自己的无参构造进行处理
    //继承下来的基类成员调用基类对应函数进行处理
};
int main()
{
    //Student s1;//如果子类s1里面什么都没有，则这里会调用父类的析构和无参构造。
    //Student s1("小李子", 18);
    //Student s2(s1);//子类中父类成员会调用父类的拷贝构造。
    把子类分为三个部分，内置类型，自定义类型，父类的那一部分，父类那一部分规定死只能调用父类的成员函数。
    //Student s3("张三", 20);
    //s1 = s3;
    //Person p = s1;//调用拷贝构造，发生切片赋值
    //Person& rp = s1;//不需要用const引用，这里是天然的赋值过程。
    Student s("张三",18);
}

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;//Display是Person的友元函数，但不是Student的友元函数。
    //cout << s._stuNum << endl;//所以可以访问_name但不能访问_stuNum
}
int main()
{
    Person p;
    Student s;
    Display(p, s);
}

class Person
{
public:
  Person() { ++_count; }
  void Print()
  {
    cout << this << endl;
    //cout << _name << endl;//如果是空对象访问_name，那就会出错，因为空什么成员都没有存储，发生越界访问。
    cout << _count << endl;
  }
//protected:
  string _name; // 姓名
public:
  static int _count; // 统计人的个数。
};
int Person::_count = 0;//类内只是声明，类外进行定义
class Student : public Person
{
protected:
  int _stuNum; // 学号
};
//静态成员属于整个类的所有对象，同时也属于所有的派生类的所有对象，换句话可以说为静态成员属于基类和派生类
int main()
{
  Person p;
  Student s;
  p._name = "张三";
  s._name = "李四";
  //虽然对象s是子类继承父类之后实例化的，但是s里面的_name和p里面的_name并不是相同的。
  p._count++;
  s._count++;
  cout << p._count << endl;
  cout << s._count << endl;
  cout << &p._count << endl;
  cout << &s._count << endl;
  cout << Person::_count << endl;
  cout << Student::_count << endl;
  //类静态成员为所有类对象所共享，不属于某个具体的对象，属于整个类，存放在静态区。
  //类静态成员访问有两种方式，一种是通过类加类域访问限定符直接访问，另一种是通过对象来间接访问。
  //非静态成员对于基类和派生类来说各有一份互不干扰，因为基类和派生类本身就是不同的类，下来的对象也是不同的，理应有各自的
  //成员变量
  Person* ptr = nullptr;
  //cout << ptr->_name << endl; // no，这里是解引用因为_name在对象里面
  ptr->Print();       // ok，这里不是解引用因为Print在代码段，也就是常量区。实际就是传递空this指针而已。
  cout << ptr->_count << endl;// ok，这里不是解引用因为_count在静态区
  (*ptr).Print();//并不是只要解引用就会报错，而是只要访问了空对象的成员才会报错，因为空对象没有成员。
  cout << (*ptr)._count << endl;
  return 0;
}

//有多继承本身没什么问题，但有多继承可能就会有菱形继承，菱形继承会引发数据冗余和二义性。
class Person
{
public:
  string _name; // 姓名
};
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; // 主修课程
};
// 空间角度来讲是数据冗余，访问角度来讲是二义性。数据冗余会导致空间浪费
int main()
{
  Assistant a;
  a._name = "小张";//这里就会出现二义性，访问的_name是属于Person的哪个派生类的，是Student还是Teacher呢？
  a.Teacher::_name = "张老师";
  a.Student::_name = "张三";//指定访问类域也只是解决了二义性，还没有解决数据冗余的问题。
  cout << a._name << endl;//虚拟继承之后，_name就只有一份了。
}

//C++引入虚拟继承来解决菱形继承的数据冗余和二义性问题。virtual继承
class A
{
public:
  int _a;
};
// class B : public A
class B : virtual public A
{
public:
  int _b;
};
// class C : public A
class C : virtual public A
{
public:
  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;
  //监视窗口被编译器优化处理过，不是那么准了，我们改用内存窗口进行观察。
  B b; 
  b._a = 1;
  b._b = 2;
  B* ptr = &b;
  ptr->_a = 10;
  ptr->_b = 11;
  ptr = &d;//发生切片赋值
  ptr->_a = 20;
  ptr->_b = 21;
  //虚继承之后，虚基类对象不属于派生类对象里面了，而是到派生类对象外面，只能通过存偏移量的方式来找到虚基类对象。
  //这里是因为节省的比消耗的小，所以体现出来的是没有节省内存，但如果A对象很大的花，那消耗用于存储地址偏移量的内存是
  //远远小于节省出的A对象的字节的。存地址这里消耗8字节，节省了A对象的4字节，多消耗4字节，但如果A很大，那就节省空间了。
  //模型上来说，把虚基类对象放到最下面，喜欢把有效内容上方的地址所指向的表叫做虚基表，虚基表中存储的是偏移量
  //Java直接就不支持多继承，这样根本就没有菱形继承这样的存在，不会引发大坑的出现了就。
  return 0;
}

//继承和组合，两者都是复用。继承是白箱复用，组合是黑箱复用。
//黑盒测试和白盒测试，未知底层针对功能设计测试用例，已知底层针对代码实现设计测试用例。
class X
{
  int _x;
};
class Y:public X
{
  int _y;//X的保护成员，Y的对象可以直接访问，因为是公有继承，protect到Y里面后访问限定符还是protect
};
//组合的耦合度低，继承的耦合度高，软件工程思想高内聚低耦合，耦合就是模块之间的依赖关系，或者叫类之间的依赖关系
//互相影响的
class M
{
  int _m;
};
class N
{
  M mm;//mm的保护成员，N对象不能访问，因为类外不能访问类内私有或保护成员。
  int _n;
};