[C++ Primer Plus] 第10章、对象和类（二）课后习题

1.

bank.h

#include <string>
using namespace std;

class BankAccount
{
private:
    std::string m_name;//若是不用命名空间的话，就需要加std::
    string m_id;
    double m_money;
public:
    BankAccount();
    BankAccount(const string & name,const string & id,double money=0.0);
    void show() const;
    void add(double money);
    void sub(double money);
};    

bank.cpp

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

//构造函数
BankAccount::BankAccount(){
    m_name = "";
    m_id = "";
    m_money = 0.0;
}
BankAccount::BankAccount(const string & name,const string & id,double money){
    m_name = name;
    m_id = id;
    m_money = money;
}

void BankAccount::show() const{
    ios_base::fmtflags orig=cout.setf(ios_base::fixed,ios_base::floatfield);//设置cout对象的一个标记，命令cout使用定点表示法
    streamsize prec=cout.precision();
    cout<< "Name: " << m_name << "    ID: " << m_id << "    Money: " << m_money << endl; //因为bank.h中已经声明了命名空间，所以不需要加std::
}
void BankAccount::add(double money){
    m_money += money;
}
void BankAccount::sub(double money){
    m_money -= money;
}

main.cpp

#include "bank.h"

void main(){
    BankAccount a("MR.Zhang","",8888888.88);
    a.show();
    a.add(88888.88);
    a.show();
    a.sub(88888.88);
    a.show();
    system("pause");
}

---

//person.h
#include <string>  

class Person {
private:
    static const int LIMIT = ;
    std::string lname;
    char fname[LIMIT];
public:
    Person() { lname = ""; fname[] = '\0'; }  //无参数
    Person(const std::string &ln, const char *fn = "Heyyou");  //两参数
    void Show() const;
    void FormalShow() const;
};  

//person.cpp
#include <iostream>
#include "Person.h"

Person::Person(const std::string & ln, const char *fn)
{
    lname = ln;
    strncpy_s(fname, fn ,);  //fname的长度为25
}
void Person::Show() const
{
    std::cout << fname << " " << lname << std::endl;
}  

void Person::FormalShow() const
{
    std::cout << lname << ", " << fname << std::endl;
}  

//main.cpp
#include "person.h"

void main(){
    Person one;
    Person two("Smythecraft");
    Person three("Dimwiddy", "Sam");
    one.Show();
    one.FormalShow();
    two.Show();
    two.FormalShow();
    three.Show();
    three.FormalShow();
    system("pause");
}

前两行的显示：one为空，没有输出，FormalShow有一个逗号

---

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

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

这两题参考http://blog.csdn.net/qq20004604/article/details/50540039　　或者 　　http://blog.csdn.net/acm_yuuji/article/details/47374799

---

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

　　char fullname[35];

　　double payment;

};

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

//stack.h
struct customer{
    char fullname[];
    double payment;
};
typedef customer Item;

class Stack        //类声明
{
private:
    double total;
    enum{MAX=};
    Item items[MAX];
    int top;
public:
    Stack();    //默认构造函数
    bool isempty() const;
    bool isfull() const;
    bool push(const Item & item);//压栈
    bool pop(Item & item);//出栈
};    

//stack.cpp
#include <iostream>
#include "stack.h"

//构造函数
Stack::Stack(){
    top=;
    total=;
}

bool Stack::isempty() const{
    return top==;//top为0返回true，反之为false
}
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>){
        item=items[--top];
        total += item.payment;
        std::cout << "总共已取出" << total << "元" << std::endl;
        return true;
    }else
        return false;
}

//main.cpp
#include<iostream>
#include<cctype>
#include "stack.h"
using namespace std;

void main(){
    cout.setf(ios_base::fixed);
    cout.precision();  //设置输出保留两位小数
    Stack st;//创建对象储物柜
    customer one;
    char ch;
    cout<<"Enter A to save money, P to withdraw money, 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':
            if(st.isfull())//该方法判断：如果满了（top等于MAX）返回true，没满返回false
                cout<<"Stack already full\n";
            else{
                cout << "请输入存钱的人的名字：";
                cin.getline(one.fullname,);
                cout << "请输入要存多少钱：";
                cin >> one.payment;
                cin.sync(); //清除输入缓存，防止干扰
                if (st.push(one))
                    cout << "存放成功！" << one.fullname << " 共计 " << one.payment << " 元钱已经被存进来啦！" << endl;
                else
                    cout << "由于某种未知的原因，存放失败了。。。。" << endl;
            }
            break;
        case 'P':
        case 'p':
            if(st.isempty())
                cout<<"Stack already empty\n";
            else{
                st.pop(one);
            }
            break;
        }
        cout<<"Enter A to save money, P to withdraw money, Q to quit.\n";
    }
    system("pause");
}

---

//1.h
class Move
{
private:
    double x;
    double y;
public:
    Move(double a = , double b = );   //set x,y to a,b
    void showmove()const;   //shows current x,y values
    Move add(const Move & m) const; //这个函数将被调用对象m的x和y值与自己的x，y值相加，并得到2个新值，然后创建一个使用新的x、y值的move对象，并将增加后的x、y值赋给她，然后将这个新对象作为返回值
    void reset(double a = , double b = ); //resets x,y to a,b
};  

//1.cpp
#include <iostream>
#include "1.h"

Move::Move(double a, double b){
    x = a;
    y = b;
}

void Move::showmove()const{
    std::cout << "x = " << x << ", y = " << y << std::endl;
}

Move Move::add(const Move & m) const{
    Move q(this->x + m.x, this->y + m.y);
    return q;
}

void Move::reset(double a , double b ){
    x = a;
    y = b;
}

//main.cpp
#include<iostream>
#include "1.h"

void main(){
    Move m,n(1.5,2.5);
    m.showmove();
    m=m.add(n);
    m.showmove();
    m.reset();
    m.showmove();
    system("pause");
}

---

7.Betelgeusean plorg有这些特征。

数据：

①plorg的名称不超过19个字符；

②plorg有满意指数（CI），这是一个整数。

操作：

①新的plorg将有名称，其CI值为50；

②plorg的CI可以修改；

③plorg可以报告其名称和CI；

④plorg的默认名称为“Plorga”。

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

//1.h
class Plorg
{
private:
    char m_name[];
    int  m_CI;
public:
    Plorg(char * name = "Plorga", int CI = );
    void show()const;
    void setName(const char *name);
    void setCI(const int CI);
};  

//1.cpp
#include <iostream>
#include "1.h"

Plorg::Plorg(char * name, int CI){
    strncpy_s(m_name, name,);
    m_CI = CI;
}

void Plorg::setName(const char *name){
    strncpy_s(m_name, name,);
}
void Plorg::setCI(const int CI){
    m_CI = CI;
}
void Plorg::show()const{
    std::cout << "name = " << m_name << ", CI = " << m_CI << std::endl;
}

//main.cpp
#include<iostream>
#include "1.h"

void main(){
    Plorg p;
    p.show();
    p.setName("Jany");
    p.setCI();
    p.show();
    system("pause");
}

---

//list.h
#include <stdlib.h>    //包含NULL的定义
typedef int Item;  

class List
{
private:
    static const int LIMIT  = ;
    Item items[LIMIT];
    int top;
public:
    List() { top = ; }   //默认构造函数
    bool push(const Item); //添加数据项
    bool isempty()const;    //确定是否为空
    bool isfull()const;        //是否为满
    void visit(void(*pf)(Item &m)); //显示每个数据项，并执行某种操作，具体是哪种，根据指针指向的函数而定
};  

//list.cpp
#include "List.h"  

bool List::push(const Item item)
{
    if (isfull() == true)
        return false;
    items[top++] = item;
    return true;
}  

bool List::isempty() const
{
    return top ==  ? true : false;
}  

bool List::isfull() const
{
    return top == LIMIT ? true : false;
}  

void List::visit(void(*pf)(Item &item))
{
    for (int i = ; i < top; ++i)
        (*pf)(items[i]);
} 

//main.cpp
#include<iostream>
#include "list.h"

void Print(Item &item)
{
    std::cout << item << std::endl;
}
void main(){
    List l;
    l.push();
    l.push();
    l.push();
    l.push();
    if(l.isempty())
        std::cout << "isEmpty? " << "Empty" << std::endl;
    else
        std::cout << "isEmpty? " << "Not Empty" << std::endl;
    if(l.isfull())
        std::cout << "isFull? " << "Full" << std::endl;
    else
        std::cout << "isFull? " << "Not Full" << std::endl;
    void(*pf)(Item &item);
    pf = Print;  //或者    void(*pf)(Item &item) = Print
    l.visit(pf);
    system("pause");
}

总结：

①在类中以函数指针作为参数的时候，纠结了很久，查了别人的答案才明白。

例如：void visit( void (*pf)(Item& m) );

这个的意思是，visit函数中，使用函数指针pf作为参数。

在调用visit函数时，哪个函数名作为参数放在里面，那么pf指针就指向哪个函数（前提是类型相同）。

因为指针作为参数，所以参数有点类似( char* pa)这样的意思，char*表示pa是char类型的指针，但不是说char*是参数，所以函数指针作为参数时，重点是pf，而不是外面那个修饰pf的。

可以使用typedef void (*PP)(Item &m);将PP作为这个的别名，于是可以改为void visit(PP pf);这样。

因为没把函数指针学透，纠结了很久，写完代码才想明白。

因为pf是函数指针，所以函数内部的pf(items[i])是将items[i]作为参数给pf指向的函数。例如当show函数作为参数给visit时，这里相当于show(items[i])。

版权声明：出处http://blog.csdn.net/qq20004604