【巧妙继承】C++玩转继承的神级技巧

这篇具有很好参考价值的文章主要介绍了【巧妙继承】C++玩转继承的神级技巧。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java


🎉博客主页:.小智

🎉欢迎关注:👍点赞🙌收藏✍️留言

🎉系列专栏:C++终极篇

🎉代码仓库:小智的代码仓库

什么是继承?

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

举个栗子:
我们描述一个学生可以通过年龄,姓名,学号等来进行描述,描述一个老师可以通过年龄,姓名,工号等来描述,我们可以发现他们有着相同的元素,"年龄和姓名",这里我们就可以将年龄和姓名单独描述成一个类,然后通过继承可以使得学生和老师可以使用这两个属性,这样可以减少重复的代码。

具体代码实现:

//包含年龄和姓名的类
class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "xiaozhi"; // 姓名
	int _age = 18;  // 年龄
};
//学生类
class Student : public Person//继承了Person类
{
protected:
	int _stuid; // 学号
};
教室类
class Teacher : public Person//继承了person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student S;
	Teacher T;
	S.Print();
	T.Print();
	return 0;
}

继承后父类的Person的成员(成员函数+成员变量)都会变成子类的一部分。这里体现出了 StudentTeacher复用了Person的成员。下面我们使用监视窗口查看StudentTeacher对象,可 以看到变量的复用。调用Print可以看到成员函数的复用。
两个成院变量的复用:
​​​​【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
Print函数的复用:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

继承的格式

下面我们看到Person是父类,也称作基类。Student是子类,也称作派生类。
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

继承关系和访问限定符

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

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

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

总结:

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

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

  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片
    或者切割。寓意把派生类中父类那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象。
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
    的指针是指向派生类对象时才是安全的。
class Person
{
protected:
    string _name; // 姓名
    string _sex;  // 性别
    int _age; // 年龄
};
class Student : public Person
{
public:
    int _No; // 学号
};
int main()
{
    Student s;
    // 1.子类对象可以赋值给父类对象/指针/引用
    Person p =s;
    Person* pp = &s;
    Person& rp = s;

    //2.基类对象不能赋值给派生类对象
    //s = p; //这里会报错

    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    Student* ps1 = (Student*)pp;// 这种情况转换时可以的。
    
    pp = &p;
    Student* ps2 = (Student*)pp;// 这种情况转换时虽然可以,但是会存在越界访问的问题

    return 0;
}

p=s的过程发生了赋值兼容(切割/切片)没有产生临时变量:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

继承中的作用域

  1. 在继承体系中基类派生类都有独立的作用域
  2. 子类和父类中有同名成员,子类成员将屏蔽父类对同名成员的直接访问,这种情况叫隐藏, 也叫重定义。(在子类成员函数中,可以使用 基类::基类成员 显示访问
  3. 需要注意的是如果是成员函数的隐藏,只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员
// 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 s1;
    s1.Print();
    return 0;
}

运行结果:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
【注意】:

// B中的fun和A中的fun不是构成重载,因为不是在同一作用域
// B中的fun和A中的fun构成隐藏,成员函数满足函数名相同就构成隐藏。
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;
    }
};

派生类的默认成员函数

6个默认成员函数,“默认” 的意思就是指我们不写,编译器会变我们自动生成一个,那么在派生类
中,这几个成员函数是如何生成的呢?

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

构造函数

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name = "张三", int id = 0)
		: _id(id)
	{
		cout << "Student()" << endl;
	}
protected:
	int _id;
};

int main()
{
	Student st;
	return 0;
}

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
这里我们创建一个Student对象可以看到先调用了父类的构造函数,再调用自己的构造函数。这个过程完全是由编译器自己来完成的。前提是父类必须有自己的默认构造。
如果父类没有默认构造的话我们就需要在子类的初始化列表中显示调用来初始化。

//父类的构造函数
Person(const char* name)//不是默认构造函数
		: _name(name)
	{
		cout << "Person()" << endl;
	}

//子类的构造函数
Student(const char* name = "张三", int id = 0)
		:Person(name)
		,_id(id)
	{
		cout << "Student()" << endl;
	}

拷贝构造

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name = "张三", int id = 0)
		: _id(id)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		:Person(s)
		,_id(s._id)
	{
		cout << "Student(const Student& s)"<<endl;
	}
	~Student()
	{
		cout << "~Student()"<<endl;
	}
protected:
	int _id;
};

int main()
{
	Student st;
	Student s(st);
	return 0;
}

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
我们利用st拷贝构造出一个s对象。
在子类的拷贝构造中我们在初始化列表中显示调用Person(s)来进行赋值兼容(切片),
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
这样父类就会使用自己的拷贝构造函数来完成拷贝。

赋值重载

class Person
{
public:
	Person(const char* name = "peter")
		: _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;
};

class Student : public Person
{
public:
	Student(const char* name = "张三", int id = 0)
		: _id(id)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		:Person(s)
		,_id(s._id)
	{
		cout << "Student(const Student& s)"<<endl;
	}
	Student& operator=(const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator=(s);
			_id = s._id;
		}
		return this;
	}
	~Student()
	{
		cout << "~Student()"<<endl;
	}
protected:
	int _id;
};
int main()
{
	Student st;
	Student s;
	s = st;
	return 0;
}

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
这里跟上面在重载运算符中显示调用父类的重载运算符。

析构函数

析构函数编译器会自动调用。

继承与友元

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

继承与静态成员

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

多继承与菱形继承

单继承:一个子类只有一个直接父类时称这个继承关系为单继承
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
多继承:一个子类有两个或以上直接父类时称这个继承关系为多继承
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
菱形继承:菱形继承是多继承的一种特殊情况。
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
菱形继承的问题:从下面的对象成员模型构造,可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份

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; // 主修课程
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	//a._name = "peter";
	// 需要显示指定访问哪个父类的成员可以解决二义性问题,但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

图解:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系,在Student和Teacher的继承Person时使用虚拟继承,即可解决问题。需要注意的是,虚拟继承不要在其他地方去使用。

菱形继承的定义方法就是在public前面加上virtaul关键字即可。

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; // 主修课程
};
void Test()
{
	Assistant a;
	a._name = "peter";
}

菱形虚拟继承的实现原理

普通菱形继承:

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;
	d._a = 0;
	return 0;
}

普通菱形继承下内存的存储结构:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
菱形虚拟继承:

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;
	d._a = 0;
	return 0;
}

菱形虚拟继承下内存的存储结构:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

但是我们发现BC对象里多了两个类似于地址的东西,我们把地址输入到内存窗口再来观察。

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
这里可以分析出D对象中将A放到的了对象组成的最下面,这个A同时属于B和C,那么B和C如何去找到公共的A呢?这里是通过了B和C的两个指针,指向的一张表。这两个指针叫虚基表指针,这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。这样设计以后每次创建一个新的对象,新的对象里面还是一样的指向这两个偏移值。
我们来验证一下:

【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java
下面是上面的Person关系菱形虚拟继承的原理解释:
【巧妙继承】C++玩转继承的神级技巧,C++终级篇,c++,开发语言,java

继承和组合

  • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
  • 组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象。
  • 优先使用对象组合,而不是类继承 。
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
    为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言:在继承方式中,基类的
    内部细节对子类可见 。继承一定程度破坏了基类的封装,基类的改变,对派生类有很
    大的影响。派生类和基类间的依赖关系很强,耦合度高。
  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
    来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
    用(black-box reuse),因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
    组合类之间没有很强的依赖关系,耦合度低。优先使用对象组合有助于你保持每个类被
    封装。
  • 实际尽量多去用组合。组合的耦合度低,代码维护性好。不过继承也有用武之地的,有
    些关系就适合继承那就用继承,另外要实现多态,也必须要继承。类之间的关系可以用
    继承,可以用组合,就用组合。
class A
{
public:
	int _a;
};
//继承
class B : public A
{
public:
	int _b;
};
//组合
class C 
{
public:
	int _c;
	A a;
};

🍀小结🍀

今天我们学习了了C++继承相信大家看完有一定的收获。种一棵树的最好时间是十年前,其次是现在! 把握好当下,合理利用时间努力奋斗,相信大家一定会实现自己的目标!加油!创作不易,辛苦各位小伙伴们动动小手,三连一波💕💕~~~,本文中也有不足之处,欢迎各位随时私信点评指正!
本节课的代码已上传gitee仓库文章来源地址https://www.toymoban.com/news/detail-641529.html

到了这里,关于【巧妙继承】C++玩转继承的神级技巧的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 低代码如何玩转面向对象的类继承

    老铁们!要说Mendix 在低代码领域的过人之处,没两瓶白的再来几斤花生米是唠不完的。 话说“低代码,高逻辑”、“最接近高代码的低代码”、“高低结合”,大家也已耳熟能详。一个要登大雅之堂的产品从来没什么小秘密,无奈江湖险恶,各路玩家从没放弃调(mo)研(

    2024年02月02日
    浏览(34)
  • C++中=delete的巧妙用法

    在C++11中, =delete 是一个新的特性,它允许我们显式地禁止编译器自动生成某些函数。这个特性在很多场合都非常有用,比如当我们想要阻止一个类被复制或者赋值时。 1.1.1 函数原型的基本概念 函数原型(Function Prototype)是函数声明的一种形式,它指定了函数的名称、返回类

    2024年02月07日
    浏览(24)
  • vue3---组件基础(上)保姆级篇

    关于 vue3 基础学习,前面两篇博客讲了 单页面应用程序、 vite 的基本使用  。 这期就来一篇多一点的吧!这期主要内容有: 组件化开发思想、vue 组件的构成、组件的基本使用、封装组件的案例 。 看完这些,砸门也就详细了解什么是组件了。废话不多说,直接上刺刀!!

    2024年02月06日
    浏览(29)
  • C++共享之道:用extern实现源文件变量与类成员函数的巧妙共享

    概述: 在C++中,使用`extern`可实现在源文件之间共享变量与类成员函数。通过声明变量或类在头文件中,再在一个源文件中定义,其他源文件通过`extern`引用,促使模块化、可维护的代码组织。 在C++中, extern 可用于在源文件之间共享变量。它告诉编译器某个变

    2024年03月24日
    浏览(55)
  • 玩转AIGC(人工智能生成内容)需要一些小技巧

    玩转AIGC(人工智能生成内容)的确需要一些技巧,而Prompt提示词的选择非常关键,可以影响到生成的答案。以下是一些与AI对话的技巧和咒语示例: 确保你的Prompt清晰明了,包括主题、问题或指令,以便AI能够更好地理解你的需求。 有点像小学语文,老师会要求你用一句话描

    2024年02月05日
    浏览(83)
  • 玩转百度SEO:你所需要知道的14个技巧

    是的,我们数字营销人员都听说过那句古老的格言,即内容为王。就像谷歌一样,百度在从好内容中剔除不良内容时会考虑许多因素。但百度也比西方同行更进一步,以确保向用户展示的内容有足够的资格进入索引参与排名。 对于百度来说,尤其重要的是您的内容是独一无二

    2024年02月11日
    浏览(61)
  • IntelliJ IDEA 使用技巧 | 查看类的继承关系图

    快捷键CTRL+H查看 利用idea快捷键查看hierarchy,效果如下 好处:可以看向上和向下的继承关系 缺点:只能看继承关系,不能看实现了哪些接口 在指定类右键查看diagram 也可以使用快捷键ctrl+alt+u,更快捷 好处:可以看向上的继承关系 缺点:既能看继承关系,也能看实现了哪些接

    2024年02月07日
    浏览(50)
  • 玩转文本统计利器:Linux wc命令详解与实用技巧

      原创2023-06-04 23:56·程序猿食堂 玩转文本统计利器:Linux wc命令详解与实用技巧 Linux  的  wc  命令是一个用于统计文件内容的实用工具。它主要用于计算文件中的字节数、单词数和行数。这些统计信息对于文本文件的分析和处理非常有用。 wc 命令的基本语法如下: 其中,选

    2024年02月10日
    浏览(53)
  • 【002JavaScript 类继承】基本继承、调用父类方法和混入模式等方面的知识。掌握类继承的概念和技巧,提升代码的灵活性和可维护性。

    在 JavaScript 中,类继承是实现代码复用和扩展的重要概念。通过继承,我们可以基于现有类创建新类,并继承父类的属性和方法。本文将详细介绍 JavaScript 类继承的各个方面和技巧。 使用 extends 可以实现基本的类继承。 } class Dog extends Animal { bark() { console.log( ${this.nam

    2024年02月08日
    浏览(59)
  • AI绘画参数关键词设置技巧教程,零基础小白玩转AI绘画

    在本篇文章中,我们将讨论如何使用AI绘画软件生成美丽和高端的图片。AI绘画参数设置技巧教程! 一、推荐3个排名前三的AI绘画网站 首先,我们推荐3个排名前三的AI绘画网站: 触站、轻微课、约触。 这些网站都可以免费使用,但它们的功能和画风各有不同,因此您

    2024年02月11日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包