不怨天，不尤人。——《论语》楠少博客 阅读文章

C++期末复习题

楠少
2020-12-24
6666666
8888888
Cpp
校园

摘要简化版本，便于记忆。分程序题、简答题。程序题简化了，简答题未做修改。

# C++期末复习题
坚果云在线浏览：https://www.jianguoyun.com/p/DbYGGncQ0PyGCRiB9tQD

## 程序题

``` cpp 
/*
1. 编写一个程序，将两个文本文件连接成一个文件。
 */
#include <iostream>
#include <fstream>

using namespace std;

int main() {
    char n1[100], n2[100], n3[100];
    cout << "依次输入两个源文件名、一个目标文件名：";
    cin >> n1 >> n2 >> n3;

fstream f1(n1, ios::in), f2(n2, ios::in), f3(n3, ios::out);

char ch;
    while ((ch = f1.get()) != EOF) {
        f3.put(ch);
    }
    while ((ch = f2.get()) != EOF) {
        f3.put(ch);
    }

f1.close();
    f2.close();
    f3.close();

return 0;
}

```

``` cpp 
/*
2. 编写一个程序，设计一个类 Trig，给定三角形的三条边长 x、y、z，并设计一个友元函数 twoarea()调用函数 area()成员函数求两个三角形面积之和。
 */
#include <iostream>
#include <cmath>

using namespace std;

class Trig {
private:
    double x, y, z;
public:
    Trig(double x, double y, double z) : x(x), y(y), z(z) {}

bool isTrig() {
        return (x + y) > z && (x + z) > y && (y + z) > x;
    }

double area() {
        double p = (x + y + z) / 2;
        return sqrt(p * (p - x) * (p - y) * (p - z));
    }

friend double twoArea(Trig &t1, Trig &t2) {
        return t1.area() + t2.area();
    }
};

int main() {
    Trig t1(3, 4, 5), t2(6, 8, 10);
    if (t1.isTrig() && t2.isTrig()) {
        cout << "面积和为：" << twoArea(t1, t2);
    } else {
        cout << "不能构成三角形";
    }
    return 0;
}

```

``` cpp 
/*
3. 设计一个类 Sample，实现两个复数的乘法运算。
 */
#include <iostream>

using namespace std;

class Sample {
private:
    double a, b;
public:
    Sample() {}

Sample(double a, double b) : a(a), b(b) {}

void print() {
        if (b >= 0) {
            cout << a << " + " << b << "i" << endl;
        } else {
            cout << a << " - " << -b << "i" << endl;
        }
    }

Sample mult(Sample &s) {
        return Sample(a * s.a - b * s.b, a * s.b + b * s.a);
    }
};

int main() {
    Sample s1(1, 3), s2(2, -4), s3;

cout << "s1:";
    s1.print();

cout << "s2:";
    s2.print();

cout << "result:";
    s3 = s1.mult(s2);
    s3.print();
    return 0;
}

```

``` cpp 
/*
4．一个 Sample 类模板的私有数据成员为 n，数据类型为 T，在该类模板中设计一个 operator==重载运算符函数，用于比较各对象的 n 数据是否相等。
 */
#include <iostream>

using namespace std;

template<class T>
class Sample {
private:
    T n;
public:
    Sample(T n) : n(n) {}

bool operator==(Sample &s) {
        return s.n == n;
    }
};

int main() {
    Sample<int> s1(2), s2(3);
    cout << "s1 和 s2 数据：" << (s1 == s2 ? "相等" : "不相等") << endl;

Sample<double> s3(1.6), s4(1.6);
    cout << "s3 和 s4 数据：" << (s3 == s4 ? "相等" : "不相等") << endl;
    
    return 0;
}

```

``` cpp 
/*
5．编写一个对具有 n 个元素的数组 x[]求最大值的程序，要求将求最大值的函数设计成函数模板。
 */
#include <iostream>

using namespace std;

template<class T>
T getMax(T arr[], int n) {
    T res = arr[0];
    for (int i = 0; i < n; i++) {
        if (res < arr[i]) {
            res = arr[i];
        }
    }
    return res;
}

int main() {
    int a[] = {1, 9, 5, 6, 4};
    cout << "a 数组最大为：" << getMax(a, 5) << endl;

double b[] = {2.1, 6.2, 8.5, 3.1};
    cout << "b 数组最大为：" << getMax(b, 4) << endl;

return 0;
}

```

``` cpp 
/*
6．编写一个程序，求给定数的平方根，并用异常处理机制检测负数的情况。
 */
#include <iostream>
#include <cmath>

using namespace std;

double sqrt1(double a) {
    if (a < 0) {
        throw 1;
    }
    return sqrt(a);
}

int main() {
    double a;
    cout << "输入正数：";
    cin >> a;
    try {
        cout << sqrt1(a);
    } catch (int) {
        cout << "负数无平方根";
    }
    return 0;
}

```

``` cpp 
/*
7．编写一个程序，采用异常处理的方法，在指定的文件不存在时显示出错信息，文件存在时显示其大小。
 */
#include <iostream>
#include <fstream>

using namespace std;

int main() {
    char name[100];
    cout << "输入文件名：";
    cin >> name;
    ifstream f(name, ios::in);
    try{
	    if (f.fail()) {
	        throw 1;
	    } 
        f.seekg(0, ios::end);
        cout << "大小为：" << f.tellg() << "bytes" << endl;
	}catch (int) {
        cout << "文件不存在";
    }
    return 0;
}

```

``` cpp 
/*
8. 设计一个学生类 student，包括姓名和三门课程成绩，利用重载运算符“+”将所有学生的成绩相加放在一个对象中，再对该对象求各门课程的平均分。
 */
#include <iostream>

using namespace std;

class Student {
private:
    string name;
    double a, b, c;
public:
    Student() {
        name = "";
        a = b = c = 0.0;
    }

Student(string name, double a, double b, double c) : name(name), a(a), b(b), c(c) {}

friend Student operator+(Student s1, Student s2) {
        static Student avgS;
        avgS.a = s1.a + s2.a;
        avgS.b = s1.b + s2.b;
        avgS.c = s1.c + s2.c;
        return avgS;
    }

void print() {
        cout << "姓名:" << name << "\t分数1：" << a << "\t分数2：" << b << "\t分数3：" << c << endl;
    }

void avg(int n) {
        cout << "平均分1：" << a / n << endl;
        cout << "平均分2：" << b / n << endl;
        cout << "平均分3：" << c / n << endl;
    }
};

int main() {
    Student s,
            s1("Jack", 55, 96, 84),
            s2("Rose", 95, 63.5, 60),
            s3("Jerry", 59.5, 85, 78),
            s4("Tom", 99, 99, 99);

s1.print();
    s2.print();
    s3.print();
    s4.print();

s = s1 + s2 + s3 + s4;
    s.avg(4);

return 0;
}

```

``` cpp 
/*
9．有一个学生类 student，包括学生姓名、成绩、设计一个友元函数，输出成绩大于等于80 分以上者的信息。
 */
 #include <iostream>
#include <iomanip>

using namespace std;

class Student {
private:
    string name;
    int score;
public:
    Student(string name, int score) : name(name), score(score) {}

friend void display(Student &s) {
        if (s.score >= 80) {
            cout << setw(10) << s.name << setw(10) << s.score << endl;
        }
    }
};

int main() {
    Student s[] = {
            Student("张三", 78),
            Student("李四", 88),
            Student("王五", 61),
            Student("赵六", 99),
    };
    cout << "输出结果：" << endl;
    cout << setw(10) << "name" << setw(10) << "score" << endl;

for (int i = 0; i < 4; i++) {
        display(s[i]);
    }
    return 0;
}
```

``` cpp 
/*
10．定义一个点类 point，并由此派生出一个圆类，主程序中输出圆心和半径。
 */
#include <iostream>

using namespace std;

class Point {
private:
    double x, y;
public:
    Point(double x, double y) : x(x), y(y) {}

double getX() {
        return x;
    }

double getY() {
        return y;
    }
};

class Circle : public Point {
private:
    double r;
public:
    Circle(double x, double y, double r) : Point(x, y), r(r) {}

double getR() {
        return r;
    }
};

int main() {
    Circle c(2.1, 3.2, 0.8);
    cout << "圆心：(" << c.getX() << "," << c.getY() << ")" << endl;
    cout << "半径：" << c.getR() << endl;
    return 0;
}

```

``` cpp 
/*
11．编写一个程序，设计一个点类 Point，求两个点之间的距离。
 */
#include <iostream>
#include <cmath>

using namespace std;

class Point {
    double x, y;
public:
    Point(double x, double y) : x(x), y(y) {}

double getDistance(Point &p) {
        return sqrt(pow(x - p.x, 2) + pow(y - p.y, 2));
    }

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

int main() {
    Point p1(1.5, 1.5), p2(10.5, 5.5);
    p1.print();
    cout << "与";
    p2.print();
    cout << "间距离为：" << p1.getDistance(p2);
    return 0;
}

```

``` cpp 
/*
12.设计一个圆类 circle 和一个桌子类 table，另设计一个圆桌类 roundtable，它是从前两个类派生的，要求输出一个圆桌的高度、面积和颜色等数据。
 */
#include <iostream>
#include <cmath>

using namespace std;

class Circle {
private:
    double r;
public:
    Circle(double r) : r(r) {}

double area() {
        return pow(r, 2) * acos(-1);
    }
};

class Table {
private:
    double h;
public:
    Table(double h) : h(h) {}

double getH() {
        return h;
    }
};

class RoundTable : public Circle, public Table {
private:
    string color;
public:
    RoundTable(double r, double h, string color) : Circle(r), Table(h), color(color) {}

string getColor() {
        return color;
    }
};

int main() {
    RoundTable rt(1, 0.8, "蓝色");
    cout << "高度：" << rt.getH() << endl;
    cout << "面积：" << rt.area() << endl;
    cout << "颜色：" << rt.getColor() << endl;
    return 0;
}

```

``` cpp 
/*
13. 以面向对象的概念设计一个类，此类包含 3 个私有数据：unlead（无铅汽油）、lead（有铅汽油）以及 total（当天总收入）。
    无铅汽油的价格是 17 元/公升，有铅汽油的价格是16 元/公升。请以构造函数方式建立此值。
    试输入某天所加的汽油量，程序将列出加油站当天的总收入。
 */
#include <iostream>

using namespace std;

class Oil {
private:
    double unLead, lead, total, unPrice, price;
public:
    Oil() {
        unPrice = 17;
        price = 16;
        unLead = lead = total = 0.0;
    }

void getData() {
        cout << "输入无铅汽油量:";
        cin >> unLead;
        cout << "输入有铅汽油量:";
        cin >> lead;
        total = unLead * unPrice + lead * price;
    }

double getTotal() {
        return total;
    }
};

int main() {
    Oil o;
    o.getData();
    cout << "总收入为：" << o.getTotal();
    return 0;
}

```

## 简答题

1. 指针和引用有什么区别？
	+ 答：
	+ ①引用在定义时必须被初始化，而指针可以随意；(2 分)
	+ ②指针可以被引用，但引用不能被引用；(2 分)
	+ ③指针是变量，可指向不同的变量或对象，而引用始终指向某个变量或对象。(2 分)

2. 什么是单继承、多继承？
	+ 答：
	+ ①单继承是指派生类只直接继承了一个基类的继承关系；(3 分) 
	+ ②多继承是指多个基类派生出一个派生类的继承关系。(3 分)

3. 类定义的一般格式是什么？
	+ 答：
``` txt 
class 类名    (1 分)
{ 
public: 
	公有数据成员和成员函数; (1 分)
private: 
	私有数据成员和成员函数; (1 分)
pretected:
	保护数据成员和成员函数; (1 分)
};
各个成员函数的实现；(2 分) 
```

4. cerr 和 clog 之间的区别是什么？
	+ 答：
	+ ①cerr 是非缓冲型标准出错流，发给它的任何内容都立即输出；(3 分)
	+ ②clog 是缓冲型标准出错流，只有当缓冲区满时才进行输出，也可以通过刷新流的方式强迫刷新缓冲区。(3 分)

5. 什么是函数重载？调用重载函数时，通过什么来区分不同的重载函数？
	+ 答：
	+ ①函数重载是指函数同名却有不同的函数实现。(3 分)
	+ ②调用重载函数时，编译器根据参数的个数、类型、顺序调用具体的重载函数。(3 分)

6. 友元函数有什么作用？
	+ 答：
	+ ①友元函数是独立于当前类的外部函数，但它可以访问该类的所有对象的成员。(2 分)
	+ ②通过友元函数，可以在不放弃私有数据安全性的情况下，使得类外部的函数能够访问类中的私有成员。(3 分)
	+ ③在一个函数需要访问多个类时和运算符被重载时，常用到友元函数。(1 分)

7. C++有哪 4 个预定义的流？它们分别与什么具体设备相关联？
	+ 答：
	+ ①标准输入流 cin：与标准输入设备相关联；(1.5 分)
	+ ②标准输出流 cout：与标准输出设备相关联；(1.5 分)
	+ ③非缓冲型标准出错流 cerr：与标准错误输出设备相关联（非缓冲方式）；(1.5 分)
	+ ④缓冲型标准出错流 clog：与标准错误输出设备相关联（缓冲方式）。(1.5 分)

8. 什么是类，什么是对象，类与对象的关系是什么？
	+ 答：
	+ ①类是包含数据和方法的自定义类型。对象是类的实例，也可以说是被一个特定的类说明的变量。(3 分)
	+ ②类是具有相同数据和相同操作的一组对象的集合，是抽象数据类型；对象是类的具体实例。(3 分)

9. 在函数调用过程中，实参传给形参有哪两种方式？这两种传送方式有什么区别？
	+ 答：
	+ ①函数调用中参数传递有按值传递和按地址传递两种方式。(2 分)
	+ ②按值传递时，系统将实参的值传递给形参，形参参与代码运算，函数返回时，形参值的改变不影响实参；(2 分)
	+ ③按地址传递时，实参将其地址传递给形参，由于实参形参共用同一地址，形参值的改变会使实参值发生同样的改变。(2 分)

10. 什么是纯虚函数，什么是抽象类，并写出纯虚函数的定义形式？
	+ 答：
	+ ①纯虚函数是一个在基类中说明的虚函数，它在该基类中没有定义，但在派生类中必须有自己的定义。(2 分)
	+ ②包含有纯虚函数的类称为抽象类。(2 分)
	+ ③纯虚函数的定义形式为：virtual 函数类型 函数名(参数表)=0；(2 分)

11. 简述 3 种访问修饰符对类成员的访问限制？
	+ 答：
	+ ①public：公有成员可被程序中的任何代码访问；(2 分)
	+ ②private：私有成员可被类本身的成员函数和类的友元函数访问；(2 分)
	+ ③protected：保护成员可被类本身的成员函数、类的友元函数、类的派生类的成员函数访问。(2 分)

下一篇：2020年11月01日星期日 (庚子年（鼠年）九月十六）

文章评论

[ 聊聊技术聊聊自己 ]

在巴甫洛夫条件反射试验中：给定一条狗，每次摇铃后喂食，足够次数后，狗则听到铃声将会习惯性的分泌唾液，由此引发对铃声的依恋。延伸到实际，给定一个喜欢的妹子，每次见面赠与巴甫洛夫式的礼品或者零食，由此引发妹子的依恋。引入薛定谔的猫理论，在未表白前，妹子与自己一直处于一种“概率云”的状态，一旦表白则“概率云”将消失成为实际。在巴甫洛夫式后且未表白前，自己与妹子的关系为“既是恋人又不是恋人”的矛盾体。返回巴甫洛夫式试验中，在妹纸形成足够的依恋过后，则可以打破薛定谔 “概率云”的状态。这个谜一样的自己，这一刻薛定谔附体，带着量子论般深沉的哀愁，让她从此不能自拔! 自此创作 巴甫洛夫薛定谔把妹法，深藏功与名。

不怨天，不尤人。——《论语》 楠少博客 阅读文章

C++期末复习题

文章评论

不怨天，不尤人。——《论语》楠少博客阅读文章