C++进阶：（一）深入理解继承机制

class 派生类名 : 继承方式 基类名 {
    // 派生类的成员（属性+方法）
};

// 基类Person
class Person {
public:
    void publicFunc() { cout << "基类public成员函数" << endl; }
protected:
    string _protectedVar = "基类protected成员变量";
private:
    string _privateVar = "基类private成员变量";
};

// 公有继承
class PublicDerived : public Person {
public:
    void accessBaseMember() {
        publicFunc(); // 可访问基类public成员
        cout << _protectedVar << endl; // 可访问基类protected成员
        // cout << _privateVar << endl; // 编译报错：基类private成员不可见
    }
};

// 保护继承
class ProtectedDerived : protected Person {
public:
    void accessBaseMember() {
        publicFunc(); // 基类public成员变为protected，类内可访问
        cout << _protectedVar << endl; // 基类protected成员仍为protected，类内可访问
        // cout << _privateVar << endl; // 编译报错
    }
};

// 私有继承
class PrivateDerived : private Person {
public:
    void accessBaseMember() {
        publicFunc(); // 基类public成员变为private，类内可访问
        cout << _protectedVar << endl; // 基类protected成员变为private，类内可访问
        // cout << _privateVar << endl; // 编译报错
    }
};

int main() {
    PublicDerived pd;
    pd.publicFunc(); // 可访问（基类public成员继承后仍为public）
    // pd._protectedVar; // 编译报错：protected成员类外不可访问
    
    ProtectedDerived pd2;
    // pd2.publicFunc(); // 编译报错：基类public成员经protected继承后变为protected，类外不可访问
    
    PrivateDerived pd3;
    // pd3.publicFunc(); // 编译报错：基类public成员经private继承后变为private，类外不可访问
    
    return 0;
}

class Person {
protected:
    string _name; // 姓名
    string _sex;  // 性别
    int _age;     // 年龄
};

class Student : public Person {
public:
    int _stuNo; // 学号（特有成员）
};

int main() {
    Student sobj; // 派生类对象
    
    // 1. 派生类对象赋值给基类指针
    Person* pPtr = &sobj; 
    // pPtr->_stuNo; // 编译报错：基类指针无法访问派生类特有成员
    
    // 2. 派生类对象赋值给基类引用
    Person& pRef = sobj;
    // pRef->_stuNo; // 编译报错：基类引用无法访问派生类特有成员
    
    // 3. 派生类对象赋值给基类对象（调用基类拷贝构造）
    Person pObj = sobj;
    
    // 4. 基类对象赋值给派生类对象：编译报错
    // sobj = pObj; 
    
    return 0;
}

class Person {
public:
    virtual ~Person() {} // 多态类型标志
};

class Student : public Person {
public:
    int _stuNo;
};

int main() {
    Person* pPtr = new Student(); // 基类指针指向派生类对象
    
    // 安全转换：使用dynamic_cast
    Student* sPtr = dynamic_cast<Student*>(pPtr);
    if (sPtr != nullptr) {
        sPtr->_stuNo = 1001; // 安全访问派生类特有成员
    }
    
    delete pPtr;
    return 0;
}

class Person {
protected:
    string _name = "小李子";
    int _num = 111; // 基类成员：身份证号
};

class Student : public Person {
public:
    void Print() {
        cout << "姓名：" << _name << endl;
        cout << "身份证号：" << Person::_num << endl; // 显式访问基类同名成员
        cout << "学号：" << _num << endl; // 访问派生类同名成员
    }
protected:
    int _num = 999; // 派生类成员：学号（隐藏基类的_num）
};

int main() {
    Student s;
    s.Print();
    // 输出结果：
    // 姓名：小李子
    // 身份证号：111
    // 学号：999
    return 0;
}

class A {
public:
    void func() {
        cout << "A::func()" << endl;
    }
};

class B : public A {
public:
    // 函数名相同，参数列表不同，构成隐藏（非重载）
    void func(int i) {
        cout << "B::func(int i)：" << i << endl;
    }
};

int main() {
    B b;
    b.func(10); // 调用派生类函数：B::func(int i)
    // b.func(); // 编译报错：基类func被隐藏，需显式指定作用域
    b.A::func(); // 显式调用基类函数：A::func()
    
    return 0;
}

class A {
public:
    void func() { cout << "A::func()" << endl; }
};

class B : public A {
public:
    void func(int i) { cout << "B::func(int i)：" << i << endl; }
};

int main() {
    B b;
    b.func(10); // 正常运行：输出B::func(int i)：10
    b.func();   // 编译报错：基类func被隐藏
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    // 基类构造函数
    Person(const char* name = "peter") : _name(name) {
        cout << "Person(const char* name)" << 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; // 姓名
};

class Student : public Person {
public:
    // 派生类构造函数：初始化列表中显式调用基类构造函数
    Student(const char* name, int num) : Person(name), _num(num) {
        cout << "Student(const char* name, int num)" << endl;
    }

    // 派生类拷贝构造函数：初始化列表中显式调用基类拷贝构造
    Student(const Student& s) : Person(s), _num(s._num) {
        cout << "Student(const Student& s)" << endl;
    }

    // 派生类赋值运算符重载：显式调用基类赋值运算符
    Student& operator=(const Student& s) {
        cout << "Student& operator=(const Student& s)" << endl;
        if (this != &s) {
            Person::operator=(s); // 显式调用基类赋值运算符（避免隐藏）
            _num = s._num;
        }
        return *this;
    }

    // 派生类析构函数：编译器自动调用基类析构
    ~Student() {
        cout << "~Student()" << endl;
    }

protected:
    int _num; // 学号
};

int main() {
    // 测试构造与析构顺序
    Student s1("jack", 1001);
    // 输出：
    // Person(const char* name)
    // Student(const char* name, int num)

    // 测试拷贝构造
    Student s2(s1);
    // 输出：
    // Person(const Person& p)
    // Student(const Student& s)

    // 测试赋值运算符
    Student s3("rose", 1002);
    s1 = s3;
    // 输出：
    // Student& operator=(const Student& s)
    // Person& operator=(const Person& p)

    // 测试析构顺序（先派生后基类）
    // 输出：
    // ~Student()
    // ~Person()
    // ~Student()
    // ~Person()
    // ~Student()
    // ~Person()

    return 0;
}

class NonInheritable {
private:
    // 私有化构造函数
    NonInheritable() {}
};

// class Derived : public NonInheritable {}; // 编译报错：无法访问基类构造函数

class NonInheritable final { // final修饰，禁止继承
public:
    void func() { cout << "不能被继承的类" << endl; }
};

// class Derived : public NonInheritable {}; // 编译报错：无法继承final类

class Student; // 前向声明

class Person {
public:
    // 声明Display为Person的友元
    friend void Display(const Person& p, const Student& s);
protected:
    string _name = "张三"; // Person的保护成员
};

class Student : public Person {
protected:
    int _stuNum = 1001; // Student的保护成员
};

// Display是Person的友元，但不是Student的友元
void Display(const Person& p, const Student& s) {
    cout << p._name << endl; // 可访问Person的保护成员
    // cout << s._stuNum << endl; // 编译报错：无法访问Student的保护成员
}

// 解决方案：同时将Display声明为Student的友元
class Student {
    friend void Display(const Person& p, const Student& s);
    // ...
};

class Person {
public:
    static int _count; // 静态成员：计数（统计继承体系中对象总数）
protected:
    string _name;
};

// 静态成员类外初始化
int Person::_count = 0;

class Student : public Person {
protected:
    int _stuNum;
};

class Teacher : public Person {
protected:
    int _teaId;
};

int main() {
    Person p;
    Student s;
    Teacher t;

    // 所有对象共享同一个_count
    p._count++;
    s._count++;
    t._count++;

    cout << Person::_count << endl; // 输出3
    cout << Student::_count << endl; // 输出3
    cout << Teacher::_count << endl; // 输出3

    // 验证静态成员地址相同（共享一份）
    cout << &Person::_count << endl;
    cout << &Student::_count << endl;
    cout << &Teacher::_count << endl; // 三个地址完全一致

    return 0;
}

class Person {
public:
    string _name; // 姓名
};

class Student : public Person {
protected:
    int _stuNum; // 学号
};

class Teacher : public Person {
protected:
    int _teaId; // 教师编号
};

// 菱形继承：Assistant继承Student和Teacher
class Assistant : public Student, public Teacher {
protected:
    string _major; // 主修课程
};

int main() {
    Assistant a;
    // a._name = "peter"; // 编译报错：访问不明确（二义性）

    // 显式指定作用域解决二义性，但无法解决数据冗余
    a.Student::_name = "张三";
    a.Teacher::_name = "李四";

    return 0;
}

class 直接基类 : virtual 继承方式 间接基类 {
    // 成员定义
};

class Person {
public:
    string _name; // 姓名
};

// 虚继承：Student虚继承Person
class Student : virtual public Person {
protected:
    int _stuNum; // 学号
};

// 虚继承：Teacher虚继承Person
class Teacher : virtual public Person {
protected:
    int _teaId; // 教师编号
};

// 菱形继承：Assistant继承Student和Teacher
class Assistant : public Student, public Teacher {
protected:
    string _major; // 主修课程
};

int main() {
    Assistant a;
    a._name = "peter"; // 正常访问，无二义性（仅一份_name）

    return 0;
}

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };

int main() {
    Derive d;
    Base1* p1 = &d; // 指向派生类中Base1部分的起始地址
    Base2* p2 = &d; // 指向派生类中Base2部分的起始地址
    Derive* p3 = &d; // 指向派生类对象的起始地址

    cout << "p1: " << p1 << endl;
    cout << "p2: " << p2 << endl;
    cout << "p3: " << p3 << endl;

    // 输出结果：p1 == p3 != p2（Base2部分在内存中位于Base1之后）
    return 0;
}

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits> {
    // 输入流相关实现
};

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits> {
    // 输出流相关实现
};

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_iostream : public basic_istream<CharT, Traits>, 
                       public basic_ostream<CharT, Traits> {
    // 输入输出流相关实现
};

// 轮胎类
class Tire {
protected:
    string _brand = "米其林"; // 品牌
    int _size = 17; // 尺寸
};

// 汽车类：组合轮胎类
class Car {
protected:
    string _color = "白色"; // 颜色
    string _license = "陕AB1234"; // 车牌号
    Tire _t1, _t2, _t3, _t4; // 组合4个轮胎对象
};

// 宝马车：继承Car（is-a关系）
class BMW : public Car {
public:
    void Drive() { cout << "宝马：操控精准" << endl; }
};

class Car {
public:
    virtual void Drive() { cout << "汽车：可以行驶" << endl; }
};

class BMW : public Car {
public:
    void Drive() override { cout << "宝马：操控精准" << endl; }
};

class Benz : public Car {
public:
    void Drive() override { cout << "奔驰：乘坐舒适" << endl; }
};

// 组合实现（推荐）
template<class T>
class Stack {
public:
    void push(const T& x) { _v.push_back(x); }
    void pop() { _v.pop_back(); }
    const T& top() { return _v.back(); }
private:
    vector<T> _v; // 组合vector，隐藏其内部细节
};

// 继承实现（不推荐）
template<class T>
class Stack : public vector<T> {
public:
    void push(const T& x) { this->push_back(x); }
    void pop() { this->pop_back(); }
    const T& top() { return this->back(); }
};