【C++继承】继承的概念，不可见，切片，派生类的默认成员函数

一个普通的小白

已于 2023-08-11 14:00:39 修改

阅读量592

点赞数 3

分类专栏： c++ 文章标签： c++ 开发语言

于 2022-10-09 13:51:14 首次发布

本文链接：https://blog.csdn.net/m0_72964546/article/details/127224316

版权

c++ 专栏收录该内容

34 篇文章 4 订阅

订阅专栏

1.继承的基础知识

1.1继承的概念

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

1.2继承的格式

1.3 继承基类成员访问方式的变化

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

1.3.1不可见

继承基类的public成员可以直接访问s.addr;
继承基类的protected成员可以使用成员函数访问s.funcprotected();
继承基类的private成员,不可见，继承了是我的一个成员变量但是我不可以使用任意方式访问

class Person
{
public:
	void Print()
	{
		cout << _name << endl;
	}
	string _addr;
protected:
	string _name; // 姓名
private:
	int _age; // 年龄
};

class Student : public Person
{
public:
	void funcprotected()
	{
		cout << _name << endl;
	}
	void func()
	{
		//基类继承下来的私有成员不可见:内存上，派生类对象有这个成员，但是语法规定了我们不能去访问
		cout << _age << endl;
	}
protected:
	int _stunum; // 学号
};
int main()
{
	Student s;
	s._addr;
	s.funcprotected();
	s.func();
	return 0;
}

2.基类和派生类对象赋值转换

2.1切片、切割

派生类对象可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象

class Person
{
public:
	void Print()
	{
		cout << _name << endl;
	}
	string _name; // 姓名
	int _age; // 年龄
};

class Student : public Person
{
public:
	int _stunum; // 学号
};
int main()
{
	Person p;
	Student s;
	s._name = "李四";
	s._age = 20;
	s._stunum = 100234;

	p = s;//父<-子，切片/切割
	Person* ptr = &s;//指针指向子类对象，ptr只能访问继承的父类成员
	Person& ref = s;//子类对象中包含父类部分成员的别名
}

3.继承中的作用域

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

3.1成员变量的隐藏

//Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
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; // 学号
};
int main()
{
	Student s;
	s.Print();
}

3.2成员函数的隐藏

如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
fun()和fun(int i)不是重载，因为在不同的两个类里面

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);
	b.A::fun();
}

4.派生类的默认成员函数

4.1派生类的构造函数

基类的构造函数就是普通类的构造函数
派生类继承基类的成员变量，则使用固定格式（Person(name))来调用基类的构造函数

有多个成员变量，格式：Person(x1，x2)
一定是先调用父类构造函数初始化继承的父类部分， 再初始化自己的成员

class Person
{
public:
	Person(const char* name)
		: _name(name)
	{
		cout << "Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	Student(const char* name, int id)
		: Person(name)
		, _id(id)
	{
		// 调用父类构造函数初始化继承的父类部分
		// 再初始化自己的成员
		cout << "Student()" << endl;
	}
private:
	int _id;
};

4.2派生类的拷贝构造函数

基类的拷贝构造函数就是普通类的拷贝构造函数
派生类拷贝构造继承基类的那部分成员变量，使用固定格式（Person(s))来调用基类的拷贝构造函数

（Person(s))传一个派生类的对象给基类的拷贝构造函数，为什么可以？发生了切片行为
切片行为把派生类中父类那部分切来赋值过去

class Person
{
public:
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
public:
	Student(const Student& s)
		:Person(s)  // ->s传递给Person& s 是一个切片行为
		, _id(s._id)
	{
		// 类似构造函数
		cout << "Student(const Student& s)" << endl;
	}
private:
	int _id;
};

4.3派生类的赋值运算符重载

基类的赋值运算符重载就是普通类的赋值运算符重载
派生类赋值运算符重载继承基类的那部分成员变量，使用固定格式（Person::operator=(s))来调用基类的赋值运算符重载

Person::operator=(s)是一个隐含，不使用类作用域操作符，将会调用派生类的赋值运算符重载
同拷贝构造函数是一个切片行为

class Person
{
public:
	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& operator=(const Student& s)
	{
		// 同上
		if (this != &s)
		{
			// 小心这里是隐藏
			Person::operator=(s);
			_id = s._id;
		}
		cout << "Student& operator=(const Student& s)" << endl;
		return *this;
	}
private:
	int _id;
};

4.4派生类的析构函数

这里想调用，需要指定父类，Person::~Person();
为了保证析构时，保持先子再父的后进先出的顺序析构， 子类析构函数完成后，会自动去调用父类的析构函数

因为在调用构造函数时一定会先构造基类

class Person
{
public:
	~Person() // -> 因为后面多态的一些原因，任何类析构函数名都会被统一处理成destructor()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
public:
	~Student() // 编译器认为子类的析构函数和父类的析构函数构成隐藏
	{
		//Person::~Person(); // 所以这里想调用，需要指定父类的

		// 清理自己的
		// delete ptr;

		cout << "~Student()" << endl;
		// 为了保证析构时，保持先子再父的后进先出的顺序析构
		// 子类析构函数完成后，会自动去调用父类的析构函数
	}
private:
	int _id;
};

5.继承与友元

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

如果想访问子类的私有和保护成员那么，在子类里面加一个友元就好了

6. 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

基类静态变量一定不被派生类包含，这个变量属于我的，但是会被继承，我可以访问

那么可以使用这个静态变量来统计构造函数执行了多少次

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; // 研究科目
};
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

7.继承和组合怎么选择

继承：像is a的关系
组合：像has a的关系

可以根据上叙，来判断使用继承还是组合

狗是一种动物：继承

汽车有轮子：组合

一个普通的小白

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
【C++继承】继承的概念，不可见，切片，派生类的默认成员函数

4.1派生类的构造函数基类的构造函数就是普通类的构造函数派生类继承基类的成员变量，则使用固定格式（Person(name))来调用基类的构造函数有多个成员变量，格式：Person(x1，x2)一定是先调用父类构造函数初始化继承的父类部分，再初始化自己的成员
复制链接

扫一扫