(一四七)私有继承

  1. 云栖社区>
  2. 博客>
  3. 正文

(一四七)私有继承

零零水 2016-02-21 17:08:00 浏览738
展开阅读全文

C++的另一种实现has-a关系的途径(前一种是将类对象作为新类的成员)是私有继承

 

使用私有继承,基类的公有成员和保护成员都将成为派生类的私有成员。

这意味着基类方法将不会成为派生类对象公有接口的一部分(公有继承,派生类可以使用基类的大部分方法),但可以在派生类的成员函数中使用它们。

 

 

私有继承的特点:

①继承方式类似公有继承,但使用private关键字替代public关键字;

 

②没有显式的对象名;

 

③需要使用其他办法替代 当使用类对象作为类数据成员时使用的方法。

 

④基类被称为子类。

 

 

使用多个基类的继承,被称为 多重继承(MI,通常,MI,尤其是公有MI将导致一些问题,必须使用额外的语法规则来解决他们。

 

 

私有继承的一些特殊之处:

 

①私有继承将提供无名称的子类对象成员,因此不能使用像name来描述对象,而应使用用于公有继承的技术。

 

②访问基类的方法:使用私有继承时,只能在派生类中使用基类的方法,但有时候可能希望基类工具是公有的。那么就在公有方法的函数中,使用私有方法。例如double Student::average(int i) { return arr::average(i); }这样,通过作用域解析运算符来区分。

 

③访问基类的对象:使用强制类型转换,

例如 (const string&)*this,其中this是指向当前对象的指针,*this是当前对象,强制类型转换后获得子类string

对于数组的访问,使用((const arr&)*this)[i],用括号括起来,强制类型转换后(成为一个valarray数组)然后添加运算符。

 

④访问基类的友元函数:

访问类的子类时,使用强制类型转换,将类对象显式转换为基类来调用正确的函数(前提是子类有相应的类方法)

 

 

对普通has-a关系的进行修改,使用私有继承类的方法:

#ifndef STU_
#define STU_
#include<string>
#include<valarray>

using namespace std;
class Student:private string,private valarray<double>
{
	typedef valarray<double> arr;	//将arr作为其别名
	ostream& scores_out(ostream& os)const;	//输出分数,我怀疑可以使用void作为返回值应该也可以。
public:
	Student() :string("No Student"), arr() {}	//默认构造函数,名字为No Student,分数无
	explicit Student(const string& s) :string(s), arr() {}		//构造函数,参数为string类对象,赋值给name,关闭隐式转换
	explicit Student(int n) :string("No name"), arr(n) {}		//构造函数,初始化分数的数量(不是值),关闭隐式转换
	Student(const string&s, int n) :string(s), arr(n) {}		//参数为name赋值,并声明有几个分数
	Student(const string&s, const arr&a) :string(s), arr(a) {}		//参数为name赋值,并将数组赋值给分数(调用的valarray的复制构造函数)
	Student(const string&s, const double*pd, int n) :string(s), arr(pd, n) {}		//类似上面,分数有n个成员,并用pd数组初始化能初始化的那几个
	~Student() {}			//析构函数,不声明也可以
	double Average();		//返回平均分
	const string& Name()const;		//返回姓名
	double & operator[](int i);		//返回第n个分数,可被修改
	double operator[](int i)const;		//这个和上面有啥区别?不能被修改?
										//friend友元函数
	friend istream& operator >> (istream&is, Student& Stu);	//输入,一个单词
	friend istream& getline(istream&is, Student& stu);	//输入,但是一行
	friend ostream& operator<<(ostream&os, const Student&stu);	//输出
};
#endif // !STU_

#include<iostream>
#include"stu.h"
using namespace std;

ostream& Student::scores_out(ostream& os)const
{
	int i = 0;
	int lim = arr::size();		//使用作用域解析运算符替代scores.
	if ( lim > 0)
	{
		for (i = 0;i < lim;i++)
		{
			os << arr::operator[](i) << " ";	//显式调用子类的方法,这里不能使用强制类型转换,因为是数组(
			if (i % 5 == 4)	
				os << endl;
		}
		if (i % 5 != 0)	
			os << endl;
	}
	else
		os << "empty" << endl;
	return os;
}

double Student::Average()	//返回平均分
{
	if (arr::size() > 0)
	{
		return arr::sum() / arr::size();
	}
	else
		return 0;
}

const string& Student::Name()const
{
	return (const string&)*this;	//使用强制类型转换来替代
}
double & Student::operator[](int i)	//返回分数
{
	return arr::operator[](i);	//使用了valarray的类方法
}
double Student::operator[](int i)const
{
	return arr::operator[](i);
}

istream& operator>>(istream& is, Student&stu)//输入,一个单词
{
	is >> (string&)stu;	//因为是输入,不能加const
	return is;
}

istream& getline(istream&is, Student& stu)	//输入,但是一行
{
	getline(is, (string&)stu);
	return is;
}
ostream& operator<<(ostream&os, const Student&stu)	//输出
{
	os << (const string&)stu << "'s scores: " << endl;
	stu.scores_out(os);
	return os;
}

使用包含还是私有继承:

建立has-a关系,一般来说,使用包含,因为包含用起来更简单,也可以包含多个同类对象,例如string name; string firstname; string lastname; 而若使用继承,则只能包含一个子类对象。

但若要使用基类的保护对象,则使用继承,因为只有派生类能访问基类的保护成员,而包含是不能访问被包含对象的基类成员的(只能通过公有接口)。

 

 

保护继承:

保护继承的方式类似私有继承,使用关键字protected

如:

class Student:protected std::string , protected std::valarray<double>

{..}

 

使用保护继承时,基类的公有成员和保护成员,都将成为派生类的保护成员。

 

和私有继承一样,基类的接口在派生类中也是可用的(通过基类对象访问基类的公有方法),

 

但在继承层次之外的结构是不可用的(保护继承是因为成为保护成员,不能在类外访问,即流程为public-->protected,而protected只能被基类和派生类使用)(私有继承则因为本身就视派生类为类外,派生类不能使用私有继承的基类方法,只能通过基类的公共接口调用,使用作用域解析运算符)。

 

因此,二者都可以通过基类接口调用

 

保护继承和私有继承的区别在于:

①在派生类派生出第三代时(即派生类的派生类),由于保护成员将被派生类继承,因此,保护继承的第三代将能使用第一代的基类接口(因为第一代的公共成员在第二代变为保护成员,而保护成员在派生类内,被视为公有成员)。

 

②而私有继承的第三代则不能使用,因为第一代的公共方法在第二代内作为私有方法被继承,因此第二代只能通过第一代的公共接口来调用。

访问形式为:基类的作用域解析运算符来使用方法。但需要注意的是,此时基类已经成为私有成员。

而进入第三代后,由于派生类不能访问基类的私有成员。因此,第三代是不能访问身为第二代私有成员的第一代类对象的(无论第三代通过什么来继承)。

 

附表:



使用using重新定义访问权限:

在保护继承或私有继承时,基类的公有成员将成为派生类的保护或者私有成员(因此,该方法是不能在类外使用的)。如果要使用基类的方法,那么

 

方法一:定义一个该基类方法的派生类方法。

例如:

double Student::sum()const

{
return std::valarray<double>::sum();

}

通过这种方法,Student类调用方法.sum()时,实际上相当于调用基类的sum()方法,即将其基类valarray对象求和。

 

 

方法二:在公有部分使用using声明。

例如:

class Student

{

...

public:

using std::valarray<double>::sum;

...

}

效果和方法一是相同的,即使得基类的sum()方法就像成为了派生类的公有方法一样。

注意:只需要函数名sum,不需要特征标,返回类型,和圆括号。

 

那么对于重载函数的兼容性如何?可以使用所有重载函数?从文中看来是这样的。

 

对于运算符重载,需要加上相应的重载运算符符号。例如:

using std::valarray<double>::operator[];

这将使const和非const版本都可用。

 

需要注意的是:

using声明 只适合继承,不适合 包含。

也就是私有继承可用,但将类对象作为另一个类对象成员时(包含)是不可用的。

 

还有一种老式方式,可用于在派生类中重新声明基类方法,即将方法名放在派生类的公有部分。

如:

class Student

{

...

public:

std::valarray<double>::sum;

...

}

using声明很像,但按书上所说,这种方法即将被抛弃,应放弃使用这种方法,而改用using方法,除非编译器不支持using方法。

 

 

 

 

 


网友评论

登录后评论
0/500
评论
零零水
+ 关注