《C++ Primer Plus》第七章课后题

复习题

1.使用函数的3个步骤是什么?

这3个步骤是定义函数、提供原型、调用函数。

2.请创建与下面的描述匹配的函数原型。

a. igor()没有参数,且没有返回值。

b. tofu()接受一个int参数,并返回一个float。

c.mpg()接受两个double 参数,并返回一个double。

d.summation()将long数组名和数组长度作为参数,并返回一个long值。

e. doctor()接受一个字符串参数(不能修改该字符串),并返回一个double 值。

f. ofcourse()将boss 结构作为参数,不返回值。

g. plot()将map结构的指针作为参数,并返回一个字符串。

a. void igor(void);

b. float tofu(int);

c. double mpg(double,double);

d. long summation(long [],int);

e. double doctor(const string);

f. void ofcourse(boss);

g. string plot(map*);

3. 编写一个接受3个参数的函数:int数组名、数组长度和一个int值,并将数组的所有元素都设置为该int值。

void setin(int arr[],int n,int a)

{

for(int i=0;i<n;i++)

arr[i]=a;

}

4. 编写一个接受3个参数的函数:指向数组区间中第一个元素的指针、指向数组区间最后一个元素后面的指针以及一个int值,并将数组中的每个元素都设置为该int值。

void setin(int* begin,int* end,int a)

{

for(int* p=begin;p!=end;p++)

*p=a;

}

5. 编写将 double 数组名和数组长度作为参数,并返回该数组中最大值的函数。该函数不应修改数组的内容。

double biggest(const double d[],int n)

{

double max;

if(size<2)

{

cout << "Invalid array size of " << size << endl;

cout << "Returning a value of on";

return 0;

}

else

{

max=d[0];

for(int i=0;i<n;i++)

if(d[i]>max)

max=d[i];

return max;

}

}

6.为什么不对类型为基本类型的函数参数使用const限定符?

将const 限定符用于指针,以防止指向的原始数据被修改。程序传递基本类型(如int或double)

时,它将按值传递,以便函数使用副本。这样,原始数据将得到保护。

7.C++程序可使用哪3种C-风格字符串格式?

字符串可以存储在char 数组中,可以用带双引号的字符串来表示,也可以用指向字符串第一个字符的指针来表示。

8.编写一个函数,其原型如下:

int replace(char * str, char c1, char c2);

该函数将字符串中所有的c1都替换为c2,并返回替换次数。

int replace(char * str, char c1, char c2)

{

int count=0;

while(*str)

{

if(*str==c1)

{

*str=c2;

count++;

}

str++;

}

return count;

}

9. 表达式*"pizza"的含义是什么?"taco"[2]呢?

由于C++将"pizza"解释为其第一个元素的地址,因此使用*运算符将得到第一个元素的值,即字符p。由于C++将"taco"解释为第一个元素的地址;因此它将"taco"[2]解释为第二个元素的值,即字符c。换句话来说,字符串常量的行为与数组名相同。

10. C++允许按值传递结构,也允许传递结构的地址。如果glitz是一个结构变量,如何按值传递它?如何传递它的地址?这两种方法有何利弊?

要按值传递它,只要传递结构名glitz.即可。要传递它的地址,使用地址运算符&glitz。按值传递将自动保护原始数据,但这是以时间和内存为代价的。按地址传递可节省时间和内存,但不能保护原始数据,除非对函数参数使用了const 限定符。另外,按值传递意味着可以使用常规的结构成员表示法,但传递指针则必须使用间接成员运算符。

11. 函数judge()的返回类型为int,它将这样一个函数的地址作为参数:将const char指针作为参数,并返回一个int值。请编写judge()函数的原型。

int judge (int (*pf) (const char *));

12. 假设有如下结构声明:

struct applicant

{

char name [30];

int credit_ratings [3];

};

a. 编写一个函数,它将application结构作为参数,并显示该结构的内容。

b. 编写一个函数,它将application结构的地址作为参数,并显示该参数指向的结构的内容。

a. 注意,如果ap是一个applicant结构,则ap.credit_ratings就是一个数组名,而 ap.credit_ratings[i]是一个数组元素：

void display (applicant ap)

{

cout << ap.name << endl;

for (int i = 0; i < 3; i++)

cout << ap.credit_ratings[i] << endl;

}

b. 注意,如果 pa 是一个指向 applicant 结构的指针,则 pa->credit_ratings 就是一个数组名,而

pa->credit_ratings[i]是一个数组元素：

void show(const applicant * pa)

{

cout << pa->name << endl;

for (int i = 0; i < 3; i++)

cout << pa->credit_ratings[i] << endl;

}

13. 假设函数f1()和f2()的原型如下:

void f1(applicant * a);

const char * f2(const applicant * al, const applicant *a2);

请将p1和p2分别声明为指向f1和f2的指针;将ap声明为一个数组,它包含5个类型与p1相同的指针;将pa声明为一个指针,它指向的数组包含10个类型与p2相同的指针。使用typedef来帮助完成这项工作。

typedef void (*p_f1) (applicant *);

p_f1 p1=f1;

typedef const char * (*p_f2) (const applicant *, const applicant *);

p_f2 p2=f2;

p_f1 ap[5];

p_f2 (*pa)[10];

编程练习

1. 编写一个程序,不断要求用户输入两个数,直到其中的一个为0。对于每两个数,程序将使用一个函数来计算它们的调和平均数,并将结果返回给main(),而后者将报告结果。调和平均数指的是倒数平均值的倒数,计算公式如下:调和平均数=2.0*x*y/(x+y)

#include <iostream>
using namespace std;

double calculate(double x, double y) 
{
    return 2.0*x*y/(x+y);
}

int main()
{
    double x=1, y=1;
    cout<<"请输入两个数的值：";
    while(cin>>x>>y&&x!=0&&y!=0)
    {
        cout<<"调和平均数为："<<calculate(x,y)<<endl;
        cout<<"请继续输入两个数的值：";
    }
    return 0;
}

2. 编写一个程序,要求用户输入最多10个高尔夫成绩,并将其存储在一个数组中。程序允许用户提早结束输入,并在一行上显示所有成绩,然后报告平均成绩。请使用3个数组处理函数来分别进行输入、显示和计算平均成绩。

#include <iostream>
using namespace std;
double grade[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
void set_grade(void);
void display_grade(void);
void calculate_grade(void);
int main()
{
    set_grade();
    display_grade();
    calculate_grade();
    return 0;
}

void set_grade(void)
{
    for (int i = 0; i < 10; i++)
    {
        cout << "Enter the grade of " << i + 1 << " subject: ";
        if (cin >> grade[i])
        {
        }
        else
        {
            grade[i] = -1;
            break;
        }
    }
    return;
}

void display_grade(void)
{
    cout << "The grades are: ";
    for (int i = 0; grade[i] != -1&&i<10; i++)
        cout << grade[i] << " ";
    cout << endl;
    return;
}

void calculate_grade(void)
{
    double sum = 0;
    for (int i = 0; grade[i] != -1&&i<10; i++)
    {
        sum += grade[i];
    }
    cout << "The average grade is: " << sum / 10 << endl;
    return;
}

3. 下面是一个结构声明:

struct box

{

char maker [40];

float height;

float width;

float length;

float volume;

}

a. 编写一个函数,按值传递box结构,并显示每个成员的值。

b. 编写一个函数,传递box结构的地址,并将volume成员设置为其他三维长度的乘积。

c. 编写一个使用这两个函数的简单程序。

#include <iostream>
using namespace std;
struct box
{
char maker [40];
float height;
float width;
float length;
float volume;
};
void display(box b);
void set_volume(box* b);
int main()
{
    box b={"abcd",1.1,2,3,4.4};
    display(b);
    set_volume(&b);
    return 0;
}
void display(box b)
{
    cout<<b.maker<<endl;
    cout<<b.height<<endl;
    cout<<b.width<<endl;
    cout<<b.length<<endl;
    cout<<b.volume<<endl;
}
void set_volume(box* b)
{
    b->volume=b->height*b->width*b->length;
}

4.许多州的彩票发行机构都使用如程序所示的简单彩票玩法的变体。在这些玩法中,玩家从一组被称为域号码(field number)的号码中选择几个。例如,可以从域号码1~47中选择5个号码;还可以从第二个区间(如1~27)选择一个号码(称为特选号码)。要赢得头奖,必须正确猜中所有的号码。中头奖的几率是选中所有域号码的几率与选中特选号码几率的乘积。例如,在这个例子中,中头奖的几率是从47个号码中正确选取5个号码的几率与从27个号码中正确选择1个号码的几率的乘积。请修改程序,以计算中得这种彩票头奖的几率。

#include <iostream>
using namespace std;
// Note: some implementations require double instead of long double
long double probability(unsigned numbers, unsigned picks);
int main()
{
	cout<<"从47个域号码中选取5个并在第二个区间27个中选取一个的概率为：";
    cout<<probability(47,5)*probability(27,1)<<endl;
	return 0;
}

long double probability(unsigned numbers, unsigned picks)
{
	long double result = 1.0;
	long double n;
	unsigned p;
	for (n = numbers, p = picks; p > 0; n--, p--)
		result = result * p / n;
	return result;
}

5. 定义一个递归函数,接受一个整数参数,并返回该参数的阶乘。前面讲过,3的阶乘写作3!,等于3*2!,依此类推;而0!被定义为1。通用的计算公式是,如果n大于零,则n != n*(n-1)!。在程序中对该函数进行测试,程序使用循环让用户输入不同的值,程序将报告这些值的阶乘。

#include <iostream>
using namespace std;

int func(int n);
int main()
{
	int n;
	cout<<"请输入一个数字：";
	while(cin>>n)
	{
		cout<<n<<"的阶乘为：";
		cout<<func(n)<<endl;
		cout<<"请继续输入一个数字：";
	}
	return 0;
}
int func(int n)
{
	if(n==1||n==0)
        return 1;
    else
        return n*func(n-1);
}

6. 编写一个程序,它使用下列函数:

Fill_array()将一个double数组的名称和长度作为参数。它提示用户输入double值,并将这些值存储到数组中。当数组被填满或用户输入了非数字时,输入将停止,并返回实际输入了多少个数字。
Show_array()将一个double数组的名称和长度作为参数,并显示该数组的内容。
Reverse-array()将一个double数组的名称和长度作为参数,并将存储在数组中的值的顺序反转。程序将使用这些函数来填充数组,然后显示数组;反转数组,然后显示数组;反转数组中除第一个和最后一个元素之外的所有元素,然后显示数组。

#include <iostream>
using namespace std;
int fill_array(double* d,int n);
void show_array(double* d,int n);
void reserve_array(double* d,int n);
int main()
{
	double d[10];
    int len=fill_array(d,10);
    show_array(d,len);
	reserve_array(d,len);
	show_array(d,len);
	reserve_array(d+1,len-2);
	show_array(d,len);
    return 0;
}


int fill_array(double* d,int n)
{
	cout<<"请输入数组元素：";
	int i;
	for(i=0;i<n&&cin>>d[i];i++)
	{
		cout<<"请继续输入:";
	}
	return i;
}
void show_array(double* d,int n)
{
	for(int i=0;i<n;i++)
    {
        cout<<d[i]<<" ";
    }
	cout<<endl;
}
void reserve_array(double* d,int n)
{
	for(int i=0;i<n/2;i++)
	{
		double temp=d[i];
        d[i]=d[n-i-1];
        d[n-i-1]=temp;
	}
}

7. 修改程序清单7.7中的3个数组处理函数,使之使用两个指针参数来表示区间。fill_array()函数不返回实际读取了多少个数字,而是返回一个指针,该指针指向最后被填充的位置;其他的函数可以将该指针作为第二个参数,以标识数据结尾。

#include <iostream>
using namespace std;
const int Max = 5;
double *fill_array(double *begin, double *end);
void show_array(double *begin, double *end); // don't change data
void revalue(double *begin, double *end,double r);
int main()
{
	double properties[Max];
	double *end = fill_array(properties, properties + Max);
	show_array(properties, end);
	cout << "Enter revaluation factor: ";
	double factor;
	while (!(cin >> factor))
	{
		cin.clear();
		while (cin.get() != '\n')
			continue;
		cout << "Bad input; Please enter a number: ";
	}
	revalue(properties, end,factor);
	show_array(properties, end);
	cout << "Done.\n";
	return 0;
}
double *fill_array(double *begin, double *end)
{
	double *now;
	int i;
	for (now = begin, i = 0; now != end; now++, i++)
	{
		cout << "Enter value #" << (i + 1) << ": ";
		if (!(cin >> *now))
		{
			cin.clear();
			while (cin.get() != '\n')
				continue;
			cout << "Bad input;input process terminated.\n";
			break;
		}
	}
	return now;
}
void show_array(double *begin, double *end)
{
	cout << "数组为：";
	for (double *i = begin; i != end; i++)
	{
		cout << *i << " ";
	}
	cout << endl;
}
void revalue(double *begin, double *end, double r)
{
	for (double *i = begin; i != end; i++)
		*i *= r;
}

8. 在不使用array类的情况下完成程序清单7.15所做的工作。编写两个这样的版本:

a. 使用const char*数组存储表示季度名称的字符串,并使用double数组存储开支。
b. 使用const char *数组存储表示季度名称的字符串,并使用一个结构,该结构只有一个成员------一个用于存储开支的double数组。这种设计与使用array类的基本设计类似。

#include <iostream>
#include <string>
using namespace std;

const int Seasons = 4;
const char* Snames[4] =
    {"Spring", "Summer", "Fall", "Winter"};
void fill(double *);
void show(double *);
int main()
{
    double expenses[Seasons];
    fill(expenses);
    show(expenses);
    return 0;
}
void fill(double * d)
{
    using namespace std;
    for (int i = 0; i < Seasons; i++)
    {
        cout << "Enter " << Snames[i] << " expenses: ";
        cin >> d[i];
    }
}
void show(double * d)
{
    using namespace std;
    double total = 0.0;
    cout << "\nEXPENSES\n";
    for (int i = 0; i < Seasons; i++)
    {
        cout << Snames[i] << ": $" << d[i] << endl;
        total += d[i];
    }
    cout << "Total Expenses: $" << total << endl;
}

#include <iostream>
#include <string>
using namespace std;
const int Seasons = 4;
const char* Snames[4] =
    {"Spring", "Summer", "Fall", "Winter"};
struct Arr
{
	double ex[Seasons];
};
void fill(Arr*);
void show(Arr);
int main()
{
    Arr array1;
    fill(&array1);
    show(array1);
    return 0;
}
void fill(Arr* array)
{
    using namespace std;
    for (int i = 0; i < Seasons; i++)
    {
        cout << "Enter " << Snames[i] << " expenses: ";
        cin >> array->ex[i];
    }
}
void show(Arr array)
{
    using namespace std;
    double total = 0.0;
    cout << "\nEXPENSES\n";
    for (int i = 0; i < Seasons; i++)
    {
        cout << Snames[i] << ": $" << array.ex[i]<< endl;
        total += array.ex[i];
    }
    cout << "Total Expenses: $" << total << endl;
}

9. 这个练习让您编写处理数组和结构的函数。下面是程序的框架,请提供其中描述的函数,以完成该程序。

#include <iostream>
using namespace std;
const int SLEN = 30;
struct student
{
	char fullname[SLEN];
	char hobby[SLEN];
	int ooplevel;
};
// getinfo() has two arguments: a pointer to the first element of
// an array of student structures and an int representing the
// number of elements of the array. The function solicits and
// stores data about students. It terminates input upon filling
// the array or upon encountering a blank line for the student
// name. The function returns the actual number of array elements
// filled.
// getinfo() 函数有两个参数：一个指向学生结构数组第一个元素的指针，一个表示数组元素数量的 int。该函数通过询问学生数据并将其存储在数组中。当填充数组或在输入学生姓名时遇到空白行时，该函数将终止输入。该函数返回实际填充数组元素数量。
int getinfo(student pa[], int n);
// display1() takes a student structure as an argument
// and displays its contents
void display1(student st);
// display2() takes the address of student structure as an
// argument and displays the structure's contents
void display2(const student *ps);
// display3 () takes the address of the first element of an array
// of student structures and the number of array elements as
// arguments and displays the contents of the structures
void display3(const student pa[], int n);

int main()
{
	cout << "Enter class size: ";
	int class_size;
	cin >> class_size;
	while (cin.get() != '\n')
		continue;
	student *ptr_stu = new student[class_size];
	int entered = getinfo(ptr_stu, class_size);
	for (int i = 0; i < entered; i++)
	{
		display1(ptr_stu[i]);
		display2(&ptr_stu[i]);
	}
	display3(ptr_stu, entered);
	delete[] ptr_stu;
	cout << "Done\n";
	return 0;
}
int getinfo(student pa[], int n)
{
	int i = 0;
	while (i < n)
	{
		cout << "Enter student name: ";
		if (cin.getline(pa[i].fullname, SLEN)&&pa[i].fullname[0]=='\0')
		{
			cin.clear();
			break;
		}
		cout << "Enter hobby: ";
		if (cin.getline(pa[i].hobby, SLEN)&&pa[i].hobby[0]=='\0')
		{
			cin.clear();
			break;
		}
		cout << "Enter ooplevel: ";
		if (!(cin >> pa[i].ooplevel))
		{
			cin.clear();
			while (cin.get() != '\n')
				continue;
			break;
		}
		i++;
		while (cin.get() != '\n')
			continue;
	}
	return i;
}
void display1(student st)
{
	cout << "Student name: " << st.fullname << endl;
	cout << "Hobby: " << st.hobby << endl;
	cout << "OOP level: " << st.ooplevel << endl;
}
void display2(const student *ps)
{
	cout << "Student name: " << ps->fullname << endl;
	cout << "Hobby: " << ps->hobby << endl;
	cout << "OOP level: " << ps->ooplevel << endl;
}
void display3(const student pa[], int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << "Student name: " << pa[i].fullname << endl;
		cout << "Hobby: " << pa[i].hobby << endl;
		cout << "OOP level: " << pa[i].ooplevel << endl;
	}
}

10. 设计一个名为calculate()的函数,它接受两个double值和一个指向函数的指针,而被指向的函数接受两个double参数,并返回一个double值。calculate()函数的类型也是double,并返回被指向的函数使用calculate()的两个double参数计算得到的值。例如,假设add()函数的定义如下:

double add(double x, double y)

{

return x+y;

}

则下述代码中的函数调用将导致calculate()把2.5和10.4传递给add()函数,并返回add()的返回
值(12.9):
double q =calculate(2.5, 10.4, add);
请编写一个程序,它调用上述两个函数和至少另一个与add()类似的函数。该程序使用循环来让用户
成对地输入数字。对于每对数字,程序都使用calculate()来调用add()和至少一个其他的函数。如果读者爱冒险,可以尝试创建一个指针数组,其中的指针指向add()样式的函数,并编写一个循环,使用这些指针连续让calculate()调用这些函数。提示:下面是声明这种指针数组的方式,其中包含三个指针:
doubIe (*pf [3]}(double, double};可以采用数组初始化语法,并将函数名作为地址来初始化这样的数组。

#include <iostream>
using namespace std;

double calculate(double x, double y, double (*f)(double,double)) ;
double add1(double x, double y);
double add2(double x, double y);
double add3(double x, double y);
int main()
{
	double x,y;
	double (*p[3])(double,double)={add1,add2,add3};
	while(cin>>x>>y)
	{
		for(int i=0;i<3;i++)
        {
            cout<<calculate(x,y,p[i])<<endl;
        }
	}
	return 0;
}
double calculate(double x, double y, double (*f)(double,double))
{
	return f(x,y);
}
double add1(double x, double y)
{
	return x+y;
}
double add2(double x, double y)
{
	return 2*x+2*y;
}
double add3(double x, double y)
{
	return 3*x+3*y;
}