C++ primer plus(第六版)编程练习答案第13章类继承

古城微笑少年丶 2024-03-24 08:37 53阅读 0赞

## 一、程序清单 ##

## tabtenn0.h ##

// tabtenn0.h -- a table-tennis base class
    #ifndef TABTENN0_H_
    #define TABTENN0_H_
    #include <string>
    using std::string;
    // simple base class
    class TableTennisPlayer
    {
    private:
    	string firstname;
    	string lastname;
    	bool hasTable;
    public:
    	TableTennisPlayer(const string & fn = "none",
    		const string & ln = "none", bool ht = false);
    	void Name() const;
    	bool HasTable() const { return hasTable; };
    	void ResetTable(bool v) { hasTable = v; };
    };
    #endif

## **tabtenn0.cpp**  ##

//tabtenn0.cpp -- simple base-class methods
    #include "tabtenn0.h"
    #include <iostream>
    
    TableTennisPlayer::TableTennisPlayer(const string & fn,
    	const string & ln, bool ht) : firstname(fn),
    	lastname(ln), hasTable(ht) {}
    
    void TableTennisPlayer::Name() const
    {
    	std::cout << lastname << ", " << firstname;
    }

## usett0.cpp ##

// usett0.cpp -- using a base class
    #include <iostream>
    #include "tabtenn0.h"
    
    int main(void)
    {
    	using std::cout;
    	TableTennisPlayer player1("Chuck", "Blizzard", true);
    	TableTennisPlayer player2("Tara", "Boomdea", false);
    	player1.Name();
    	if (player1.HasTable())
    		cout << ": has a table.\n";
    	else
    		cout << ": hasn't a table.\n";
    	player2.Name();
    	if (player2.HasTable())
    		cout << ": has a table";
    	else
    		cout << ": hasn't a table.\n";
    	// std::cin.get();
    	return 0;
    }

执行结果：

Blizzard, Chuck: has a table.
    Boomdea, Tara: hasn't a table.

## tabtenn1.h ##

// tabtenn1.h -- a table-tennis base class
    #ifndef TABTENN1_H_
    #define TABTENN1_H_
    #include <string>
    using std::string;
    // simple base class
    class TableTennisPlayer
    {
    private:
    	string firstname;
    	string lastname;
    	bool hasTable;
    public:
    	TableTennisPlayer(const string & fn = "none",
    		const string & ln = "none", bool ht = false);
    	void Name() const;
    	bool HasTable() const { return hasTable; };
    	void ResetTable(bool v) { hasTable = v; };
    };
    
    // simple derived class
    class RatedPlayer : public TableTennisPlayer
    {
    private:
    	unsigned int rating;
    public:
    	RatedPlayer(unsigned int r = 0, const string & fn = "none",
    		const 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

## tabtenn1.cpp ##

//tabtenn1.cpp -- simple base-class methods
    #include "tabtenn1.h"
    #include <iostream>
    
    TableTennisPlayer::TableTennisPlayer(const string & fn,
    	const string & ln, bool ht) : firstname(fn),
    	lastname(ln), hasTable(ht) {}
    
    void TableTennisPlayer::Name() const
    {
    	std::cout << lastname << ", " << firstname;
    }
    
    // RatedPlayer methods
    RatedPlayer::RatedPlayer(unsigned int r, const string & fn,
    	const string & ln, bool ht) : TableTennisPlayer(fn, ln, ht)
    {
    	rating = r;
    }
    
    RatedPlayer::RatedPlayer(unsigned int r, const TableTennisPlayer & tp)
    	: TableTennisPlayer(tp), rating(r)
    {
    }

## usett1.cpp ##

// usett1.cpp -- using base class and derived class
    #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);
    	rplayer1.Name();          // derived object uses base method
    	if (rplayer1.HasTable())
    		cout << ": has a table.\n";
    	else
    		cout << ": hasn't a table.\n";
    	player1.Name();           // base object uses base method
    	if (player1.HasTable())
    		cout << ": has a table";
    	else
    		cout << ": hasn't a table.\n";
    	cout << "Name: ";
    	rplayer1.Name();
    	cout << "; Rating: " << rplayer1.Rating() << endl;
    	// initialize RatedPlayer using TableTennisPlayer object
    	RatedPlayer rplayer2(1212, player1);
    	cout << "Name: ";
    	rplayer2.Name();
    	cout << "; Rating: " << rplayer2.Rating() << endl;
    	// std::cin.get();
    	return 0;
    }

执行结果：

Duck, Mallory: has a table.
    Boomdea, Tara: hasn't a table.
    Name: Duck, Mallory; Rating: 1140
    Name: Boomdea, Tara; Rating: 1212

## brass.h ##

// brass.h  -- bank account classes
    #ifndef BRASS_H_
    #define BRASS_H_
    #include <string>
    // Brass Account Class
    class Brass
    {
    private:
    	std::string fullName;
    	long acctNum;
    	double balance;
    public:
    	Brass(const std::string & s = "Nullbody", long an = -1,
    		double bal = 0.0);
    	void Deposit(double amt);
    	virtual void Withdraw(double amt);
    	double Balance() const;
    	virtual void ViewAcct() const;
    	virtual ~Brass() {}
    };
    
    //Brass Plus Account Class
    class BrassPlus : public Brass
    {
    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);
    	virtual void ViewAcct()const;
    	virtual void Withdraw(double amt);
    	void ResetMax(double m) { maxLoan = m; }
    	void ResetRate(double r) { rate = r; };
    	void ResetOwes() { owesBank = 0; }
    };
    
    #endif

## brass.cpp ##

// brass.cpp -- bank account class methods
    #include <iostream>
    #include "brass.h"
    using std::cout;
    using std::endl;
    using std::string;
    
    // formatting stuff
    typedef std::ios_base::fmtflags format;
    typedef std::streamsize precis;
    format setFormat();
    void restore(format f, precis p);
    
    // Brass methods
    
    Brass::Brass(const string & s, long an, double bal)
    {
    	fullName = s;
    	acctNum = an;
    	balance = bal;
    }
    
    void Brass::Deposit(double amt)
    {
    	if (amt < 0)
    		cout << "Negative deposit not allowed; "
    		<< "deposit is cancelled.\n";
    	else
    		balance += amt;
    }
    
    void Brass::Withdraw(double amt)
    {
    	// set up ###.## format
    	format initialState = setFormat();
    	precis prec = cout.precision(2);
    
    	if (amt < 0)
    		cout << "Withdrawal amount must be positive; "
    
    		<< "withdrawal canceled.\n";
    	else if (amt <= balance)
    		balance -= amt;
    	else
    		cout << "Withdrawal amount of $" << amt
    		<< " exceeds your balance.\n"
    		<< "Withdrawal canceled.\n";
    	restore(initialState, prec);
    }
    double Brass::Balance() const
    {
    	return balance;
    }
    
    void Brass::ViewAcct() const
    {
    	// set up ###.## format
    	format initialState = setFormat();
    	precis prec = cout.precision(2);
    	cout << "Client: " << fullName << endl;
    	cout << "Account Number: " << acctNum << endl;
    	cout << "Balance: $" << balance << endl;
    	restore(initialState, prec); // Restore original format
    }
    
    // BrassPlus Methods
    BrassPlus::BrassPlus(const string & s, long an, double bal,
    	double ml, double r) : Brass(s, an, bal)
    {
    	maxLoan = ml;
    	owesBank = 0.0;
    	rate = r;
    }
    
    BrassPlus::BrassPlus(const Brass & ba, double ml, double r)
    	: Brass(ba)   // uses implicit copy constructor
    {
    	maxLoan = ml;
    	owesBank = 0.0;
    	rate = r;
    }
    
    // redefine how ViewAcct() works
    void BrassPlus::ViewAcct() const
    {
    	// set up ###.## format
    	format initialState = setFormat();
    	precis prec = cout.precision(2);
    
    	Brass::ViewAcct();   // display base portion
    	cout << "Maximum loan: $" << maxLoan << endl;
    	cout << "Owed to bank: $" << owesBank << endl;
    	cout.precision(3);  // ###.### format
    	cout << "Loan Rate: " << 100 * rate << "%\n";
    	restore(initialState, prec);
    }
    
    // redefine how Withdraw() works
    void BrassPlus::Withdraw(double amt)
    {
    	// set up ###.## format
    	format initialState = setFormat();
    	precis prec = cout.precision(2);
    
    	double bal = Balance();
    	if (amt <= bal)
    		Brass::Withdraw(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);
    		Brass::Withdraw(amt);
    	}
    	else
    		cout << "Credit limit exceeded. Transaction cancelled.\n";
    	restore(initialState, prec);
    }
    
    format setFormat()
    {
    	// set up ###.## format
    	return cout.setf(std::ios_base::fixed,
    		std::ios_base::floatfield);
    }
    
    void restore(format f, precis p)
    {
    	cout.setf(f, std::ios_base::floatfield);
    	cout.precision(p);
    }

## usebrass1.cpp ##

// usebrass1.cpp -- testing bank account classes
    // compile with brass.cpp
    #include <iostream>
    #include "brass.h"
    
    int main()
    {
    	using std::cout;
    	using std::endl;
    
    	Brass Piggy("Porcelot Pigg", 381299, 4000.00);
    	BrassPlus Hoggy("Horatio Hogg", 382288, 3000.00);
    	Piggy.ViewAcct();
    	cout << endl;
    	Hoggy.ViewAcct();
    	cout << endl;
    	cout << "Depositing $1000 into the Hogg Account:\n";
    	Hoggy.Deposit(1000.00);
    	cout << "New balance: $" << Hoggy.Balance() << endl;
    	cout << "Withdrawing $4200 from the Pigg Account:\n";
    	Piggy.Withdraw(4200.00);
    	cout << "Pigg account balance: $" << Piggy.Balance() << endl;
    	cout << "Withdrawing $4200 from the Hogg Account:\n";
    	Hoggy.Withdraw(4200.00);
    	Hoggy.ViewAcct();
    	// std::cin.get();
    	return 0;
    }

执行结果：

Client: Porcelot Pigg
    Account Number: 381299
    Balance: $4000.00
    
    Client: Horatio Hogg
    Account Number: 382288
    Balance: $3000.00
    Maximum loan: $500.00
    Owed to bank: $0.00
    Loan Rate: 11.125%
    
    Depositing $1000 into the Hogg Account:
    New balance: $4000
    Withdrawing $4200 from the Pigg Account:
    Withdrawal amount of $4200.00 exceeds your balance.
    Withdrawal canceled.
    Pigg account balance: $4000
    Withdrawing $4200 from the Hogg Account:
    Bank advance: $200.00
    Finance charge: $22.25
    Client: Horatio Hogg
    Account Number: 382288
    Balance: $0.00
    Maximum loan: $500.00
    Owed to bank: $222.25
    Loan Rate: 11.125%

## usebrass2.cpp ##

// usebrass2.cpp -- polymorphic example
    // compile with brass.cpp
    #include <iostream>
    #include <string>
    #include "brass.h"
    const int CLIENTS = 4;
    
    int main()
    {
    	using std::cin;
    	using std::cout;
    	using std::endl;
    
    	Brass * p_clients[CLIENTS];
    	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();
    		cout << endl;
    	}
    
    	for (int i = 0; i < CLIENTS; i++)
    	{
    		delete p_clients[i];  // free memory
    	}
    	cout << "Done.\n";
    	/* code to keep window open
    	  if (!cin)
    		 cin.clear();
    	  while (cin.get() != '\n')
    		 continue;
       */
    	return 0;
    }

执行结果：

Enter client's name: Harry Fishsong
    Enter client's account number: 112233
    Enter opening balance: $1500
    Enter 1 for Brass Account or 2 for BrassPlus Account: 1
    Enter client's name: Dinah Otternoe
    Enter client's account number: 121213
    Enter opening balance: $1800
    Enter 1 for Brass Account or 2 for BrassPlus Account: 2
    Enter the overdraft limit: $350
    Enter the interest rate as a decimal fraction: 0.12
    Enter client's name: Brenda Birdherd
    Enter client's account number: 212118
    Enter opening balance: $5200
    Enter 1 for Brass Account or 2 for BrassPlus Account: 2
    Enter the overdraft limit: $800
    Enter the interest rate as a decimal fraction: 0.10
    Enter client's name: Tim Turtletop
    Enter client's account number: 233255
    Enter opening balance: $688
    Enter 1 for Brass Account or 2 for BrassPlus Account: 1
    
    Client: Harry Fishsong
    Account Number: 112233
    Balance: $1500.00
    
    Client: Dinah Otternoe
    Account Number: 121213
    Balance: $1800.00
    Maximum loan: $350.00
    Owed to bank: $0.00
    Loan Rate: 12.000%
    
    Client: Brenda Birdherd
    Account Number: 212118
    Balance: $5200.00
    Maximum loan: $800.00
    Owed to bank: $0.00
    Loan Rate: 10.000%
    
    Client: Tim Turtletop
    Account Number: 233255
    Balance: $688.00
    
    Done.

## acctabc.h ##

// acctabc.h  -- bank account classes
    #ifndef ACCTABC_H_
    #define ACCTABC_H_
    #include <iostream>
    #include <string>
    
    // Abstract Base Class
    class AcctABC
    {
    private:
    	std::string fullName;
    	long acctNum;
    	double balance;
    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:
    	AcctABC(const std::string & s = "Nullbody", long an = -1,
    		double bal = 0.0);
    	void Deposit(double amt);
    	virtual void Withdraw(double amt) = 0; // pure virtual function
    	double Balance() const { return balance; };
    	virtual void ViewAcct() const = 0;     // pure virtual function
    	virtual ~AcctABC() {}
    };
    
    // Brass Account Class
    class Brass :public AcctABC
    {
    public:
    	Brass(const std::string & s = "Nullbody", long an = -1,
    		double bal = 0.0) : AcctABC(s, an, bal) { }
    	virtual void Withdraw(double amt);
    	virtual void ViewAcct() const;
    	virtual ~Brass() {}
    };
    
    //Brass Plus Account Class
    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.10);
    	BrassPlus(const Brass & ba, double ml = 500, double r = 0.1);
    	virtual void ViewAcct()const;
    	virtual void Withdraw(double amt);
    	void ResetMax(double m) { maxLoan = m; }
    	void ResetRate(double r) { rate = r; };
    	void ResetOwes() { owesBank = 0; }
    };
    
    #endif

## acctabc.cpp ##

// acctabc.cpp -- bank account class methods
    #include <iostream>
    #include "acctabc.h"
    using std::cout;
    using std::ios_base;
    using std::endl;
    using std::string;
    
    // Abstract Base Class
    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;
    }
    
    void AcctABC::Withdraw(double amt)
    {
    	balance -= amt;
    }
    
    // protected methods for formatting
    AcctABC::Formatting AcctABC::SetFormat() const
    {
    	// set up ###.## format
    	Formatting f;
    	f.flag =
    		cout.setf(ios_base::fixed, ios_base::floatfield);
    	f.pr = cout.precision(2);
    	return f;
    }
    
    void AcctABC::Restore(Formatting & f) const
    {
    	cout.setf(f.flag, ios_base::floatfield);
    	cout.precision(f.pr);
    }
    
    // Brass methods
    void Brass::Withdraw(double amt)
    {
    	if (amt < 0)
    		cout << "Withdrawal amount must be positive; "
    		<< "withdrawal canceled.\n";
    	else if (amt <= Balance())
    		AcctABC::Withdraw(amt);
    	else
    		cout << "Withdrawal amount of $" << amt
    		<< " exceeds your balance.\n"
    		<< "Withdrawal canceled.\n";
    }
    
    void Brass::ViewAcct() const
    {
    
    	Formatting f = SetFormat();
    	cout << "Brass Client: " << FullName() << endl;
    	cout << "Account Number: " << AcctNum() << endl;
    	cout << "Balance: $" << Balance() << endl;
    	Restore(f);
    }
    
    // BrassPlus Methods
    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)   // uses implicit copy constructor
    {
    	maxLoan = ml;
    	owesBank = 0.0;
    	rate = r;
    }
    
    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);
    }
    
    void BrassPlus::Withdraw(double amt)
    {
    	Formatting f = SetFormat();
    
    	double bal = Balance();
    	if (amt <= bal)
    		AcctABC::Withdraw(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);
    		AcctABC::Withdraw(amt);
    	}
    	else
    		cout << "Credit limit exceeded. Transaction cancelled.\n";
    	Restore(f);
    }

## usebrass3.cpp ##

// 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];
    	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();
    		cout << endl;
    	}
    
    	for (int i = 0; i < CLIENTS; i++)
    	{
    		delete p_clients[i];  // free memory
    	}
    	cout << "Done.\n";
    	// cin.get();
    	return 0;
    }

执行结果：

Enter client's name: Harry Fishsong
    Enter client's account number: 112233
    Enter opening balance: $1500
    Enter 1 for Brass Account or 2 for BrassPlus Account: 1
    Enter client's name: Dinah Otternoe
    Enter client's account number: 121213
    Enter opening balance: $1800
    Enter 1 for Brass Account or 2 for BrassPlus Account: 2
    Enter the overdraft limit: $350
    Enter the interest rate as a decimal fraction: 0.12
    Enter client's name: Brenda Birdherd
    Enter client's account number:
    212118
    Enter opening balance: $5200
    Enter 1 for Brass Account or 2 for BrassPlus Account: 2
    Enter the overdraft limit: $800
    Enter the interest rate as a decimal fraction: 0.10
    Enter client's name: Tim Turtletop
    Enter client's account number: 233255
    Enter opening balance: $688
    Enter 1 for Brass Account or 2 for BrassPlus Account: 1
    
    Brass Client: Harry Fishsong
    Account Number: 112233
    Balance: $1500.00
    
    BrassPlus Client: Dinah Otternoe
    Account Number: 121213
    Balance: $1800.00
    Maximum loan: $350.00
    Owed to bank: $0.00
    Loan Rate: 12.000%
    
    BrassPlus Client: Brenda Birdherd
    Account Number: 212118
    Balance: $5200.00
    Maximum loan: $800.00
    Owed to bank: $0.00
    Loan Rate: 10.000%
    
    Brass Client: Tim Turtletop
    Account Number: 233255
    Balance: $688.00
    
    Done.

## dma.h ##

// dma.h  -- inheritance and dynamic memory allocation
    #ifndef DMA_H_
    #define DMA_H_
    #include <iostream>
    
    //  Base Class Using DMA
    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);
    };
    
    // derived class without DMA
    // no destructor needed
    // uses implicit copy constructor
    // uses implicit assignment operator
    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);
    };
    
    // derived class with DMA
    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 & rs);
    	friend std::ostream & operator<<(std::ostream & os,
    		const hasDMA & rs);
    };
    
    #endif

## dma.cpp ##

// dma.cpp --dma class methods
    
    #include "dma.h"
    #include <cstring>
    #pragma warning(disable:4996)
    
    // baseDMA methods
    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 methods
    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)
    {
    	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;
    }
    
    // hasDMA methods
    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)  // invoke base class copy constructor
    {
    	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);  // copy base portion
    	delete[] style;         // prepare for new 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 ##

// usedma.cpp -- inheritance, friends, and DMA
    // compile with dma.cpp
    #include <iostream>
    #include "dma.h"
    int main()
    {
    	using std::cout;
    	using std::endl;
    
    	baseDMA shirt("Portabelly", 8);
    	lacksDMA balloon("red", "Blimpo", 4);
    	hasDMA map("Mercator", "Buffalo Keys", 5);
    	cout << "Displaying baseDMA object:\n";
    	cout << shirt << endl;
    	cout << "Displaying lacksDMA object:\n";
    	cout << balloon << endl;
    	cout << "Displaying hasDMA object:\n";
    	cout << map << endl;
    	lacksDMA balloon2(balloon);
    	cout << "Result of lacksDMA copy:\n";
    	cout << balloon2 << endl;
    	hasDMA map2;
    	map2 = map;
    	cout << "Result of hasDMA assignment:\n";
    	cout << map2 << endl;
    	// std::cin.get();
    	return 0;
    }

执行结果：

Displaying baseDMA object:
    Label: Portabelly
    Rating: 8
    
    Displaying lacksDMA object:
    Label: Blimpo
    Rating: 4
    Color: red
    
    Displaying hasDMA object:
    Label: Buffalo Keys
    Rating: 5
    Style: Mercator
    
    Result of lacksDMA copy:
    Label: Blimpo
    Rating: 4
    Color: red
    
    Result of hasDMA assignment:
    Label: Buffalo Keys
    Rating: 5
    Style: Mercator

## 二、复习题 ##

1. 派生类从基类那里继承了什么？

派生类继承了基类的公有成员、基类的保护成员和基类的私有成员，但派生类不能直接访问从基类继承过来的私有成员。

2. 派生类不能从基类那里继承什么？

派生类不能继承构造函、析构函数、赋值运算符合友元。

3. 假设baseDMA::operator=()函数的返回类型为void，而不是baseDMA &，这将有什么后果？如果返回类型为baseDMA，而不是baseDMA &，又将有什么后果？

如果返回值为`void`的，则`baseDMA`对象仍可以使用单个赋值，但是不能使用连续赋值。即：

baseDMA magazine("Pandering to Glitz", 1);
    baseDMA gift1, gift2, gift3;
    gift1 = magazine;          //ok
    gitft2 = gift3 = gift1;    //no 不可用

如果方法返回类型为`baseDMA`，则该方法返回的是一个对象，不是引用，导致返回语句的时候需要复制对象，导致该方法执行速度会有所减慢。

4. 创建和删除派生类对象时，构造函数和析构函数调用的顺序是怎样的？

按照派生的顺序调用构造函数，最早的构造函数最先调用。调用析构函数的顺序正好相反。

5. 如果派生类没有添加任何数据成员，它是否需要构造函数？

需要，每个类都必须有自己的构造函数，如果派生类没有添加新成员，则构造函数可以为空，但必须存在。

6. 如果基类和派生类定义了同名的方法，当派生类对象调用该方法时，被调用的将是哪个方法？

调用派生类方法，它取代基类定义。仅当派生类没有重新定义方法或使用作用域解析运算符时，才会调用基类方法。

7. 在什么情况下，派生类应定义赋值运算符？

如果派生类构造函数使用new或者new\[\]运算符来初始化类的指针成员，则应定义一个赋值运算符。更普通的说，如果对于派生类成员来说，默认赋值不正确，则应定义赋值运算符。

8. 可以将派生类对象的地址赋给基类指针吗？可以将基类对象的地址赋给派生类指针吗？

可以将派生类对象的地址赋给基类指针。但只有通过显示类型转换，才可以将基类对象的地址赋给派生类指针（向下转换），而使用这样的指针不一定安全。

9. 可以将派生类对象赋给基类对象吗？可以将基类对象赋给派生类对象吗？

可以将派生类对象的地址赋值给基类对象，对于派生类中新增的数据成员都不会传递给基类对象，程序也将使用基类的赋值运算符。仅当派生类定义了转换运算符（即包含将基类引用作为唯一参数的构造函数）或使用基类为参数的赋值运算符时，相反的赋值才是可能的。

10. 假设定义了一个函数，它将基类对象的引用作为参数。为什么该函数也可以将派生类对象作为参数？

应为c++允许基类引用指向从该基类派生而来的任何类型。

11. 假设定义了一个函数，它将基类对象作为参数（即函数按值传递基类对象）。为什么该函数也可以将派生类对象作为参数？

按值传递对象将调用复制构造函数，由于形参是基类对象，因此将调用基类的复制构造函数，复制构造函数已基类引用为参数，该引用可以将指向作为参数传递的派生对象，最终的结构是，将生成一个新的基类对象，其成员对应于派生类对象的基类部分。

12. 为什么通常按引用传递对象比按值传递对象的效率更高？

按引用传递对象，这样可以确保函数从虚函数受益。另外，按引用传递对象可以节省内存和时间，尤其对于大型对象。按值传递对象的主要有点在于可以保护原始数据，但可以通过将引用作为const类型传递，来达到同样的目的。

13. 假设Corporation是基类，PublicCorporation是派生类。再假设这两个类都定义了head()函数，ph是指向Corporation类型的指针，且被赋给了一个PublicCorporation对象的地址。如果基类将head( )定义为：

a. 常规非虚方法；

b. 虚方法；

则ph->head()将被如何解释？

a. `ph-head()`调用`Corporation::head()`;

b. `ph-head()`调用`PublicCorporation::head()`;

14. 下述代码有什么问题？

>     class Kitchen
>     {
>         private:
>         double kit_sq_ft;
>         public:
>         Kitchen() { kit_sq_ft = 0.0; }
>         virtual double area() const { return kit_sq_ft * kit_sq_ft; }
>     };
>     class House : public Kitchen
>     {
>         private:
>         double all_sq_ft;
>         public: 
>         House() { all_sq_ft += kit_sq_ft;}
>         double area(const char *s) const { cout << s; return all_sq_ft; }
>     };

首先，这种情况不符合`is-a`模型，因此公有继承不适用。其次，`House中area()`定义成带参数的，将隐藏`area()`的`Kitchen`版本。

## 三、编程练习 ##

1. 以下面的类声明为基础：

>     // base class
>     class Cd { // represents a CD disk
>         private:
>         char performers[50];
>         char label[20];
>         int selections; // number of selections
>         double playtime; // playing time in minutes
>         public:
>         Cd(char * s1, char * s2, int n, double x);
>         Cd(const Cd & d);
>         Cd();
>         ~Cd();
>         void Report() const; // reports all CD data
>         Cd & operator=(const Cd & d);
>     };

派生出一个Classic类，并添加一组char成员，用于存储指出CD中主要作品的字符串。修改上述声明，使基类的所有函数都是虚的。如果上述定义声明的某个方法并不需要，则请删除它。使用下面的程序测试您的产品：

>     #include <iostream>
>     using namespace std;
>     #include "classic.h" // which will contain #include cd.h
>     void Bravo(const Cd & disk);
>     int main()
>     {
>         Cd c1("Beatles", "Capitol", 14, 35.5);
>         Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C",
>                              "Alfred Brendel", "Philips", 2, 57.17);
>         Cd *pcd = &c1;
>         cout << "Using object directly:\n";
>         c1.Report(); // use Cd method
>         c2.Report(); // use Classic method
>         cout << "Using type cd * pointer to objects:\n";
>         pcd->Report(); // use Cd method for cd object
>         pcd = &c2;
>         pcd->Report(); // use Classic method for classic object
>         cout << "Calling a function with a Cd reference argument:\n";
>         Bravo(c1);
>         Bravo(c2);
>         cout << "Testing assignment: ";
>         Classic copy;
>         copy = c2;
>         copy.Report();
>         return 0;
>     }
>     void Bravo(const Cd & disk)
>     {
>         disk.Report();
>     }

classic.h:

// base class
    class Cd {  // represents a CD disk
     private:
      char performers[50];
      char label[20];
      int selections;   // number of selections
      double playtime;  // playing time in minutes
     public:
      Cd(char* s1, char* s2, int n, double x);
      Cd(const Cd& d);
      Cd();
      virtual ~Cd();
      virtual void Report() const;  // reports all CD data
      virtual Cd& operator=(const Cd& d);
    };
    
    class Classic : public Cd {
     private:
      char* primary_work;
    
     public:
      Classic(char* sc, char* s1, char* s2, int n, double x);
      Classic(const Classic& c);
      Classic();
      virtual ~Classic();
      virtual void Report() const;
      virtual Classic& operator=(const Classic& c);
    };

classic.cpp:

#include "classic.h"
    
    #include <cstring>
    #include <iostream>
    
    Cd::Cd(char* s1, char* s2, int n, double x) {
      std::strncpy(performers, s1, 50);
      std::strncpy(label, s2, 20);
      selections = n;
      playtime = x;
    }
    
    Cd::Cd(const Cd& d) {
      std::strncpy(performers, d.performers, 50);
      std::strncpy(label, d.label, 20);
      selections = d.selections;
      playtime = d.playtime;
    }
    Cd::Cd() {
      performers[0] = '\0';
      label[0] = '\0';
      selections = 0;
      playtime = 0;
    }
    Cd::~Cd() {}
    
    void Cd::Report() const {
      std::cout << "Performers: " << performers << std::endl;
      std::cout << "Label: " << label << std::endl;
      std::cout << "Selections: " << selections << std::endl;
      std::cout << "PlayTime: " << playtime << std::endl;
    }
    
    Cd& Cd::operator=(const Cd& d) {
      if (&d == this) return *this;
      std::strncpy(performers, d.performers, 50);
      std::strncpy(label, d.label, 20);
      selections = d.selections;
      playtime = d.playtime;
      return *this;
    }
    
    Classic::Classic(char* sc, char* s1, char* s2, int n, double x)
        : Cd(s1, s2, n, x) {
      primary_work = new char[std::strlen(sc) + 1];
      std::strcpy(primary_work, sc);
    }
    
    Classic::Classic(const Classic& c) : Cd(c) {
      primary_work = new char[std::strlen(c.primary_work) + 1];
      std::strcpy(primary_work, c.primary_work);
    }
    
    Classic::Classic() : Cd() { primary_work = nullptr; }
    
    Classic::~Classic() { delete[] primary_work; }
    
    void Classic::Report() const {
      Cd::Report();
      std::cout << "PrimaryWork: " << primary_work << std::endl;
    }
    
    Classic& Classic::operator=(const Classic& c) {
      if (&c == this) return *this;
      delete[] primary_work;
      Cd::operator=(c);
      primary_work = new char[std::strlen(c.primary_work) + 1];
      std::strcpy(primary_work, c.primary_work);
      return *this;
    }

main.cpp:

#include <iostream>
    using namespace std;
    #include "classic.h"  // which will contain #include cd.h
    void Bravo(const Cd &disk);
    int main() {
      Cd c1("Beatles", "Capitol", 14, 35.5);
      Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C",
                           "Alfred Brendel", "Philips", 2, 57.17);
      Cd *pcd = &c1;
      cout << "Using object directly:\n";
      c1.Report();  // use Cd method
      c2.Report();  // use Classic method
      cout << "Using type cd * pointer to objects:\n";
      pcd->Report();  // use Cd method for cd object
      pcd = &c2;
      pcd->Report();  // use Classic method for classic object
      cout << "Calling a function with a Cd reference argument:\n";
      Bravo(c1);
      Bravo(c2);
      cout << "Testing assignment: ";
      Classic copy;
      copy = c2;
      copy.Report();
      return 0;
    }
    void Bravo(const Cd &disk) { disk.Report(); }

2. 完成练习1，但让两个类使用动态内存分配而不是长度固定的数组来记录字符串。

classic.h:

// base class
    class Cd {  // represents a CD disk
     private:
      char* performers;
      char* label;
      int selections;   // number of selections
      double playtime;  // playing time in minutes
     public:
      Cd(char* s1, char* s2, int n, double x);
      Cd(const Cd& d);
      Cd();
      virtual ~Cd();
      virtual void Report() const;  // reports all CD data
      virtual Cd& operator=(const Cd& d);
    };
    
    class Classic : public Cd {
     private:
      char* primary_work;
    
     public:
      Classic(char* sc, char* s1, char* s2, int n, double x);
      Classic(const Classic& c);
      Classic();
      virtual ~Classic();
      virtual void Report() const;
      virtual Classic& operator=(const Classic& c);
    };

classic.cpp:

#include "classic.h"
    
    #include <cstring>
    #include <iostream>
    
    Cd::Cd(char* s1, char* s2, int n, double x) {
      performers = new char[std::strlen(s1) + 1];
      label = new char[std::strlen(s2) + 1];
      std::strcpy(performers, s1);
      std::strcpy(label, s2);
      selections = n;
      playtime = x;
    }
    
    Cd::Cd(const Cd& d) {
      performers = new char[std::strlen(d.performers) + 1];
      label = new char[std::strlen(d.label) + 1];
      std::strcpy(performers, d.performers);
      std::strcpy(label, d.label);
      selections = d.selections;
      playtime = d.playtime;
    }
    Cd::Cd() {
      performers = nullptr;
      label = nullptr;
      selections = 0;
      playtime = 0;
    }
    Cd::~Cd() {
      delete[] performers;
      delete[] label;
    }
    
    void Cd::Report() const {
      std::cout << "Performers: " << performers << std::endl;
      std::cout << "Label: " << label << std::endl;
      std::cout << "Selections: " << selections << std::endl;
      std::cout << "PlayTime: " << playtime << std::endl;
    }
    
    Cd& Cd::operator=(const Cd& d) {
      if (&d == this) return *this;
      std::strncpy(performers, d.performers, 50);
      std::strncpy(label, d.label, 20);
      selections = d.selections;
      playtime = d.playtime;
      return *this;
    }
    
    Classic::Classic(char* sc, char* s1, char* s2, int n, double x)
        : Cd(s1, s2, n, x) {
      primary_work = new char[std::strlen(sc) + 1];
      std::strcpy(primary_work, sc);
    }
    
    Classic::Classic(const Classic& c) : Cd(c) {
      primary_work = new char[std::strlen(c.primary_work) + 1];
      std::strcpy(primary_work, c.primary_work);
    }
    
    Classic::Classic() : Cd() { primary_work = nullptr; }
    
    Classic::~Classic() { delete[] primary_work; }
    
    void Classic::Report() const {
      Cd::Report();
      std::cout << "PrimaryWork: " << primary_work << std::endl;
    }
    
    Classic& Classic::operator=(const Classic& c) {
      if (&c == this) return *this;
      delete[] primary_work;
      Cd::operator=(c);
      primary_work = new char[std::strlen(c.primary_work) + 1];
      std::strcpy(primary_work, c.primary_work);
      return *this;
    }

main.cpp:

3. 修改baseDMA-lacksDMA-hasDMA类层次，让三个类都从一个ABC派生而来，然后使用与程序清单13.10相似的程序对结果进行测试。也就是说，它应使用ABC指针数组，并让用户决定要创建的对象类型。在类定义中添加virtual View()方法以处理数据显示。

abc.h:

#ifndef ABC_H_
    #define ABC_H_
    
    #include <iostream>
    class ABC {
     private:
      char* label;
      int rating;
    
     public:
      ABC(const char* l = "null", int r = 1);
      ABC(const ABC& a);
      virtual ~ABC() = 0;
      virtual void View() const;
      ABC& operator=(const ABC& a);
      friend std::ostream& operator<<(std::ostream& os, const ABC& a);
    };
    
    class baseDMA : public ABC {
     private:
     public:
      baseDMA(const char* l = "null", int r = 0);
      friend std::ostream& operator<<(std::ostream& os, const baseDMA& rs);
    };
    
    class lacksDMA : public ABC {
     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 ABC& a);
      virtual void View() const;
      friend std::ostream& operator<<(std::ostream& os, const lacksDMA& rs);
    };
    
    class hasDMA : public ABC {
     private:
      char* style;
    
     public:
      hasDMA(const char* s = "none", const char* l = "null", int r = 0);
      hasDMA(const char* s, const ABC& c);
      hasDMA(const hasDMA& hs);
      ~hasDMA();
      virtual void View() const;
      hasDMA& operator=(const hasDMA& rs);
      friend std::ostream& operator<<(std::ostream& os, const hasDMA& rs);
    };
    
    #endif  // ABC_H_

abc.cpp:

#include "abc.h"
    
    #include <cstring>
    
    ABC::ABC(const char* l, int r) {
      label = new char(std::strlen(l) + 1);
      std::strcpy(label, l);
      rating = r;
    }
    ABC::ABC(const ABC& a) {
      label = new char(std::strlen(a.label) + 1);
      std::strcpy(label, a.label);
      rating = a.rating;
    }
    
    ABC::~ABC() { delete[] label; }
    
    void ABC::View() const { std::cout << *this << std::endl; }
    
    ABC& ABC::operator=(const ABC& a) {
      if (&a == this) return *this;
      delete[] label;
      label = new char[std::strlen(a.label) + 1];
      std::strcpy(label, a.label);
      rating = a.rating;
    }
    
    std::ostream& operator<<(std::ostream& os, const ABC& a) {
      os << "label: " << a.label << ", rating: " << a.rating;
      return os;
    }
    
    /***************baseDMA************/
    
    baseDMA::baseDMA(const char* l, int r) : ABC(l, r) {}
    
    std::ostream& operator<<(std::ostream& os, const baseDMA& rs) {
      os << (const ABC&)rs;
      return os;
    }
    
    /***************lacksDMA************/
    lacksDMA::lacksDMA(const char* c, const char* l, int r) : ABC(l, r) {
      std::strncpy(color, c, COL_LEN);
    }
    
    lacksDMA::lacksDMA(const char* c, const ABC& a) : ABC(a) {
      std::strncpy(color, c, COL_LEN);
    }
    
    void lacksDMA::View() const { std::cout << *this << std::endl; }
    
    std::ostream& operator<<(std::ostream& os, const lacksDMA& rs) {
      os << (const ABC&)rs << ", color: " << rs.color;
      return os;
    }
    
    /***************hasDMA************/
    hasDMA::hasDMA(const char* s, const char* l, int r) : ABC(l, r) {
      style = new char[std::strlen(s) + 1];
      std::strcpy(style, s);
    }
    
    hasDMA::hasDMA(const char* s, const ABC& c) : ABC(c) {
      style = new char[std::strlen(s) + 1];
      std::strcpy(style, s);
    }
    
    hasDMA::hasDMA(const hasDMA& hs) : ABC(hs) {
      style = new char[std::strlen(hs.style) + 1];
      std::strcpy(style, hs.style);
    }
    
    hasDMA::~hasDMA() { delete[] style; }
    
    void hasDMA::View() const { std::cout << *this << std::endl; }
    
    hasDMA& hasDMA::operator=(const hasDMA& hs) {
      if (this == &hs) return *this;
      ABC::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& rs) {
      os << (const ABC&)rs << ", style: " << rs.style;
      return os;
    }

main.cpp:

#include <iostream>
    
    #include "abc.h"
    
    int main() {
      using std::cout;
      using std::endl;
    
      baseDMA shirt("Portrabelly", 8);
      lacksDMA balloon("red", "Blumpo", 4);
      hasDMA map("Mercator", "Buffalo Kyes", 5);
      cout << shirt << endl;
      cout << balloon << endl;
      cout << map << endl;
      lacksDMA balloon2(balloon);
      hasDMA map2;
      map2 = map;
      cout << balloon2 << endl;
      cout << map2 << endl;
    
      ABC* pts[3];
      pts[0] = &shirt;
      pts[1] = &balloon;
      pts[2] = &map;
    
      for (int i = 0; i < 3; ++i) cout << *pts[i] << endl;
      for (int i = 0; i < 3; ++i) pts[i]->View();
    
      return 0;
    }

4. Benevolent Order of Programmers用来维护瓶装葡萄酒箱。为描述它，BOP Portmaster设置了一个Port类，其声明如下

>     #include <iostream>
>     using namespace std;
>     class Port
>     {
>         private:
>         char * brand;
>         char style[20]; // i.e., tawny, ruby, vintage
>         int bottles;
>         public:
>         Port(const char * br = "none", const char * st = "none", int b = 0);
>         Port(const Port & p); // copy constructor
>         virtual ~Port() { delete [] brand; }
>         Port & operator=(const Port & p);
>         Port & operator+=(int b); // adds b to bottles
>         Port & operator-=(int b); // subtracts b from bottles, if available
>         int BottleCount() const { return bottles; }
>         virtual void Show() const;
>         friend ostream & operator<<(ostream & os, const Port & p);
>        };

show()方法按下面的格式显示信息：

>     Brand: Gallo
>     Kind: tawny
>     Bottles: 20

operator<<()函数按下面的格式显示信息（末尾没有换行符）：

>     Gallo, tawny, 20

PortMaster完成了Por类的方法定义后派生了VintagePort类，然后被解职——因为不小心将一瓶45度Cockburn泼到了正在准备烤肉调料的人身上，VintagePort类如下所示：

>     class VintagePort : public Port // style necessarily = "vintage"
>     {
>         private:
>         char * nickname; // i.e., "The Noble" or "Old Velvet", etc.
>         int year; // vintage year
>         public:
>         VintagePort();
>         VintagePort(const char * br, int b, const char * nn, int y);
>         VintagePort(const VintagePort & vp);
>         ~VintagePort() { delete [] nickname; }
>         VintagePort & operator=(const VintagePort & vp);
>         void Show() const;
>         friend ostream & operator<<(ostream & os, const VintagePort & vp);
>     };

您被指定负责完成VintagePort。

a. 第一个任务是重新创建Port方法定义，因为前任被开除时销毁了方法定义。

b. 第二个任务是解释为什么有的方法重新定义了，而有些没有重新定义。

c. 第三个任务是解释为何没有将operator=()和operator<<()声明为虚的。

d. 第四个任务是提供VintagePort中各个方法的定义。

port.h:

#ifndef PORT_H_
    #define PORT_H_
    
    #include <iostream>
    using namespace std;
    class Port {
     private:
      char* brand;
      char style[20];  // i.e., tawny, ruby, vintage
      int bottles;
    
     public:
      Port(const char* br = "none", const char* st = "none", int b = 0);
      Port(const Port& p);  // copy constructor
      virtual ~Port() { delete[] brand; }
      Port& operator=(const Port& p);
      //派生类的计算逻辑与基类一致，且在该方法中派生类未操作其新增成员，因此该函数在派生类中不需要重新定义
      Port& operator+=(int b);  // adds b to bottles
      //派生类的计算逻辑与基类一致，且在该方法中派生类未操作其新增成员，因此该函数在派生类中不需要重新定义
      Port& operator-=(int b);  // subtracts b from bottles, if available
      int BottleCount() const { return bottles; }
      virtual void Show() const;
      friend ostream& operator<<(ostream& os, const Port& p);
    };
    
    class VintagePort : public Port  // style necessarily = "vintage"
    {
     private:
      char* nickname;  // i.e., "The Noble" or "Old Velvet", etc.
      int year;        // vintage year
     public:
      VintagePort();//派生类使用了动态内存分配，需要重新定义
      VintagePort(const char* br, int b, const char* nn, int y);//同上
      VintagePort(const VintagePort& vp);//同上
      ~VintagePort() { delete[] nickname; }//派生类使用了动态内存分配，且析构函数不能被继承，需要重新定义
      VintagePort& operator=(const VintagePort& vp);//增加了新的成员nickname和year，且赋值运算符不能被继承，需要重新定义
      void Show() const;//增加了新的成员nickname和year，需要重新定义
      friend ostream& operator<<(ostream& os, const VintagePort& vp);//友元函数不属于成员函数，无法继承
    };
    
    #endif  // PORT_H_

port.cpp:

#include "port.h"
    
    #include <cstring>
    
    Port::Port(const char* br, const char* st, int b) {
      brand = new char[strlen(br) + 1];
      strcpy(brand, br);
      strncpy(style, st, 20);
      bottles = b;
    }
    
    Port::Port(const Port& p) {
      brand = new char[strlen(p.brand) + 1];
      strcpy(brand, p.brand);
      strncpy(style, p.style, 20);
      bottles = p.bottles;
    }
    
    Port& Port::operator=(const Port& p) {
      if (&p == this) return *this;
      delete[] brand;
      brand = new char[strlen(p.brand) + 1];
      strcpy(brand, p.brand);
      strncpy(style, p.style, 20);
      bottles = p.bottles;
      return *this;
    }
    
    Port& Port::operator+=(int b) {
      bottles += b;
      return *this;
    }
    
    Port& Port::operator-=(int b) {
      bottles -= b;
      return *this;
    }
    
    void Port::Show() const {
      cout << "Brand: " << brand << endl;
      cout << "Style: " << style << endl;
      cout << "Bottles: " << bottles << endl;
    }
    
    ostream& operator<<(ostream& os, const Port& p) {
      os << p.brand << ", " << p.style << ", " << p.bottles;
      return os;
    }
    
    VintagePort::VintagePort() : Port() {
      nickname = new char[strlen("none") + 1];
      strcpy(nickname, "none");
      year = 0;
    }
    
    VintagePort::VintagePort(const char* br, int b, const char* nn, int y)
        : Port(br, "Vintage", b) {
      nickname = new char[strlen(nn) + 1];
      strcpy(nickname, nn);
      year = y;
    }
    
    VintagePort::VintagePort(const VintagePort& vp) : Port(vp) {
      nickname = new char[std::strlen(vp.nickname) + 1];
      std::strcpy(nickname, vp.nickname);
      year = vp.year;
    }
    
    VintagePort& VintagePort::operator=(const VintagePort& vp) {
      if (this == &vp) return *this;
      Port::operator=(vp);
      delete[] nickname;
      nickname = new char[std::strlen(vp.nickname) + 1];
      std::strcpy(nickname, vp.nickname);
      year = vp.year;
    
      return *this;
    }
    
    void VintagePort::Show() const {
      Port::Show();
      cout << "Nickname: " << nickname << endl;
      cout << "Year: " << year << endl;
    }
    
    ostream& operator<<(ostream& os, const VintagePort& vp) {
      os << (const Port&)vp;
      os << ", " << vp.nickname << ", " << vp.year;
      return os;
    }

main.cpp:

#include <iostream>
    
    #include "port.h"
    
    int main() {
      Port p1;
      Port p2("Abc", "Bcc", 30);
      std::cout << p1 << std::endl;
      std::cout << p2 << std::endl;
      Port p3 = p2;
      p3.Show();
      p3 += 3;
      p3.Show();
      Port p4 = p2;
      p3 -= 2;
      p3.Show();
    
      VintagePort vp1("Vabc", 50, "hn", 1983);
      vp1.Show();
      VintagePort vp2;
      vp2.Show();
      vp1 -= 3;
      vp2 = vp1;
      std::cout << vp2 << std::endl;
    
      return 0;
    }