🧪 C++ 程序设计 · 考试题库

条件：函数名相同，但参数个数不同或参数类型不同（或参数顺序不同）。
原因：编译器根据函数调用时传入的实参类型和个数来确定调用哪个函数。如果两个函数的函数名、参数个数、参数类型完全相同，仅返回值不同，编译器无法从调用形式上区分应该调用哪个函数。例如 int f() 和 float f()，调用 f() 时不知道用哪个。

① 值传递：将实参的值复制给形参，形参和实参各自占用独立的内存空间。函数内修改形参不影响实参。
② 指针传递：将实参的地址传递给形参，形参是指针变量。通过指针可以间接修改实参的值，调用时需取地址。
③ 引用传递：形参是实参的别名，形参和实参共享同一块内存。函数内对形参的修改直接影响实参。
引用传递的优点：比指针更直观（不需要取地址和*解引用），比值传递效率高（不产生副本），适合需要修改实参或传递大型对象时使用。

引用：引用是变量的别名，格式为 类型 &别名 = 变量名。引用和被引用的变量共享同一块内存空间。
限制：① 定义引用时必须初始化（不能只声明不赋值）；② 一旦初始化，不能改变引用的指向；③ 不能建立引用的数组；④ 不能建立引用的引用；⑤ 不能取引用的地址。

① 抽象：从具体事物中提取共性特征，形成类的过程。如从"张三"、"李四"中抽象出"学生"类。
② 封装：将数据（成员变量）和操作数据的方法（成员函数）捆绑在一起，并隐藏内部实现细节，只对外开放必要的接口。通过访问权限（private/public/protected）实现。
③ 继承：派生类自动获得基类的全部成员，并可新增自己的成员。体现了"is-a"关系，提高了代码复用性。
④ 多态：同一操作作用于不同对象时产生不同的执行结果。静态多态通过函数重载实现，动态多态通过虚函数实现。

this 指针：每个非静态成员函数都有一个隐含的指针参数 this，它指向调用该函数的对象自身。当调用 obj.func() 时，编译器自动将对象的地址传递给 this。
作用：① 在成员函数中通过 this->成员 访问本对象的成员；② 返回当前对象的引用（如 return *this;）。
必须显式使用的情况：当成员函数的形参名与数据成员名相同时，必须用 this->成员 来区分。例如 void set(int x) { this->x = x; }。

构造函数特点：① 函数名与类名相同；② 没有返回值（不写 void）；③ 可以重载；④ 创建对象时自动调用；⑤ 如果用户不定义，系统自动生成一个默认构造函数。
析构函数特点：① 函数名为 ~类名；② 没有返回值，没有参数；③ 不能重载（一个类只有一个析构函数）；④ 对象销毁时自动调用。
调用顺序：先构造的后析构（栈式）。构造函数：基类构造函数 → 子对象构造函数 → 派生类构造函数体。析构函数：派生类析构函数 → 子对象析构函数 → 基类析构函数。

复制构造函数：用一个已存在的对象来初始化新对象时调用的构造函数。格式为 类名(const 类名 &对象)，参数必须是本类对象的引用。
自动调用的情况：① 用已存在的对象初始化新对象（Box box2 = box1;）；② 函数参数传值时实参传递给形参；③ 函数返回对象时。
为什么需要自己定义：默认复制构造函数执行浅拷贝（逐个成员复制）。如果类中有指针成员指向 new 出来的内存，浅拷贝会导致两个对象的指针指向同一块内存。析构时先析构的对象 delete 了内存，后析构的对象会重复 delete，导致程序崩溃。自己定义复制构造函数可以执行深拷贝（为新对象重新分配内存并复制内容）。

静态数据成员：① 被所有对象共享，只占用一份内存空间；② 必须在类外定义和初始化（格式：类型 类名::静态成员 = 值）；③ 可以通过类名访问（类名::静态成员），也可以通过对象名访问。
静态成员函数：① 属于类本身，与具体对象无关；② 可以直接通过类名调用（类名::静态函数()）；③ 不能直接访问非静态成员（因为非静态成员属于具体对象，静态函数没有 this 指针）。

不能重载的 5 个运算符：.（成员访问运算符）、.*（成员指针运算符）、::（作用域运算符）、sizeof（长度运算符）、?:（条件运算符）。
规则限制：① 不能改变运算符的优先级和结合性；② 不能改变操作数的个数；③ 不能臆造新的运算符（只能重载已有的）；④ 不能改变运算符用于基本类型时的原有语义；⑤ 重载不能带默认值参数；⑥ 重载为成员函数时参数个数 = 原操作数个数 - 1，重载为友元函数时参数个数 = 原操作数个数。

因为重载为成员函数时，第一个操作数必须是本类的对象（由 this 指针隐含传递）。而 << 和 >> 的第一个操作数分别是 ostream 对象（如 cout）和 istream 对象（如 cin），它们不是本类类型。所以必须重载为友元函数，将 ostream& 或 istream& 作为第一个显式参数。
此外，重载为友元函数能保证使用习惯 cout << 对象 自然流畅，不需要写成 对象 << cout 这种反直觉的形式。

三种继承方式的影响：
  ① public 继承：基类的 public 成员在派生类中仍为 public；protected 成员仍为 protected；private 成员不可访问。
  ② protected 继承：基类的 public 和 protected 成员在派生类中都变为 protected；private 成员不可访问。
  ③ private 继承：基类的所有成员（public 和 protected）在派生类中都变为 private；private 成员不可访问。
为什么 public 继承最常用：public 继承保持了"is-a"关系（如"学生是一种人"），派生类对象可以当作基类对象使用，支持向上转型和通过基类指针/引用调用派生类对象，是实现多态的基础。

虚基类：在派生类声明基类时加上 virtual 关键字，如 class B: virtual public A，A 就是虚基类。
解决的问题：菱形继承中，派生类从不同路径继承同一个基类时（如 D 继承 B 和 C，B 和 C 都继承 A），基类 A 的成员会在派生类 D 中产生两个副本，导致二义性。使用虚基类后，D 中只保留一份 A 的副本。
构造函数调用规则：如果虚基类定义了带参数的构造函数，那么所有直接或间接派生类都要在初始化表中列出虚基类构造函数。但编译系统只执行最终派生类对虚基类的构造函数调用，中间类的调用被忽略。

多态：同一函数调用在不同的对象上产生不同的行为。
静态多态（编译时多态）：通过函数重载和运算符重载实现，在编译时就确定了调用哪个函数。优点是执行效率高，缺点是灵活性差。
动态多态（运行时多态）：通过虚函数实现，在运行时才确定调用哪个函数。用基类指针指向派生类对象时，根据对象实际类型调用对应版本的函数。
实现条件：① 基类中声明虚函数（使用 virtual 关键字）；② 派生类中重写（override）该虚函数；③ 通过基类指针或引用调用虚函数；④ 若使用纯虚函数（= 0），基类成为抽象类，不能实例化。

继承和派生的关系（课件5.1节）：继承和派生是同一个过程的两个视角。继承是从子类的角度，描述子类获得基类特性的过程；派生是从基类的角度，描述从基类产生新类的过程。两者描述的实质是同一种机制——在已有类的基础上建立新类。

访问规则（课件5.4节）：
① 无论哪种继承方式，基类的 private 成员在派生类中均不可直接访问。
② public 继承：基类 public 成员在派生类中保持 public，基类 protected 成员保持 protected。
③ protected 继承：基类 public 和 protected 成员在派生类中都变为 protected。
④ private 继承：基类 public 和 protected 成员在派生类中都变为 private。
⑤ 派生类可通过基类的 public/protected 成员函数间接访问基类的 private 成员（课件5.3-5.4节）。

// 参考代码
class Box {
public:
    Box(int h, int w, int len): // 初始化表
        height(h), width(w), length(len) {}
    int volume() { return height * width * length; }
private:
    int height, width, length;
};
int main() {
    Box box1(12, 25, 30);
    Box box2(15, 30, 21);
    cout << "box1体积=" << box1.volume() << endl;
    cout << "box2体积=" << box2.volume() << endl;
    return 0;
}

// 参考代码
class Complex {
    friend Complex operator+(Complex &c1, Complex &c2);
    friend ostream& operator<<(ostream &out, Complex &c);
public:
    Complex(double r = 0, double i = 0): real(r), imag(i) {}
private:
    double real, imag;
};
Complex operator+(Complex &c1, Complex &c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
ostream& operator<<(ostream &out, Complex &c) {
    out << "(" << c.real << "," << c.imag << "i)";
    return out;
}

class Student {
protected:
    int num; string name;
public:
    Student(int n, string nam): num(n), name(nam) {}
    void display() { cout<<"num:"<" name:"<class Student1: public Student {
protected: int age;
public:
    Student1(int n, string nam, int a): Student(n, nam), age(a) {}
};
class Student2: public Student1 {
    int score;
public:
    // 只须调用直接基类 Student1 的构造函数
    Student2(int n, string nam, int a, int s): Student1(n, nam, a), score(s) {}
    void show_all() { display(); cout<<"age:"<" score:"<
            

// 引用作为函数参数（形参是实参的别名）
void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}
// 调用时直接传变量（不用取地址）
int i = 3, j = 5;
swap(i, j);  // i=5, j=3

class Shape {
public:
    virtual void area() = 0;  // 纯虚函数
};
class Circle: public Shape {
    float r;
public:
    Circle(float rr): r(rr) {}
    void area() { cout << 3.14 * r * r; }
};
void fun(Shape *ptr) { ptr->area(); }  // 动态关联
// 使用：
Circle c(15);
Shape *p = &c;
fun(p);  // 输出 Circle 的 area

template <typename T>
T my_max(T a, T b) {
    return (a > b) ? a : b;
}
// 测试
cout << my_max(3, 7) << endl;          // int → 7
cout << my_max(45.78, 93.6) << endl;     // float → 93.6
cout << my_max('a', 'A') << endl;       // char → 'a'