C++多重继承,虚基类与友元

2024-06-20 20:52
文章标签 c++ 继承 基类 多重 友元

本文主要是介绍C++多重继承,虚基类与友元,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

一.多重继承

就是一个类继承多个基类;

class <派生类名>:<派生方式1><基类名1>,```<派生方式n><基类名n>

class Derived:public:Base1,public:Base2

上述形式:基类之间由逗号隔开,且必须指明继承方式,否则默认为私有继承;

1.注意事项:

a.各种派生方式对于基类成员在派生类中的访问权限与单继承相同;

b.在使用多继承时,对基类成员的访问应无二义性

 2.二义性问题:

多重继承需要解决的主要问题:标识符不唯一造成的二义性,当继承的多个基类中有同名成员时就会造成二义性问题,这是不被允许的;

class Base1
{
public:int x;int a();int b();
};
class Base2
{int x;int a();
public:float b();
};
class Derived :Base1, Base2
{;
};void d(Derived& e)
{e.x = 10;e.a();e.b();
}int main()
{Derived ob;return 0;
}

像上述:Base1和Base2中都有相应的 x,a,b成员,此时就会造成二义性;

如何解决?

(1)使用域运算符“::”(范围解析运算符)

派生类的基类之间没有继承关系,同时又没有共同的基类(基类之间不是父与子的关系,也不是兄弟关系)则在引用同名成员时,可以在成员名前加上类名和域运算符来区别来自不同的基类的成员;

void d(Derived& e)
{e.Base1::x = 10;e.Base1::a();e.Base2::b();
}

使用域运算符,将d函数修改为这个形式就可以调用相应的函数,不再有二义性;非常直观

(2)使用同名覆盖的原则

在派生类中重新定义与基类中同名的成员(如果是成员函数,则参数表也要相同,参数不同则为重载)以屏蔽掉基类中的同名成员,在引用这些同名的成员时,引用的就是派生类中的成员;

class Base
{
public:int x;void show(){cout << "This is Base x=" << x << endl;}
};class Derived :public Base
{
public:int x;void show(){cout << "This is Derived x=" << x << endl;}
};int main()
{Derived ob;ob.x = 5;ob.show();ob.Base::x = 12;ob.Base::show();return 0;
}

此时直接调用类对象的成员就是派生类中的,不会产生歧义;

(3)使用虚基类(后面再提)

3.多重继承的构造函数和析构函数

在C++中声明多重继承构造函数的一般形式:

<派生类名>(参数总表)::基类名1(参数表)……基类名n(参数表n),对象成员名1(对象成员参数表1)……对象成员名n(对象成员参数表n)

多重继承构造函数和析构函数的执行顺序与单继承相同,但是需要强调的是,基类之间的执行顺序是严格按照声明从左到右的顺序来的,与他们在定义派生类构造函数中的次序无关;

class Base1
{int x1;
public:Base1(int y1){x1 = y1;cout << "constructing Based,x1=" << x1 << endl;}~Base1(){cout << "destructing Base1" << endl;}
};class Base2
{int x2;
public:Base2(int y2){x2 = y2;cout << "constructing Base2.x2=" << x2 << endl;}~Base2(){cout << "destructing Base2" << endl;}
};class Derived :public Base2, public Base1
{
private:Base1 ob1;Base2 ob2;
public:Derived(int x, int y, int z, int v) :Base1(x), Base2(y), ob1(z), ob2(v){cout << "constructing Derived" << endl;}
};int main()
{Derived ob(1, 2, 3, 4);return 0;
}

上述代码的运行结果为:

由此我们可以理解上面那句话: 基类之间的执行顺序是严格按照声明从左到右的顺序来的,与他们在定义派生类构造函数中的次序无关;

在上述程序中,先继承的Base2,那么先执行基类Base2,之后再执行Base1;

在定义对象的时候,先定义的为ob1,那么先执行Base1的初始化,再执行Base2的初始化

二.虚基类

虚基类是指被virtual修饰,用来解决基类中由于同名成员的问题而产生的二义性问题;

1.虚基类的声明

在派生类的声明过程中进行的:class <派生类名>: virtual<派生方式><基类名>

只对紧跟在virtual后的基类起作用;

class Base1:virtual public Base

声明虚基类之后,虚基类的成员在进一步派生过程中和派生类一起维护同一个内存

class Base
{
protected:int x;
public:Base(){x = 1;}
};class Base1 :virtual public Base
{
public:Base1(){cout << "constructing Base1,x=" << x << endl;}
};class Base2 :virtual public Base
{
public:Base2(){cout << "constructing Base2,x=" << x << endl;}
};class Derived :public Base1, public Base2
{
public:Derived(){cout << "constructing Derived x=" << x << endl;}
};int main()
{Derived obj;return 0;
}

由于把公共基类Base声明为类Base1和Base2的虚基类,所以由类Base1和类Base2派生的类Derived只有一个基类Base,在这里虚基类就可以避免二义性;按照顺序执行虚基类1,虚基类2的构造函数;(默认构造函数不需要调用,且这里都是没有参数的构造函数)

2.虚基类的构造函数和初始化

虚基类的初始化与一般的多继承的初始化在语法上是一样的,但构造函数的执行顺序不同;

(1)基类的构造函数;(2)虚基类的构造函数1;虚基类的构造函数2......(3)非虚基类的构造函数

class Base
{
protected:int x;
public:Base(int x1){x = x1;cout << "constructing Base,x=" << x << endl;}
};class Base1 :virtual public Base
{int y;
public:Base1(int x1, int y1) :Base(x1){y = y1;cout << "constructing Base1,y=" << y << endl;}
};class Base2 :virtual public Base
{int z;
public:Base2(int x1, int z1) :Base(x1){z = z1;cout << "constructing Base2,z=" << z << endl;}
};class Derived :public Base1, public Base2
{int xyz;
public:Derived(int x1, int y1, int z1, int xyz1) :Base(x1), Base1(x1, y1), Base2(x1, z1){xyz = xyz1;cout << "constructing Derived xyz=" << xyz << endl;}
};int main()
{Derived obj(1, 2, 3, 4);return 0;
}

 

在这里我们可以看出:虚基类Base的构造函数只执行了一次,因为当派生类Derived调用了虚基类Base的构造函数后,类Base1和Base2对虚基类的构造函数调用被忽略了!

注意事项:

a.virtual和派生方式的关键字的书写位置无关紧要,可以先写虚基类的关键字,也可以先写派生方式的关键字;

b.一个基类在作为某些类的虚基类的同时也可以作为另一些类的非虚基类;

c.虚基类构造函数的参数必须是由最新派生出来的类负责初始化,即使不是直接继承也是这样!(就是上面的derived:Base(x),初始化x)

三.友元

友元是用关键字friend修饰的,它提供了不同的类或对象的成员函数之间,类的成员函数与一般函数之间进行数据共享的机制

1.友元的引入

引入友元的目的:为了使类的私有成员和保护成员能够被其他类或其他成员函数访问

分类:(1)友元函数:友元是普通函数或类的成员函数;(2)友元类:友元是一个类

(友元类的所有成员函数都称为友元函数);

2.友元函数

友元函数不是当前类的成员函数,而是独立于当前类的外部函数它可以是普通函数或者其他类的成员函数。友元函数定义后可以访问该类的所有对象的所有成员函数,包括私有成员,保护成员和公有成员;

友元函数使用之前必须要在类定义时声明:其定义可以在类内部进行,也可以在类外部进行,但通常都定义在类的外部

C++将普通函数声明为友元函数的一般形式:

friend<数据类型><友元函数名>(参数表)

eg:friend double area(Rectangle &rectangle);

class Rectangle
{double length, width;
public:Rectangle(double a = 0, double b = 0){length = a;width = b;}//Rectangle(Rectangle& r);//不重载也完全没影响啊!!!friend double area(Rectangle& rectangle);};double area(Rectangle& rectangle)
{return(rectangle.width * rectangle.length);
}
int main()
{Rectangle ob(4, 5);cout << "The area is:" << area(ob) << endl;return 0;
}

上述程序,如果把friend关键字去掉,那么在函数外定义的area函数就会报错,因为width和length都是类的私有成员,不可访问;但是加上友元定义就可以访问;

3.友元成员

如果一个类的成员函数是另一个类的友元函数,那么称这个成员函数为友元成员,那么通过该成员函数可以访问另一个类的成员,也可以访问自己所在类的成员;

——可以使得两个类相互访问;

class boy;
class girl
{char* name;int age;
public:girl(const char* n, int a){name = new char[strlen(n) + 1];strcpy(name, n);age = a;}void prt(boy& b);
};class boy
{char* name;int age;
public:boy(const char* n, int a){name = new char[strlen(n) + 1];strcpy(name, n);age = a;}friend void girl::prt(boy& b);//声明友元成员
};void girl::prt(boy& b)//定义友元成员
{cout << "girl's name" << name << " " << "age" << age << endl;cout << "boy's name" << b.name << " " << "age" << b.age << endl;
}int main()
{girl gl("ztn", 19);boy bl("zhang", 18);gl.prt(bl);return 0;
}

在boy类内声明了girl类的成员函数prt为其友元,girl的prt既可以访问girl类的成员,也可以访问boy类的数据成员name和age;

上述:声明友元成员,定义友元成员等与上面的友元函数的区别就在于,此时存在两个类,该有友元成员可以访问另一个类的私有成员,保护成员和公有成员等;

上面也谈到:友元可以实现一般函数与成员函数之间,不同类之间进行数据共享的方式,那个人理解:友元函数:就可以实现一般函数与成员函数之间的数据共享,而友元成员则实现不同类之间的数据共享

使用友元成员需注意:

(1)必须先定义成员函数所在的类;上述例子中就是先定义了girl

(2)声明友元函数时,要加上成员函数所在类的类名和作用域,使用域运算符

(3)在主函数中一定要创建类girl的一个对象,只有这样才能通过对象名调用友元函数。

(4)如果在类定义前要使用到该类的成员,需要在使用前对该类进行声明,如class boy;(那么在上面的程序中,就是先声明友元函数所在的类,但是并不定义,先将友元成员所在的类进行声明定义,再定义友元函数的所在的类)

4.友元类

一个类作为另一个类的友元,称这个类为友元类。友元类中的所有成员函数都成为另一个类的友元函数。友元类中的所有成员函数都可以通过对象名直接访问另一个类中的所有成员从而实现不同类之间的数据共享

friend class<友元类名>——friend class girl

class boy;
class girl
{char* name;int age;
public:girl(const char* n, int a){name = new char[strlen(n) + 1];strcpy(name, n);age = a;}void prt(boy& b);
};class boy
{char* name;int age;friend class girl;
public:boy(const char* n, int a){name = new char[strlen(n) + 1];strcpy(name, n);age = a;}
};void girl::prt(boy& b)
{cout << "girl's name" << name << " " << "age" << age << endl;cout << "boy's name" << b.name << " " << "age" << b.age << endl;
}int main()
{girl gl("ztn", 18);boy bl("zhang", 19);gl.prt(bl);return 0;
}

其实可以看出和友元成员类似,最终的运行结果也一样!都实现了不同类之间的数据共享。


这篇关于C++多重继承,虚基类与友元的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1079232

相关文章

C++中实现调试日志输出

《C++中实现调试日志输出》在C++编程中,调试日志对于定位问题和优化代码至关重要,本文将介绍几种常用的调试日志输出方法,并教你如何在日志中添加时间戳,希望对大家有所帮助... 目录1. 使用 #ifdef _DEBUG 宏2. 加入时间戳:精确到毫秒3.Windows 和 MFC 中的调试日志方法MFC

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中,规

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode(VSCode)中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境:详细教程1. 什么是 VSCode?2. 安装 VSCo

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

hdu1171(母函数或多重背包)

题意:把物品分成两份,使得价值最接近 可以用背包,或者是母函数来解,母函数(1 + x^v+x^2v+.....+x^num*v)(1 + x^v+x^2v+.....+x^num*v)(1 + x^v+x^2v+.....+x^num*v) 其中指数为价值,每一项的数目为(该物品数+1)个 代码如下: #include<iostream>#include<algorithm>

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名