为了账号安全,请及时绑定邮箱和手机立即绑定
首页 手记 番外篇--C++中的代码重用

番外篇--C++中的代码重用

2022.11.13 20:37 59浏览
  • 实现代码重用的一些方法(这里并不是全部):
    • 包含(组合、层次化):类包含另一个类的对象
    • 使用私有继承或保护继承
  • 以上两种方法都用于实现has-a关系,常用第一种方法
  • 多重继承可以使多个基类派生出一个新类,将基类的功能组合到一起

包含对象成员的类

  • 公有继承实现is-a模型,没有增加新接口,可增加新实现
  • 包含(组合、层次化)、私有继承、保护继承实现has-a模型,没有增加新接口,可增加新实现;
  • 接口:直接暴露在外的函数;实现:函数定义;注意:这两个概念不是互斥的

私有继承

要区分开 类成员的访问类型 和 类的继承类型 之间的关系
类成员的访问类型 决定 类成员的可访问性和可继承性:

访问类型 外部可访问性 可继承性
public 可访问 可继承
protect 不可访问 可继承
private 不可访问 不可继承

类的继承类型 决定 继承下来的成员 的访问类型会变成什么:

继承类型 变化
公有继承 不改变继承下来内容的访问类型
保护继承 将继承下来的内容的访问类型都变为protect
私有继承 将继承下来的内容的访问类型都变为private

派生类的指针(引用)要赋值给私有继承下来的基类类型指针(引用),必要强转派生类的指针(引用)


包含将对象作为一个有名字的成员添加到类中,私有继承将一个没有名字的成员添加到类中;这些成员称为子对象(subobject)

私有继承是默认继承方式

访问基类成员的格式:类名::基类成员

ps:友元函数不是类成员

若要直接获得子对象,则只需要对this(*this)进行强制类型转换即可,转换成你想要的子对象类型的指针(引用)


  • 包含 与 私有继承 实现has-a关系的对比:
    • 包含易于理解,可包含多个同类子对象,不可访问子对象的保护成员、不可重新定义虚函数
    • 私有继承比较抽象,不易包含多个同类子对象,容易出问题(多重继承);但是特性多:可访问子对象的保护成员、可重新定义虚函数
  • 一般来说,能用包含就用包含,实在不行再用私有继承
  • 如果想要改变私有继承(或保护继承(可以吗?))下来的基类成员的访问属性,可以使用using关键字,将那些成员强行引入到特性的访问区块:
class Student : private std::string, private std::valarray<double>
{
...
public:
  //使用using将那些继承下来的成员强行引入到public中,min和max函数的访问属性由private改成了public
  using std::valarray<double>::min;
  using std::valarray<double>::max;
  //注意:using声明只需要成员名

  //实现这个功能的一种更老的方法,但即将停用
  //std::valarray<double>::min;
...
};

多重继承

多重继承(MI):有多个直接基类的类,每一个基类都要写上自己的继承属性

以下面的继承关系图为例介绍MI:

如果上图中所有的继承关系都是公有继承,那么SingingWaiter实例就会有两个Worker基类对象:

多重继承引入的问题

  • 派生类对象(SingingWaiter)指针(引用)无法自动上转为相同基类类型(Worker)的指针(引用)
    • 解决方法:手动强转下派生类对象(SingingWaiter)指针(引用)到上一级基类(Singer或Waiter)就好了
  • 从不同的基类继承同名的方法
    • 解决方法:可在调用同名函数时,通过类名指定

从不同继承路线上继承相同的基类

为了删除多个相同基类,有点像融合,C++引入了新技术— 虚基类 ;

要指定哪条继承线的相同基类进行融合,则继承这个相同类(Worker)的直接派生类(Singer和Waiter)都要在继承时加上virtual关键字:

class Singer : public virtual Worker{};
class Waiter : virtual public Worker{};

然后派生类(SingingWaiter)的基类对象情况就会变成这样:

引入虚基类的多重继承需要解决的问题

构造函数的问题

只能在类(SingingWaiter)在构造函数 初始化列表 中调用虚基类(Worker)的构造函数,类(SingingWaiter)的所有基类(Singer和Waiter)都不能在构造函数 初始化列表 中调用虚基类(Worker)的构造函数;

只能由类(SingingWaiter)来 自动 调用虚基类(Worker)的构造函数,类(SingingWaiter)的所有基类(Singer和Waiter)都不能再 自动 调用虚基类(Worker)的构造函数;

总的来说就是:类(SingingWaiter)的所有基类(Singer和Waiter)已无权调用虚基类(Worker)的构造函数,只能由类(SingingWaiter)调用虚基类(Worker)的构造函数;

虚基类中虚函数的问题

如果一个类(SingingWaiter)继承了虚基类(Worker)但是没有实现虚基类(Worker)的虚函数vfun,会出现下面两种情况:

如果有两个以上 虚基类(Worker)的派生类(Singer和Waiter) 都实现了虚基类(Worker)的虚函数vfun;这个时候如果通过这个类(SingingWaiter)的对象指针去调用虚函数vfun,那么将出现二义性;因为虚函数从虚基类(Worker)开始往下走会有两个最新版本出现;因此这个类(SingingWaiter)最好重写(override)虚函数vfun,否则多态性就会异常;

如果只有一个 虚基类(Worker)的派生类(Singer或Waiter) 实现了虚基类(Worker)的虚函数vfun;这个时候如果通过这个类(SingingWaiter)的对象指针去调用虚函数vfun,那么不会有任何问题;

重写虚函数的问题

在重写(override)虚基类(Worker)的虚函数vfun时最好不要以 递增 的方式去写;所谓的 递增 指的是:在重写(override)的时候调用了基类的虚函数vfun;

后记

虚函数的调用规则不受访问类型的影响,该调用哪个就调用哪个,如果调到了私有函数或者保护函数,那运行时就报错;

基类普通函数的调用规则也不受访问类型的影响,如果基类出现两个同名普通函数函数,即使一个是私有的、一个是公有的,那么一样存在调用的二义性;

类模板

类模板的声明与定义

//T是类型参数
//typename和class是等价的,但是class是C++98之前的版本
template <typename T>  
class A
{
public:
  void fun1(){ //do something }
  void fun2();

  A<T> fun3(){ //do something }
  A fun4();
  //注意:fun3和fun4的返回类型其实是等价的,没有差别;在类的块中,所有的A<T>和A都是等价的
};

//如果函数定义与函数声明分开,那么定义格式如下:
template <typename T>
void A<T>::fun2()
{
  //do something
}

template <typename T>
A<T> A<T>::fun4()      //注意:返回值的写法与函数原型不同,因为在类的块外面
{
  //do something
}

//跟函数模板一样,以上只是类模板,机器码中不会包含类模板的信息;编译器会根据类模板来生成相应类定义机器码
//注意:类模板函数声明与定义不能放在两个独立的文件中

类模板的使用

A<int> test1;
A<string> test2
//注意:类型参数必须要手动确定,编译器不会像函数模板一样自动识别

数组模板实例和非类型参数

非类型(non-type)参数or表达式(expression)参数:

//数组模板
template <class T,int n>    //n就是非类型参数;看起来像是一个变量,但我觉得是一个可以指定类型的宏定义,编译生成具体模板实例的时候,类成员的声明和定义中的n标识符将全部被替换为n的具体数值
class ArrayTP
{
private:
  T ar[n];          //由于是宏定义,所以编译时可以确定数组大小
public:
  ...
  void set(){};
};

template <class T, int n>
void ArrayTP<T,n>::set()
{
  for(int i=0;i<n;++i)
    ar[i]=i;
}

int main()
{
  ...
  ArrayTP<double,12> example1;
  ArrayTP<double,20> example2;
  //注意:上面将生产两个模板实例,因为非类型参数不同

  example1.set();
  example2.set();
  ...
}
  • 非类型参数的限制:
    • 类型只能是整形、枚举、引用、指针
    • 模板中的代码不能修改非类型参数的值,也不能获取参数的地址(引用也不行吧?)(因为非类型参数没有内存空间?)
    • 在实例化模板的时候,用作非类型参数的值必须是常量表达式
  • 非类型参数数组模板的优点:
    • 使用非类型参数来创建数组速度更快,因为数组是自动变量;而且不需要手动new和delete;
  • 非类型参数数组模板的缺点:
    • 不同的非类型参数数值都会生成自己的模板实例,占用内存增加;
    • 无法将一种尺寸的数组模板实例赋给另一种尺寸的数组模板实例;

模板多功能性

类模板也可以用作基类、派生类、组件类、其它模板的类型参数:

template <typename T>
class Array
{
private:
	T entry;
};

template <typename Type>
class GrowArray:public Array<type>		//派生类模板 继承 基类模板
{ ... };

template <typename Tp>
class Stack
{
	Array<TP> ar;			//类模板 作为 组件
};

Array<Stack<int> > asi;		//类模板 作为 其它类模板的 类型参数;C++98要求后面两个 > 分开,但是C++11不用

递归使用类模板:一个类模板的类型参数还是类模板,例如:vector<vector<int,6>,7>

模板可以包含多个类型参数:

template<typaname T1,typename T2>
class Pair
{
private:
  T1 a;
  T2 b;
public:
  ...
  void set(const T1 &aa,const T2 &bb);
};

template<typename T1,typrname T2>
void Pair<T1,T2>::set(const T1 &aa,const T2 &bb)
{
  a=aa;
  b=bb;
}

int main()
{
  ...
  Pair<int,double> example1;
  Pair<float,string> example2;

  example1.set(3,6.268);
  example2.set(3.1415,"hello world");
  ...
} 

默认模板参数:

template <typename T1,typename T2 = int>  //一定要确保有默认值的类型参数右边的类型参数都是有默认值的
class Topo                                //还可以为非类型参数设置默认值
{};

int main()
{
  ...
  Topo<double> m2;  //由于没有给出第二个类型参数,所以默认第二个类型参数为int
  ...
}

模板的具体化

隐式实例化(implicit instantiation) 、 显式实例化(explicit instantiation) 、 显式具体化(explicit specialization) 统称为 具体化(specialization)

假设有这样一个类模板:

template <typename T1,typename T2>
class ArrayTP
{
  ...
};

隐式实例化

ArrayTP<int,100> stuff;			//隐式实例化
...

ArrayTP<double,30> *pt;			//不会实例化
pt = new ArrayTP<double,30>;	//隐式实例化

这种实例化在函数模板中是显式实例化的一种形式

显式实例化

template class ArrayTP<string,100>;		//显式实例化

显式具体化

template<>
class ArrayTP<string,100>
{
  ...
};

当同时存在具体化模板和通用模板时,编译器优先选择具体化模板;如果还存在普通函数,是不是普通函数最优先

部分具体化

template <typename T1>		//没有具体化的参数就保留下来了;是否要确保已具体化参数右边的函数都是被具体化了???
class ArrayTP<T1,int>
{
  ...
};

部分具体化的更多例子:

//general template
template <class T1, class T2, class T3> class Trio{...};
//specialization tith T3 set to T2
template <class T1, class T2> class Trio<T1, T2, T2>{...};
//specialization with T3 and T2 set to T1*
template <class T1> class Trio<T1, T1*, T1*>{...};

//给定上述声明,编译器将作出如下选择:
Trio<int, short char*> t1;    //use general template
Trio<int, short> t2;          //use Trio<T1, T2, T2>
Trio<char, char*, char*> t3;  //use Trio<T1, T1*, T1*>

函数调用时,模板匹配优先度:显式具体化>部分具体化>实例化

指针(引用)类型优先与T*(T&)匹配,非指针(引用)类型优先与T匹配

成员模板

老编译器不接受模板成员

可以在类模板中定义类模板或者函数模板:

template <typename T>
class beta
{
private:
  template <typename V>
  class hold
  {
  private:
    V val;
  };

  hold<T> q;
  hold<int> n;
public:
  template <typename U>
  U blad(U u,T t,hold<T> ht,hold<int> hi)
  { ... }
};

//以上的类模板和函数模板都是在类中定义的,接下来看看在类外要怎么定义
//注意:部分编译器不接受类外定义

template <typename T>
class beta
{
private:
  template <typaneme V>
  class hold;          //声明
  
  hold<T> q;
  hold<int> n;
public:
template<typename U>
U blad(U u,T t,hold<T> ht,hold<int> hi);
};

template <typename T>
  template <typename V>
  class beta<T>::hold      //注意作用域解析运算符
  {
  private:
    V val;
  };

template <typename T>
  template <typename U>
  U beta<T>::blad(U u,T t,hold<T> ht,hold<int> hi)    //注意作用域解析运算符
  { ... }

点击查看更多内容
C++
0人点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
软件工程师
手记
粉丝
0
获赞与收藏
1

关注TA,一起探索更多经验知识

同主题相似文章浏览排行榜

风间影月说签约讲师

51篇手记,涉及Java、MySQL、Redis、Spring等方向

进入讨论

Tony Bai 说签约讲师

151篇手记,涉及Go、C、Java、Python等方向

进入讨论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消