一文彻底读懂C++的继承机制

class student
{
public:
	void study()
	{
		//学习
	}
	void identity()
	{
		//身份认证
	}
private:
	string _name;      //姓名
	string _address;   //地址
	string _tel;       //电话
	int _age;          //年龄

	int _stuid;        //学号
};

class teacher
{
public:
	void teach()
	{
		//教授
	}
	void identity()
	{
		//身份认证
	}
private:
	string _name;      //姓名
	string _address;   //地址
	string _tel;       //电话
	int _age;          //年龄

	int _title;        //职工号
};

#include<string.h>
class person
{
public:
	void identity()
	{
		//身份认证
	}
	string _name;      //姓名
	string _address;   //地址
	string _tel;       //电话
	int _age;          //年龄
};

class student:public person  //stuedent继承person类
{
public:
	void study()
	{
		//学习
	}
private:
	int _stuid;     //学号
};

class teacher:public person  //teacher继承person类
{
public:
	void teach()
	{
		//教授
	}
private:
	int _title;   //职工号
};

// 定义一个类模板
template <typename t>
class container {
protected:
    t data;
public:
    container(t val) : data(val) {}
    t get() const { return data; }
    void set(t val) { data = val; }
};

// 普通类继承实例化的类模板
class intcontainer : public container<int> {
public:
    intcontainer(int val) : container<int>(val) {}
    
    // 新增方法
    void increment() { data++; }
};

#include <iostream>

// 基类模板
template <typename t>
class base {
protected:
    t value;
public:
    base(t v) : value(v) {}
    void print() const {
        std::cout << "base value: " << value << std::endl;
    }
};

// 派生类模板继承基类模板
template <typename t, typename u>
class derived : public base<t> {
private:
    u extra;
public:
    // 注意初始化列表中需要显式指定基类模板
    derived(t v, u e) : base<t>(v), extra(e) {}
    
    void show() const {
        // 访问基类成员时，可能需要使用this指针或base<t>::限定
        std::cout << "derived value: " << this->value 
                  << ", extra: " << extra << std::endl;
    }
};

int main() {
    derived<int, std::string> obj(42, "example");
    obj.print();  // 调用基类方法
    obj.show();   // 调用派生类方法
    
    return 0;
}

template <typename t>
class derived : public base<double> {  // 固定使用double类型
    // ...
};

class base {
public:
    virtual void func() { cout << "base::func()" << endl; }
};
class derived : public base {
public:
    void func() override { cout << "derived::func()" << endl; }
    void derivedfunc() { cout << "derived独有的函数" << endl; }
};

int main() {
    derived d;
    base* ptr = &d; // 基类指针指向派生类对象
    ptr->func();    // 调用derived::func()（动态绑定）
    // ptr->derivedfunc(); // 错误：不能直接访问派生类新增成员
    return 0;
}

int main() {
    derived d;
    base& ref = d; // 基类引用绑定派生类对象
    ref.func();    // 调用derived::func()（动态绑定）
    return 0;
}

int main() {
    derived d;
    base baseobj = d; // 对象切片：仅复制基类部分
    baseobj.func();   // 调用base::func()（无动态绑定）
    return 0;
}

class person
{
protected:
	int _num = 111;
	string _name = "⼩李⼦"; 
};
class student : public person
{
public:
	void print()
	{
		cout <<_num<<endl;//这里打印结果为999因为person中的_num被隐藏了
	}
protected:
	int _num = 999; 
};
int main()
{
	student s1;
	s1.print();
	return 0;
};

class person
{
public:
	void print()
	{
		cout << "我是基类中的print函数" << endl;
	}
};
class student : public person
{
public:
	void print()
	{
		cout <<"我是派生类中的print函数" << endl;
	}
};
int main()
{
	student s1;
	s1.print();
	return 0;
};

int main()
{
	student s1;
	s1.person::print();
	return 0;
};

class a
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class b : public a
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << i << endl;
	}
};
int main()
{
	b b;
	b.fun(10);
	return 0;
};

class a
{
public:
	//这里基类没有默认构造函数需要传递参数
	a(string _name)
	{
		name = _name;
	}

	string name;
};
class b : public a
{
public:
	//派生类中需要显式调用基类构造函数初始化基类的成员变量
	b(int _n1,string _name)
		:a(_name)
		,n1(_n1)
	{}
	void print()
	{
		cout << name << n1 << std::endl;
	}
private:
	int n1;
};
int main()
{
	b ss(18,"张三");
	ss.print();
	return 0;
};

class a
{
public:
	//这里基类没有默认构造函数需要传递参数
	a(string _name)
	{
		name = _name;
	}

	a(const a& _a)
	{
		name = _a.name;
	}
	string name;
};
class b : public a
{
public:
	b(int _n1,string _name)
		:a(_name)
		,n1(_n1)
	{}
	b(const b& _b)
		:a(_b)//显式调用基类的拷贝构造完成构造初始化
		,n1(_b.n1)
	{}
	void print()
	{
		cout << name << n1 << std::endl;
	}
private:
	int n1;
};
int main()
{
	b ss(18,"张三");
	b pp(ss);
	pp.print();
	return 0;
};

class a
{
public:
	//这里基类没有默认构造函数需要传递参数
	a(string _name)
	{
		name = _name;
	}

	a& operator=(a& _a)
	{
		if (this != &_a)
		{
			name = _a.name;
		}
		return *this;
	}
	string name;
};
class b : public a
{
public:
	b(int _n1,string _name)
		:a(_name)
		,n1(_n1)
	{}
	b& operator=(b& _b)
	{
		if (this != &_b)
		{
            //这里不能是operator(_b)因为构成隐藏会递归调用b中的operator=导致栈溢出
			a::operator=(_b);
			n1 = _b.n1;
		}
		return *this;
	}
	void print()
	{
		cout << name << n1 << std::endl;
	}
private:
	int n1;
};
int main()
{
	b ss(18,"张三");
	b pp=ss;
	pp.print();
	return 0;
};

#include <iostream>
class base {
public:
    ~base() { std::cout << "base destructor" << std::endl; }
};

class derived : public base {
public:
    ~derived() { std::cout << "derived destructor" << std::endl; }
};

int main() {
    derived d;  // 销毁时先调用 ~derived()，再调用 ~base()
    return 0;
}
// 输出：
// derived destructor
// base destructor

class myclass {
private:
    int secret;
public:
    myclass(int s) : secret(s) {}
    // 声明友元函数
    friend void printsecret(myclass obj);
};

// 友元函数定义（无需加friend关键字）
void printsecret(myclass obj) {
    // 可以直接访问私有成员
    cout << "secret value: " << obj.secret << endl;
}

class a {
private:
    int value;
public:
    a(int v) : value(v) {}
    // 声明b为a的友元类
    friend class b;
};

class b {
public:
    void showa(a a) {
        // b的成员函数可以访问a的私有成员
        cout << "a's value: " << a.value << endl;
    }
};

class b; // 前向声明

class a {
public:
    void showb(b b);
};

class b {
private:
    int data;
public:
    b(int d) : data(d) {}
    // 仅将a的showb函数声明为友元
    friend void a::showb(b b);
};

// 实现a的showb函数
void a::showb(b b) {
    cout << "b's data: " << b.data << endl;
}

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;
}
int main()
{
	person p;
	student s;
	// 编译报错：error c2248 : “student::_stunum” :⽆法访问protected成员
    // 解决⽅案：display也变成student的友元即可
	display(p, s);
	return 0;
}

#include <iostream>
using namespace std;

class base {
public:
    static int public_static;  // 公有静态成员
protected:
    static int protected_static;  // 保护静态成员
private:
    static int private_static;  // 私有静态成员
};

// 初始化基类静态成员
int base::public_static = 0;
int base::protected_static = 0;
int base::private_static = 0;

class derived : public base {
public:
    void print() {
        // 访问基类的public静态成员
        cout << "public_static: " << public_static << endl;
        
        // 访问基类的protected静态成员（仅在派生类内部可访问）
        cout << "protected_static: " << protected_static << endl;
        
        // 错误：无法访问基类的private静态成员
        // cout << "private_static: " << private_static << endl;
    }
};

int main() {
    derived d;
    d.print();  // 正确：通过派生类对象调用，访问基类的public/protected静态成员
    
    // 直接访问基类的public静态成员（通过基类名或派生类名）
    cout << base::public_static << endl;    // 正确
    cout << derived::public_static << endl; // 正确（派生类共享基类的静态成员）
    
    return 0;
}

class 基类1 { ... };
class 基类2 { ... };

class 派生类 : 继承方式 基类1, 继承方式 基类2, ... {
    // 派生类成员
};

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;
	base2* p2 = &d;
	derive* p3 = &d;
	return 0;
}

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()
{
	// 编译报错：error c2385 :对“_name”的访问不明确
	assistant a;
	a._name = "peter";
	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
	a.student::_name = "xxx";
	a.teacher::_name = "yyy";
	return 0;
}

// 间接基类
class a {
public:
    int x;
};

// 虚继承自a
class b : virtual public a { };
class c : virtual public a { };

// 继承自b和c，此时a只会有一份副本
class d : public b, public c {
public:
    void func() {
        x = 10;  // 不会产生二义性，因为a只有一份
    }
};

// tire(轮胎)和car(⻋)更符合has - a的关系
class tire {
protected:
	// 品牌
	string _brand = "michelin";  
	// 尺⼨
	size_t _size = 17;
};
class car {
protected:
	string _colour = "⽩⾊";           
	string _num = "陕abit00";         
	tire _t1;
	tire _t2;
	tire _t3;
	tire _t4;
};


class bmw : public car {
public:
	void drive() 
	{
		cout << "好开操控" << endl; 
	}
};
// car和bmw / benz更符合is - a的关系
class benz : public car {
public:
	void drive()
	{
		cout << "好坐舒适" << endl; 
	}
};

template<class t>
class vector
{};
// stack和vector的关系，既符合is - a，也符合has - a
template<class t>
class stack : public vector<t>
{};
template<class t>
class stack
{
public:
	vector<t> _v;
};
int main()
{
	return 0;
}