第十三章 类继承

如果构造函数不用初始化列表会
调用默认构造函数（string的）
再用复制构造函数将name初始化为name

但构造函数的形参类型为const string &,导致类型不匹配，但是string类
有一个将const char *作为参数的构造函数，使用C-风格字符串初始化string
对象时，将自动调用这个构造函数 。//？？

可以将string对象或C-风格字符串作为构造函数TableTennisPlayer的参数。

class RatedPlayer : public TableTennisPlayer
{
   ......
}

表明TableTennisPlayer是一个公有基类。派生类对象包含基类对象。

公有派生：基类公有成员函数成为派生类的公有成员，基类的保护成员函数称为派生类的
保护成员函数。
私有部分称为派生类的一部分。（只能通过基类的公有保护方法访问）！！！

子主题

系统默认的会把基类部分调用基类的赋值函数

创建派生类对象时，先创建基类对象（先调用基类对象的构造函数），
再进入派生类的构造函数中。

派生类的构造函数要给基类和派生类的新成员提供数据。
基类用初始化列表的方法赋初值

如果省略成员初始化列表。程序先给基类调用默认的构造函数。
（反正都要用到构造函数），派生类的构造函数总是调用一个基类
的构造函数

RatePlayer(unsigned int r ,const string & fn ,const string &ln , bool ht )
: TableTennisPlayer( fn , ln , ht )
{ .... }

说明

派生类对象过期时，先调用派生类对象的析构函数，再调用基类的析构函数。

除虚基类外，类只能将值传递回相邻的基类。//？？？

class TableTennis{
public:
    void f1();
    void f2();
}

class RatePlayer:public TableTennis{
public:
    void f1();
    void ex();
}


//在派生类实现中
void ex()
{
      f2();
      TableTennis::f1();
}

void Show( const TableTennisPlayer & rt)//注意是引用或者指针。
{
              ...........
}

TableTennisPlayer  player1("Tara",true);
RatedPlayer  rplayer1(1140,"Tom",true);

Show( player1 );
Show(  rplayer1 );

例子

原理

例子

原理

午餐有fruit,但不能从fruit 中派生出来

方法通过常规变量
调用

方法通过指针/引用调用

方法通过常规变量
调用

方法通过指针/引用调用

 virtual ~Brass();

~Brassplus();

Brass * p1;
p1=new BrassPlus(.....);

delete p1; 

结果

如果BrassPlus包含一个执行某些操作的构造函数，
则Brass必须有一个虚构函数，即使该析构函数不执行任何操作

C中的函数

C++中的重载函数虽然复杂了，但是也是静态联编

虚方法

void fr( Brass & rb );
void fp( Brass * pb );
voud fv( Brass pv );
 
int main()
{
     Brass b(....);
     BrassPlus bp( .... );

    fr(b);
    fr(bp);

    fp(b);
    fp(bp);

   fv(b);
   fv(bp);
   //valid;
}

说明

Brass sally( ... );
BrassPlus *ptr = &sally //invalid
BrassPlus *ptr= ( BrassPluds *) sally; //valid

效率

概念模型

仅将在派生类中重新定义基类的方法，设置为虚方法，否则，设置为非虚方法

子主题

如果在基类定义了虚函数，在派生类没有重新定义，虚函数表保存函数原始版本的地址

每个对象都将增大，增大量为存储地址的空间

对于每个类，编译器都创建一个虚函数地址表（数组）

对于每个函数调用，都需要执行一项额外的操作
，即到表中查找地址

要求

要求

不是虚类
问题

注意

要求

使用该函数的基类版本，如果派生类位于派生链中，将使用最
新的虚函数版本。例外，基类版本是隐藏的。

代码

子主题

教训

纯虚函数是在基类中只声明虚函数而不给出具体的函数定义体，将它的具体定义放在各派生类中，称此虚函数为纯虚函数.
通过该基类的指针或引用就可以调用所有派生类的虚函数，基类只是用于继承，仅作为一个接口，具体功能在派生类中实现.

virtual 函数原型=0；

声明为纯虚函数的函数体可以不定义，
也可以定义（主要作用为声明基类为抽象类）

代码

说明

代码

说明

代码

说明

代码

说明

代码

说明

代码

子主题

// usebrass3.cpp -- polymorphic example
// compile with acctacb.cpp
#include <iostream>
#include <string>
#include "acctabc.h"
const int CLIENTS = 4;

int main()
{
using std::cin;
using std::cout;
using std::endl;

AcctABC * p_clients[CLIENTS]; //建立基类，brass，bassplus都可以存储在里面。
std::string temp;
long tempnum;
double tempbal;
char kind;

for (int i = 0; i < CLIENTS; i++)
{
cout << "Enter client's name: ";
getline(cin,temp);
cout << "Enter client's account number: ";
cin >> tempnum;
cout << "Enter opening balance: $";
cin >> tempbal;
cout << "Enter 1 for Brass Account or "
<< "2 for BrassPlus Account: ";
while (cin >> kind && (kind != '1' && kind != '2'))
cout <<"Enter either 1 or 2: ";
if (kind == '1')
p_clients[i] = new Brass(temp, tempnum, tempbal);//建立Brass 类型
else//建立BrassPlus类型
{
double tmax, trate;
cout << "Enter the overdraft limit: $";
cin >> tmax;
cout << "Enter the interest rate "
<< "as a decimal fraction: ";
cin >> trate;
p_clients[i] = new BrassPlus(temp, tempnum, tempbal,
tmax, trate);
}
while (cin.get() != '\n') //确保下一个客户的信息由下一个值输入！！！
continue;
}
cout << endl;
for (int i = 0; i < CLIENTS; i++)
{
p_clients[i]->ViewAcct();
cout << endl;
}

for (int i = 0; i < CLIENTS; i++)
{
delete p_clients[i]; // free memory
}
cout << "Done.\n";
// cin.get();
return 0;
}

暂无

void seta(int a){ m_a = a; } 改为：
void seta(int a){ B::m_a = a; / /C::m_a = a;}正确

class lacksDMA :public baseDMA
{
private:
       enum { COL_LEN = 40};
       char color[COL_LEN];
public:
        lacksDMA(const char * c = "blank", const char * l = "null",
        int r = 0);
        lacksDMA(const char * c, const baseDMA & rs);
        friend std::ostream & operator<<(std::ostream & os,
        const lacksDMA & rs);
};

lacksDMA::lacksDMA(const char * c, const char * l, int r)
: baseDMA(l, r)
{
        std::strncpy(color, c, 39);
        color[39] = '\0';
}

lacksDMA::lacksDMA(const char * c, const baseDMA & rs)
: baseDMA(rs)// 调用base的复制构造函数。
{
        std::strncpy(color, c, COL_LEN - 1);
        color[COL_LEN - 1] = '\0';
}

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls)
{
       os << (const baseDMA &) ls;
       os << "Color: " << ls.color << std::endl;
       return os;
}

调用的是基类的构造函数，所以可以

调用的是基类的复制构造函数，所以可以

成员复制将根据数据类型采用相应的复制方式，
复制继承的类的组件时，使用该类的复制构造函数完成的

执行自身的代码后调用基类的析构函数。（先派生类的析构函数，再基类的析构函数）

自动使用类的赋值运算符来对基类组件进行赋值。

class hasDMA :public baseDMA
{
private:
     char * style; //要使用new的成员
public:
     hasDMA(const char * s = "none", const char * l = "null",
     int r = 0);
     hasDMA(const char * s, const baseDMA & rs);
     hasDMA(const hasDMA & hs);
     ~hasDMA(); 
     hasDMA & operator=(const hasDMA & rs);
     friend std::ostream & operator<<(std::ostream & os,
     const hasDMA & rs);
};

hasDMA::hasDMA(const hasDMA & hs)
: baseDMA(hs) // invoke base class copy constructor

//直接把hasDMA传递给baseDMA

baseDMA::operator=(hs); // copy base portion
基类部分给基类的赋值构造函数处理即可.
需要作用域解析运算符。

调用基类的友元函数。
就是说，派生类也可以不通过对象调用基类的友元函数。

使用强制类型转换法（如上），转换成基类的<<中接收的类型。

问题

方法1

方法2

第一个函数，显示buzz的全部
第二个函数，只显示buzz的brass部分