0
点赞
收藏
分享

微信扫一扫

C++之继承详解（万字长文！）

ITWYY 2023-03-29 阅读 103
派生类父类复用C/C++后端开发
加载失败

继承

继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

以前我们写函数的时候，可以使用一个函数去实现另一个函数，这就是函数层面的复用

而继承就是一种类层面的复用！——像是我们设置一个管理系统——管理系统里面就有很多的角色，每个角色都有各自的基本信息

image-20230303090315864

但是我们发现里面其实==每个类==都有很多重复的信息！每个类都要进行修改，写各自的构造

这样子太麻烦了！

所以我们可以把这些共有的信息都抽离出来写成一个新的类用来复用，然后其他的特有的信息就各自写在各自的类里面

image-20230303091513049

==那么我们如何复用这个类呢？==——这时候就得使用继承了！所以==继承就是类设计定义层次的复用==

#include<iostream>
#include <string>
using namespace std;
class Person
{
public:
	Person(string name = 小明, int age = 18, string address = 北京)
		:_name(name),
		_age(age),
		_address(address)
	{
	}
	void print()
	{
		cout << _name: << _name << endl;
		cout << _age << _age << endl;
		cout << _address: << _address<< endl;

	}
protected:
	string _name;
	int _age;
	string _address;
};
class Student :public Person
{
protected:
	int _stuid;
};

class teacher :public Person
{
protected:
	int _jobid;
};
int main()
{
	teacher t;
	Student s;
	t.print();
	s.print();

	return 0;
}

image-20230303094249835

==我们没有在teacher/student类里面定义print函数，但是我们依旧可以使用！==

==继承不仅仅是继承成员，而且也继承函数！==

继承格式

image-20230303095314709

==也可以叫父类与子类==

继承关系与访问限定符

image-20230303100052954

==这就衍生出了9中关系==

继承基类成员的访问关系的变化

类成员/继承方式 public继承 protected继承 private继承
基类的public成员 派生类的public成员 派生类的protected成员 派生类的private成员
基类的protected成员 派生类的protected成员 派生类的protected成员 派生类的private成员
基类的private成员 派生类中不可见 派生类中不可见 派生类中不可见

基类private成员在派生类中无论以什么方式继承都是不可见的——即不可以使用但是本身却依旧存在于派生类中

#include<iostream>
using namespace std;
class Person
{
public:
	Person(string name = 小明, int age = 18, string address = 北京)
		:_name(name),
		_age(age),
		_address(address)
	{
	}
	void print()
	{
		cout << _name: << _name << endl;
		cout << _age << _age << endl;
		cout << _address: << _address<< endl;

	}
protected:
	string _name;
	string _address;
private:
	int _age;//我们将这个改成私有
};
class Student :public Person
{
protected:
	int _stuid;
};
class teacher :public Person
{
protected:
	int _jobid;
};
int main()
{
	teacher t;
	Student s;
	t.print();
	s.print();
	return 0;
}

image-20230303102059883

==我们发现依旧可以访问这是为什么呢？==——记住私有是不允许==在派生类里面==去继承使用！但是在==父类里面的函数任然是可以调用==的！我们调用的函数是存在于父类里面的！

class Student :public Person
{
public:
    void stu_print()
    {
        cout << _age << _age << endl;
    }
protected:
	int _stuid;
};

==如果我们在子类的函数中使用！那就是无法访问！但是_age依旧是在派生类里面的！==

image-20230303102413066

继承方式也可以不用写！——struct默认共有，class默认私有——但是最好还是显示的写出来！

class Student :Person//默认私有
{
protected:
	int _stuid;
};

struct teacher:Person//
{
protected:
	int _jobid;
};
int main()
{
	teacher t;
	Student s;
    t.print();
    s.print();
	return 0;
}

image-20230303104351998

==print在父类是共有的函数！在私有继承后就变成了private！所以无法外部访问！，但是共有继承后任然是共有所以可以外部使用！==

总结

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它 ——==基类中的私有本质就是不想让子类继承！但是仍然存在于派生类里面但是无法使用==
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出==保护成员限定符是因继承才出现的==。
  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected> private ——==可以认为是一种权限的缩小，权限不能放大但是可以缩小==
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强
  6. 一般父类里面的通常很少使用私有成员！因为设计出来但却不让使用的情况太少了！一般都是保护！

基类域派生类的对象赋值转换——也叫向上转换

  • 派生类对象是可以赋值给基类的对象/基类的指针/基类的引用——又被叫做切片或者切割意思就是将派生类中父类的那一部分赋值过去！——==而且之间是不发生类型转换的！==
  • 基类对象不能赋值给派生类对象！——因为派生类对象一般是比基类对象的大小更大！
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

image-20230303110906375

int main()
{
	Person p;
	Student s;

	p = s;
	//中间不存在类型转换——意味着不存在临时变量！

	int i = 0;
	double d = 2.2;
	i = d;

	return 0;
}

image-20230303140233729

==这样也就意味着==

int main()
{
	Person p;
	Student s;
    Person//这是可以的！

	int i = 0;
	double d = 2.2;
    int//这是不可以的！
    //const int& ri = d //这样就行！
	return 0;
}

==将double类型的变量赋给int类型的引用发生隐式类型转换，会产生一个临时变量！而临时变量是一个常量！发生了权限的放大所以会赋值失败！==

==但是派生类变量赋值给基类的引用则不会！因为它是直接切割过去！没有发生隐式类型转换！==

image-20230303141041813

==可以简单的认为派生类是一个特殊的基类！==——因为基类里面所含有的派生类都有！

image-20230303141420765

==这个就变成了派生类中基类那一部分的别名！可以将这一部分看做是基类使用！==

image-20230303142104854

还可以赋值给基类的指针

int main()
{
	Person p;
	Student s;

	Person* ptrp = 
	ptrp->_age = 100;

	return 0;
}

image-20230303142340700

image-20230303142519498

==被基类指针指向的派生类变量可以将其当初一个父类的变量使用！==

==这也叫向上转换！是天然可以的！==

继承中的作用域

  1. 在继承的体系中基类和派生类都有独立的作用域
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 **基类::基类成员 **显示访问 )
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。

派生类的默认成员函数

基类的成员函数和以往的正常的成员函数是一样的！

但是派生类的默认成员函数相比正常的默认成员函数更加的复杂！

class Person
{
public:
	Person(const string& name = peter)//构造
		:_name(name)
	{
		cout << Person() << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << Person（const Person << endl;
	}
	Person& operator=(const Person& p)//赋值重载
	{
		cout <<  operator= << endl;
		if(this != &p)
		_name = p._name;
	}
	~Person()//析构
	{
		cout << ~Person << endl;
	}
protected:
	string _name;
};
//派生类
class student :public Person
{
public:
	student(int id = 0)//构造
		:_id(id)
	{
		cout << student(int id) << endl;
	}
	student(const student& s)//拷贝构造
		:_id(s._id)
	{
		cout << student(const student << endl;
	}
	student& operator=(const student& s)//赋值重载
	{
		_id = s._id;
	}
	~student()//析构
	{
		cout << ~student() << endl;
	}
protected:
	int _id;
};

构造函数

class Person
{
public:
	Person(const string& name = peter)//构造
		:_name(name)
	{
		cout << Person() << endl;
	}
protected:
	string _name;
};
class student :public Person
{
public:
	student(int id = 0)//构造
		:_id(id)
	{
		cout << student(int id) << endl;
	}
protected:
	int _id;
};
int main()
{
    student s1;
}

image-20230303154127003

==我们可以发现是s1不仅调用了自己的构造函数，而且还去调用的基类的构造函数==

为什么呢？因为派生类的成员可以分为两个部分一份是基类的，一份是派生类自己的——==而基类的成员是通过调用基类的构造函数来进行初始化的！剩下的派生类的成员才是使用派生类自己的构造函数进行初始化！==

假如基类没有默认构造那么我们是不是就应该在派生类里面的去初始化呢？

class Person
{
public:
	Person(const string& name)//构造
		:_name(name)
	{
		cout << Person() << endl;
	}
protected:
	string _name;
};
class student :public Person
{
public:
	student(int id,const string& name)//构造
		:_id(id),
		_name(name)

	{
		cout << student(int id) << endl;
	}
protected:
	int _id;
};
int main()
{
	student s1(1,peter);
}

image-20230303155017821

==这样子是不行的！基类的成员就必须使用基类的构造函数进行初始！==

==所以必须显示的去调用基类的构造函数！==

class student :public Person
{
public:
	student(int id,const string& name)//构造
		:_id(id),
    	Person(name)//显示的调用构造函数
	{
		cout << student(int id) << endl;
	}
protected:
	int _id;
};
int main()
{
	student s1(1,peter);
}

image-20230303155324898

拷贝构造

class Person
{
public:
	Person(const string& name = peter)//构造
		:_name(name)
	{
		cout << Person() << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << Person（const Person << endl;
	}
protected:
	string _name;
};
//派生类
class student :public Person
{
public:
	student(int id,const string name)//构造
		:_id(id),
		Person(name)
	{
		cout << student(int id) << endl;
	}
	student(const student& s)//拷贝构造
		:_id(s._id),
		Person(s)
	{
		cout << student(const student << endl;
	}
protected:
	int _id;
};
int main()
{
	student s1(1, 小明);
	student s2(s1);
	return 0;
}

当我们==不写拷贝构造==的时候

image-20230303160313388

==生成的默认拷贝构造，父类的那一部分会自动的去调用基类的拷贝构造！剩下的部分都是进行按字节拷贝！==

如何我们显示的去写了拷贝构造我们就要==去显示的调用基类的拷贝构造==！不能去自己去处理！

image-20230303160947884

==如果不去显示的调用的话，只会处理派生类自己的成员变量！==

student(const student& s)//拷贝构造
	:_id(s._id),
	Person(s)//发生了切割
{
	cout << student(const student << endl;
}

我们发现了 Person的拷贝构造类型是==Person&==但是传过去的s类型是 ==studen&== 此时就发生了切割！

赋值重载

class Person
{
public:
	Person(const string& name = peter)//构造
		:_name(name)
	{
		cout << Person() << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << Person（const Person << endl;
	}
	Person& operator=(const Person& p)//赋值重载
	{
		cout << Person::operator= << endl;
		if(this != &p)
		_name = p._name;
        return *this;
	}
protected:
	string _name;
};
//派生类
class student :public Person
{
public:
	student(int id, const string name)//构造
		:_id(id),
		Person(name)
	{
		cout << student(int id) << endl;
	}
	student(const student& s)//拷贝构造
		:_id(s._id),
		Person(s)
	{
		cout << student(const student << endl;
	}
	student& operator=(const student& s)//赋值重载
	{
		Person::operator=(s);//这里同样的发生切割
        	cout << student:operator=() <<endl;
        	if(this != &p)
			_id = s._id;
     		return *this;
	}
protected:
	int _id;
};
int main()
{
	student s1(1, 小明);
	student s2(s1);
	return 0;
}

和拷贝构造一样如果不写赋值运算符重载，编译器生成的就会去自动的调用基类的赋值运算符去给基类的那一部分赋值！剩下的派生类的那一部分就按字节拷贝

image-20230303162302763

如果我们显式的写了这个赋值运算符重载我们同样的要去进行显示的调用

image-20230303162436329

student& operator=(const student& s)//赋值重载
{
    //operator=(s);//不可以怎么写因为同名函数发生了隐藏！我们怎么调用是在调用这个函数本身！会发生无限递归！
    //要使用作用域指定！
    Person::operator=(s);//这里同样的发生切割
    cout << student:operator=() <<endl;
    if(this != &p)
	   _id = s._id;
    return *this;
}

析构函数

class Person
{
public:
	Person(const string& name = peter)//构造
		:_name(name)
	{
		cout << Person() << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << Person（const Person << endl;
	}
	Person& operator=(const Person& p)//赋值重载
	{
		cout << Person::operator= << endl;
		if(this != &p)
		_name = p._name;
     return *this;
	}
    ~Person()
	{
		cout << ~Person() << endl;
	}
protected:
	string _name;
};
//派生类
class student :public Person
{
public:
	student(int id, const string name)//构造
		:_id(id),
		Person(name)
	{
		cout << student(int id) << endl;
	}
	student(const student& s)//拷贝构造
		:_id(s._id),
		Person(s)
	{
		cout << student(const student << endl;
	}
	student& operator=(const student& s)//赋值重载
	{
		Person::operator=(s);//这里同样的发生切割
     cout << student:operator=() <<endl;
     if(this != &p)
		_id = s._id;
  return *this;
	}
    ~student()
	{
        //~Person();//这样写是错误的！
        //Person::~Person();
		cout << ~student() << endl;
	}
protected:
	int _id;
};
int main()
{
	student s1(1, 小明);
	student s2(s1);
	return 0;
}

按照上面的经验我们调用派生类的析构去处理派生类的部分，显示的调用基类的析构去处理基类的部分！——但是这样写其实是错误的！

image-20230303212652051 ==为什么？因为子类的析构函数和父类的析构函数默认构成隐藏关系！==（由于多态关系的需求，所有的析构函数都会被特殊处理变成destructor的函数名！所以构成隐藏关系） 想要调动Person的析构函数必须使用作用域 image-20230303213054629 ==我们发现调了两次Person的析构函数！==——调用了两次就会出现多次释放！ 这是为什么？因为我们自己写的时候，基类的析构函数会自己去调用而不用我们显示的去调用！——==在派生类的析构函数调用完毕后就去自动调用基类的析构函数！==

image-20230303213836240

image-20230303214717767

==从汇编我们也可以看出来！最后编译器自己去调用了一次Person的析构函数！==

那为什么是这样子的呢？

class A
{
private:
    int _num;
}
int main()
{
    A a;
    A aa;
}

==上面的代码我们可以知道a先构造然后aa再构造！aa先析构 a再析构！==

==而类也是一样的！类分为两部分 基类的部分先构造，派生类的部分后构造！派生类的部分先析构！基类的部分后析构==

image-20230303215427883

因为如果我们去显示的调用析构的话就无法保持这个顺序了！所以就不让我们去显示的调用，让编译器在派生类析构结束后自己去调用！

总结

  1. ==派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员==。如果基类没有默认 的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能 保证派生类对象先清理派生类成员再清理基类成员的顺序
  5. 派生类对象初始化先调用基类构造再调派生类构造
  6. 派生类对象析构清理先调用派生类析构再调基类的析构
  7. 因为多态场景析构函数需要构成重写，重写的条件之一是函数名相同那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

继承与友元

==友元关系不能继承==，也就是说==基类友元不能访问子类私有和保护成元==

class B;
class A
{
	friend void test(A a,B b);
private:
	int _num = 10;
};
class B :public A
{
private:
	int _id = 100;
};

void test(A a,B b)
{
	cout << i am A's friend! << endl;
	cout << a._num <<endl;
	//cout << b._id << endl;//是不能访问子类的私有成员！
    cout << b._num <<endl;// _num 是属于父类的！所以可以访问！
}
int main()
{
	test(A(), B());
	return 0;
}

image-20230303221338473

==想要使用子了的成员函数就要将函数也变成子类的友元！==

继承与静态成员

class Person
{
public:
	Person()
	{
		_count++;
	}
    void fun()
	{
		cout << this << endl;
	}
	string _name;
public:
	static int _count;
};
int Person::_count = 0;

class Student :public Person
{
protected:
	int _id;
};
int Studen::_count = 0;//也可以这样初始化但是没有必要,最好还是父类初始化！
int main()
{
	Person p;
	Student s;	
    p._name = 小明;
	s._name = 小红;   
    cout << &p._count << endl;
	cout << &s._count << endl;
    
	Person* ptr = nullptr;
	//这是可行的！因为静态成员不在对象里面！其实没有发生解引用
	cout << ptr->_count << endl;
	//这也是可行的！因为函数也不再对象里面！其实没有发生解引用
	ptr->fun();
	//这是不行的！因为_name是在对象里面发生了解引用
	ptr->_name;
    
    (*ptr)._count;
	(*ptr).fun();
    //这两个也都不会报错！因为这个和上面的-> 等价的！-> 与* 不一定会发生解引用！
	return 0;
}

像是上面的p与s，里面都有一个_name 但是不是同一份的 _name 但是，子类与父类都自己的对象模型！

image-20230313171104109 image-20230313171255646

但是==静态成员变量不一样！==

image-20230313171622183

我们可以发现两个对象的_count地址一样的！

为什么呢？——因为存储的区域是不一样的！普通成员变量都是存在对象里面的！

但是==静态成员是存储在静态区（全局区）里面的！==

静态成员变量是==属于整个类的所有对象！同时也属于所有的派生类及其对象！==

下面的代码我们也可以看出来静态成员变量与函数都是不存在与对象里面的！

image-20230313173009748

class Person
{
public:
	void fun()
	{
		cout << this << endl;
	    cout << _name <<endl;//在nullptr里面这个会报错！因为发生了解引用在类里面的调用成员变量本质就是this -> _name
	    cout << _count <<endl;//这个不会报错！
	}
}
	ptr->_count;
	ptr->fun();
    //都是两两等价的！
    (*ptr)._count;
	(*ptr).fun();

image-20230313173841601

从汇编上我们也可以看出来并没有什么差别！都不会去解引用去对象里面找，都是在代码段里面找这个函数的地址然后call，这个 -> 的作用仅仅只是用来传递this指针（一般通过压栈来进行传递）——主要看要不要到对象里面找东西！

多继承

单继承: 一个子类只有一个==直接父类==的时候！就叫做单继承——如下

image-20230314155332237

多继承: 一个子类有两个或者以上的==直接父类==时称这个关系为多继承！

image-20230314155527670

菱形继承的问题

我们可以看一下菱形继承后的类的结构

image-20230314160545748

发现我们Person类在assistant类里面是有两份的！出现了==数据冗余和二义性！==

class Person
{
public:
	int _id;
};

class Student :public Person
{
protected:
	int _num;
};
class Teacher :public Person
{
protected:
	int _jobid;
};

class assistant :public Student, public Teacher
{
public:
	string _major;
};
int main()
{
	assistant a;
	//a._id;//出现了二义性！
    a.Student::_id;//可以通过指定作用域的防止二义性！
	a.Teacher::_id;
	return 0;
}

访问对象不明确:

image-20230314162120714

通过作用域里解决二义性：

image-20230314162716849

==但是这个方式依旧无法解决数据冗余的问题！==

所以应该要怎么解决？——虚继承！

虚继承

C++引入的==关键字virtual==来实现虚继承！

image-20230314162955033

==谁引发了数据冗余就谁进行虚继承！==

class Person
{
public:
	int _id;
};

class Student :virtual public Person//要在腰部进行虚继承！
{
public:
	int _num;
};
class Teacher :virtual public Person
{
protected:
	int _jobid;
};

class assistant :public Student, public Teacher
{
public:
	string _major;
};
int main()
{
	assistant a;
	a._id = 100;//二义性问题得到了解决！
     a.Student::_id;//仍然可以这样访问！
	a.Teacher::_id;
	return 0;
}

image-20230314163509315

==vs此时的监视窗口其实已经不准确了！因为虽然看上去有三个_id但是其实此时类里面只有一个 _id存在！==

虚继承是如何实现

class A
{
public:
	int _a;
};

class B :virtual public A
{
public:
	int _b;
};
class C :virtual public A 
{
public:
	int _c;
};

class D :public B, public C 
{
public:
	int _d;
};
int main()
{
	D d;
	d._b = 1;
	d._c = 2;
	d._d = 3;
	d.B::_a = 4;
	d.C::_a = 5;
	d._a = 6;//虚拟继承情况下

 //虚继承下对象的模型也会发生改变！
 B b;
	b._a = 1;
	b._b=2;

	B* ptr = 
	ptr->_a = 10;

	ptr = 
	ptr->_a = 20;

	return 0;
}

此时因为vs的监视窗口已经不准确了！所以我们要通过内存窗口看这个真实的对象模型！

==在不在virtual的菱形继承的情况下==——其内存结构是十分简单的！

<img src="https://s2.loli.net/2023/03/14/LQFuMHNOi84h6pG.png" alt="image-20230314170925762" style="zoom:150%;" />

这是菱形虚拟继承后的对象模型

image-20230314172820762

==我们可以看到原来的B,C的_a的位置的值变成了两个奇怪的数值，然后A类被放在了最下面！==

image-20230314174159307

image-20230314174924738

虚继承下的类型B的对象的模型

image-20230317142928349

我么发现对象b在虚继承后向量_a也是保存在最下面

同时也保存了一个地址！那个地址里面也存着一个偏移量！

我们可以发现ptr既可以指向切片也可以指向一个正常的对象！==但是虚基类对象在一般对象里面和切片里的位置其实都是不一样的！==正常的类对象是在最下面没有错，但是如果是一个切片就不清楚位置在哪里了！可能是在指针能看到的空间的最下面，也可能隔了好几个位置！

所以有了这个偏移量，就可以无论是切片还是正常的情况，==都是使用这个偏移量去找虚基类对象就没有问题了！==

==这个存偏移量的空间我们称之为虚基表（和虚表要区分）！那个指向虚基表的指针就是虚基表指针！==

image-20230317152101222

==因为多了一步用偏移量找，所以虚继承会导致一定的性能损失！==

image-20230317153009978

==从汇编我们可以看到访问a比访问b更加的复杂==

上面的看上去虚继承后，比起原先占用的内存空间似乎更大了？这是为什么，虚继承不是为了解决内存冗余吗？——==其实是因为我们的虚基类太小了！才4个字节，导致了看上去更加的浪费了！当有一个很大的虚基类对象的时候，例如100 字节，那么如果不是虚继承就多浪费了100字节，但是如果是虚继承，我们就可以在B，C类里面存一个指针来指向同一个虚基类对象！用8个字节的消耗节省了92字节，但是那么节省空间的效果就显示出来了！==

继承和组合

  • public 继承是一个is-a的关系——==也就是说每一个派生类对象都是一个基类对象！==
  • 组合是一种has-a——例如B组合了A，==就是说每一个B对象都有一个对象A==
//继承
class X
{
	int _x;
};
class Y :public X
{
	int _y;
};
//组合
class M
{
	int _m;
};
class N
{
	M _m;
	int _n;
};

继承和组合都是完成了复用，但是继承相比访问有更大的权限！

组合只能使用public成员，但是继承可以访问public成员和protected成员！

所以继承又被叫做——白箱复用！

举报

相关推荐

C++ 继承和派生 万字长文超详解

c++qt学习windeployqtQTranslator

C++之多态详解（万字长文详解）

虚函数多态子类C/C++后端开发yyds干货盘点

linux之基础IO（万字长文详解）

#include#define系统调用C/C++后端开发yyds干货盘点

linux之线程互斥（万字长文详解）

互斥锁线程C/C++后端开发yyds干货盘点

linux之线程同步（万字长文详解）

数据互斥条件变量C/C++后端开发yyds干货盘点

HTTP协议详解（2万字长文详解）

#includeServer服务器C/C++后端开发yyds干货盘点

linux之进程控制（万字长文详解）

#include子进程父进程C/C++后端开发yyds干货盘点

HTTP协议详解(2万字长文详解)

#includeServer服务器C/C++后端开发yyds干货盘点

C++11之智能指针(万字长文详解)

智能指针释放资源抛出异常C/C++后端开发yyds干货盘点

IO多路转接之select（万字长文详解）

文件描述符#include位图C/C++后端开发yyds干货盘点
0 条评论
加载失败