Chapter 13 类继承

#ifndef TABTENN0_H_
#define TABTENN0_H_
#include <string>

// 简单的基类
class TableTennisPlayer {
private:
    std::string firstname;
    std::string lastname;
    bool hasTable;
public:
    // 构造函数
    TableTennisPlayer (const std::string & fn = "none",
                       const std::string & ln = "none",
                       bool ht = false);
    // 方法
    void Name() const; // 显示姓名
    bool HasTable() const { return hasTable; }; // 是否有球桌
    void ResetTable(bool v) { hasTable = v; }; // 重置球桌状态
};
#endif // TABTENN0_H_

#include "tabtenn0.h"
#include <iostream>

TableTennisPlayer::TableTennisPlayer (const std::string & fn,
                                      const std::string & ln, bool ht)
                                      : firstname(fn), lastname(ln), hasTable(ht) {} // 使用成员初始化列表

void TableTennisPlayer::Name() const {
    std::cout << lastname << ", " << firstname;
}

class DerivedClassName : accessSpecifier BaseClassName {
    // ... 派生类新增的成员 ...
};

// ... (TableTennisPlayer 定义之后) ...

// 简单的派生类
class RatedPlayer : public TableTennisPlayer { // 使用 public 继承
private:
    unsigned int rating; // 新增成员：积分
public:
    // 派生类构造函数
    RatedPlayer (unsigned int r = 0, const std::string & fn = "none",
                 const std::string & ln = "none", bool ht = false);
    // 使用基类对象进行构造
    RatedPlayer(unsigned int r, const TableTennisPlayer & tp);

    // 新增方法
    unsigned int Rating() const { return rating; } // 获取积分
    void ResetRating (unsigned int r) { rating = r; } // 重置积分
};

// ... (endif) ...

// ... (TableTennisPlayer 实现之后) ...

// RatedPlayer 构造函数实现
RatedPlayer::RatedPlayer(unsigned int r, const std::string & fn,
                         const std::string & ln, bool ht)
                         : TableTennisPlayer(fn, ln, ht), rating(r) { // 调用基类构造函数
    // rating(r) 初始化派生类自己的成员
    // 基类部分的初始化委托给 TableTennisPlayer 的构造函数
}

RatedPlayer::RatedPlayer(unsigned int r, const TableTennisPlayer & tp)
                         : TableTennisPlayer(tp), rating(r) { // 调用基类的复制构造函数 (这里是隐式生成的)
    // rating(r) 初始化派生类自己的成员
}

// filepath: d:\ProgramData\files_Cpp\250424\usett0.cpp
#include <iostream>
#include "tabtenn0.h" // 包含基类和派生类定义

int main ( void ) {
    using std::cout;
    using std::endl;
    TableTennisPlayer player1("Chuck", "Blizzard", true);
    RatedPlayer rplayer1(1140, "Mallory", "Duck", true); // 使用派生类构造函数

    // 派生类对象可以使用基类的方法
    rplayer1.Name(); // 调用继承来的 TableTennisPlayer::Name()
    if (rplayer1.HasTable()) // 调用继承来的 TableTennisPlayer::HasTable()
        cout << ": has a table.\n";
    else
        cout << ": hasn't a table.\n";

    // 派生类对象可以使用自己的方法
    cout << "Name: ";
    rplayer1.Name();
    cout << "; Rating: " << rplayer1.Rating() << endl; // 调用 RatedPlayer::Rating()

    // 可以使用基类对象初始化派生类对象 (通过特定构造函数)
    RatedPlayer rplayer2(1212, player1);
    cout << "Name: ";
    rplayer2.Name();
    cout << "; Rating: " << rplayer2.Rating() << endl;

    return 0;
}

RatedPlayer rp("May", "Lee", true, 1500);
TableTennisPlayer ttp("John", "Doe", false);

// "is-a" 关系允许这种赋值/初始化
TableTennisPlayer & rt = rp; // 基类引用可以引用派生类对象
TableTennisPlayer * pt = &rp; // 基类指针可以指向派生类对象

// 可以通过基类引用/指针调用基类的方法
rt.Name(); // 输出 Lee, May
pt->Name(); // 输出 Lee, May

// 但不能直接通过基类引用/指针调用派生类特有的方法
// rt.Rating(); // 错误! TableTennisPlayer 没有 Rating() 方法
// pt->Rating(); // 错误!

// 也可以将派生类对象传递给需要基类对象的函数
void showPlayerName(const TableTennisPlayer & player) {
    player.Name();
    std::cout << std::endl;
}

showPlayerName(ttp); // 传递基类对象 (OK)
showPlayerName(rp);  // 传递派生类对象 (OK, 因为 RatedPlayer is-a TableTennisPlayer)

RatedPlayer rp("May", "Lee", true, 1500);
TableTennisPlayer * pt = &rp; // 基类指针指向派生类对象

pt->Name(); // 调用哪个 Name() 方法？ TableTennisPlayer::Name() 还是 RatedPlayer::Name()？

#ifndef TABTENN1_H_
#define TABTENN1_H_
#include <string>
#include <iostream> // 添加 iostream 以便在头文件中使用 cout (虽然通常不推荐)

// 基类 - 使用虚函数
class TableTennisPlayer {
private:
    std::string firstname;
    std::string lastname;
    bool hasTable;
public:
    TableTennisPlayer (const std::string & fn = "none",
                       const std::string & ln = "none",
                       bool ht = false);
    // 将 Name() 声明为虚函数
    virtual void Name() const;
    bool HasTable() const { return hasTable; };
    void ResetTable(bool v) { hasTable = v; };
    // 添加一个虚析构函数通常是好习惯 (稍后解释)
    virtual ~TableTennisPlayer() { }
};

// 派生类
class RatedPlayer : public TableTennisPlayer {
private:
    unsigned int rating;
public:
    RatedPlayer (unsigned int r = 0, const std::string & fn = "none",
                 const std::string & ln = "none", bool ht = false);
    RatedPlayer(unsigned int r, const TableTennisPlayer & tp);
    unsigned int Rating() const { return rating; }
    void ResetRating (unsigned int r) { rating = r; }
    // 覆盖基类的虚函数 Name()
    // C++11 推荐使用 override 关键字明确表示覆盖
    virtual void Name() const override; // 也可以只写 virtual void Name() const;
                                        // 或 void Name() const; (如果基类是 virtual，派生类同名同参方法自动也是 virtual)
};

#endif // TABTENN1_H_

#include "tabtenn1.h"
#include <iostream>

// TableTennisPlayer 方法
TableTennisPlayer::TableTennisPlayer (const std::string & fn,
                                      const std::string & ln, bool ht)
                                      : firstname(fn), lastname(ln), hasTable(ht) {}

void TableTennisPlayer::Name() const {
    std::cout << lastname << ", " << firstname;
}

// RatedPlayer 方法
RatedPlayer::RatedPlayer(unsigned int r, const std::string & fn,
                         const std::string & ln, bool ht)
                         : TableTennisPlayer(fn, ln, ht), rating(r) {
}

RatedPlayer::RatedPlayer(unsigned int r, const TableTennisPlayer & tp)
                         : TableTennisPlayer(tp), rating(r) {
}

// RatedPlayer 覆盖的 Name() 方法实现
void RatedPlayer::Name() const {
    // 可以调用基类的 Name() 方法
    TableTennisPlayer::Name();
    // 添加自己的输出
    std::cout << ", Rating: " << rating;
}

#include <iostream>
#include "tabtenn1.h" // 使用包含虚函数的新版本

int main ( void ) {
    using std::cout;
    using std::endl;
    TableTennisPlayer player1("Tara", "Boomdea", false);
    RatedPlayer rplayer1(1140, "Mallory", "Duck", true);

    // 通过对象直接调用，总是调用对象所属类的方法 (静态联编)
    cout << "Direct call:\n";
    player1.Name(); cout << endl; // 调用 TableTennisPlayer::Name()
    rplayer1.Name(); cout << endl; // 调用 RatedPlayer::Name()

    // 通过指针调用虚函数 (动态联编)
    cout << "\nUsing pointers to base type:\n";
    TableTennisPlayer * pt1 = &player1;
    TableTennisPlayer * pt2 = &rplayer1;

    pt1->Name(); cout << endl; // pt1 指向 TableTennisPlayer 对象，调用 TableTennisPlayer::Name()
    pt2->Name(); cout << endl; // *** pt2 指向 RatedPlayer 对象，调用 RatedPlayer::Name() ***

    // 通过引用调用虚函数 (动态联编)
    cout << "\nUsing references to base type:\n";
    TableTennisPlayer & rt1 = player1;
    TableTennisPlayer & rt2 = rplayer1;

    rt1.Name(); cout << endl; // rt1 引用 TableTennisPlayer 对象，调用 TableTennisPlayer::Name()
    rt2.Name(); cout << endl; // *** rt2 引用 RatedPlayer 对象，调用 RatedPlayer::Name() ***

    return 0;
}

void ShowPlayerInfo(const TableTennisPlayer & player) {
    player.Name(); // 会根据 player 实际类型调用正确的 Name() 版本
    cout << endl;
}

// ... in main ...
ShowPlayerInfo(player1);
ShowPlayerInfo(rplayer1);

// 假设 RatedPlayer 公有继承自 TableTennisPlayer
RatedPlayer rp;
TableTennisPlayer * pt = &rp; // OK
TableTennisPlayer & rt = rp; // OK

pt->SomeMethod();
rt.SomeMethod();

#ifndef TABTENN_PROT_H_
#define TABTENN_PROT_H_
#include <string>
#include <iostream>

// 基类 - 使用 protected 成员
class TableTennisPlayerProt {
// protected 成员:
protected: // 改为 protected
    std::string firstname;
    std::string lastname;
private:   // hasTable 仍然是 private
    bool hasTable;
public:
    TableTennisPlayerProt (const std::string & fn = "none",
                           const std::string & ln = "none",
                           bool ht = false);
    // Name() 不再需要，因为派生类可以直接访问 protected 成员来构建自己的 Name()
    // virtual void Name() const; // 可以移除或保留
    bool HasTable() const { return hasTable; };
    void ResetTable(bool v) { hasTable = v; };
    virtual ~TableTennisPlayerProt() { }
};

// 派生类
class RatedPlayerProt : public TableTennisPlayerProt {
private:
    unsigned int rating;
public:
    RatedPlayerProt (unsigned int r = 0, const std::string & fn = "none",
                     const std::string & ln = "none", bool ht = false);
    RatedPlayerProt(unsigned int r, const TableTennisPlayerProt & tp);
    unsigned int Rating() const { return rating; }
    void ResetRating (unsigned int r) { rating = r; }
    // 派生类可以直接访问基类的 protected 成员
    void ShowInfo() const; // 新增一个方法来演示访问
};

#endif // TABTENN_PROT_H_

#include "tabtenn_prot.h"
#include <iostream>

// TableTennisPlayerProt 方法
TableTennisPlayerProt::TableTennisPlayerProt (const std::string & fn,
                                              const std::string & ln, bool ht)
                                              : firstname(fn), lastname(ln), hasTable(ht) {}

// RatedPlayerProt 方法
RatedPlayerProt::RatedPlayerProt(unsigned int r, const std::string & fn,
                                 const std::string & ln, bool ht)
                                 : TableTennisPlayerProt(fn, ln, ht), rating(r) {
}

// 注意：这个构造函数仍然需要调用基类构造函数，
// 因为即使 firstname/lastname 是 protected，初始化也应由基类负责。
// 但如果基类没有提供合适的构造函数，派生类可以在其构造函数体中
// 直接给 protected 成员赋值 (虽然不推荐)。
RatedPlayerProt::RatedPlayerProt(unsigned int r, const TableTennisPlayerProt & tp)
                                 : TableTennisPlayerProt(tp), rating(r) {
}

// 派生类方法可以直接访问基类的 protected 成员
void RatedPlayerProt::ShowInfo() const {
    // 直接访问继承来的 protected 成员 firstname 和 lastname
    std::cout << "Name: " << lastname << ", " << firstname;
    std::cout << "; Rating: " << rating;
    // 不能直接访问基类的 private 成员 hasTable
    // std::cout << HasTable(); // 需要通过基类的 public 方法访问
    if (HasTable())
         std::cout << "; Has Table: Yes\n";
    else
         std::cout << "; Has Table: No\n";
}

#include <iostream>
#include "tabtenn_prot.h"

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

    RatedPlayerProt rplayer1(1140, "Mallory", "Duck", true);
    TableTennisPlayerProt player1("Tara", "Boomdea", false); // 基类对象

    cout << "Rated Player Info:\n";
    rplayer1.ShowInfo(); // 调用派生类方法，该方法访问了基类的 protected 成员

    // 外部代码不能直接访问 protected 成员
    // cout << rplayer1.firstname; // 错误！firstname 是 protected
    // cout << player1.lastname;  // 错误！lastname 是 protected

    // 外部代码可以访问 public 成员
    cout << "\nPlayer 1 Has Table? " << player1.HasTable() << endl; // OK

    return 0;
}

#ifndef ACCTABC_H_
#define ACCTABC_H_
#include <iostream>
#include <string>

// 抽象基类 AcctABC
class AcctABC {
private:
    std::string fullName;
    long acctNum;
    double balance;
protected: // 改为 protected 以便派生类访问
    // 辅助格式化函数 (protected，派生类可用)
    struct Formatting {
        std::ios_base::fmtflags flag;
        std::streamsize pr;
    };
    const std::string & FullName() const { return fullName; }
    long AcctNum() const { return acctNum; }
    Formatting SetFormat() const;
    void Restore(Formatting & f) const;
public:
    // 构造函数 (ABC 也可以有构造函数)
    AcctABC(const std::string & s = "Nullbody", long an = -1,
            double bal = 0.0);
    // 存款
    void Deposit(double amt);
    // 取款 - 设为纯虚函数，具体实现在派生类
    virtual void Withdraw(double amt) = 0;
    // 查询余额
    double Balance() const { return balance; }
    // 查看账户信息 - 设为纯虚函数
    virtual void ViewAcct() const = 0;
    // 虚析构函数 (基类有虚函数，析构函数也应是虚的)
    virtual ~AcctABC() {}
};

// 具体的派生类: Brass Account (支票账户)
class Brass : public AcctABC {
public:
    Brass(const std::string & s = "Nullbody", long an = -1,
          double bal = 0.0) : AcctABC(s, an, bal) {}
    // 实现基类的纯虚函数 Withdraw
    virtual void Withdraw(double amt) override;
    // 实现基类的纯虚函数 ViewAcct
    virtual void ViewAcct() const override;
    // Brass 类没有新的纯虚函数，所以是具体类
    virtual ~Brass() {}
};

// 具体的派生类: BrassPlus Account (带透支保护的支票账户)
class BrassPlus : public AcctABC {
private:
    double maxLoan;     // 最大透支额
    double rate;        // 透支利率
    double owesBank;    // 当前欠款
public:
    BrassPlus(const std::string & s = "Nullbody", long an = -1,
              double bal = 0.0, double ml = 500,
              double r = 0.11125);
    BrassPlus(const Brass & ba, double ml = 500, double r = 0.11125);
    // 实现基类的纯虚函数 Withdraw
    virtual void Withdraw(double amt) override;
    // 实现基类的纯虚函数 ViewAcct
    virtual void ViewAcct() const override;
    // 派生类自己的方法
    void ResetMax(double m) { maxLoan = m; }
    void ResetRate(double r) { rate = r; };
    void ResetOwes() { owesBank = 0; }
    virtual ~BrassPlus() {}
};

#endif // ACCTABC_H_

#include <iostream>
#include "acctabc.h"
using std::cout;
using std::ios_base;
using std::endl;
using std::string;

// --- AcctABC 方法实现 ---
// 构造函数
AcctABC::AcctABC(const string & s, long an, double bal) {
    fullName = s;
    acctNum = an;
    balance = bal;
}

// 存款 (非虚函数，所有账户类型通用)
void AcctABC::Deposit(double amt) {
    if (amt < 0)
        cout << "Negative deposit not allowed; "
             << "deposit is cancelled.\n";
    else
        balance += amt;
}

// 注意：纯虚函数 Withdraw() 和 ViewAcct() 在基类中没有实现体

// 辅助格式化函数
AcctABC::Formatting AcctABC::SetFormat() const {
    Formatting f;
    f.flag = cout.setf(ios_base::fixed, ios_base::floatfield); // use fixed-point
    f.pr = cout.precision(2); // for $$$.cc format
    return f;
}

void AcctABC::Restore(Formatting & f) const {
    cout.setf(f.flag, ios_base::floatfield);
    cout.precision(f.pr);
}

// --- Brass 方法实现 ---
// 实现纯虚函数 Withdraw
void Brass::Withdraw(double amt) {
    if (amt < 0) {
        cout << "Withdrawal amount must be positive; "
             << "withdrawal canceled.\n";
    } else if (amt <= Balance()) { // 使用基类的 Balance() 方法
        AcctABC::Withdraw(amt); // 调用基类版本来更新余额 (如果基类有实现的话，这里假设基类没实现，直接修改)
        balance -= amt;

    } else {
        cout << "Withdrawal amount of $" << amt
             << " exceeds your balance.\n"
             << "Withdrawal canceled.\n";
    }
}

// 实现纯虚函数 ViewAcct
void Brass::ViewAcct() const {
    Formatting f = SetFormat(); // 使用基类的格式化辅助函数
    cout << "Brass Client: " << FullName() << endl; // 使用基类的 protected 方法
    cout << "Account Number: " << AcctNum() << endl; // 使用基类的 protected 方法
    cout << "Balance: $" << Balance() << endl;     // 使用基类的 public 方法
    Restore(f); // 恢复格式
}

// --- BrassPlus 方法实现 ---
BrassPlus::BrassPlus(const string & s, long an, double bal,
                     double ml, double r) : AcctABC(s, an, bal) {
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

BrassPlus::BrassPlus(const Brass & ba, double ml, double r)
           : AcctABC(ba) { // 使用 AcctABC 的隐式复制构造函数 (如果存在且可用)
                           // 或者显式调用 AcctABC(ba.FullName(), ba.AcctNum(), ba.Balance())
                           // (需要 ba 提供访问器或 AcctABC 成员是 protected)
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

// 实现纯虚函数 ViewAcct
void BrassPlus::ViewAcct() const {
    Formatting f = SetFormat();
    cout << "BrassPlus Client: " << FullName() << endl;
    cout << "Account Number: " << AcctNum() << endl;
    cout << "Balance: $" << Balance() << endl;
    cout << "Maximum loan: $" << maxLoan << endl;
    cout << "Owed to bank: $" << owesBank << endl;
    cout.precision(3);
    cout << "Loan Rate: " << 100 * rate << "%\n";
    Restore(f);
}

// 实现纯虚函数 Withdraw
void BrassPlus::Withdraw(double amt) {
    if (amt < 0) {
        cout << "Withdrawal amount must be positive; "
             << "withdrawal canceled.\n";
        return;
    }

    Formatting f = SetFormat();
    double bal = Balance(); // 获取当前余额

    if (amt <= bal) { // 如果余额足够
        // 调用基类的 Withdraw (如果它修改余额) 或直接修改
        // 假设 balance 是 protected:
        balance -= amt;
    } else if (amt <= bal + maxLoan - owesBank) { // 如果余额+剩余可透支额度足够
        double advance = amt - bal; // 需要透支的金额
        owesBank += advance * (1.0 + rate); // 计算欠款 (加上利息)
        cout << "Bank advance: $" << advance << endl;
        cout << "Finance charge: $" << advance * rate << endl;
        Deposit(advance); // 先存入透支额度 (增加余额)
        // 再取款 (修改余额)
        // 假设 balance 是 protected:
        balance -= amt;
    } else {
        cout << "Credit limit exceeded. Transaction cancelled.\n";
    }
    Restore(f);
}

#include <iostream>
#include "acctabc.h" // 包含 ABC 和派生类

const int CLIENTS = 4;

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

    // AcctABC anAccount; // 错误！不能创建抽象基类对象

    AcctABC * p_clients[CLIENTS]; // 可以创建指向 ABC 的指针数组
    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);
        else {
            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(); // 调用虚函数 ViewAcct()
        cout << endl;
    }

    // 释放内存
    for (int i = 0; i < CLIENTS; i++) {
        delete p_clients[i]; // 调用虚析构函数，确保正确的析构函数被调用
    }
    cout << "Done.\n";

    return 0;
}

// dma.h -- 继承和动态内存分配
#ifndef DMA_H_
#define DMA_H_
#include <iostream>

// 使用动态内存分配的基类
class baseDMA {
private:
    char * label;
    int rating;
public:
    baseDMA(const char * l = "null", int r = 0);
    baseDMA(const baseDMA & rs); // 复制构造函数
    virtual ~baseDMA(); // 虚析构函数
    baseDMA & operator=(const baseDMA & rs); // 赋值运算符
    friend std::ostream & operator<<(std::ostream & os, const baseDMA & rs);
};

// 派生类 - 不使用 new
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 & ls);
};
#endif // DMA_H_

// dma.cpp -- 实现
#include "dma.h"
#include <cstring>

// --- baseDMA 实现 ---
baseDMA::baseDMA(const char * l, int r) {
    label = new char[std::strlen(l) + 1];
    std::strcpy(label, l);
    rating = r;
}

baseDMA::baseDMA(const baseDMA & rs) { // 深复制
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
}

baseDMA::~baseDMA() {
    delete [] label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs) { // 深复制赋值
    if (this == &rs)
        return *this;
    delete [] label; // 释放旧内存
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
    return *this;
}

std::ostream & operator<<(std::ostream & os, const baseDMA & rs) {
    os << "Label: " << rs.label << std::endl;
    os << "Rating: " << rs.rating << std::endl;
    return os;
}

// --- lacksDMA 实现 ---
lacksDMA::lacksDMA(const char * c, const char * l, int r)
    : baseDMA(l, r) { // 调用基类构造函数
    std::strncpy(color, c, COL_LEN - 1);
    color[COL_LEN - 1] = '\0';
}

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

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls) {
    // 调用基类的 operator<< (需要友元或类型转换，或者直接访问)
    // 这里假设通过类型转换或直接调用基类方法
    os << (const baseDMA &) ls; // 将派生类引用转换为基类引用来调用基类 operator<<
    os << "Color: " << ls.color << std::endl;
    return os;
}

// usedma.cpp -- 使用示例
#include <iostream>
#include "dma.h"
int main() {
    using std::cout;
    using std::endl;
    baseDMA shirt("Portabelly", 8);
    lacksDMA balloon("red", "Blimpo", 4); // 派生类对象
    lacksDMA balloon2(balloon); // 使用默认复制构造函数
    cout << "Displaying baseDMA object:\n";
    cout << shirt;
    cout << "Displaying lacksDMA object:\n";
    cout << balloon;
    cout << "Result of lacksDMA copy:\n";
    cout << balloon2;

    baseDMA * p_dma = &balloon; // 基类指针指向派生类
    cout << "Deleting derived object via base pointer:\n";
    delete p_dma; // 正确调用 ~lacksDMA() (默认) 然后 ~baseDMA() (虚函数)

    return 0;
}

// dma.h (续)
// 派生类 - 使用 new
class hasDMA : public baseDMA {
private:
    char * style; // 派生类管理的动态内存
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 & hs); // 赋值运算符
    friend std::ostream & operator<<(std::ostream & os, const hasDMA & hs);
};

// dma.cpp (续)
// --- hasDMA 实现 ---
hasDMA::hasDMA(const char * s, const char * l, int r)
    : baseDMA(l, r) { // 调用基类构造函数
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const char * s, const baseDMA & rs)
    : baseDMA(rs) { // 调用基类复制构造函数
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const hasDMA & hs)
    : baseDMA(hs) { // *** 调用基类复制构造函数 ***
    style = new char[std::strlen(hs.style) + 1]; // 深复制派生类成员
    std::strcpy(style, hs.style);
}

hasDMA::~hasDMA() {
    delete [] style; // 释放派生类分配的内存 (基类析构函数会自动调用)
}

hasDMA & hasDMA::operator=(const hasDMA & hs) {
    if (this == &hs)
        return *this;
    baseDMA::operator=(hs); // *** 调用基类赋值运算符 ***
    delete [] style;        // 释放派生类旧内存
    style = new char[std::strlen(hs.style) + 1]; // 深复制派生类成员
    std::strcpy(style, hs.style);
    return *this;
}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs) {
    os << (const baseDMA &) hs; // 显示基类部分
    os << "Style: " << hs.style << std::endl; // 显示派生类部分
    return os;
}

// usedma.cpp (续)
int main() {
    // ... (之前的代码) ...

    cout << "\nTesting hasDMA:\n";
    hasDMA map("Mercator", "Buffalo Keys", 5);
    hasDMA map2 = map; // 调用 hasDMA 复制构造函数
    hasDMA map3;
    map3 = map; // 调用 hasDMA 赋值运算符

    cout << "Displaying hasDMA object:\n";
    cout << map;
    cout << "Result of hasDMA copy:\n";
    cout << map2;
    cout << "Result of hasDMA assignment:\n";
    cout << map3;

    baseDMA * p_dma2 = &map; // 基类指针指向派生类
    cout << "Deleting derived object via base pointer:\n";
    delete p_dma2; // 正确调用 ~hasDMA() 然后 ~baseDMA()

    return 0;
}