C++——继承

18 篇文章 0 订阅

作为面向对象的语言,c++开发了名为继承的机制,它是c++中代码复用的重要手段

允许程序员在保持原有特性的基础(基类)上进行扩展,并产生新的类(派生类),这就是继承。

继承的格式

class (派生类名) :  (继承方式) (基类名)

class A {
public:
	int _a;
	

};

class B :public A{
public :
	int _b;
};

int main()
{
	B b;
	return 0;
}

在上面的一段代码中,我让 B 类以 public 方式继承了 A 类;

并且通过断点,我们发现,b 对象中包含了 A 类的成员; 

而这里的继承方式又起着什么作用呢?

继承方式 

public、protected、private;

 我们继承一共有三种方式,而这三种方式和类的访问限定符是一样的;

而这三种方式继承分别有什么不同呢?

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

虽然这个表很复杂难记,但是实际上用一句话概括就是:

派生类继承的基类成员,选继承方式基类成员访问限定符权限小的那个作为派生类中基类成员的权限大小;

其中比较特殊的就是基类的private成员派生类不可见;

之前在了解类和对象的时候就说过三个访问限定符,其中private和protected的作用类似

都是在类外面不可见,但是实际上,protected 的范围稍微大点,可以在派生类中看见

private 则只能在基类里面看见

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

 我们都知道,c++中的赋值都是创建一个中间临时变量,然后将这个临时变量给对应的对象;

比如:

 这里编译器实际上是先创建一个中间变量记录b的值,然后再把中间变量赋给a;

但是中间变量具有常性,因此我们这样写就会出错;

 我们必须加上 const 修饰符才行;

 但是基类和派生类对象之间的赋值转换则没有这样的限制

这就是基类和派生类对象的赋值转换;

但是实际上,这里的赋值转换只传递了 b 对象中基类的那一部分给了 a2;

class A {
public:
	int _a;
	A(int a = 10)
		:_a(a)
	{

	}
};

class B : public A {
public:
	int _b;
	B()
		:_b(5), A(5)
	{

	}
};

int main()
{
	A a1;
	B b;
	cout << a1._a << endl;
	a1 = b;
	cout << a1._a << endl;

	return 0;
}

这就是继承的特殊之处——基类和派生类的切割

从字面意思上看,就是指基类对象接收派生类对象的时候,只会接收基类成员的那一部分;

规则:

1.派生类对象可以赋给基类对象 / 指针 / 引用 ;

2.基类对象不能赋值给派生类对象;

3.基类对象的指针和引用可以通过强制类型转换赋值给派生类对象的指针和引用;

通过规则我们可以知道,实际上基类对象的指针和引用是可以通过强制类型转换赋给派生类对象的指针和引用的;

但是也有特殊情况:

根据基类指针或者引用指向的地址不同,可能导致越界访问; 

 继承的作用域

 由于派生类会继承基类的一切成员,当基类和派生类中出现同名成员时,就会构成隐藏关系;

1.基类和派生类有独立的作用域

2.基类和父类出现同名成员时,派生类将屏蔽基类中同名成员的访问——隐藏

3.成员函数只需要函数名相同就构成隐藏

4.继承体系中最好不要定义同名成员

虽然会构成隐藏关系,但是我们也能够显式的访问父类的同名成员;

class A {
public:
	int _a;
	A(int a = 10)
		:_a(a)
	{

	}

	void func()
	{
		cout << "A::func()" << endl;
	}
};

class B : public A {
public:
	int _b;
	B()
		:_b(5), A(5)
	{

	}

	void func()
	{
		A::func();
		cout << "B::func()" << endl;
	}

};

int main()
{
	B b;
	b.func();
	return 0;
}

 

 就像上面写的一样,通过  <基类名>::<同名成员> 来访问同名成员;

而若是不显式访问,就只会访问派生类的成员;

派生类的默认成员函数

 在派生类的默认成员函数中,我们一般都是先调用基类构建,再派生类构建,先派生类析构再基类析构;

而不管是拷贝构造还是 运算符=重载,都需要先调用基类函数,再使用派生类的函数;

class A {
public:
	int _a;
	A(int a = 10)
		:_a(a)
	{
		cout << "A::A()" << endl;
	}
	~A()
	{
		cout << "A::~A()" << endl;
	}
	void func()
	{
		cout << "A::func()" << endl;
	}
};

class B : public A {
public:
	int _b;
	B()
		:_b(5), A(5)
	{
		cout << "B::B()" << endl;
	}

	~B()
	{
		cout << "B::~B()" << endl;
	}

	void func()
	{
		A::func();
		cout << "B::func()" << endl;
	}

};

int main()
{
	B b;
	return 0;
}

继承与友元

友元关系无法继承,因此基类友元无法访问子类私有和保护成员;

 

继承和静态成员

整个继承体系只有一个这样的成员

class A {
public:
	static int cout;
	A()
	{
		cout++;
	}
};

int A::cout = 0;

class B :public A {
public :
	B()
	{
		cout++;
	}
};

int main()
{
	A a1;
	cout << A::cout<<endl;

	B b1;
	cout << B::cout << endl;

	return 0;
}

可以发现,cout 的值是始终都是根据 A 类 和 B 类的构造函数来变化的;

复杂的菱形继承和菱形虚拟继承

继承这个机制是允许多继承的,也就是一个子类可以有多个父类;

但是这就造成了菱形继承;

 

 

 

 一般的单继承和多继承没有什么问题,但是菱形继承就会导致数据冗余和二义性的问题;

在上图中,D 类就含有两个 A 类的成员,并且当 D 类使用 A 类的成员时,编译器无法区分是用 C类的 A 还是 B 类的 A ,就导致了二义性的问题; 

而解决方法就是让 B 类 和 C 类虚拟继承 A 类,这样就解决了数据冗余和二义性的问题;

那么虚拟继承是如何做到解决这些问题的呢?

class A {
public: int _a = 1;
};

class B : public A {
public: int _b = 2;
};

class C : public A {
public:int _c = 3;
};

class D :public B, public C {
public: int _d = 4;
};

int main()
{
	D d;
	return 0;
}

 我们简单的写一段菱形继承的代码;

然后我们通过内存来看看 d 如何存储的;

 我们可以看到,普通的菱形继承中有两个 A 的成员。然后最底下是它自身;

而虚拟继承又如何呢?

class A {
public: int _a = 1;
};

class B : virtual public A {
public: int _b = 2;
};

class C :virtual public A {
public:int _c = 3;
};

class D :public B, public C {
public: int _d = 4;
};

int main()
{
	D d;
	return 0;
}

我们写下菱形虚拟继承的代码;

 当我们虚拟继承的时候, D 里面只有一个 A,因此 为了找到这个 A,B和C原来存储 A 的位置改为了一个地址,这个地址指向了一个表,用来记录 B 地址 和 C 地址分别 距离 A 的偏移量,用来访问那一个 A ;

总结

继承是 is_a 的关系,而组合是 has_a 的关系。

继承允许你根据基类的实现来定义派生类的实现,这破坏了类的封装性,因为派生类能够看到基类的内部实现细节,增加了代码的耦合度,而继承这种代码复用被称为 白箱复用

而组合则不同,组合要求被组合的对象有定义良好定义的接口,这被称为黑箱复用,由于基类的细节不可见,一定程度上保证了代码的封装性,降低了耦合度。

因此一般不推荐使用继承,更推荐使用组合。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值