（一二一）第十章编程练习

1.为下面这个类提供方法和定义，并编写一个小程序用于演示所有特性。

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

①创建一个对象并将其初始化；

②显示储户姓名、账号和存款；

③存入参数指定的存款；

④取出参数指定的款项。

#include<string>

class Bankaccount

{

std::string name;

char id[20];

double money; public:

Bankaccout();

Bankaccout(const std::string na, const char* id_, double mo);

void show()const;

void savemoney(const double mo);

void loadmoney(double mo); //这行在参数多加了一个const

}

答：

#include<iostream>
#include<string>

class Bankaccout
{
private:
std::string name;
char id[20];
double money;
public:
Bankaccout();
Bankaccout(const std::string na, const char* id_, const double mo);
void show()const;
void savemoney(const double mo);
void loadmoney(double mo);
};

int main()
{
using namespace std;
cout << "请输入你要创建的银行账号的储户姓名：";
string name;
getline(cin, name);
cin.sync();
cout << "请输入账号名（不要超过19个字符）：";	//只读取前19个输入的字符，但是如果超出，
char id[20];
char *x = new char[30];	//创建一个临时的字符串，用于储存输入，符合的话，则将其复制到字符串之中，不符合则要求重新输入
x[19] = '\0';
cin.getline(x, 29);
cin.sync();
while (x[19]!='\0')
{
cin.clear();
cin.sync();
cout << "你输入的账号超过了19个字符，请重新输入：";
x[19] = '\0';
cin.getline(x, 30);
}
strcpy_s(id, x);	//复制过去
delete x;	//删除这个临时的

cout << "请输入你要存入的款项：";
double money;
cin >> money;
while (!cin)
{
cout << "输入错误，请重新输入：";
cin.sync();
cin.clear();
cin >> money;
}
Bankaccout p1(name, id, money);

char choice;
cout << "请输入你的选择：\na.存款\tb.取款\tc.查询账号信息\tq.退出\n请输入：";
while (cin >> choice)
{
cin.sync();
if (!isalpha(choice))
{
cout << "输入错误，请重新输入。" << endl;
cout << "请输入你的选择：\na.存款\tb.取款\tc.查询账号信息\tq.退出\n请输入：";
continue;
}
if (choice == 'q' || choice == 'Q')break;
switch (choice)
{
case 'a':
case'A':
cout << "请输入您要存入的金额：";
cin >> money;
p1.savemoney(money);
break;
case'b':
case'B':
cout << "请输入你要取款的金额：";
cin >> money;
p1.loadmoney(money);
break;
case'c':
case'C':
p1.show();
break;
default:cout << "输入错误，请重新输入：" << endl;
break;
}
cout << "请输入你的选择：\na.存款\tb.取款\tc.查询账号信息\tq.退出\n请输入：";
}
cout << "Bye!" << endl;
system("pause");
return 0;
}

Bankaccout::Bankaccout()
{
name = "";
id[0] = '\0';
money = 0;
}
Bankaccout::Bankaccout(const std::string na, const char*id_, const double mo)
{
name = na;
int i;
for (i = 0;i < 20 && id_[i];i++)	//这里感觉strncpy()并不能使用
id[i] = id_[i];
id[i] = '\0';
money = mo;
}
void Bankaccout::show()const
{
using namespace std;
cout << "********储户信息********" << endl;
cout << "储户姓名：" << name << endl;
cout << "储户账号：" << id << endl;
cout << "储户存款：" << money << "元" << endl;
cout << "***********************" << endl;
}
void Bankaccout::savemoney(const double mo)
{
money += mo;
std::cout << "你成功的存入了" << mo << "元。" << std::endl << std::endl;
}
void Bankaccout::loadmoney(double mo)
{
if (money >= mo)
{
money -= mo;
std::cout << "你成功的取出了" << mo << "元。" << std::endl << std::endl;
}
else std::cout << "对不起，您的存款余额只有" << money << "元，无法满足您的取款需求。本次取款请求失败。" << std::endl;
}

输出：

请输入你要创建的银行账号的储户姓名：dsa
请输入账号名（不要超过19个字符）：3rffvsdviodvamoavmdnvdvfd
你输入的账号超过了19个字符，请重新输入：vdsvsovmpeoqmvwevmpwemvw
你输入的账号超过了19个字符，请重新输入：dd
请输入你要存入的款项：300
请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：c
********储户信息********
储户姓名：dsa
储户账号：dd
储户存款：300元
***********************
请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：a
请输入您要存入的金额：500
你成功的存入了500元。

请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：c
********储户信息********
储户姓名：dsa
储户账号：dd
储户存款：800元
***********************
请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：b
请输入你要取款的金额：2000
对不起，您的存款余额只有800元，无法满足您的取款需求。本次取款请求失败。
请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：b
请输入你要取款的金额：300
你成功的取出了300元。

请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：c
********储户信息********
储户姓名：dsa
储户账号：dd
储户存款：500元
***********************
请输入你的选择：
a.存款  b.取款  c.查询账号信息  q.退出
请输入：q
Bye!
请按任意键继续. . .

疑问：

①遇见一个问题，在输入名字那里，假如使用：

char id[20];

id[19] = '\0';

cin.getline(id, 19);

cin.sync();

while (id[19]!='\0')

{

cin.clear();

cin.sync();

cout << "你输入的账号超过了19个字符，请重新输入：";

id[19] = '\0';

cin.getline(id, 19);

}

那么，这段代码无法检测用户输入的字符串是否超标。只能默认读取前19位（假如用户输入20位或者更多的话）。

如果改为：cin.getline(id, 20);

那么即使用户输入超过20位，也会默认通过循环条件（即，认为第20位是空字符）。不能理解为什么

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

class Person {

private:

static const 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.

答：

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

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

// etc. for two and three.

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

int main()
{
using namespace std;
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();
cout << endl << endl;
two.Show();
cout << endl;
two.FormalShow();
cout << endl << endl;
three.Show();
cout << endl;
three.FormalShow();
cout << endl << endl;
system("pause");
return 0;
}

Person::Person(const std::string & ln, const char *fn)
{
lname = ln;
strncpy_s(fname, fn, 24);
}
void Person::Show() const
{
std::cout << "firstname, lastname format:" << std::endl;
if (lname == "") {
std::cout << "no name" << std::endl;
return;
}
std::cout << fname << " " << lname << std::endl;
}
void Person::FormalShow()const
{
std::cout << "lastname, firstname format:" << std::endl;
if (lname == "") {
std::cout << "no name" << std::endl;
return;
}
std::cout << lname << " " << fname << std::endl;
}

输出：

firstname, lastname format:
no name

lastname, firstname format:
no name

firstname, lastname format:
Heyyou Smythecraft

lastname, firstname format:
Smythecraft Heyyou

firstname, lastname format:
Sam Dimwiddy

lastname, firstname format:
Dimwiddy Sam

请按任意键继续. . .

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

答：

//1.h	头文件，类定义
#pragma once
#include<cstring>

class golf
{
enum { len = 40 };
char fullname[len];
int handicap;
public:
golf(const char *ln = "\0", int x = 0) { strcpy_s(fullname,ln);handicap = x; }
int setgolf(const char * name, int hc);
int setgolf()const;
void sethandicap(const int hc);
void showgolf()const;
};
//1.cpp 要求：3.完成第9章的编程练习1，但要用正确的golf类声明替换那里的代码。用带合适参数的构造函数替换setgolf(golf &, const char*, int), 以提供初始值。保留setgolf()的交互版本，但要用构造函数来实现它（例如，setgolf()的代码应该获得数据，将数据传递给构造函数来创建一个临时对象，并将其赋给调用对象，即*this）。
#include<iostream>
#include"1.h"

int main()
{
using namespace std;
golf man[5];
int i;
for (i = 0;i < 5;i++)
{
char name[39];
cout << "请输入姓名和一个人的等级。若输入在姓名输入空字符串时（在输入名字的时候直接按回车键），则结束输入" << endl;
cout << i + 1 << "# 姓名：";
cin.get(name, 39);
int lv;
cout << "等级：";
cin >> lv;
cin.sync();
if (!man[i].setgolf(name, lv))break;
}
cout << endl << "现在为显示所有人的数据：" << endl;
for (int j = 0;man[j].setgolf();j++)
{
cout << j + 1 << "#：";
man[j].showgolf();
}
cout << "————显示结束————" << endl << endl;
cout << "设置第一个人的handicap为2：" << endl;
man[0].sethandicap(2);
cout << "再次显示第一个人的数据：" << endl;
man[0].showgolf();
system("pause");
return 0;
}
//2.cpp 源代码文件，存放类函数定义
#include<iostream>
#include"1.h"

int golf::setgolf(const char * name, int hc)
{
golf m(name, hc);
*this = m;
if (fullname[0] == '\0')return 0;
else return 1;
}
int golf::setgolf()const
{
if (fullname[0] == '\0')return 0;
else return 1;
}
void golf::sethandicap(const int hc)	//不能用handicap，会导致名称冲突
{
handicap = hc;
}
void golf::showgolf()const
{
std::cout << "fullname: " << fullname << " , and handicap: " << handicap << std::endl;
}

输出：

请输入姓名和一个人的等级。若输入在姓名输入空字符串时（在输入名字的时候直接按回车键），则结束输入
1# 姓名：分
等级：4
请输入姓名和一个人的等级。若输入在姓名输入空字符串时（在输入名字的时候直接按回车
键），则结束输入
2# 姓名：hy
等级：6
请输入姓名和一个人的等级。若输入在姓名输入空字符串时（在输入名字的时候直接按回车
键），则结束输入
3# 姓名：
等级：
现在为显示所有人的数据：
1#：fullname: 分 , and handicap: 4
2#：fullname: hy  , and handicap: 6
————显示结束————

设置第一个人的handicap为2：
再次显示第一个人的数据：
fullname: 分 , and handicap: 2
请按任意键继续. . .

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

答：

//1.h	头文件，类定义
#pragma once
namespace SALES
{
const int QUARTERS = 4;
class Sales
{
enum { QUARTERS = 4 };
double sales[QUARTERS];
double average;
double max;
double min;
public:
Sales(const double ar[], int n);
Sales(const Sales &x);
void showSales()const;
};
}
//1.cpp 要求：完成第9章的编程练习4，但将Sales结构及相关的函数转换为一个类及其方法。用构造函数替换setSales ( sales&, double [] , int)函数。用构造函数实现setSales(Sales&)方法的交互版本。将类保留在名称空间SALES中。
#include<iostream>
#include"1.h"

int main()
{
using namespace std;
using namespace SALES;
double x[3] = { 1.1,5.5,3.3 };
Sales name_1( x, 3);
Sales name_2(name_1);
name_1.showSales();
name_2.showSales();
system("pause");
return 0;
}
//2.cpp 源代码文件，存放类函数定义
#include<iostream>
#include<cstring>
#include"1.h"

using namespace SALES;

Sales::Sales(const double ar[], int n)
{
int i;
for (i = 0;i < n && i < 4;i++)	//赋值
sales[i] = ar[i];

for (int j = i;j < 4;j++)	//将未赋值的设置为0
sales[j] = 0;

double total = 0;
for (int j = 0;j < i;j++)	//total为所有有效值的总和
total += sales[j];
average = total / i;	//设置平均值

max = min = sales[0];	//最大最小值初始化为第一个值

for (int j = 0;j < i;j++)	//设置最大最小值
{
if (sales[j] > max)max = sales[j];
if (sales[j] < min)min = sales[j];
}
}
Sales::Sales(const Sales &x)	//将一个类对象作为参数时赋值
{
*this = x;
}
void Sales::showSales()const
{
using namespace std;
cout << "输出：" << endl;
for (int i = 0;i < 4 && sales[i] != 0;i++)
cout << "s.sales[" << i << "] = " << sales[i] << endl;
cout << "average = " << average << endl;
cout << "max = " << max << endl;
cout << "min = " << min << endl;
}

输出：

输出：
s.sales[0] = 1.1
s.sales[1] = 5.5
s.sales[2] = 3.3
average = 3.3
max = 5.5
min = 1.1
输出：
s.sales[0] = 1.1
s.sales[1] = 5.5
s.sales[2] = 3.3
average = 3.3
max = 5.5
min = 1.1
请按任意键继续. . .

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

struct customer {

char fullname[35];

double payment;

};

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

答：

//1.h	头文件，类定义
#include<string>
#pragma once
struct customer {
char fullname[35];
double payment;
};
typedef customer Item;	//Item作为unsigned long的别名

class Stack
{
private:
enum { Max = 5 };	//创建枚举常量
Item items[Max];	//Item是unsigned long的别名，见上面
int top;
double total;
public:
Stack();
bool isempty()const;	//用于检测是否为空
bool isfull()const;	//是否为满
bool push(const Item&);	//放入
bool pop(Item&);	//取出
};
//1.cpp 要求：编写一个程序，它从栈中添加和删除cunstomer结构（栈用Stack类声明表示）。每次customer结构被删除时，其payment的值都将被加入到总数中，并报告总数。注意：应该可以直接使用Stack类而不做修改；只需修改typedef声明，使Item的类型为customer，而不是unsigned long即可。
//1.cpp 主程序所在源代码文件
#include<iostream>
#include<string>
#include<Windows.h>
#include"1.h"

int main()
{
using namespace std;
cout.setf(ios_base::fixed);
cout.precision(2);
Stack chuwugui;	//创建对象储物柜
cout << "这里是一个存钱箱，你是否要存/取东西呢？" << endl;
cout << "a.存\tp.取\tq.退出\n我的选择是：";
char choice;
while (cin >> choice&&choice != 'q')
{
while (!isalpha(choice))	//如果输入的不是字母，清除输入缓存，并提示重新输入，然后重新开始循环
{
cout << "请输入a.存\tp.取\tq.退出";
cin.sync();
continue;
}
cin.sync();	//清除输入缓存，只读取第一个输入的字母
switch (choice)	//根据输入的不同，执行不同的选项
{
case 'a':	//输入大写小写的a都是这里
case 'A':
if (chuwugui.isfull())	//如果满的话，返回提示信息
{
cout << "已经满啦！无法继续存放东西了，你需要取出一些东西才可以。" << endl;
break;
}
else	//否则可以存放东西
{
Item one;	//创建结构，用于存储存放的东西
cout << "请输入存钱的人的名字：";
cin.getline(one.fullname,34);
cout << "请输入要存多少钱：";
cin >> one.payment;
cin.sync();	//清除输入缓存，防止干扰
if (chuwugui.push(one))
{
cout << "存放成功！" << one.fullname << " 共计 " << one.payment << " 元钱已经被存进来啦！" << endl;
break;
}
else
{
cout << "由于某种未知的原因，存放失败了。。。。" << endl;
break;
}
}
case 'p':
case 'P':
if (chuwugui.isempty())
{
cout << "很抱歉，存钱箱里面已经空空如也了，你不可能再从里面取出什么东西了。" << endl;
cout << "等等！你难道要抢走这个萌萌哒的存钱箱吗？！警察叔叔！！！～～～" << endl;
break;
}
else
{
Item one;
cout << "现在帮你取钱~~亲~请稍微等待一秒钟。。。" << endl;
Sleep(1000);
if (chuwugui.pop(one))
{
cout << "取出来啦！" << endl;
cout << "取出来  " << one.fullname << " 的money，一共有 " << one.payment << " 元~~~喏！给你！" << endl;
if (chuwugui.isempty())
{
cout << "另外呢~~不得不告诉你一声，存钱箱里面已经空空如也啦~~" << endl;
break;
}
break;

}
else
{
cout << "因为某种未知的错误，什么都没取出来！怎么会这样？" << endl;
break;
}
}
default:cout << "可以输入 a 或者 p 或者 q 嘛？你乱输入的话，我是不会知道你想干嘛的！" << endl;
break;
}
cout << endl;
cout << "口←一个萌萌哒的存钱箱，你是否要存/取moeny呢？" << endl;
cout << "a.存\tp.取\tq.退出\n我的选择是：";
}
cout << endl << "Bye~~~" << endl;
system("pause");
return 0;

}
//2.cpp	存放类的成员函数定义
#include<iostream>
#include<string>
#include"1.h"

Stack::Stack()	//默认构造函数，初始化top为0，top用于计数当前指针指向数组下一次填充时的位置（即如果有一个成员，为items[0]，此时top=1
{
top = 0;
total = 0;
}

bool Stack::isempty()const	//调用函数，询问是否为空，如果top=0（指向0号位置，说明数组里没有东西），那么top==0为真（返回true），如果top>0（说明数组里至少有一个东西），那么top==0为假（返回false）。
{
return top == 0;
}

bool Stack::isfull()const	//调用函数，询问是否满了。如果top=5（说明0~4都有成员），于是top==Max为真（返回true，这里表示满了）相反，则返回false，说明没满
{
return top == Max;
}

bool Stack::push(const Item&x)	//调用函数，用于放置
{
if (top < Max)	//如果没满（原理上面已经解释）
{
items[top++] = x;	//新内容被放置到items数组里，位置为top（因为top指向新内容放置的数组位置），然后top+1
return true;	//返回true，说明放置成功
}
else return false;	//否则返回false，说明放置失败
}

bool Stack::pop(Item&x)
{
if (top > 0)	//如果top>0，说明至少有一个元素
{
x = items[--top];	//传递的参数等于top-1后（也就是说上一次放置的位置），相当于把里面的内容取出，并赋值给传递的参数（注意，参数是引用）
total += x.payment;
std::cout << "总共已取出" << total << "元" << std::endl;
return true;	//返回true，说明取出成功
}
else return false;	//否则返回false，取出失败
}

输出：

这里是一个存钱箱，你是否要存/取东西呢？
a.存    p.取    q.退出
我的选择是：a
请输入存钱的人的名字：aa
请输入要存多少钱：44.22
存放成功！aa 共计 44.22 元钱已经被存进来啦！

口←一个萌萌哒的存钱箱，你是否要存/取moeny呢？
a.存    p.取    q.退出
我的选择是：p
现在帮你取钱~~亲~请稍微等待一秒钟。。。
总共已取出44.22元
取出来啦！
取出来  aa 的money，一共有 44.22 元~~~喏！给你！
另外呢~~不得不告诉你一声，存钱箱里面已经空空如也啦~~

口←一个萌萌哒的存钱箱，你是否要存/取moeny呢？
a.存    p.取    q.退出
我的选择是：q

Bye~~~
请按任意键继续. . .

6.下面是一个类声明

class Move

{

private:

double x;

double y;

public:

Move(double a = 0, double b = 0); //set 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,

// add 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

};

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

答：

//1.h	头文件，类定义
#pragma once
class Move
{
private:
double x;
double y;
public:
Move(double a = 0, double b = 0);	//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 = 0, double b = 0);	//resets x,y to a,b
};
//1.cpp
#include<iostream>
#include"1.h"

int main()
{
using namespace std;
double x[3];
double y[3];
Move point[3];	//创建对象数组，使用默认值

for (int i = 0;i < 2;i++)
{
cout << "请输入" << i + 1 << "#坐标的x和y值：" << endl;
cout << "x：";
cin >> x[i];
cout << "y：";
cin >> y[i];
point[i].reset(x[i], y[i]);	//给对像赋值
}
cout << "3#的坐标是1#和2#之和。" << endl;
point[2] = point[0].add(point[1]);
cout << "现在显示3个坐标的x、y值：" << endl;
for (int i = 0;i < 3;i++)
{
cout << i + 1 << "#坐标：";
point[i].showmove();
}
cout << "现在将2#坐标的x、y值设置为1，1" << endl;
point[1].reset(1, 1);
cout << "2#坐标的值：";
point[1].showmove();
cout << "bye!" << endl;

system("pause");
return 0;
}
//2.cpp 源代码文件，存放类函数定义
#include<iostream>
#include"1.h"

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

输出：
请输入1#坐标的x和y值：
x：3
y：6
请输入2#坐标的x和y值：
x：2.3
y：9.1
3#的坐标是1#和2#之和。
现在显示3个坐标的x、y值：
1#坐标：x = 3, y = 6
2#坐标：x = 2.3, y = 9.1
3#坐标：x = 5.3, y = 15.1
现在将2#坐标的x、y值设置为1，1
2#坐标的值：x = 1, y = 1
bye!
请按任意键继续. . .

7.Betelgeusean plorg有这些特征。

数据：

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

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

操作：

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

②plorg的CI可以修改；

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

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

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

答：

#include<iostream>

class Plorg
{
char name[20];
int CI;
public:
Plorg(const char* na = "Plorga", int ci = 50) { strcpy_s(name, na);CI = ci; }
void change_CI(int m);	//修改CI
void showPlorg()const;	//报告其名称和CI
};

int main()
{
using namespace std;
char name[20];
cout << "请输入姓名：";
cin.getline(name,19);
cout << "初始化Plorg对象。。。\n显示对象：" << endl;
Plorg one(name);
one.showPlorg();
cout << "请输入CI修改后的值：";
int m;
cin >> m;
one.change_CI(m);
cout << "再次显示对象：" << endl;
one.showPlorg();
cout << "Bye." << endl;
system("pause");
return 0;
}

void Plorg::change_CI(int m)
{
CI = m;
}
void Plorg::showPlorg()const
{
std::cout << "name:" << name << "'s CI is " << CI << std::endl;
}

输出：

请输入姓名：里克
初始化Plorg对象。。。
显示对象：
name:里克's CI is 50
请输入CI修改后的值：90
再次显示对象：
name:里克's CI is 90
Bye.
请按任意键继续. . .

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

①可存储0或多个某种类型的列表；

②可创建空列表；

③可在列表中添加数据项；

④可确定列表是否为空；

⑤可确定列表是否为满；

⑥可访问列表中的每一个数据项，并对他执行某种操作。

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

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

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

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

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

答：

//list.h
#pragma once
class List
{
public:
typedef int Item;
private:
enum { LIMIT = 5 };
Item items[LIMIT];
int top;
public:
List(const Item[] = NULL, int m = 0) { top = 0; }	//默认构造函数
bool push(const Item&);	//添加数据项
bool isempty()const;	//确定是否为空
bool isfull()const;	//是否为满
void visit(void(*pf)(Item &m));	//显示每个数据项，并执行某种操作，具体是哪种，根据指针指向的函数而定
};
void show(List::Item &m);	//显示	注意，我这里犯过一个错误，在定义里，参数加上了&，但是忘记在函数原型加&
void change(List::Item &m);	//修改
List::Item getin();	//获取插入的内容

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

int main()
{
using namespace std;
List m;
if (m.isempty())  cout << "是空的！" << endl;
else cout << "不是空的" << endl;
while (!m.isfull())
{
List::Item a = getin();
if (m.push(a))
cout << "插入成功" << endl;
else  cout << "插入失败" << endl;
}
m.visit(show);
m.visit(change);
m.visit(show);
system("pause");
return 0;
}

//list.cpp
#include<iostream>
#include"list.h"
bool List::push(const Item&a)
{
if (!isfull())
{
items[top++] = a;
return true;
}
else
{
std::cout << "插入失败." << std::endl;
return false;
}
}
bool List::isempty()const
{
if (!top)return true;
else return false;
}
bool List::isfull()const
{
if (top == LIMIT)return true;
else return false;
}
void List::visit(void(*pf)(Item &item))	//pf指针指向一个函数，然后pf(items[i])用items[i]作为这个函数的参数
{
for (int i = 0;i < top;i++)
pf(items[i]);
}

void show(List::Item &item)	//之所以用List::，是因为Item是在类的公有成员之中定义的
{
std::cout << item << ", ";
}
void change(List::Item &item)
{
std::cout << "请输入需要替换的内容：";
List::Item a;
std::cin >> a;
if ((item = a))
{
std::cout << "替换成功。新的值为：" << item << std::endl;
}
else { std::cout << "替换失败。" << std::endl; }

}
List::Item getin()	//获取插入的内容
{
List::Item a;
std::cout << "请输入你想要插入的内容：";
std::cin >> a;
while (!std::cin)	//如果输入错误
{
std::cin.sync();
std::cin.clear();
std::cout << "输入错误，请重新输入：";
std::cin >> a;
}
return a;
}

输出：

是空的！
请输入你想要插入的内容：1
插入成功
请输入你想要插入的内容：2
插入成功
请输入你想要插入的内容：3
插入成功
请输入你想要插入的内容：qs
输入错误，请重新输入：4
插入成功
请输入你想要插入的内容：5
插入成功
1, 2, 3, 4, 5, 请输入需要替换的内容：9
替换成功。新的值为：9
请输入需要替换的内容：8
替换成功。新的值为：8
请输入需要替换的内容：7
替换成功。新的值为：7
请输入需要替换的内容：6
替换成功。新的值为：6
请输入需要替换的内容：5
替换成功。新的值为：5
9, 8, 7, 6, 5, 请按任意键继续. . .

总结：

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

例如：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])。