C++ Primer Plus习题及答案-第九章

C++ Primer Plus习题及答案-第九章

习题选自：C++ Primer Plus(第六版)
内容仅供参考，如有错误，欢迎指正 !

• static函数与普通函数作用域不同（仅在本文件）。只在当前源文件中使用的函数应该说明为内部函数(static修饰的函数)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件。

复习题

1. 对于下面的情况，应使用哪种存储方案？

• a. homer是函数的形参。
• b. secret变量由两个文件共享。
• c. topsecret变量由一个文件中的所有函数共享，但对于其他文件来说是隐蔽的。
• d. beencalled记录包含它的函数被调用的次数

a. home将自动成为自动变量。

b. secret在一个文件应该定义为一个外部变量，在第二个文件用extern声明。

c. 在topsecret前面添加关键字static，将topsecret定义为一个有内部链接的静态变量。或者将其在一个未命名的的名称空间中进行定义。

d. 在beencalled前面添加关键字static，将其定义为一个本地静态变量。

2.using声明和using编译指令有何区别？

using声明使得名称空间中的单个名称可用，其作用域与using所在的声明区域相同。using编译指令使名称空间中的所有名称可用。使用using编译指令时，就像在一个包含using声明和名称空间本身的最小声明区域中声明了这些名称一样。

3.重新编写下面的代码，使其不使用using声明和using编译指令。

#include <iostream>
using namespace std;

int main()
{
       double x;
       cout << "Enter value: ";
       while (!(cin >> x))
       {
            cout << "Bad input. Please enter a number: ";
            cin.clear();
            while (cin.get() != '\n')
                continue;
       }

       cout << "Value = " << x << endl;
       return 0;
}

不使用using声明和using编译指令：

#include <iostream>

int main()
{
    double x;
    std::cout << "Enter value: ";
    while (!(std::cin >> x))
    {
        std::cout << "Bad input. Please enter a number: ";
        std::cin.clear();
        while (std::cin.get() != '\n')
            continue;
    }

    std::cout << "Value = " << x << std::endl;
    return 0;
}  

4.重新编写下面的代码，使之使用using声明，而不是using编译指令。

#include <iostream>

using namespace std;
int main()
{
       double x;
       cout << "Enter value: ";
       while (!(cin >> x))
       {
           cout << "Bad input. Please enter a number: ";
           cin.clear();
           while (cin.get() != '\n')
               continue;
       }
       cout << "Value = " << x << endl;
       return 0;
}

使用using声明：

#include <iostream>

using std::cin;
using std::cout;
using std::endl;

int main()
{
    double x;
    cout << "Enter value: ";
    while (!(cin >> x))
    {
        cout << "Bad input. Please enter a number: ";
        cin.clear();
        while (cin.get() != '\n')
            continue;
    }
    cout << "Value = " << x << endl;
    return 0;
}

5.在一个文件中调用average(3,6)函数时，它返回两个int参数平均值，在同一个程序的另一个文件中调用时，它返回两个int参数的double平均值。应如何实现？

在每个文件中使用静态函数定义。或者每个文件都在未命名空间中定义一个合适的average函数。

6.下面的程序由两个文件组成，该程序显示什么内容？

//file1.cpp
#include <iostream>

using namespace std;
void other();
void another();
int x = 10;
int y;
int main()
{
       cout << x << endl;
       {
           int x = 4;
           cout << x << endl;
           cout << y << endl;
       }
       other();
       another();
       return 0;
}

void other()
{
       int y = 1;
       cout << "Other: " << x << ", " << y << endl;
}

//file2.cpp
#include <iostream>

using namespace std;
extern int x;

namespace
{
       int y = -4;
}

void another()
{
       cout << "another() " << x << ", " << y << endl;
}

10
4
0
Other:: 10, 1
another() 10, -4

7.下面的代码将显示什么内容？

#include <iostream>

using namespace std;

void other();
namespace n1
{
       int x = 1;
}

namespace n2
{
       int x = 2;
}

int main()
{
       using namespace n1;
       cout << x << endl;
       {
           int x = 4;
           cout << x << ", " << n1::x << ", " << n2::x << endl;
       }
       using n2::x;
       cout << x << endl;
       other();
       return 0;
}
void other()
{
       using namespace n2;
       cout << x << endl;
       {
           int x = 4;
           cout << x << ", " << n1::x << ", " << n2::x << endl;
       }
       using n2::x;
       cout << x << endl;
}

1
4, 1, 2
2
2
4, 1, 2
2

编程题

1.根据这个头文件：

// golf.h -- for pe9-1.cpp
const int Len = 40;
struct golf
{
       char fullname(Len);
       int handicap;
};
// non-interactive version:
// function sets golf structure to provided name, handicap
// using values passed as arguments to the function
void setgolf(golf & g, const char * name, int hc);
// interactive version:
// function solicits name and handicap from uaer
// and sets the members of g to the valus entered
// returns 1 if name is entered, 0 if name is empty string
int setgolf(golf & g);
// function resets handicap to new value
void handicap(golf & g, int hc);
// function displays  contents of golf structure
void showgolf(const golf &g);

注意到setgolf()被重载，可以这样使用其第一个版本：

golf ann;
setgolf(ann, "Ann Birdfree", 24);

上述函数调用提供了存储在ann结构中的信息。可以这样使用其第二个版本：

golf andy;
setgolf(andy);

上述函数将提示用户输入姓名和等级，并将它们存储在andy结构中。这个函数可以（但是不一定必须）在内部使用第一个版本。

根据这个头文件，创建一个多文件程序。其中的一个文件名为golf.cpp，它提供了与头文件中的原型匹配的函数定义；另一个文件应包含main()，并演示原型化函数的所有特性。例如，包含一个让用户输入的循环，并使用输入的数据来填充一个由golf结构组成的数组，数组被填满或用户将高尔夫选手的姓名设置为空字符串时，循环将结束。main()函数只使用头文件中原型化的函数来访问golf结构。

golf.cpp:

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

using namespace std;

void setgolf(golf &g, const char *name, int hc)
{
    strcpy(g.fullname, name);
    g.handicap = hc;
}

int setgolf(golf &g)
{
    cout << "please enter fullname : ";
    cin.getline(g.fullname, Len);
    if (strlen(g.fullname) == 0)
        return 0;
    else
    {
        cout << "please enter handicap : ";
        cin >> g.handicap;
        cin.get();
        return 1;
    }
}

void handicap(golf &g, int hc)
{
    g.handicap = hc;
}

void showgolf(golf &g)
{
    cout << "fullname : " << g.fullname << ", handicap : " << g.handicap << endl;
}

main.cpp:

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

using namespace std;

int main()
{
    golf ann, andy, arrGolf[3];
    setgolf(ann, "Ann Birdfree", 24);
    showgolf(ann);

    if (setgolf(andy) == 1)
        showgolf(andy);
    handicap(andy, 20);
    showgolf(andy);

    int i = 0;
    while (i < 3 && setgolf(arrGolf[i]))
    {
        showgolf(arrGolf[i]);
        i++;
        if(i<3)
            cout << "next one: " << endl;
    }
    return 0;
}

2.修改程序清单9.9：

//Listing 9.9 static.cpp
// static.cpp -- using a static local variable
#include <iostream>
// constants
const int ArSize = 10;
// function prototype˜
void strcount(const char *str);
int main()
{
    using namespace std;
    char input[ArSize];
    char next;
    cout << "Enter a line:\n";
    cin.get(input, ArSize);
    while (cin)
    {

        cin.get(next);
        while (next != '\n') // string didn't fit!
            cin.get(next);   // dispose of remainder strcount(input);
        cout << "Enter next line (empty line to quit):\n";
        cin.get(input, ArSize);
    }
    cout << "Bye\n";
    return 0;
}
void strcount(const char *str)
{
    using namespace std;
    static int total = 0;
    int count = 0;
    // static local variable // automatic local variable
    cout << "\"" << str << "\" contains ";
    while (*str++) // go to end of string
        count++;
    total += count;
    cout << count << " characters\n";
    cout << total << " characters total\n";
}

用string对象代替字符数组。这样，该程序将不再需要检查输入的字符串是否过长，同时可以将输入字符串同字符串“”进行比较，以判断是否为空行。

#include <iostream>
#include <string>
void strcount(const std::string &str);

int main()
{
    using namespace std;
    string input;
    cout << "Enter a line:\n";
    getline(cin, input);
    while (input.size())
    {
        strcount(input);
        cout << "Enter next line (empty line to quit):\n";
        getline(cin, input);
    }
    cout << "Bye\n";
    return 0;
}
void strcount(const std::string &str)
{
    using namespace std;
    static int total = 0;
    int count = str.size();
    cout << "\"" << str << "\" contains ";
    total += count;
    cout << count << " characters\n";
    cout << total << " characters total\n";
}

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

struct chaff
{
     char dross[20];
     int slag;
};

编写一个程序，使用定位new运算符将一个包含两个这种结构的数组放在一个缓冲区中。然后，给结构的成员赋值（对于char数组，使用函数strcpy()），并使用一个循环来显示内容。一种方法是像程序清单9.10那样将一个静态数组用作缓冲区；另一种方法是使用常规new运算符来分配缓冲。

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

const int LEN = 512;
const int N = 3;
char buff[LEN];

struct chaff
{
    char dross[20];
    int slag;
};

int main()
{
    chaff *cf1 = new chaff[N];
    chaff *cf2 = new (buff) chaff[N];
    string temp;
    for (int i = 0; i < N; i++)
    {
        cout << "Please enter dross of #" << i + 1 << " chaff :";
        cin.getline(cf1[i].dross, 20);
        strcpy(cf2[i].dross, cf1[i].dross);
        cout << "enter slag :";
        cin >> cf1[i].slag;
        cf2[i].slag = cf1[i].slag;
        cin.ignore();
    }
    for (int i = 0; i < N; i++)
    {
        cout << "#" << i + 1 << " chaff:" << endl;
        cout << "cf1[" << i << "].dross : " << cf1[i].dross << ", slag :"
             << "cf1[" << i << "].slag : " << cf1[i].slag << endl;
        cout << "cf2[" << i << "].dross : " << cf2[i].dross << ", slag :"
             << "cf2[" << i << "].slag : " << cf2[i].slag << endl;
    }
    return 0;
}

4。请基于下面这个名称空间编写一个由3个文件组成的程序：

namespace SALES
{
    const int QUARTERS = 4;
    struct Sales
    {
        double sales [QUARTERS];
        double average;
        double max;
        double min;
    };
    // copies the lesser of 4 or n items from the array ar
    // to the sales member of s and computes and stores the 
    // average, maximum, and minimum values of the entered items;
    // remaining elements of sales ,if any, set to 0
    void setSales(Sales & s,const double ar[],int n);
    // gathers sales for 4 quarters interactively,stores them
    // in the sales member of s and computes and stores the
    // average,maximum,and minimum values
    void setSales (Sales & s);
    // display all information in structure s
    void showSales(const Sales & s);
}

第一个文件是一个头文件，其中包含名称空间：第二个文件是一个源代码文件，它对这个名称空间进行扩展，以提供这三个函数的定义；第三个文件声明两个Sales对象，并使用setSales（）的交互式版本为一个结构提供值，然后使用setSales（）的非交互式版本为另一个结构提供值。另外它还使用showSales（）来显示这两个结构的内容。

1.sales.h

//sales.h-----头文件
namespace SALES
{
    const int QUARTERS = 4;
    struct Sales
    {
        double sales [QUARTERS];
        double average;
        double max;
        double min;
    };
    void setSales(Sales & s,const double ar[],int n);
    void setSales (Sales & s);
    void showSales(const Sales & s);
}

2.sales.cpp

//sales.cpp-----源代码文件
#include "sales.h"

using namespace std;
namespace SALES
{
    void setSales(Sales &s, const double ar[], int n)
    {
        double min = 0, max = 0, sum = 0;
        s.min = s.max = ar[0];
        for (int i = 0; i < n; i++)
        {
            s.sales[i] = ar[i];
            sum += ar[i];
            if (ar[i] > max)
            {
                max = ar[i];
            }
            if (ar[i] < min)
            {
                min = ar[i];
            }
        }
        s.average = sum / n;
    }

    void setSales(Sales &s)
    {
        cout << "Please enter 4 quarters for sales:" << endl;
        cout << "the 1 quarter :";
        cin >> s.sales[0];
        s.min = s.max = s.sales[0];
        for (int i = 1; i < 4; i++)
        {
            cout << "the " << i << " quarter :";
            cin >> s.sales[i];
            if (s.max < s.sales[i])
            {
                s.max = s.sales[i];
            }
            if (s.min > s.sales[i])
            {
                s.min = s.sales[i];
            }
        }
        s.average = (s.sales[0] + s.sales[1] + s.sales[2] + s.sales[3]) / 4;
    }

    void showSales(const Sales &s)
    {
        cout << "Display all information in sales : " << endl;
        cout << "The 4 quarters are $" << s.sales[0] << ", $" << s.sales[1] << ", $" << s.sales[2] << ", $" << s.sales[3] << endl;
        cout << "The average income is $" << s.average << endl;
        cout << "The maximum income is $" << s.max << endl;
        cout << "The minimum income is $" << s.min << endl;
    }
}

3.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, s2;
    setSales(s1, arr, 4);
    showSales(s1);
    setSales(s2);
    showSales(s2);
    return 0;
}