考研复试——C、C++

C语言、C++

1. C和C++的区别？

1. 面向对象编程：C++是一种面向对象编程语言，可以使用类和对象等概念来编写程序。而C语言不支持面向对象编程，只能使用过程式编程。
2. 标准库：C++标准库比C语言标准库更大更丰富。C++标准库包含了很多STL容器、算法、迭代器等，这使得C++编程更加方便。而C语言标准库则只包含了一些基本的输入输出和字符串处理函数等。
3. 名称空间：C++中有名称空间的概念，它可以避免名称冲突和提高代码的可读性。C语言没有名称空间的概念，因此在C程序中需要手动避免名称冲突。
4. 异常处理：C++支持异常处理机制，可以在程序运行时捕获异常并进行处理。而C语言没有内置的异常处理机制，需要使用特殊的技术来处理错误。
5. 其他特性：C++还有其他一些特性，比如运算符重载、模板等，这些都是C语言所不具备的。

总之，C++比C语言更加高级，功能更加丰富。但是，由于C语言的简洁性和效率，它仍然在很多领域得到广泛应用，比如系统编程和嵌入式开发等。

2. 封装、继承、多态分别是什么意思？

• 封装（Encapsulation）是面向对象编程（OOP）的一个核心概念，指将数据和对数据的操作封装在一起，以便对外界隐藏数据的具体实现细节，提高代码的可维护性和安全性。封装可以通过访问控制修饰符（如 public、private、protected）来实现，以控制类成员的可见性。

• 继承（Inheritance）是 OOP 中一个允许一个类继承另一个类的属性和方法的机制。这个被继承的类称为父类（或基类），继承它的类称为子类（或派生类）。子类可以在不改变父类接口的情况下，扩展或重写父类的行为，从而避免了重复编写代码的问题。

• 多态（Polymorphism）是指一个类的实例对象在不同情况下表现出不同的行为，它是面向对象编程中的一种重要特性。多态性有两种实现方式：编译时多态（静态多态）和运行时多态（动态多态）。编译时多态是指函数重载，即通过不同的参数列表来实现不同的行为。运行时多态则是通过虚函数（virtual function）和纯虚函数（pure virtual function）来实现的。在运行时多态中，通过基类的指针或引用来调用派生类的方法，从而实现多态性。

3. new/delete, malloc/free的关系？

new/delete和malloc/free都是动态内存管理的函数，但是它们在实现方式和用途上有一些不同。

• new和delete是C++中的关键字，用于动态地分配和释放内存，它们是C++对动态内存管理的封装。使用new操作符时，会在堆上分配一块内存，并返回一个指向该内存地址的指针，而使用delete操作符则会释放该内存空间，使其可用于其他用途。new/delete可以自动处理对象的构造和析构，因此适用于动态分配和释放对象的情况。

• malloc和free是C语言中的库函数，用于动态分配和释放内存。使用malloc函数时，会在堆上分配一块内存，并返回一个指向该内存地址的指针，而使用free函数则会释放该内存空间，使其可用于其他用途。malloc/free只能分配和释放内存空间，无法处理对象的构造和析构，因此适用于分配和释放简单数据类型的情况。

虽然new/delete和malloc/free的功能类似，但它们在实现方式和使用方法上有很大的不同。在C++中，使用new/delete来动态分配和释放内存空间可以自动处理对象的构造和析构，更加方便和安全。在C语言中，使用malloc/free则是常见的动态内存分配和释放方式。

4. 什么是引用，引用和指针的区别？

引用（Reference）是C++中的一种数据类型，它提供了一个别名来访问已存在的变量。引用可以被看作是变量的另一个名字，即原变量和其引用在内存中共享同一个地址。引用使用&符号定义，在声明时必须初始化，一旦初始化完成，就无法再改变其引用的对象。

与指针相比，引用有以下几个不同点：

1. 引用不需要使用解引用运算符，而指针需要使用*运算符来访问指针指向的值。
2. 引用必须在声明时初始化，而指针可以在任何时候初始化或赋值。
3. 引用不能为NULL，而指针可以为NULL，即指向空地址。
4. 引用不能被重新赋值，一旦引用被初始化，它将一直引用同一个对象，而指针可以被重新赋值。
5. 在函数调用中，使用引用可以避免对象的拷贝，从而提高效率。而使用指针则需要进行拷贝操作，效率较低。

总之，引用和指针都是C++中用于间接访问对象的机制，但是它们在语法和用法上有很大的不同。引用提供了一种更加方便和安全的访问方式，尤其在函数调用时可以减少对象的拷贝，提高代码的效率。

5. 构造与析构函数？

构造函数和析构函数是C++中特殊的成员函数，它们在对象的生命周期中扮演着非常重要的角色。

• 构造函数是用于初始化对象数据成员的特殊函数，它在对象创建时自动调用，负责为对象分配内存并初始化其数据成员。构造函数的名称与类名相同，没有返回类型，可以有参数。在创建对象时，会自动调用合适的构造函数，以完成对象的初始化过程。

• 析构函数是用于释放对象资源的特殊函数，它在对象销毁时自动调用，负责清理对象所占用的资源，并释放对象的内存空间。析构函数的名称与类名相同，前面加上一个波浪号(~)作为标识，没有返回类型，也不接受任何参数。

构造函数和析构函数都是在对象生命周期的特定阶段自动调用的，无需手动调用。构造函数在对象创建时被调用，而析构函数在对象销毁时被调用。它们的作用分别是初始化对象和释放对象所占用的资源，是C++中实现RAII（Resource Acquisition Is Initialization，资源获取即初始化）机制的关键。

需要注意的是，当一个对象被复制或移动时，也会自动调用相应的构造函数和析构函数。在C++11之前，需要手动实现拷贝构造函数和赋值运算符重载函数来实现对象的拷贝和移动。在C++11之后，可以使用默认的拷贝构造函数和赋值运算符来实现对象的拷贝和移动，从而简化代码的编写。

6. 全局变量和局部变量的区别？

全局变量（global variable）和局部变量（local variable）是编程中常见的两种变量类型，它们的主要区别在于作用域和生命周期。

• 全局变量是在程序的任何地方都可以访问的变量，它们的作用域跨越整个程序。通常，在程序的开头或某个模块的开头定义全局变量，然后可以在程序中的任何函数或模块中使用。全局变量的生命周期与程序的执行周期相同，即在程序开始运行时创建，在程序结束时销毁。

• 局部变量是在函数或语句块内定义的变量，它们只能在定义它们的函数或语句块内部访问。局部变量的作用域仅限于定义它们的函数或语句块，它们在函数或语句块执行完后就会被销毁。因此，局部变量的生命周期是相对较短的。

总的来说，全局变量和局部变量都有它们自己的用途，需要根据具体的编程需求来选择合适的变量类型。在使用全局变量时，需要注意可能会造成命名冲突或程序不易维护的问题。而在使用局部变量时，需要注意在变量的作用域之外访问变量可能会导致编译错误。

7. static声明静态变量

在C语言和C++中，static是用于声明静态变量和静态函数的关键字。

当static用于声明变量时，它会将变量的作用域限制在声明它的文件中，即使其他文件包含了同名变量，也不会发生命名冲突。此外，静态变量的生命周期会持续到整个程序的执行结束。如果一个函数内部使用了静态变量，则该变量在函数调用结束后不会被销毁，而是保留其值等待下次调用。

当static用于声明函数时，它会将函数的作用域限制在声明它的文件中，该函数不能被其他文件中的函数调用。此外，声明为静态函数可以在一定程度上提高程序的安全性，因为其他文件无法访问该函数，也无法修改其内容。

需要注意的是，在C++中，static关键字还有其他用途，比如用于声明静态成员变量和静态成员函数。在这种情况下，static关键字表示该成员变量或成员函数与类相关联，而不是与对象相关联。这些静态成员在类的所有对象中都共享，而不是每个对象都有一份。

8. const 修饰符

在C++中，const是用于声明常量的修饰符。

当const用于声明变量时，它表示该变量的值不能被修改。例如：

const int x = 10;

这里声明了一个常量x，它的值为10，并且不能被修改。如果试图修改x的值，编译器将会报错。

当const用于声明函数时，它表示该函数不会修改任何对象的状态。例如：

int func(const int x);

这里声明了一个函数func，它接受一个参数x，该参数被声明为const，表示该函数不会修改x的值。

在C++中，const还可以用于声明成员函数，表示该函数不会修改对象的状态。此外，const还可以用于定义常量指针、常量引用和常量对象等。

使用const可以提高程序的可读性和可维护性，因为它可以防止不必要的修改和意外的副作用。在程序设计中，应该尽可能使用const来声明常量、指针和引用，以避免意外的错误和不必要的代码。

9. 解释一下预处理程序?

预处理程序（Preprocessor）是C和C++编译器的一个重要组成部分，它在编译过程之前对源代码进行一些预处理操作。预处理程序会根据源代码中的预处理指令，对源代码进行宏替换、文件包含和条件编译等操作，生成一个新的源代码文件，再由编译器进行编译和链接。

在C和C++中，预处理指令以#字符开头，例如：

#include <stdio.h>
#define MAX_SIZE 100

这里的#include指令用于包含头文件，#define指令用于定义宏。在预处理阶段，预处理程序会读取源代码文件，将所有的预处理指令替换为相应的代码或文件，生成一个新的源代码文件。例如，上面的#include指令会将<stdio.h>头文件中的代码插入到源文件中，#define指令会将所有出现的MAX_SIZE替换为100。

预处理程序还支持条件编译指令，例如：

#ifdef DEBUG
    printf("Debug mode\n");
#else
    printf("Release mode\n");
#endif

这里的#ifdef指令用于判断是否定义了DEBUG宏，如果定义了就执行第一条printf语句，否则执行第二条printf语句。这样可以根据不同的编译选项生成不同的程序。

总的来说，预处理程序可以扩展C和C++语言的功能，提高程序的可读性、可维护性和可移植性。但是，在使用预处理指令时，也需要注意预处理程序可能会产生一些意想不到的问题，比如宏定义的替换可能会导致代码出现不可预知的错误，文件包含的路径可能会出现问题等。因此，使用预处理指令时需要谨慎，并遵循编程规范和最佳实践。

10. 面向过程和面向对象的区别？

面向过程编程（Procedural Programming）和面向对象编程（Object-Oriented Programming）是两种不同的程序设计范式。

面向过程编程是以过程为中心的编程方法，通过将程序划分为一个个独立的函数或过程，然后按照一定的逻辑顺序调用这些函数来完成任务。面向过程编程的思想强调程序的执行过程，将数据和函数分开处理。在面向过程编程中，数据和函数是分离的，函数通过对数据的处理来完成任务。

面向对象编程则是以对象为中心的编程方法，通过将程序划分为一组相互作用的对象，来描述问题的解决方案。面向对象编程的思想强调数据的封装和功能的内聚，将数据和函数封装在一个对象中，通过对象之间的交互来完成任务。

下面是面向过程和面向对象编程的几个不同点：

1. 数据和函数的关系

在面向过程编程中，数据和函数是分离的，函数通过对数据的处理来完成任务。

在面向对象编程中，数据和函数封装在一个对象中，通过对象之间的交互来完成任务。

2. 对象的概念

面向过程编程中，没有对象的概念，程序是以函数为中心组织的。

而面向对象编程中，对象是程序的基本组成单元。

3. 数据的访问权限

在面向过程编程中，数据通常是公共的，任何函数都可以访问。

而在面向对象编程中，数据的访问权限由对象的访问控制决定，可以是公共的、私有的或受保护的。

4. 代码的重用性

面向过程编程中，代码的重用性较低，需要手动将函数复制到其他地方。而面向对象编程中，可以通过继承和多态等机制实现代码的重用性，减少代码的重复。

5. 编程风格

面向过程编程通常采用函数式的编程风格，通过函数的调用来完成任务。而面向对象编程则采用面向对象的编程风格，通过对象的交互来完成任务。

总的来说，面向过程编程和面向对象编程各有优点，应根据具体的问题和需求来选择合适的编程范式。在实际编程中，也可以将面向过程和面向对象编程结合起来，以发挥各自的优点，提高程序的可读性、可维护性和可扩展性。

11. 全局区、堆和栈的区别？

全局区、堆和栈是计算机内存中的三个不同的存储区域，它们的主要区别如下：

1. 全局区

全局区是指在程序运行期间一直存在的一块内存空间，主要用于存放全局变量、静态变量和常量等数据。在程序运行期间，这些数据都可以被任何函数调用和访问，直到程序结束后才会被系统回收。

2. 堆

堆是一种动态分配内存的区域，程序可以在运行期间根据需要动态地申请和释放内存。在堆中分配的内存通常需要手动释放，否则会导致内存泄漏。

堆的大小不是固定的，可以根据程序的需要动态调整。在堆中分配内存时，需要手动管理内存的分配和释放，因此容易出现内存泄漏或者内存溢出等问题。

3. 栈

栈是一种存储程序运行状态的区域，它在程序运行时自动分配和释放内存。栈中存储的数据通常是函数的参数、局部变量、函数返回值等。

栈的大小是固定的，一般由操作系统或者编译器指定，不可修改。在栈中分配内存时，由系统自动管理内存的分配和释放，因此通常不会出现内存泄漏等问题。

总的来说，全局区、堆和栈是计算机内存中不同的存储区域，它们有不同的生命周期、大小和使用方式。程序员需要根据程序的需求合理地使用这些存储区域，以提高程序的性能和可靠性。

12. 形参和实参的区别？

在编程中，函数的参数可以分为形式参数（简称形参）和实际参数（简称实参），它们的区别如下：

1. 形参

形参是函数定义中的参数，它用于接收调用函数时传递的实参值，相当于函数内部的局部变量。形参只有在函数被调用时才会被赋值，函数执行结束后会被销毁，形参的值不会影响到函数外的其他变量。

函数的形参在函数定义时被声明，可以指定类型、名称和默认值等。形参的作用域仅限于函数内部，函数外部无法访问。

2. 实参

实参是函数调用时传递给函数的值，它是在函数调用时被传递的，可以是常量、变量、表达式、函数等。实参的值会被传递给函数的形参，函数可以使用这些值进行计算或处理。

实参的类型和数量必须与函数定义时的形参类型和数量一致或者符合类型转换规则，否则会导致编译错误。

实参传递方式有按值传递、按引用传递和按指针传递等方式。按值传递是指将实参的值复制一份传递给函数，按引用传递是指将实参的地址传递给函数，按指针传递是指将实参指针的值传递给函数。

总的来说，形参是函数定义时声明的参数，用于接收实参的值，相当于函数内部的局部变量；实参是函数调用时传递给函数的值，它决定了函数的行为和结果。在函数调用过程中，形参和实参之间的值传递和类型匹配是非常重要的。

13. 解释一下虚函数？

在 C++ 中，虚函数是一种特殊的成员函数，它可以实现多态性和动态绑定。虚函数是在基类中声明的，而且可以在派生类中进行重写。

虚函数的作用是允许在派生类中重新定义基类中定义的同名函数，即实现了函数的多态性。在基类中将函数声明为虚函数时，编译器会在对象的虚函数表中为虚函数建立一个入口，而不是直接绑定到函数的实现。

当派生类对象调用虚函数时，程序会根据对象的实际类型决定调用哪个函数，而不是根据对象的声明类型或指针类型进行静态绑定。这种动态绑定的方式可以实现多态性，使程序更具有灵活性和可扩展性。

虚函数的声明语法如下：

class Base {
public:
    virtual void func();
};

class Derived : public Base {
public:
    void func();
};

在上面的例子中，Base 类中的 func 函数被声明为虚函数，而 Derived 类中的 func 函数被重写了。如果在派生类中不重写虚函数，那么会继承基类中的虚函数。

总的来说，虚函数是 C++ 中实现多态性和动态绑定的一种机制，可以使程序更具有灵活性和可扩展性。在使用虚函数时需要注意虚函数的定义和调用方式，以免出现错误。

14. C++中的多态是什么？如何实现多态性？

多态是一种面向对象的编程概念，它允许使用相同的名称来表示不同的行为。在C++中，有两种类型的多态性：编译时多态性和运行时多态性。

• 编译时多态性是通过函数重载和运算符重载实现的，即使用相同的名称来表示不同的函数或运算符。例如：

int add(int a, int b) {
    return a + b;
}

float add(float a, float b) {
    return a + b;
}

上述代码定义了两个名为add的函数，一个接受两个整数作为参数，另一个接受两个浮点数作为参数。在调用时，编译器会根据参数类型选择正确的函数。

• 运行时多态性是通过虚函数和类的继承实现的，即使用相同的名称来表示不同的行为。例如：

class Shape {
public:
    virtual float area() { return 0; }
};

class Circle : public Shape {
public:
    float radius;
    float area() override { return 3.14 * radius * radius; }
};

class Rectangle : public Shape {
public:
    float width, height;
    float area() override { return width * height; }
};

int main() {
    Shape *s;
    Circle c;
    Rectangle r;
    s = &c;
    printf("Circle area is %f\n", s->area());
    s = &r;
    printf("Rectangle area is %f\n", s->area());
    return 0;
}

上述代码定义了一个名为Shape的基类和两个派生类Circle和Rectangle。Shape类包含一个名为area的虚函数，在派生类中重写该函数来计算不同形状的面积。在main函数中，通过指针s调用area函数时，虚函数的机制会根据指针s指向的对象的实际类型来调用正确的area函数，实现了多态性。

15. C++中的RAII是什么？它有什么作用？

RAII（Resource Acquisition Is Initialization）是一种C++编程技术，它利用对象的生命周期来管理资源的分配和释放。在RAII中，资源分配的代码通常放在对象的构造函数中，而资源释放的代码通常放在对象的析构函数中，这样可以确保在对象离开作用域时，资源会被正确地释放。

RAII的作用在于可以避免手动管理资源分配和释放所带来的错误和复杂性，并可以增加程序的健壮性和可读性。例如，使用RAII技术可以创建一个自动锁定的互斥锁对象：

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

class Lock {
public:
    Lock(mutex& m) : mutex_(m) { mutex_.lock(); }
    ~Lock() { mutex_.unlock(); }
private:
    mutex& mutex_;
};

int main() {
    mutex m;
    {
        Lock lock(m);  // 创建一个自动锁定的互斥锁对象
        // 对共享资源进行访问
        cout << "Critical section" << endl;
    }
    return 0;
}

上述代码创建了一个名为Lock的对象，在Lock对象的构造函数中对互斥锁进行加锁，在析构函数中对互斥锁进行解锁。然后，在main函数中创建一个自动锁定的Lock对象，对共享资源进行访问，最后Lock对象离开作用域时自动调用析构函数，释放互斥锁。

16. C++中的模板是什么？它有什么作用？

模板是C++中一种通用的编程技术，它可以将类或函数定义成一种通用的模板形式，使它们可以适用于不同的数据类型和参数。在模板中，可以使用类型参数和非类型参数来表示通用的数据类型和参数。

模板的作用在于可以增加代码的复用性和通用性，使程序的设计更加灵活和简洁。例如，使用模板可以创建一个通用的堆栈类：

#include <iostream>
using namespace std;

template <typename T>
class Stack {
public:
    Stack() : top_(-1) {}
    void push(const T& item) { data_[++top_] = item; }
    void pop() { --top_; }
    T& top() { return data_[top_]; }
    bool empty() const { return top_ == -1; }
private:
    T data_[100];
    int top_;
};

int main() {
    Stack<int> s;  // 创建一个整型堆栈对象
    s.push(10);  // 压入整数10
    s.push(20);  // 压入整数20
    s.push(30);  // 压入整数30
    while (!s.empty()) {
        cout << s.top() << " ";  // 输出堆栈顶部的元素
        s.pop();  // 弹出堆栈顶部的元素
    }
    return 0;
}

上述代码使用模板创建了一个通用的堆栈类，可以适用于不同的数据类型。然后，创建一个整型堆栈对象，压入三个整数，并使用循环遍历堆栈中的所有元素并输出它们的值。