C++ primer plus(第六版)编程练习答案第10章对象和类

绝地灬酷狼 2024-03-24 08:35 53阅读 0赞

## 一、程序清单 ##

## stock00.h ##

// stock00.h -- Stock class interface
    // version 00
    #ifndef STOCK00_H_
    #define STOCK00_H_
    
    #include <string>  
    
    class Stock  // class declaration
    {
    private:
    	std::string company;
    	long shares;
    	double share_val;
    	double total_val;
    	void set_tot() { total_val = shares * share_val; }
    public:
    	void acquire(const std::string & co, long n, double pr);
    	void buy(long num, double price);
    	void sell(long num, double price);
    	void update(double price);
    	void show();
    };    // note semicolon at the end
    
    #endif

## stock00.cpp ##

// stock00.cpp -- implementing the Stock class
    // version 00
    #include <iostream>
    #include "stock00.h"
    
    void Stock::acquire(const std::string & co, long n, double pr)
    {
    	company = co;
    	if (n < 0)
    	{
    		std::cout << "Number of shares can't be negative; "
    			<< company << " shares set to 0.\n";
    		shares = 0;
    	}
    	else
    		shares = n;
    	share_val = pr;
    	set_tot();
    }
    
    void Stock::buy(long num, double price)
    {
    	if (num < 0)
    	{
    		std::cout << "Number of shares purchased can't be negative. "
    			<< "Transaction is aborted.\n";
    	}
    	else
    	{
    		shares += num;
    		share_val = price;
    		set_tot();
    	}
    }
    
    void Stock::sell(long num, double price)
    {
    	using std::cout;
    	if (num < 0)
    	{
    		cout << "Number of shares sold can't be negative. "
    			<< "Transaction is aborted.\n";
    	}
    	else if (num > shares)
    	{
    		cout << "You can't sell more than you have! "
    			<< "Transaction is aborted.\n";
    	}
    	else
    	{
    		shares -= num;
    		share_val = price;
    		set_tot();
    	}
    }
    
    void Stock::update(double price)
    {
    	share_val = price;
    	set_tot();
    }
    
    void Stock::show()
    {
    	std::cout << "Company: " << company
    		<< "  Shares: " << shares << '\n'
    		<< "  Share Price: $" << share_val
    		<< "  Total Worth: $" << total_val << '\n';
    }

## usestok0.cpp ##

// usestok0.cpp -- the client program
    // compile with stock.cpp
    #include <iostream>
    #include "stock00.h"
    
    int main()
    {
    	Stock fluffy_the_cat;
    	fluffy_the_cat.acquire("NanoSmart", 20, 12.50);
    	fluffy_the_cat.show();//20 $12.5 $250
    	fluffy_the_cat.buy(15, 18.125);
    	fluffy_the_cat.show();//20+15=35 18.125 18.125*35=634.375
    	fluffy_the_cat.sell(400, 20.00);
    	fluffy_the_cat.show();//20+15=35 18.125 634.375
    	fluffy_the_cat.buy(300000, 40.125);
    	fluffy_the_cat.show();//300000+20+15=300035 40.125 300035*40.125=12,038,904.375
    	fluffy_the_cat.sell(300000, 0.125);
    	fluffy_the_cat.show();//300035-300000=35 0.125  35*0.125=4.375
    	// std::cin.get();
    	return 0;
    }

执行结果：

Company: NanoSmart  Shares: 20
      Share Price: $12.5  Total Worth: $250
    Company: NanoSmart  Shares: 35
      Share Price: $18.125  Total Worth: $634.375
    You can't sell more than you have! Transaction is aborted.
    Company: NanoSmart  Shares: 35
      Share Price: $18.125  Total Worth: $634.375
    Company: NanoSmart  Shares: 300035
      Share Price: $40.125  Total Worth: $1.20389e+07
    Company: NanoSmart  Shares: 35
      Share Price: $0.125  Total Worth: $4.375

修改：

>     void Stock::show()
>     {
>     	using std::cout;
>     	using std::ios_base;
>     	ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
>     	std::streamsize prec = cout.precision(3);
>     	cout << "Company: " << company
>     		<< "  Shares: " << shares << '\n'
>     		<< "  Share Price: $" << share_val;
>     	cout.precision(2);
>     	cout<< "  Total Worth: $" << total_val << '\n';
>     	cout.setf(orig, ios_base::floatfield);
>     	cout.precision(prec);
>     }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16][]执行结果：

Company: NanoSmart  Shares: 20
      Share Price: $12.500  Total Worth: $250.00
    Company: NanoSmart  Shares: 35
      Share Price: $18.125  Total Worth: $634.38
    You can't sell more than you have! Transaction is aborted.
    Company: NanoSmart  Shares: 35
      Share Price: $18.125  Total Worth: $634.38
    Company: NanoSmart  Shares: 300035
      Share Price: $40.125  Total Worth: $12038904.38
    Company: NanoSmart  Shares: 35
      Share Price: $0.125  Total Worth: $4.38

## stock10.h ##

// stock10.h ?Stock class declaration with constructors, destructor added
    #ifndef STOCK1_H_
    #define STOCK1_H_
    #include <string>
    class Stock
    {
    private:
    	std::string company;
    	long shares;
    	double share_val;
    	double total_val;
    	void set_tot() { total_val = shares * share_val; }
    public:
    	Stock();        // default constructor
    	Stock(const std::string & co, long n = 0, double pr = 0.0);
    	~Stock();       // noisy destructor
    	void buy(long num, double price);
    	void sell(long num, double price);
    	void update(double price);
    	void show();
    };
    
    #endif

## stock1.cpp ##

// stock1.cpp ?Stock class implementation with constructors, destructor added
    #include <iostream>
    #include "stock10.h"
    
    // constructors (verbose versions)
    Stock::Stock()        // default constructor
    {
    	std::cout << "Default constructor called\n";
    	company = "no name";
    	shares = 0;
    	share_val = 0.0;
    	total_val = 0.0;
    }
    
    Stock::Stock(const std::string & co, long n, double pr)
    {
    	std::cout << "Constructor using " << co << " called\n";
    	company = co;
    
    	if (n < 0)
    	{
    		std::cout << "Number of shares can't be negative; "
    			<< company << " shares set to 0.\n";
    		shares = 0;
    	}
    	else
    		shares = n;
    	share_val = pr;
    	set_tot();
    }
    // class destructor
    Stock::~Stock()        // verbose class destructor
    {
    	std::cout << "Bye, " << company << "!\n";
    }
    
    // other methods
    void Stock::buy(long num, double price)
    {
    	if (num < 0)
    	{
    		std::cout << "Number of shares purchased can't be negative. "
    			<< "Transaction is aborted.\n";
    	}
    	else
    	{
    		shares += num;
    		share_val = price;
    		set_tot();
    	}
    }
    
    void Stock::sell(long num, double price)
    {
    	using std::cout;
    	if (num < 0)
    	{
    		cout << "Number of shares sold can't be negative. "
    			<< "Transaction is aborted.\n";
    	}
    	else if (num > shares)
    	{
    		cout << "You can't sell more than you have! "
    			<< "Transaction is aborted.\n";
    	}
    	else
    	{
    		shares -= num;
    		share_val = price;
    		set_tot();
    	}
    }
    
    void Stock::update(double price)
    {
    	share_val = price;
    	set_tot();
    }
    
    void Stock::show()
    {
    	using std::cout;
    	using std::ios_base;
    	// set format to #.###
    	ios_base::fmtflags orig =
    		cout.setf(ios_base::fixed, ios_base::floatfield);
    	std::streamsize prec = cout.precision(3);
    
    	cout << "Company: " << company
    		<< "  Shares: " << shares << '\n';
    	cout << "  Share Price: $" << share_val;
    	// set format to #.##
    	cout.precision(2);
    	cout << "  Total Worth: $" << total_val << '\n';
    
    	// restore original format
    	cout.setf(orig, ios_base::floatfield);
    	cout.precision(prec);
    }

## usestok1.cpp ##

// usestok1.cpp -- using the Stock class
    // compile with stock10.cpp
    #include <iostream>
    #include "stock10.h"
    
    int main()
    {
    	{
    		using std::cout;
    		cout << "Using constructors to create new objects\n";
    		Stock stock1("NanoSmart", 12, 20.0);            // syntax 1
    		stock1.show();
    		Stock stock2 = Stock("Boffo Objects", 2, 2.0); // syntax 2
    		stock2.show();
    
    		cout << "Assigning stock1 to stock2:\n";
    		stock2 = stock1;
    		cout << "Listing stock1 and stock2:\n";
    		stock1.show();
    		stock2.show();
    
    		cout << "Using a constructor to reset an object\n";
    		stock1 = Stock("Nifty Foods", 10, 50.0);    // temp object
    		cout << "Revised stock1:\n";
    		stock1.show();
    		cout << "Done\n";
    	}
    	// std::cin.get();
    	return 0;
    }

执行结果：

Using constructors to create new objects
    Constructor using NanoSmart called
    Company: NanoSmart  Shares: 12
      Share Price: $20.000  Total Worth: $240.00
    Constructor using Boffo Objects called
    Company: Boffo Objects  Shares: 2
      Share Price: $2.000  Total Worth: $4.00
    Assigning stock1 to stock2:
    Listing stock1 and stock2:
    Company: NanoSmart  Shares: 12
      Share Price: $20.000  Total Worth: $240.00
    Company: NanoSmart  Shares: 12
      Share Price: $20.000  Total Worth: $240.00
    Using a constructor to reset an object
    Constructor using Nifty Foods called
    Bye, Nifty Foods!
    Revised stock1:
    Company: Nifty Foods  Shares: 10
      Share Price: $50.000  Total Worth: $500.00
    Done
    Bye, NanoSmart!
    Bye, Nifty Foods!

## stock20.h ##

// stock20.h -- augmented version
    #ifndef STOCK20_H_
    #define STOCK20_H_
    #include <string>
    
    class Stock
    {
    private:
    	std::string company;
    	int shares;
    	double share_val;
    	double total_val;
    	void set_tot() { total_val = shares * share_val; }
    public:
    	Stock();        // default constructor
    	Stock(const std::string & co, long n = 0, double pr = 0.0);
    	~Stock();       // do-nothing destructor
    	void buy(long num, double price);
    	void sell(long num, double price);
    	void update(double price);
    	void show()const;
    	const Stock & topval(const Stock & s) const;
    };
    
    #endif

## stock20.cpp ##

// stock20.cpp -- augmented version
    #include <iostream>
    #include "stock20.h"
    using namespace std;
    // constructors
    Stock::Stock()        // default constructor
    {
    	company = "no name";
    	shares = 0;
    	share_val = 0.0;
    	total_val = 0.0;
    }
    
    Stock::Stock(const std::string & co, long n, double pr)
    {
    	company = co;
    	if (n < 0)
    	{
    		std::cout << "Number of shares can't be negative; "
    			<< company << " shares set to 0.\n";
    		shares = 0;
    	}
    	else
    		shares = n;
    	share_val = pr;
    	set_tot();
    }
    
    // class destructor
    Stock::~Stock()        // quiet class destructor
    {
    }
    
    // other methods
    void Stock::buy(long num, double price)
    {
    	if (num < 0)
    	{
    		std::cout << "Number of shares purchased can't be negative. "
    			<< "Transaction is aborted.\n";
    	}
    	else
    	{
    		shares += num;
    		share_val = price;
    		set_tot();
    	}
    }
    
    void Stock::sell(long num, double price)
    {
    	using std::cout;
    	if (num < 0)
    	{
    		cout << "Number of shares sold can't be negative. "
    			<< "Transaction is aborted.\n";
    	}
    	else if (num > shares)
    	{
    		cout << "You can't sell more than you have! "
    			<< "Transaction is aborted.\n";
    	}
    	else
    	{
    		shares -= num;
    		share_val = price;
    		set_tot();
    	}
    }
    
    void Stock::update(double price)
    {
    	share_val = price;
    	set_tot();
    }
    
    void Stock::show() const
    {
    	using std::cout;
    	using std::ios_base;
    	// set format to #.###
    	ios_base::fmtflags orig =
    		cout.setf(ios_base::fixed, ios_base::floatfield);
    	std::streamsize prec = cout.precision(3);
    
    	cout << "Company: " << company
    		<< "  Shares: " << shares << '\n';
    	cout << "  Share Price: $" << share_val;
    	// set format to #.##
    	cout.precision(2);
    	cout << "  Total Worth: $" << total_val << '\n';
    
    	// restore original format
    	cout.setf(orig, ios_base::floatfield);
    	cout.precision(prec);
    }
    
    const Stock & Stock::topval(const Stock & s) const
    {
    	if (s.total_val > total_val)
    		return s;
    	else
    		return *this;
    }

## usestok2.cpp ##

// usestok2.cpp -- using the Stock class
    // compile with stock20.cpp
    #include <iostream>
    #include "stock20.h"
    
    const int STKS = 4;
    int main()
    {
    	{
    		// craeate an array of initialized objects
    		Stock stocks[STKS] = {
    			Stock("NanoSmart", 12, 20.0),
    			Stock("Boffo Objects", 200, 2.0),
    			Stock("Monolithic Obelisks", 130, 3.25),
    			Stock("Fleep Enterprises", 60, 6.5)
    		};
    
    		std::cout << "Stock holdings:\n";
    		int st;
    		for (st = 0; st < STKS; st++)
    			stocks[st].show();
    		// set pointer to first element
    		const Stock * top = &stocks[0];
    		for (st = 1; st < STKS; st++)
    			top = &top->topval(stocks[st]);//获得total_val中值最大的
    		//调用stock20.cpp中的const Stock & Stock::topval(const Stock & s) const
    		// now top points to the most valuable holding
    		std::cout << "\nMost valuable holding:\n";
    		top->show(); }
    	// std::cin.get();
    	return 0;
    }

执行结果：

Stock holdings:
    Company: NanoSmart  Shares: 12
      Share Price: $20.000  Total Worth: $240.00
    Company: Boffo Objects  Shares: 200
      Share Price: $2.000  Total Worth: $400.00
    Company: Monolithic Obelisks  Shares: 130
      Share Price: $3.250  Total Worth: $422.50
    Company: Fleep Enterprises  Shares: 60
      Share Price: $6.500  Total Worth: $390.00
    
    Most valuable holding:
    Company: Monolithic Obelisks  Shares: 130
      Share Price: $3.250  Total Worth: $422.50

## stack.h ##

// stack.h -- class definition for the stack ADT
    #ifndef STACK_H_
    #define STACK_H_
    
    typedef unsigned long Item;
    
    class Stack
    {
    private:
    	enum { MAX = 10 };    // constant specific to class
    	Item items[MAX];    // holds stack items
    	int top;            // index for top stack item
    public:
    	Stack();
    	bool isempty() const;
    	bool isfull() const;
    	// push() returns false if stack already is full, true otherwise
    	bool push(const Item & item);   // add item to stack
    	// pop() returns false if stack already is empty, true otherwise
    	bool pop(Item & item);          // pop top into item
    };
    #endif

## stack.cpp ##

// stack.cpp -- Stack member functions
    #include "stack.h"
    Stack::Stack()    // create an empty stack
    {
    	top = 0;
    }
    
    bool Stack::isempty() const
    {
    	return top == 0;
    }
    
    bool Stack::isfull() const
    {
    	return top == MAX;
    }
    
    bool Stack::push(const Item & item)//压入
    {
    	if (top < MAX)
    	{
    		items[top++] = item;
    		return true;
    	}
    	else
    		return false;
    }
    
    bool Stack::pop(Item & item)//弹出
    {
    	if (top > 0)
    	{
    		item = items[--top];
    		return true;
    	}
    	else
    		return false;
    }

## stacker.cpp ##

// stacker.cpp -- testing the Stack class
    #include <iostream>
    #include <cctype>  // or ctype.h
    #include "stack.h"
    int main()
    {
    	using namespace std;
    	Stack st; // create an empty stack
    	char ch;
    	unsigned long po;
    	cout << "Please enter A to add a purchase order,\n"
    		<< "P to process a PO, or Q to quit.\n";
    	while (cin >> ch && toupper(ch) != 'Q')
    	{
    		while (cin.get() != '\n')
    			continue;
    		if (!isalpha(ch))
    		{
    			cout << '\a';
    			continue;
    		}
    		switch (ch)
    		{
    		case 'A':
    		case 'a': cout << "Enter a PO number to add: ";
    			cin >> po;
    			if (st.isfull())
    				cout << "stack already full\n";
    			else
    				st.push(po);
    			break;
    		case 'P':
    		case 'p': if (st.isempty())
    			cout << "stack already empty\n";
    				  else {
    			st.pop(po);
    			cout << "PO #" << po << " popped\n";
    		}
    				  break;
    		}
    		cout << "Please enter A to add a purchase order,\n"
    			<< "P to process a PO, or Q to quit.\n";
    	}
    	cout << "Bye\n";
    	return 0;
    }

执行结果：

Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 17885
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #17885 popped
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 17965
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 18002
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #18002 popped
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #17965 popped
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    stack already empty
    Please enter A to add a purchase order,
    P to process a PO, or Q to quit.
    Q
    Bye

## 二、复习题 ##

1.什么是类？

类是用户定义的类型的定义。类声明指定了数据将如何存储，同时提供了访问和操作这些数据的方法。

2.类如何实现抽象、封装和数据隐藏？

用户可以根据类的公有接口对类对象执行的操作，这是抽象。类的数据成员可以是私有的（默认值），这意味着只能通过类成员函数来对数据进行访问，这是数据隐藏。实现的具体细节（如数据的表示和方法的代码）都是隐藏的，这是封装。

3.对象和类之间的关系是什么？

类定义了一种类型，包括如何使用它。对象是一个变量或其他的数据对象（如new生成的），并根据类定义被创建和使用。类和对象之间的关系同标准类型与其变量之间的关系。

4.除了是函数之外，类函数成员与类数据成员之间的区别是什么？

如果创建给定类的多个对象，则每个对象都有其自己的数据内存空间；但所有的对象都使用同一组成员函数（通常，这个方法是公有的，而数据是私有的，但这只是策略方面的问题，而不是对类的要求）

5.定义一个类来表示银行账户、数据成员包括储户姓名、帐号（使用字符串）和存款。成员函数执行如下操作：

*  创建一个对象并将其初始化。
 *  显示储户姓名、帐号和存款。
 *  存入参数指定的存款。
 *  取出参数指定的款项。

请提供类声明，而不用给出方法实现。（编程练习1将要求编写实现）

#ifndef BANKACCOUNT_H
    #define BANKACCOUNT_H
    #include <string>
    
    using namespace std;
    
    class BankAccount
    {
    private:
        std::string name_str;
        std::string accountNum_str;
        double balance;
    
    public:
        BankAccount(const string &name, const string &accountNum, double bal = 0.0);
        void show();
        void deposit(double cash);
        void withdraw(double cash);
    };
    
    #endif

6.类构造函数在何时被调用？类析构函数呢？

在创建类对象或显示调用构造函数时，类的构造函数被调用。当函数过期时，析构函数被调用。

7.给出复习题5中的银行账户的构造函数的代码。

#include "BankAccount.h"
    #include <iostream>
    using namespace std;
    
    BankAccount::BankAccount(const string &name, const string &accountNum, double bal)
    {
        name_str = name;
        accountNum_str = accountNum;
        balance = bal;
    }
    
    void BankAccount::show()
    {
        cout << "Account Name : " << name_str << endl;
        cout << "Account Number : " << accountNum_str << endl;
        cout << "Account Balance : " << balance << endl;
    }
    
    void BankAccount::withdraw(double cash)
    {
        balance -= cash;
    }
    
    void BankAccount::deposit(double cash)
    {
        balance += cash;
    }

8.什么是默认构造函数，拥有默认构造函数有何好处？

默认构造函数是没有参数或所有参数都有默认值的构造函数。拥有默认构造函数后，可以声明对象，而不初始化它，即使已经定义了初始化构造函数。它还使得能够声明数组。

9.修改Stock类的定义（stock20.h中的版本），使之包含返回各个数据成员值的成员函数。注意：返回公司名的成员函数不应该为修改数组提供便利，也就是说，不能简单的返回string引用。

> 原stock20.h的版本：
> 
>     //Listing 10.7 stock20.h
>     // stock20.h -- augmented version
>     #ifndef STOCK20_H_
>     #define STOCK20_H_
>     #include <string>
>     class Stock
>     {
>     private:
>         std::string company;
>         int shares;
>         double share_val;
>         double total_val;
>         void set_tot() { total_val = shares * share_val; }
>     
>     public:
>         Stock(); // default constructor
>         Stock(const std::string &co, long n = 0, double pr = 0.0);
>         ~Stock(); // do-nothing destructor
>         void buy(long num, double price);
>         void sell(long num, double price);
>         void update(double price);
>         void show() const;
>         const Stock &topval(const Stock &s) const;
>     };
>     #endif

修改后：

#ifndef STOCK20_H_
    #define STOCK20_H_
    #include <string>
    class Stock
    {
    private:
        std::string company;
        int shares;
        double share_val;
        double total_val;
        void set_tot() { total_val = shares * share_val; }
    
    public:
        Stock();
        Stock(const std::string &co, long n = 0, double pr = 0.0);
        ~Stock();
        void buy(long num, double price);
        void sell(long num, double price);
        void update(double price);
        void show() const;
        const Stock &topval(const Stock &s) const;
        int shares() const { return shares; }
        double shareVal() const { return share_val; }
        double totalVal() const { return total_val; }
        const std::string &comp_name() const { return company; }
    };
    #endif

10.this和\*this是什么？

this指针是类方法可以使用的指针，它指向用于调用方法的对象。因此，this是对象的地址，\*this是对象本身。

## 三、编程练习 ##

1.为复习题5描述的类提供方法定义，并编写一个小程序来演示所有的特性。

BankAccount.h:

BankAccount.cpp:

main.cpp:

#include "BankAccount.h"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        string name, account;
        double num;
        cout << "enter name : ";
        getline(cin, name);
        cout << "enter bank account : ";
        getline(cin, account);
    
        BankAccount ba(name, account);
        cout << "enter the deposit amount : ";
        cin >> num;
        cin.get();
        ba.deposit(num);
        cout << "your current bank account information : ";
        ba.show();
    
        cout << "enter the withdrawal amount: ";
        cin >> num;
        cin.get();
        ba.withdraw(num);
        cout << "your current bank account information : ";
        ba.show();
    
        return 0;
    }

2. 下面是一个非常简单的类定义：

>     class Person
>     {
>     private:
>         static const int LIMIT = 25;
>         string lname;      // Person’s last name
>         char fname[LIMIT]; // Person’s first name
>     public:
>         Person()
>         {
>             lname = "";
>             fname[0] = '\0';
>         }                                                    // #1
>         Person(const string &ln, const char *fn = "Heyyou"); // #2
>         // the following methods display lname and fname
>         void Show() const;       // firstname lastname format
>         void FormalShow() const; // lastname, firstname format
>     };

它使用了一个string对象和一个字符数组，让您能够比较它们的用法。请提供未定义的方法的代码，以完成这个类的实现。再编写一个使用这个类的程序，它使用了三种可能的构造函数的调用（没有参数、一个参数和两个参数）以及两种显示方法。下面是一个使用这些构造函数和方法的例子：

>     Person one;                      // use default constructor
>     Person two("Smythecraft");       // use #2 with one default argument
>     Person three("Dimwiddy", "Sam"); // use #2, no defaults one.Show();
>     cout << endl;
>     one.FormalShow();
>     // etc. for two and three

Person.h :

#ifndef PERSON_H
    #define PERSON_H
    
    #include <string>
    using std::string;
    
    class Person
    {
    private:
        static const int LIMIT = 25;
        string lname;      // Person’s last name
        char fname[LIMIT]; // Person’s first name
    public:
        Person()
        {
            lname = "";
            fname[0] = '\0';
        }                                                    // #1
        Person(const string &ln, const char *fn = "Heyyou"); // #2
        // the following methods display lname and fname
        void Show() const;       // firstname lastname format
        void FormalShow() const; // lastname, firstname format
    };
    
    #endif

Person.cpp :

#include "Person.h"
    #include <iostream>
    using std::cout;
    using std::endl;
    
    Person::Person(const string &ln, const char *fn)
    {
        lname = ln;
        strcpy(fname, fn);
    }
    
    void Person::FormalShow() const
    {
        cout << fname << " " << lname << endl;
    }
    
    void Person::Show() const
    {
        cout << fname << " , " << lname << endl;
    }

main.cpp :

#include "Person.h"
    #include <iostream>
    using std::cout;
    using std::endl;
    int main()
    {
        Person one;
        Person two("Smythecraft");
        Person three("Dimwiddy", "Sam");
        cout << "Person one : " << endl;
        one.Show();
        one.FormalShow();
        cout << "Person two : " << endl;
        two.Show();
        two.FormalShow();
        cout << "Person two : " << endl;
        three.Show();
        three.FormalShow();
        return 0;
    }

3.完成第9章的编程练习1，但要用正确的golf类声明替换那里的代码。用带合适参数的构造函数替换setgolf(golf &, const char \* , int)，以提供初始值。保留setgolf()的交互版本，但要用构造函数来实现它（例如，setgolf()的代码应该获得数据，将数据传递给构造函数来创建一个临时对象，并将其赋给调用对象，即\*this）。

Golf.h：

#ifndef GOLF_H
    #define GOLF_H
    
    class Golf
    {
    public:
        Golf();
        Golf(const char *name, int hc);
        int setgolf();
        void sethandicap(int hc);
        void showgolf() const;
    
    private:
        static const int Len = 40;
        char fullname[Len];
        int handicap;
    };
    
    #endif

Golf.cpp:

#include "Golf.h"
    #include <iostream>
    
    using namespace std;
    
    Golf::Golf()
    {
        strcpy(fullname, "DefaultName");
        handicap = 0;
    }
    Golf::Golf(const char *name, int hc)
    {
        strcpy(fullname, name);
        handicap = hc;
    }
    
    int Golf::setgolf()
    {
        cout << "please enter fullname : ";
        cin.getline(fullname, Len);
        if (strlen(fullname) == 0)
            return 0;
        else
        {
            cout << "please enter handicap : ";
            cin >> handicap;
            cin.get();
            return 1;
        }
    }
    
    void Golf::sethandicap(int hc)
    {
        handicap = hc;
    }
    
    void Golf::showgolf() const
    {
        cout << "fullname : " << fullname << ", handicap : " << handicap << endl;
    }

main.cpp:

#include "Golf.h"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        Golf ann("Ann Birdfree", 24), andy, arrGolf[3];
        ann.showgolf();
    
        andy.showgolf();
        andy.setgolf();
        andy.showgolf();
        andy.sethandicap(20);
        andy.showgolf();
    
        int i = 0;
        while (i < 3 && arrGolf[i].setgolf())
        {
            arrGolf[i].showgolf();
            i++;
            if (i < 3)
                cout << "next one: " << endl;
        }
    
        return 0;
    }

4.完成第9章的编程练习4，但将Sales结构及相关的函数转换为一个类及其方法。用构造函数替换setSales(sales &, double \[\], int)函数。用构造函数实现setSales(Slaes &)方法的交互版本。将类保留在名称空间SALES 中。

sales.h:

//sales.h-----头文件
    #ifndef SALES_H
    #define SALES_H
    
    namespace SALES
    {
        const int QUARTERS = 4;
        class Sales
        {
        public:
            Sales();
            Sales(const double ar[], int n);
            void showSales();
    
        private:
            double sales[QUARTERS];
            double average;
            double max;
            double min;
        };
    }
    
    #endif

sales.cpp:

//sales.cpp-----源代码文件
    #include "sales.h"
    #include <iostream>
    
    using namespace std;
    namespace SALES
    {
        Sales::Sales(const double ar[], int n)
        {
            double min = 0, max = 0, sum = 0;
            min = max = ar[0];
            for (int i = 0; i < n; i++)
            {
                sales[i] = ar[i];
                sum += ar[i];
                if (ar[i] > max)
                {
                    max = ar[i];
                }
                if (ar[i] < min)
                {
                    min = ar[i];
                }
            }
            average = sum / n;
        }
    
        Sales::Sales()
        {
            cout << "Please enter 4 quarters for sales:" << endl;
            cout << "the 1 quarter :";
            cin >> sales[0];
            min = max = sales[0];
            for (int i = 1; i < 4; i++)
            {
                cout << "the " << i << " quarter :";
                cin >> sales[i];
                if (max < sales[i])
                {
                    max = sales[i];
                }
                if (min > sales[i])
                {
                    min = sales[i];
                }
            }
            average = (sales[0] + sales[1] + sales[2] + sales[3]) / 4;
        }
    
        void Sales::showSales()
        {
            cout << "Display all information in sales : " << endl;
            cout << "The 4 quarters are $" << sales[0] << ", $" << sales[1] << ", $" << sales[2] << ", $" << sales[3] << endl;
            cout << "The average income is $" << average << endl;
            cout << "The maximum income is $" << max << endl;
            cout << "The minimum income is $" << min << endl;
        }
    }

main.cpp:

#include "sales.h"
    #include <iostream>
    
    using namespace SALES;
    int main()
    {
        double arr[4] = {3.4, 5.6, 2.5, 6.1};
        Sales s1(arr, 4);
        s1.showSales();
        Sales s2;
        s2.showSales();
        return 0;
    }

5.考虑下面的结构声明：

>     struct customer {
>     char fullname[35];
>     double payment;
>     };

编写一个程序，它从栈中添加和删除customer结构（栈用Stack类声明表示）。每次customer结构被删除时，其payment的值都被加入到总数中，并报告总数。注意：应该可以直接使用Stack类而不作修改；只需修改typedef声明，使Item的类型为customer，而不是unsigned long即可.

stack.h :

#ifndef STACK_H
    #define STACK_H
    
    struct customer
    {
        char fullname[35];
        double payment;
    };
    
    typedef customer Item;
    
    class Stack
    {
    public:
        Stack();
        bool pop(Item &it);
        bool push(const Item &it);
        bool isfull() const;
        bool isempty() const;
    
    private:
        double total;
        int top;
        enum
        {
            MAX = 10
        };
        Item item[MAX];
    };
    
    #endif

stack.cpp :

#include "stack.h"
    #include <iostream>
    
    using namespace std;
    
    Stack::Stack()
    {
        top = 0;
        total = 0;
    }
    
    bool Stack::isempty() const
    {
        return top == 0;
    }
    
    bool Stack::isfull() const
    {
        return top == MAX;
    }
    
    bool Stack::pop(Item &it)
    {
        if (top > 0)
        {
            it = item[--top];
            total += it.payment;
            cout << "An order has been processed, current total revenue : " << total << endl;
            return true;
        }
        else
        {
            return false;
        }
    }
    
    bool Stack::push(const Item &it)
    {
        if (top < MAX)
        {
            item[top++] = it;
            return true;
        }
        else
        {
            return false;
        }
    }

main.cpp :

#include "stack.h"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        Stack stack;
        customer cu;
        char ch;
        cout << "Press a to add a customer, P to process an order, and Q to exit." << endl;
        while (cin >> ch && toupper(ch) != 'Q')
        {
            while (cin.get() != '\n')
            {
                continue;
            }
            if (!isalpha(ch))
            {
                cout << '\a';
                continue;
            }
            switch (ch)
            {
            case 'a':
            case 'A':
                if (stack.isfull())
                {
                    cout << "The order of 10 customers has been filled. Please process the existing order first !" << endl;
                }
                else
                {
                    cout << "Add customer name : ";
                    cin.getline(cu.fullname, 35);
                    cout << "Add the customer's consumption amount : ";
                    cin >> cu.payment;
                    cout << "dsssd : " << stack.push(cu);
                }
                break;
            case 'p':
            case 'P':
                if (stack.isempty())
                {
                    cout << " There are currently no unprocessed orders." << endl;
                }
                else
                {
                    stack.pop(cu);
                }
                break;
            default:
                cout << " Input error！！！" << endl;
                break;
            }
            cout << "Press a to add a customer, P to process an order, and Q to exit." << endl;
        }
        return 0;
    }

6.下面是一个类声明：

>     class Move
>     {
>     private:
>         double x;
>         double y;
>     
>     public:
>         Move(double a = 0, double b = 0); //sets x, y to a, b
>         showmove() const;                 // shows current x, y values
>         Move add(const Move &m) const;
>         // this function adds x of m to x of invoking object to get new x,
>         // adds y of m to y of invoking object to get new y, creates a new
>         // move object initialized to new x, y values and returns it
>         reset(double a = 0, double b = 0); // resets x,y to a, b
>     }

请提供成员函数的定义和测试这个类的程序。

move.h :

#ifndef MOVE_H
    #define MOVE_H
    
    class Move
    {
    private:
        double x;
        double y;
    
    public:
        Move(double a = 0, double b = 0); //sets x, y to a, b
        void showmove() const;            // shows current x, y values
        Move add(const Move &m) const;
        // this function adds x of m to x of invoking object to get new x,
        // adds y of m to y of invoking object to get new y, creates a new
        // move object initialized to new x, y values and returns it
        void reset(double a = 0, double b = 0); // resets x,y to a, b
    };
    
    #endif

move.cpp :

#include "move.h"
    #include <iostream>
    
    Move::Move(double a, double b)
    {
        x = a;
        y = b;
    }
    
    Move Move::add(const Move &m) const
    {
        return Move(x + m.x, y + m.y);
    }
    
    void Move::showmove() const
    {
        std::cout << "x is :" << x << std::endl;
        std::cout << "y is :" << y << std::endl;
    }
    void Move::reset(double a, double b)
    {
        x = a;
        y = b;
    }

main.cpp :

#include "move.h"
    #include <iostream>
    
    int main()
    {
        Move m1(1, 2), m2(3, 4);
        m1.showmove();
        m2.showmove();
        m1.add(m2).showmove();
        m1.reset(5, 6);
        m1.showmove();
        return 0;
    }

7.Betelgeusean plorg有这些特征.

数据：

*  plorg的名称不超过19个字符；
 *  plorg有满意指数（CI），这是一个整数。

操作：

*  新的plorg将有名称，其CI值为50；
 *  plorg的CI可以修改；
 *  plorg可以报告其名称和CI；
 *  plorg的默认名称为“Plorga”。

请编写一个Plorg类声明（包括数据成员和成员函数原型）来表示plorg，并编写成员函数的函数定义。然后编写一个小程序，以演示Plorg类的所有特性。

plorg.h :

#ifndef PLORG_H
    #define PLORG_H
    
    class Plorg
    {
    private:
        char name[19];
        int CI;
    
    public:
        Plorg();
        Plorg( const char *n, int ci);
        void show();
        void setCI(int ci);
    };
    
    #endif

plorg.cpp :

#include "plorg.h"
    #include <iostream>
    
    Plorg::Plorg()
    {
        strcpy(name, "Plorg");
        CI = 0;
    }
    Plorg::Plorg(const char *n, int ci)
    {
        strcpy(name, n);
        CI = ci;
    }
    
    void Plorg::setCI(int ci)
    {
        CI = ci;
    }
    
    void Plorg::show()
    {
        std::cout << "name : " << name << ", CI: " << CI << std::endl;
    }

main.cpp :

#include "plorg.h"
    #include <iostream>
    
    int main()
    {
        Plorg p1, p2("plorg2", 50);
        p1.show();
        p2.show();
        p1.setCI(30);
        p1.show();
    }

8.可以将简单列表描述成下面这样：

*  可存储0或多个类型的列表；
 *  可创建空列表
 *  可在列表中添加数据项；
 *  可确定列表是否为空；
 *  可确定列表是否已满；
 *  可访问列表中每一个数据项，并对它执行某种操作。

可以看到，这个列表确实很简单，例如它不允许插入或删除数据项。

请设计一个List类来表示这中数据类型。您应提供头文件list.h和实现文件list.cpp.前者包含定义，后者包含实现这个类的方法。您还应创建一个简短的程序来实现这个类。

该表的规范很简单，这主要旨在简化这个编程练习，可以选择使用数组或链表来实现这个列表，但公有结构不应依赖与说做的选择。也就是说，公有接口不应有数组索引，节点指针等。应使用通用概念来表达创建列表、在列表中添加数据项等操作。对于访问数据项以及执行操作，通常应使用将函数指针做为参数的函数来处理：

`void visit(void (*pf) (Item&));`

其中，pf指向一个将Item引用作为参数的函数（不是成员函数），Item是列表中数据项的类型，visit()函数将该函数用于列表中的每个数据项。

list.h :

#ifndef LIST_H
    #define LIST_H
    
    typedef int Item;
    const int MAX = 10;
    class List
    {
    private:
        Item ITEM[MAX];
        int COUNT;
    
    public:
        List();
        bool isfull();
        bool isempty();
        bool addItem(Item it);
        Item *item();
        int count();
        void visit(void (*pf)(Item &));
    };
    
    #endif

list.cpp :

#include "list.h"
    #include <iostream>
    
    List::List()
    {
        COUNT = 0;
    }
    
    bool List::isfull()
    {
        return COUNT == MAX;
    }
    
    bool List::isempty()
    {
        return COUNT == 0;
    }
    bool List::addItem(Item it)
    {
        if (this->isfull())
        {
            std::cout << "full already, add fail. " << std::endl;
            return false;
        }
        else
        {
            ITEM[COUNT++] = it;
            return true;
        }
    }
    
    Item *List::item()
    {
        return ITEM;
    }
    
    int List::count()
    {
        return COUNT;
    }
    
    void List::visit(void (*pf)(Item &))
    {
        for (int i = 0; i < COUNT; i++)
        {
            (*pf)(ITEM[i]);
        }
    }

main.cpp :

#include "list.h"
    #include <iostream>
    
    void intadd2(int &n);
    
    int main()
    {
        List l;
        l.addItem(1);
        l.addItem(2);
        l.addItem(3);
        for (int i = 0; i < 3; i++)
        {
            std::cout << l.item()[i] << std::endl;
        }
        l.visit(intadd2);
        for (int i = 0; i < 3; i++)
        {
            std::cout << l.item()[i] << std::endl;
        }
        return 0;
    }
    
    void intadd2(int &n)
    {
        n += 2;

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/1c5ae8b3960d483eba3d222265ed3e7f.png