自考c++程序设计答案4737 04737

习题1

一、单项选择题

1. 下列选项中不是C++语言关键字的是（B）。 
   A. typedef  B. mycase  C. typeid  D. typename
2. 下列选项中不是C++语言合法标识符的是（C）。 
   A. area  B. _age  C. -xy  D. w123
3. 下列选项中正确的标识符是（C）。 
   A. case  B. de。fault  C. c_ase  D. a.b

二、填空题

1. 用来处理标准输入的是 cin ，用来处理屏幕输出的是 cout 。
2. 动态分配内存使用关键字 new ，释放内存使用关键字 delete 。
3. 为整数55分配一块内存的语句为 new int[1] 。

三、改错题

1. 分析如下主程序中的错误。

void main() {
    //int num;
    int& ref = num;
    ref = ref + 100;
    num = num + 50;
}

答：变量num没有声明。 
2. 分析如下主程序中的错误。

void main() {
    int x = 58, y = 98;
    const int *p = &x;
    y = *p;
    *p = 65;
    p = &y;
}

答：code:5: error:只读变量不可更改。 
3. 分析如下主程序中的错误。

void main() {
    int x = 58, y = 98, z = 55;
    int* const p = &x;
    *p = 65;
    p = &y;
    z = *p;
}

答：code:5: error:常量指针不可更改。

四、编程题

1. 分别用字符和ASCII码形式输出整数值65和66。

#include <iostream>
using namespace std;
int main()
{
    int temp1 = 65, temp2 = 66;
    cout << (char)temp1 << " " << (char)temp2 << endl;
    cout << temp1 << " " << temp2 << endl;
    return 0;
}

1. 编写一个为int型变量分配100个整形量空间的程序。

#include <iostream>
using namespace std;
int main()
{
    int *ptr = new int[100];
    delete []ptr;
    return 0;
}

1. 编写完整的程序，它读入15个float值，用指针把它们存放在一个存储块里，然后输出这些值的和以及最小值。

#include <iostream>
using namespace std;
const int num = 15;
int main()
{
    float temp[num];
    float count = 0.0f;
    float mini = 0.0f;
    cout << "Please insert 15 numbers." << endl;
    for (int i = 0; i < num; ++i)
    {
        cin >> temp[i];
        count += temp[i];
        if (temp[i] < mini || i == 0)
        {
            mini = temp[i];
        }
    }
    cout << "equal: " << count << endl;
    cout << "mininum: " << mini << endl;
    return 0;
}

1. 声明如下数组： 
   int a[] = {1, 2, 3, 4, 5, 6, 7, 8}; 
   先查找4的位置，将数组a复制给数组b，然后将数组a的内容反转，再查找4的位置，最后分别输出数组a和b的内容。

#include <iostream>
using namespace std;
const int num = 8;

int find(int a[], int key, int n)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] == key)
        {
            return i + 1;
        }
    }
    return 0;
}

void copy(int a[],int b[], int n)
{
    for (int i = 0; i < n; ++i)
    {
        b[i] = a[i];
    }
}
void reverse(int a[], int n)
{
    int temp;
    int i, j = n - 1, m = (n - 1) / 2;
    for (i = 0; i <= m; ++i)
    {
        j = n - 1 - i;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}
int main()
{
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8};
    cout << find(a, 4, num) << endl;
    int b[num];
    copy(a, b, num);
    reverse(a, num);
    cout << find(a, 4, num) << endl;
    for (int i = 0; i < num; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    for (int i = 0; i < num; ++i)
    {
        cout << b[i] << " ";
    }
    cout << endl;
    return 0;
}

习题2

一、单项选择题

1. 使用string类建立对象的不正确方式是( D )。 
   A. string str(" OK");  B. string str=" OK";  C. string str;  D. string str='OK';
2. 下面所列各项中，不是面向对象程序设计所具特点的选项是（D）。 
   A. 封装  B. 继承  C. 抽象  D. 函数

二、作图题

1. 已知一个学生类具有性别和年龄两个属性，男学生张明的年龄为12岁，女学生李红的年龄为11岁。给出这个学生类的类图和它们的对象图。 
   
2. 一个圆具有圆心坐标和半径两个属性，并且能够给出圆的面积，请画出这个圆类的类图。 
   
3. 画出一个班级类的类图，为它设计必需的属性以表示这个类的特征。 
   
4. 画出一种电话卡的类图，为它设计必要的属性。 
   
5. 为上题的电话卡设计必要的成员函数，以便提供基本服务。 
   

三、编程题

1. 使用多种方法编写将两个字符串连接在一起的程序。

#include <iostream>
#include <string>
using std::string;
using std::cout;
using std::endl;

string push_back(string str1, string str2)
{
    string::iterator iter = str2.begin();
    for (; iter != str2.end(); ++iter)
    {
        str1.push_back(*iter);
    }
    return str1;
}

int main()
{
    string str1("Cconnect ");
    string str2("String!");
    string temp(str1);
    cout << "+ or +=: " << str1 + str2 << endl;
    cout << "append: " << str1.append(str2) << endl;
    str1 = temp;
    cout << "push_back: " << push_back(str1, str2) << endl; 
    cout << "others:insert() or str[] .." << endl;
    return 0;
}

1. 已知一个string的对象str的内容为“We are here!”，使用多种方法输出字符“h”。

#include <iostream>
#include <string>
using std::string;
using std::cout;
using std::endl;
int main()
{
    string str("We are here!");
    cout << str[str.find('h')] << endl;
    cout << str.substr(str.find('h'), 1) << endl;
    return 0;
}

习题3

一、填空题

1. 在C++语言中，函数“double abc(double, char);”表示的含义是 声明一个返回double类型的，且第一个参数为double和第二个参数为char的函数abc 。
2. 定义内联函数的关键字为 inline 。
3. C++函数参数传递的方式有 传值和传引用 。
4. 函数声明char& func(char, int)的含义是 声明一个返回char&引用类型的，且第一个参数为char和第二个参为int的函数func 。
5. 函数fun的返回值是指针，其中一个参数是字符，另一个是参数int类型的引用，声明fun的函数的原型是int * fun(char, int &);。

二、单项选择题

1. 不允许调用者改变函数参数的函数原型声明是（ A ）。 
   A. string input(const int);  B. string input(int &);  C. string* input(int *);  D. string input(string &);
2. 关于函数重载的正确叙述是（ C ）。 
   A. 函数的参数个数不能相同  B. 函数参数的数据类型不能相同  C. 函数的返回值可以相同  D. 函数的返回值不能相同
3. 下列对模板的声明中正确的一项是（ C ）。 
   A. template<T>  B. template<class T1, T2>  C. template<class T1, class T2>  D. template<class T1; class T2>

三、改错题

1. 下面程序错在何处？

template <class T>
T fun(T x) {
    T y;
    //y = x * x - T;
    y = x * x - y;
    return y;
}

答：code:4: error: 'T'不是有效的变量或常量。 
2. 找出下面程序中的错误并改正之。

#include <iostream.h>
template <class Type>
//Type max(T x, y)
Type max(Type x,Type y)
{ return (x > y) ? (x) : (y); }

答：code:3: error:'T'和'y'不是有效的变量 
3. 找出下面程序中的错误并改正之。

//void change(const string &s)
void change(string &s)
{ s = s + "pig!"; }
//}
void main() {
    string str(" it is a");
    change(str);
}

答：code:1: error:常量s的值不能改变

四、编程题

1. 编写一个求方程ax2+bx+c=0ax2+bx+c=0的根的程序，用3个函数分别求当b2−4acb2−4ac大于零、等于零、小于零时的方程的根。要求从主函数输入a、b、c的值并输出结果。

#include <iostream>
#include <math.h>
//大于0时，方程ax^2 + bx + c = 0有2个相同的解
void solver1(int a, int b, int c) {
    double x1, x2, temp;
    temp = b * b - 4 * a * c;
    x1 = (-b + sqrt(temp)) / (2 * a);
    x2 = (-b + sqrt(temp)) / (2 * a);
    std::cout << x1 << " " << x2 << std::endl;
}
//等于0时，方程ax^2 + bx + c = 0有2个相同的解
void solver2(int a, int b, int c) {
    double x1, x2, temp;
    x1 = -b / (2 * a);
    x2 = 0;
    std::cout << x1 << " " << x2 << std::endl;
}
//小于0时，方程ax^2 + bx + c = 0无解
void solver3(int a, int b, int c) {
    std::cout << "null" << std::endl;
}

int main()
{
    int a = 0, b = 0, c = 0;
    std::cout << "一元二次方程：" << "ax^2 + bx + c = 0" << std::endl;
    std::cout << "请输入a, b, c:(用空格断开)" << std::endl;
    std::cin >> a >> b >> c;

    int delta = b * b - 4 * a * c;
    if(delta > 0) {
        solver1(a, b, c);
    } else if(delta == 0) {
        solver2(a, b, c);
    } else {
        solver3(a, b, c);
    }
    return 0;
}

1. 定义函数up(ch)，如字符变量ch是小写字母就转换成大写字母并通过up返回，否则字符ch不改变。要求在短小而完全的程序中显示这个程序是怎样被调用的。

#include <iostream>
char up(char ch) {
    return toupper(ch);
}
int main()
{
    char ch;
    std::cout << "Plase enter a character:";
    std::cin >> ch;
    std::cout << up(ch) << std::endl;
    return 0;
}

1. 编写主程序调用带实数r和整数n两个参数的函数并输出r的n次幂。

#include <iostream>
double exponentiation(double r, int n) {
    double result = 1.0;
    for(int i = 0; i < n; ++i) {
        result *= r;
    }
    return result;
}
int main()
{
    double r = 0.0;
    int n = 0;
    std::cout << "Please enter r and n:" << std::endl;
    std::cin >> r >> n;
    std::cout << "r^n:" << exponentiation(r, n) << std::endl;
    return 0;
}

1. 编写有字符型参数C和整型参数N的函数，让它显示出由字符C组成的三角形。其方式为第1行有1个字符C，第2行有2个字符C等等。

#include <iostream>
void print_triangle(char c, int n) {
    for(int i = 0; i < n; i++) {
        for(int j = 0; j <= i; j++) {
            std::cout << c;
        }
        std::cout << std::endl;
    }
}
int main()
{
    char c;
    int n;
    std::cout << "Plase enter c and n:" << std::endl;
    std::cin >> c >> n;
    print_triangle(c, n);
    return 0;
}

1. 编写一个求字符串长度的函数strlen()，再用strlen()函数编写一个函数revers(s)的倒序递归程序，使字符串s逆序。

#include <iostream>
#include <string>
int strlen(char *str) {
    int len = 0;
    while(str[len] != '\0') {
        len++;  
    }   
    return len;
}
void revers(char *str) {
    char c;
    int loc, len;
    len = strlen(str);
    loc = len / 2 - 1;
    while(loc >= 0) {
        c = *(str + loc); 
        *(str + loc) = *(str + len - loc - 1);
        *(str + len - loc - 1) = c; 
        loc--;  
    }   
    str[len] = '\0';
}
int main()
{
    char str[] = {"123456789ABCDEF"};
    std::cout << "str's lenth : " << strlen(str) << std::endl;
    std::cout << "str's : " << str << std::endl;
    revers(str);
    std::cout << "str's revers : " << str << std::endl;
}

1. 用函数模板实现3个数值中按最小值到最大值排序的程序。

#include <iostream>
template <class T>
void sort(T a[], int len) {
    T temp;
    for(int i = 0; i < len; i++) {
        temp = a[i];
        for(int j = i + 1; j < len; j++) {
            if(temp > a[j]) {
                a[i] = a[j];
                a[j] = temp;
                temp = a[i];
            }
        }
    }
}
int main()
{
    int a[3] = {0, 2, 1};
    sort(a, 3);
    for(int i = 0; i < 3; i++) {
        std::cout << a[i] << " " << std::endl;
    }
    return 0;
}

1. 利用函数模板设计一个求数组元素总和的函数，并检验之。

#include <iostream>
template <class T>
T sum(T a[], int len) {
    T temp;
    for(int i = 0; i < len; i++) {
        temp += a[i];
    }
    return temp;
}
int main()
{
    int a[5] = {1, 3, 5, 7, 9};
    std::cout << sum(a, 5) << std::endl;
    return 0;
}

1. 重载上题中的函数模板，使它能够进行两个数组的求和。

#include <iostream>
template <class T>
T sum(T a[], int len) {
    T temp;
    for(int i = 0; i < len; i++) {
        temp += a[i];
    }
    return temp;
}
template <class T>
T sum(T a[], int len, T b[], int len2) {
    return sum(a, len) + sum(b, len2);
}
int main()
{
    int a[5] = {1, 3, 5, 7, 9};
    int b[5] = {2, 4, 6, 8, 10};
    std::cout << sum(a, 5, b, 5) << std::endl;
    return 0;
}

习题4

一、填空题

1. 不能使用类对象的指针取对象的private和protected的地址。
2. 构造函数是和 类 同名的函数，析构函数不允许有 返回类型和参数 ，一个类有 1 个析构函数。
3. 已知一个类的名字为fun，则其复制构造函数的原型可声明为 fun(fun&); 和 fun(const fun&); 两种形式。

二、单项选择题

1. 能提供封装的C++的下列关键字是（ C ）。 
   A. while  B. union  C. class  D. for
2. 在下面所列项中，不是面向对象的特点的是（ C ）。 
   A. 多态性  B. 抽象性和封装性  C. 多线程和多任务  D. 继承性
3. 下面选项中，对类A的析构函数的正确定义是（ A ）。解析：此题编写的不严谨，最合题意的选择是A，其中参数void，应该理解为无参，正确答案应为：~A::A(); 
   A. ~A::A(void)  B. void ~A::A(参数)  C. ~A::A(参数)  D. void ~A::A()
4. 下面有关构造函数的不正确说法是（ B ）。 
   A. 构造函数可以用来实现所有成员变量的初始化  B. 构造函数不是类的成员函数   
   C. 当生成类的实例时，自动调用构造函数进行初始化  D. 构造函数用来分配对象所需的内存
5. 有关析构函数的不正确说法是（ C ）。 
   A. 析构函数在对象生命周期结束时自动被调用  B. 析构函数不得指定参数   
   C. 定义析构函数时，可以指定返回类型为void  D. 析构函数名与类名相同
6. 下面有关类说法错误的是（ C ）。 
   A. 一个类可以有多个构造函数  B. 一个类只能有一个析构函数   
   C. 可以给析构函数指定参数  D. 一个类中可以说明具有类类型的数据成员
7. 下面有关构造函数和new运算符关系的正确说法是（ D ）。 
   A. new运算符不调用构造函数  B. 构造函数一定调用new运算符   
   C. 当生成类的实例时，先调用new运算符，然后调用构造函数进行初始化  D. 当用new运算符动态产生类的对象时，new运算符也自动调用构造函数

三、改错题

1. 找出以下类定义中的错误，并说明错在何处。

class base {
    int *p;
public:
    //base(int a) { p = &a };
    base(int a) { p = &a; }
    //int Getx() { return m; }
    int Getx() { return *p; }
    //~base() { delete p } 
    ~base() { delete p; }
};

答：code:4: error:语句应以';'结尾，方法定义的大括号后不应以';'结尾。 
code:5: error:不能使用未定义的'm'。 
code:6: error:语句应以';'结尾。 
2. 找出以下程序中的错误，并说明错在何处。

#include <iostream>
class Point {
    int x;
    public:
        void init(int a) { Setx(a); }
        int Getx() { return x; }
        //int Setx(int a) { x = a; }
        void Setx(int a) { x = a;}
//}
};
void main() {
    Point A;
    //A.init(24, 56);
    A.init(24);
    cout << "A.x = " << A.Getx() << endl;
}

答：code:8: error:类要以';'结尾。 
code:7: warning:没有返回值产生警告。 
code:10: error:未初始化的对象A，对象A没有匹配的init方法。

四、完成程序题

1. 下面是一个类的测试程序，设计出能使用如下测试程序的类：

#include <iostream>
class base {
private:
    int m, n;
public:
    void init(int M, int N) { m = M; n = N; }        
    void print() { std::cout << "2 * 68 - 55 = " << 2 * m - n << std::endl; }
};
void main() {
    base a;
    a.init(68, 55);
    a.print();
}

测试结果：2∗68−55=812∗68−55=81 
2. 完成下面类中的成员函数的定义。

class Point {
    private:
        int m, n;
    public:
        Point(int, int);
        Point(Point&);
};
Point::Point(int a, int b)
{
    m = a;
    n = b;
}
Point::Point(Point &t)
{
    m = t.m;
    n = t.n;
}

五、程序分析题

1. 给出下面程序的输出结果。

#include <iostream.h>
class base {
    private:
        int a, b;
    public:
        ~base() { cout << "Destry..." << a << "," << b << endl; }
        base(int a, int b) : b(b), a(a)
        { cout << "初始化..." << a << "," << b << endl; }
};

答：此题编写的不完整，缺少了主程序，但此题考查的是构造函数和析构函数的调用顺序，所以可得： 
初始化...a,b 
Destry...a,b 
其中变量a和b应替换为实际值。 
2. 分析下面程序的输出结果。

class base {
    private:
        int x;
    public:
        void setx(int a) { x = a; }
        int getx() { return x; }
};
void main() {
    int *p;
    base a;
    a.setx(55);
    p = new int(a.getx());
    cout << *p;
}

答：55

六、编程题

1. 设计一个点类Point，再设计一个矩形类，矩形类使用Point类的两个坐标点作为矩形对角顶点，并可以输出4个坐标值和面积。使用测试程序验证程序。

#include <iostream>

class Point {
private:
        float x, y;
public:
        Point() { x = 0; y = 0; }
        Point(float X, float Y) { x = X; y = Y; }
        float getX() { return x; };
        float getY() { return y; };
        void setX(float X) { x = X; };
        void setY(float Y) { y = Y; };
};
class Rectangular {
private:
        Point point[4];
public:
        Rectangular(Point a, Point d) {
                point[0] = a;
                point[1].setX(d.getX());
                point[1].setY(a.getY());
                point[2] = d;
                point[3].setX(a.getX());
                point[3].setY(d.getY());
        }
        void printPointsLocation() {
                for(int i = 0; i < 4; ++i) {
                        std::cout << point[i].getX() << ", " << point[i].getY() << std::endl;
                }
        }
        float getArea() {
                float height, width, area;
                height = point[0].getY() - point[3].getY();
                width = point[1].getX() - point[0].getX();
                area = height * width;
                return area;
        }
        void printArea() { std::cout << "area:" << getArea() << std::endl; }
};

int main()
{
        Point a(1.0, 10.0), b(10.0, 1.0);
        Rectangular rect(a, b);
        rect.printPointsLocation();
        rect.printArea();
        return 0;
}

1. 使用内联函数设计一个类，用来表示直角坐标系中的任意一条直线并输出它的属性。

#include <iostream>
#include <math.h>

class Line {
private:
    int x1, y1, x2, y2;
public:
    Line(int X1, int Y1, int X2, int Y2) {
        x1 = X1; y1 = Y1; x2 = X2; y2 = Y2;
    }
    inline double getLenght() { return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); }
    inline void printPoints() {
        std::cout << "Point1: " << x1 << ", " << y1 << std::endl;
        std::cout << "Point2: " << x2 << ", " << y2 << std::endl;
    }
    inline void printLenght() {
        std::cout << "Line.Lenght: " << getLenght() << std::endl;
    }

};

int main()
{
    Line line(10, 10, 60, 80);
    line.printPoints();
    line.printLenght();
    return 0;
}

七、作图题

1. 假设不涉及操作，已经定义了类Line，使用继承的方法组成Rectangle类。 
   
2. 假设不涉及操作，已经定义了类Line，使用聚合的方法组成Rectangle类。 
   

习题5

一、填空题

1. 将关键词const写在函数参数列表之后，函数体之前，说明该函数是 成员函数。
2. 一个const对象只能访问 成员函数。
3. 在函数体之前加 关键字可以防止覆盖函数改变数据成员的值。

二、单项选择题

1. 简单成员函数的声明一般不含关键字（ ）。 
   A. double  B. static  C. float  D. int
2. 已知：print()函数是一个类的常成员函数，它无返回值，下列表示中正确的是（ ）。 
   A. void print() const  B. const void print()  C. void const print()  D. void print(const)
3. 下列各类函数中，不是类的成员函数的是（ ）。 
   A. 构造函数  B. 析构函数  C. 友元函数  D. 复制初始化构造函数
4. 对友元函数描述正确的是（ ）。 
   A. 一个类的友元函数是在该类中说明的一个函数  B. 一个类的友元函数是该类的一个成员   
   C. 友元函数只允许访问该类对象的私有成员  D. 友元函数不允许访问该类的私有成员

三、改错题

1. 改正下面类定义的错误并说明理由。

class base {
        int number;
        static int a;
    public:
        void set(int i, int j);
        static int geta() { return a; }
        static int getn() { return number; }
        void show() { cout << number << "," << a << endl; }
};

1. 假设一个正确定义的类Test，改正主程序中的错误。

void main() {
    test *two[2] = { test(4, 5), test(6, 8) };
    for(i = 0 ; i < 2 ; i++)
        delete two[i];
}

四、完成程序题

完成下面程序并给出运行结果。

#include <iostream>
using namespace std;
class test {
        int X:
    public:
        test(int a) { X = a; }
        int GetX() { return X; }
};
void main() {

    test *p, a[2][3] = { {1, 2, 3}, {4, 5, 6} };
    for( ; i <= 6; p++) {
        if((p - a[0]) % 3 == 0) cout << endl;
        cout << p->GetX() << " ";
    }
}

五、编程题

1. 声明复数的类complex，使用友元函数add实现复数的加法。
2. 设计一个使用常量成员函数的示范程序。
3. 编写一个程序，该程序建立一个动态数组，为动态数组的元素赋值，显示动态数组的值并删除动态数组。
4. 定义一个Dog类，它用静态数据成员Dogs记录Dog的个体数目。静态成员函数GetDogs用来存取Dogs。设计并测试这个类。

习题6

一、填空题

1. 多重继承可以视为是 的扩展。
2. 访问控制权限是 3种。

二、单项选择题

1. 保证编译器正确调用成员函数的规则是（ ）。 
   A. 赋值兼容  B. 继承  C. 作用域  D. 支配
2. 下面叙述不正确的是（ ）。 
   A. 基类的保护成员在派生类中仍然是保护的。  B. 基类的保护成员在公有派生类中仍然是保护的。   
   C. 基类的保护成员在私有派生类中是私有的。  D. 对基类成员的访问必须是无二义性的。
3. 下面叙述不正确的是（ ）。 
   A. 成员的访问能力在私有派生类中和公有派生类中是不同的。  B. 基类的私有成员在派生类中不可访问。   
   C. 赋值兼容规则不适用于多重继承的组合。  D. 公有基类成员在保护派生类中是保护的。
4. 下面叙述不正确的是（ ）。 
   A. 派生类可以有自己的构造函数  B. 派生类继承基类的构造函数   
   C. 派生类继承基类的析构函数  D. 派生类只能继承基类的一个构造函数

三、改错题

1. 改正类定义中的错误。

class base {
        int m;
    public:
        base(int a) : m(a);
        int Getx() { return m; }
};
class derived : private base {
    public:
        derived(int b) : m(b) {};
};

1. 下面的程序含有二义性，要求不修改主程序，通过重定义成员函数Show的方法解决名字冲突。

#include <iostream.h>
class Base1 {
    protected:
        int m;
    public:
        void Show() { cout << m << endl; }
};
class Base2 {
    protected:
        int n;
    public:
        void Show() { cout << n << endl; }
};
class Derived : public Base1, public Base2 {
    public:
        void Set(int x, int y) { m = x; n = y; }
};
void main() {
    Derived Obj;
    Obj.Set(45, 87);
    Obj.Show();
    Obj.Base1::Show();
}

习题7

一、单项选择题

1. 下面关于模板叙述不正确的是（ ）。 
   A. 不可以通过一个类来派生类模板  B. 可以从一个类模板派生出一个新的类模板  C. 类模板支持单一继承  D. 类模板可以有多个参数
2. 需要一种逻辑功能一样的函数，而编制这些函数的程序文本完全一样，区别只是数据类型不同。对于这种函数，下面不能用来实现这一功能的选项是（ ）。 
   A. 宏函数  B. 为各种类型都重载这一函数  C. 模板  D. 友元函数
3. 下面关于模板叙述不正确的是（ ）。 
   A. 可以使用派生  B. 可以有多个析构函数  C. 可以有多个构造函数  D. 可以有多个参数
4. 在构造向量时，不正确的叙述是（ ）。 
   A. 可以使用基本数据类型  B. 可以使用类  C. 可以使用向量  D. 不可以使用容器
5. 对一个向量来说，不正确的叙述是（ ）。 
   A. 向量的长度可变  B. 向量有返回无需再次分配内存就能容纳对象个数的成员函数capacity()   
   C. 如果数量已满，当需要增加一个元素时，向量成员函数capacity()的长度自动增加  D. 如果数量已满，当需要增加一个元素时，capacity()的长度每次自动增加一个

二、填空题

1. 返回向量中的最后一个对象的成员函数是 ,向向量尾部插入一个对象成员函数是 。
2. 返回当前容器中已经存放的对象个数的成员函数是 ，泛型指针有 种。
3. 使用typedef定义逆向泛型指针的语句是 。

三、改错题

1. 找出下面程序的错误并说明原因。

template <typename T>
class TAnyTemp {
        T x;
    public:
        TAnyTemp(T X) : x(X) {}
        void getx() { return x; }
}

1. 找出下面程序中的错误并改正之。

class Point {
        int x, y;
    public:
        Point(int a, int b) { x = a; y = b; }
};
template <typename T>
class Line : public Point {
        T x2, y2;
    public:
        Line(T a, T b, T c, T d) : Point(a, b) { x2 = c; y2 = d; }
};

四、编程题

1. 使用类模板演示赋值兼容性规则。
2. 设计一个点的类模板，分别使用继承和包含的方法设计线段类模板，要求演示构造函数和复制构造函数的设计方法，并使用主程序验证之。
3. 已知有一个整形数组a，其内容为1 3 5 7 9 2 4 6 8 10。先对数组进行升序排序，再使用它产生向量b，然后再在向量的尾部追回11，并按降序输出向量的内容和capacity()内容。

习题8

一、单项选择题

1. 要是一个类成为抽象类，这个类应具有的条件是（ ）。 
   A. 至少有一个纯虚函数  B. 至少有一个虚函数  C. 只含有一个纯虚函数  D. 只含有一个虚函数
2. 下面是基类中的成员函数形式，其中为纯虚函数的是（ ）。 
   A. virtual void f(void);  B. virtual void f(void) = 0;  C. void f(void) = 0;  D. virtual void f(void) {}

二、分析程序题

1. 分析下面程序的输出结果。

#include <iostream>
using namespace std;
class base {
        int x;
    public:
        base(int a) { x = a; cout << "base..." << x << endl; }
        base(base &t) { x = t; cout << "base copy..." << x << endl; }
        virtual ~base() { cout << "~derived..." << y << endl; }
};
class derived : public base {
        int y;
    public:
        derived(int a, int b) : base(a)
        { y = b; cout << "derived..." << y << endl; }
        derived(derived &t) : base(t) 
        { y = t.y; cout << "derived..." << y << endl; }
        ~derived() { cout << "derived..." << y << endl; }
};
void main() {
    base *pb = new derived(52, 44);
    base a(*pb);
    delete pb;
}

1. 分析下面程序的输出结果。

#include <iostream>
using namespace std;
class A {
    public：
        virtual void fa(void) { cout << "A::fa" << endl; }
        void fb(void) { cout << "A::fb" << endl; }
};
class B ：public A {
    public:
        void fa(void) { cout << "B::fa" << endl; }
        void fb(void) { cout << "B::fb" << endl; }
}
void main() {
    A *pa = new A;
    A *pb = new B:
    pa->fa();
    pb->fb();
    pb->fa();
    pb->A::fa();
    ((B*)pb)->fb();
}

三、查错题

找出下面程序中的错误，使其输出结果如下： 
58 
18, 18 
源程序如下：

#include <iostream.h>
class base
{
        int m;
    public:
        base(int a) { m = a;}
        int Getm() { return m; }
        virtual void show() { cout << Getm() << endl; }
};
class derived : public base
{
        int n;
    public:
        derived(int a, int b) : base(a) { n = b;};
        virtual void show() { cout << Getm() << "," << n << endl; }
};
void print(base p)
{ p.show(); }
void main() {
    base A(58);
    derived B(18, 28);
    print(A);
    print(B);
}

四、完成程序题

仔细阅读下面的程序，根据输出结果分别给出基类base和派生类derived类中没有定义的内联函数void display(void)const。

#include <iostream.h>
class base
{
    int i;
    int j;  
public:
    base(int I, int J) : i(I), j(J) { display(); }
    int getI(void) { return i; }
    int getJ(void) { return j; }
};
class derived : public base
{
    int k;
public:
    derived(int I, int J, int K) : base(I, J), k(K) { display(); }
    //定义display
};
void main(void)
{
    base b3(8, 9);
    derived d1(10, 20, 5);
}

程序输出： 
i=8 i=9 
i=10 i=20 
i=10 i=20 k=5 
i+k=15 j+k=25

习题9

一、单项选择题

1. 进行文件操作时需要包含的头文件是（ ）。
2. 下列各项不是C++中的标准设备名的是（ ）。
3. width函数控制输出宽度，含有这个成员函数的是（ ）。
4. 用来检测提取操作已经到达文件尾的成员函数是（ ）。
5. 使用函数setprecision(int n)必须包含的头文件是（ ）。
6. 下面正确的说法是（ ）。

二、填空题

1. 设置ios_base::right含义是 。
2. 提取并舍弃从当前输入位置的3个字符的函数形式是 。
3. 现有如下两条语句： 
   ofstream fout; 
fout.open("Text.txt"); 
   它们的等效语句是 。

三、分析程序题

1. 分析下面程序的输出结果。

2. 分析程序功能。

四、完成程序题

1. 完成下面的主程序，使其输出为:−2.589000e+001+2.589000e+001−2.589000e+001+2.589000e+001。主程序如下：

void main() {

    std::cout << -25.89F << " ";
    std::cout << 25.89f << std::endl;
}

1. 完成下面的程序，使其输出为：******12345 54321******。源程序如下：

#include <iomanip>
using namespace std;
class FUN {
    friend ostream (ostream&, FUN);
}fun;
ostream    (ostream& os, FUN f)
{
    os.self(ios::left);
    return os;
}
void main() {
    cout << setfill('*') << setw(10) << 12345 << " ";
    cout << fun << setw(10) << 54321 << endl;
}

五、编程题

1. 利用流格式控制，进行成绩和名字的输出，要求名字左对齐，分数右对齐。
2. 编写一个产生文本文件的程序。
3. 编写一个程序，要求输入三角形的3条边，然后判断是否合理，如果不合理，给出信息并要求重新输入；如果合理，计算其面积并将结果存入文件中。
4. 改写上题的程序，使程序反复计算，直到输入结束符为止。要求在停止计算之后，询问要保存的文件名，然后将结果一次写入指定文件中。
5. 从文件TEST中读出字符并写到文件TEST1里，要求均附加错误检查。
6. 从键盘输入一个字符串，将其中的大写字母全部转换成小写字母，然后存入到文件名为”text“的磁盘文件中保存。输入的字符串以”$“结束。

习题10

一、单项选择题

1. 下面叙述正确的是（ ）。
2. 下面叙述正确的是（ ）。
3. 声明实函数的目的是使（ ）。
4. 下面叙述正确的是（ ）。

二、填空题

1. 抽象的原则主要是 .
2. OOA使用 映射问题域中的事物。
3. 寻找候选对象的基本方法的主要策略是从 三方面找出可能有的候选对象。
4. 类的数据成员有 和 两大类。
5. 按照本领域已有的分类方法，可以找出一些与它对应的 。

三、问答题

1. 为什么要对初步发现的数据成员进行审查和筛选？
2. 简述纯虚函数最显著的特点。

四、编程题

1. 取消设计实例中的Cow属性，练习使用模板实现包含的设计方法。
2. 取消设计实例中的Cow属性，练习使用模板实现继承的设计方法。