30道C++ 基础高频题整理（附答案背诵版）_中物院c++题目

1. C和C++有什么区别？

C++是C语言的超集（我看网上很多文章说这是不对的），这意味着几乎所有的C程序都可以在C++编译器中编译和运行。然而，C++引入了许多新的概念和特性，使得两种语言在一些关键点上有显著的区别。

以下是C和C++的一些主要区别：

1. 面向对象编程：C++支持面向对象编程（OOP），包括类、对象、继承、封装、多态等特性。这使得C++更适合大型软件项目，因为OOP可以提高代码的重用性和可读性。C语言是一种过程性语言，没有这些特性。
2. STL（Standard Template Library）：C++提供了STL，这是一套强大的模板类和函数的库，包括列表、向量、队列、栈、关联数组等。这些可以大大提高开发效率。C语言没有内置的数据结构库。
3. 异常处理：C++提供了异常处理机制，可以更优雅地处理错误情况。C语言处理错误通常依赖于函数返回值。
4. 构造函数和析构函数：C++支持构造函数和析构函数，这些特殊的函数允许对象在创建和销毁时执行特定的代码。C语言没有这个概念。
5. 运算符重载：C++允许运算符重载，这意味着开发者可以更改已有运算符的行为，或者为用户自定义类型添加新的运算符。C语言不支持运算符重载。

例如，如果我们要创建一个复数类并对其进行算术运算，C++的面向对象和运算符重载特性就非常有用。我们可以定义一个复数类，然后重载+、-和*运算符以执行复数的加法、减法和乘法。这样，我们就可以像处理内置类型一样处理复数对象。反观C语言，我们需要定义结构体来存储复数，并且需要写一堆函数来处理复数的加法、减法和乘法。

2. C语言的结构体和C++的有什么区别

C语言的结构体和C++的结构体在基本的使用上是相似的，都是用来封装多个不同或相同类型的数据。然而，C++中的结构体继承了C++面向对象的特性，与C语言中的结构体有一些关键性的区别：

1. 成员函数：C++的结构体可以包含成员函数（包括构造函数和析构函数），而C语言的结构体不能。
2. 访问控制：C++的结构体支持公有（public）、保护（protected）和私有（private）三种访问控制级别，而C语言的结构体中的所有成员都是公有的。
3. 继承：C++的结构体可以从其他结构体或类继承，而C语言的结构体不能继承。

举个例子，假设我们需要创建一个表示日期的结构体，包含年、月、日这三个字段，并且需要一个函数来检查日期是否有效。在C语言中，我们需要定义一个结构体和一个独立的函数：

struct Date {
    int year;
    int month;
    int day;
};

// 独立函数
int is_valid_date(struct Date date) {
    // 验证日期的逻辑
}
1
2
3
4
5
6
7
8
9
10

在C++中，我们可以将这个函数作为结构体的成员函数：

struct Date {
    int year;
    int month;
    int day;

    bool is_valid() const {
        // 验证日期的逻辑
    }
};
1
2
3
4
5
6
7
8
9

这样，在C++中使用时，我们可以直接调用成员函数 is_valid()，代码更加清晰和易于维护。

Date date;
//...
if (date.is_valid()) {
    //...
}
1
2
3
4
5

3. C 语言的关键字 static 和 C++ 的关键字 static 有什么区别

在C和C++中，static关键字有三个主要的用途，但其在C++中的用法更加丰富：

1. 在函数内部：在C和C++中，static关键字可用于函数内部变量。此时，此变量的生命周期将贯穿整个程序，即使函数执行结束，这个变量也不会被销毁。每次调用这个函数时，它都不会重新初始化。这可以用于实现一些需要保持状态的函数。
2. 在函数外部或类内部：在C和C++中，static关键字可以用于全局变量或函数。此时，此变量或函数的作用域被限制在定义它的文件内，无法在其他文件中访问。这可以防止命名冲突或不必要的访问。
3. 在类内部：只有C++支持此用法。在C++中，static关键字可以用于类的成员变量或成员函数。对于静态成员变量，无论创建多少个类的实例，都只有一份静态成员变量的副本。静态成员函数则可以直接通过类名调用，而无需创建类的实例。

以下是一个C++中使用static的例子：

class MyClass {
public:
    static int count; // 静态成员变量，所有实例共享一份

    MyClass() {
        count++; // 每次创建实例，计数加1
    }

    static int getCount() { // 静态成员函数，通过类名直接调用
        return count;
    }
};

int MyClass::count = 0; // 静态成员变量的初始化

int main() {
    MyClass a;
    MyClass b;
    MyClass c;

    std::cout << MyClass::getCount(); // 输出3，因为创建了3个实例
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这个例子中，我们创建了一个名为MyClass的类，它有一个静态成员变量count和一个静态成员函数getCount()。每创建一个MyClass的实例，count就会增加1。我们可以直接通过类名调用getCount()来获取count的值，而无需创建类的实例。

4. C++ 和 Java有什么核心区别？

1. C++和Java都是广泛使用的编程语言，但它们在设计理念、功能和用途上有很大的不同。以下是C++和Java的几个核心区别：
2. 运行环境：Java是一种解释型语言，它的代码在JVM（Java虚拟机）上运行，这使得Java程序可以在任何安装有JVM的平台上运行，实现了“一次编写，到处运行”的理念。而C++是一种编译型语言，其代码直接编译成目标机器的机器码运行，因此需要针对特定平台编译。
3. 内存管理：Java有自动内存管理和垃圾回收机制，程序员不需要直接管理内存。而在C++中，程序员需要手动进行内存的分配和释放，这提供了更大的控制力，但同时也增加了内存泄漏的风险。
4. 面向对象编程：Java是一种纯面向对象的编程语言，所有的代码都需要包含在类中。与此不同，C++支持面向对象编程，但它也允许过程式编程。
5. 错误处理：Java使用异常处理机制进行错误处理，而C++既支持异常处理，也支持通过返回值进行错误处理。
6. 多线程：Java内置了对多线程的支持，而C++在C++11标准之后引入了对多线程的支持。
7. 性能：因为C++的代码直接编译为机器码，所以它通常比Java程序运行得更快。但是，Java的跨平台能力和内置的垃圾回收机制使其在开发大型企业级应用时更具优势。

例如，如果你正在开发一个需要直接访问硬件，或者需要高性能数学计算的应用（比如游戏，图形渲染，科学计算），C++可能是一个更好的选择。而如果你正在开发一个大型的企业级web应用，Java的跨平台能力，内置的垃圾回收和强大的类库可能会更有优势。

5. C++中，a和&a有什么区别？

在C++中，a和&a表示的是两种完全不同的概念：

1. a：当你在代码中写a时，你正在引用变量a的值。例如，如果你之前写的int a = 10;，那么a的值就是10。
2. &a：&是一个地址运算符，它给出了变量a在内存中的位置。这被称作a的引用或者是指向a的指针。例如，如果你写int* p = &a;，那么p就是一个指向a的指针，你可以通过*p来访问或修改a的值。

这是C++中的一种基础概念，被称为指针和引用。通过指针和引用，你可以直接操作内存，这在很多情况下都非常有用，例如，动态内存分配，函数参数传递，数据结构（如链表和树）等等。

6. C++中，static关键字有什么作用？

在C++中，static关键字有多个用途，它的作用主要取决于它在哪里被使用：

1. 在函数内部：如果static被用于函数内部的变量，那么它会改变该变量的生命周期，使其在程序的整个运行期间都存在，而不是在每次函数调用结束时被销毁。这意味着，这个变量的值在函数调用之间是保持的。
2. 在函数外部：如果static被用于函数外部的全局变量或函数，那么它会将这个变量或函数的链接范围限制在它被定义的文件内。换句话说，这个变量或函数不能在其他文件中被直接访问。这可以帮助减少命名冲突，而且能提供一种控制变量和函数可见性的方式。
3. 在类中：如果static被用于类的成员变量，那么该变量将会成为这个类的所有实例共享的变量，也就是说，类的每个实例都能访问到这个同样的变量。如果static被用于类的成员函数，那么这个函数可以直接通过类来调用，而不需要创建类的实例。

以下是一个C++中使用static的例子：

class MyClass {
public:
    static int count; // 静态成员变量，所有实例共享一份

    MyClass() {
        count++; // 每次创建实例，计数加1
    }

    static int getCount() { // 静态成员函数，通过类名直接调用
        return count;
    }
};

int MyClass::count = 0; // 静态成员变量的初始化

int main() {
    MyClass a;
    MyClass b;
    MyClass c;

    std::cout << MyClass::getCount(); // 输出3，因为创建了3个实例
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个例子中，MyClass有一个静态成员变量count和一个静态成员函数getCount()。每次创建一个MyClass的实例，count就会增加1。我们可以直接通过类名调用getCount()来获取count的值，而无需创建类的实例。

7. C++中，#define和const有什么区别？

#define和const都可以用来定义常量，但它们在实现方式和使用上有一些区别。

1. 预处理器与编译器：#define是预处理器指令，在编译前会被预处理器替换，它只是简单的文本替换，不进行类型检查，也不会分配内存。而const是编译器处理的，它会在编译时进行类型检查，确保你不会意外地改变它的值。
2. 作用域：#define没有作用域的概念，一旦定义，到文件结束都有效。而const常量有作用域，它的作用范围限制在定义它的块或者文件中。
3. 调试：在调试时，#define定义的宏常量无法查看，因为在预处理阶段就已经被替换掉了。而const定义的常量在调试过程中是可以查看的。

例如，考虑以下的代码：

#define PI 3.14
const double Pi = 3.14;

double area1 = PI * r * r; // 使用#define定义的常量
double area2 = Pi * r * r; // 使用const定义的常量
1
2
3
4
5

在这个例子中，PI是一个预处理器定义的宏，而Pi是一个const定义的常量。两者都可以用来计算圆的面积，但Pi在编译时进行类型检查，并且在调试过程中可以查看其值。

9. 静态链接和动态链接有什么区别？

静态链接和动态链接是两种不同的程序链接方式，它们主要的区别在于链接的时间和方式。

1. 静态链接：在静态链接中，所有代码（包括程序本身的代码和它依赖的库的代码）都会在编译时期被合并为一个单一的可执行文件。这个可执行文件包含了程序运行所需的所有信息，因此它不依赖于任何外部的库文件。静态链接的优点是部署简单，因为不需要额外的依赖，只需要一个文件就可以运行。缺点是可执行文件通常会比动态链接的大，因为它包含了所有需要的代码，而且如果库更新，程序需要重新编译和链接。
2. 动态链接：在动态链接中，程序的代码和它依赖的库的代码被分开。程序的可执行文件只包含了程序本身的代码和一些标记，这些标记表示程序在运行时需要链接到哪些库。当程序运行时，操作系统会负责加载这些库并进行链接。动态链接的优点是可执行文件更小，因为它不包含库的代码，而且多个程序可以共享同一份库，节省内存。此外，如果库更新，只需要替换库文件，程序无需重新编译和链接。缺点是部署稍微复杂一些，因为需要确保运行环境中有所需的库文件。

例如，假设我们有一个程序，它使用了一个数学库。如果我们静态链接这个库，那么所有的数学函数都会被包含在我们的可执行文件中，我们可以将这个文件复制到任何地方运行。如果我们动态链接这个库，那么我们的可执行文件就会小得多，但如果我们想在另一台机器上运行这个程序，我们就需要确保那台机器上也安装了这个数学库。

10. 变量的声明和定义有什么区别

在C++中，变量的声明和定义是两个不同的概念。

声明是告诉编译器某个变量的存在，以及它的类型。声明并不分配存储空间。例如，外部变量的声明extern int a;，这里只是告诉编译器有一个类型为int的变量a存在，具体的a在哪里定义的，编译器此时并不知道。

定义是声明的延伸，除了声明变量的存在和类型以外，还分配了存储空间。例如，int a;就是一个定义，编译器在这里为a分配了足够的存储空间来存储一个整数。

在C++中，一个变量可以被声明多次，但只能被定义一次。例如，我们可以在多个文件中声明同一个变量，但只能在一个文件中定义它。如果在多个地方定义同一个变量，编译器会报错。

举个例子，假设我们正在编写一个大型程序，这个程序有一个全局变量需要在多个文件中使用。我们可以在一个文件中定义这个变量，然后在其他需要使用这个变量的文件中声明它。这样，所有的文件都可以访问到这个变量，但只有一个文件负责管理它的存储空间。

11. typedef 和define 有什么区别

typedef和#define都是C++中用于定义别名的关键字，但它们的用途和行为有所不同。

typedef是C++的一个关键字，用于为现有的类型创建一个新的名称（别名）。例如，如果我们想要为unsigned long int创建一个更简单的别名，我们可以写typedef unsigned long int ulong;，然后在代码中就可以使用ulong来代替unsigned long int。typedef只能为类型定义别名，不能为值定义别名。

#define是预处理器的一个指令，用于创建宏。宏可以是一个值，也可以是一段代码。例如，#define PI 3.14159就定义了一个名为PI的宏，它的值是3.14159。#define的作用范围更广，它不仅可以为类型定义别名，也可以为值定义别名，甚至可以定义一段代码。

两者的主要区别在于：

1. typedef仅作用于类型，而#define可以定义类型、值或者代码。
2. typedef是由编译器解析的，而#define是由预处理器处理的。因此，typedef的作用范围是局部的，只在定义它的文件或作用域内有效，而#define的作用范围是全局的，一旦定义即在整个源代码中有效。
3. typedef定义的别名会受到类型检查，而#define定义的宏不会。例如，如果你试图使用typedef为一个函数类型定义别名，然后使用这个别名定义一个整数，编译器会报错。但是如果你使用#define定义一个函数类型的宏，然后使用这个宏定义一个整数，预处理器会默默地接受。
4. typedef可以处理模板化的类型，而#define不能。例如，typedef std::vector int_vector;是合法的，但是使用#define来做同样的事情就会出现问题。
5. typedef定义的别名在调试时更友好。因为它是编译器处理的，所以在调试时可以看到别名。而#define定义的宏在预处理阶段就被替换掉了，所以在调试时看不到宏的名称，只能看到宏的值。

12. final和override关键字

final和override是C++11引入的两个关键字，主要用于类的继承和虚函数的覆盖。

1. final：如果一个类被声明为final，那么它不能被继承。例如，class Base final { … };，此时任何试图继承Base的类都会导致编译错误。此外，如果一个虚函数被声明为final，那么它不能在派生类中被覆盖。例如，virtual void fun() final;，此时任何派生类试图覆盖fun()函数都会导致编译错误。
2. override：如果一个虚函数被声明为override，那么编译器会检查这个函数是否真的覆盖了基类中的一个虚函数。如果没有，编译器会报错。这个关键字可以帮助我们避免因为拼写错误或者函数签名错误而导致的错误。例如，void fun() override;，如果基类中没有一个函数的签名和fun()完全匹配，那么编译器就会报错。

例如，假设我们有一个基类Animal和一个派生类Dog。Animal有一个虚函数make_sound()，Dog需要覆盖这个函数。如果我们在Dog的make_sound()函数声明中加上了override关键字，那么如果我们不小心将函数名拼写成了mkae_sound()，编译器就会因为找不到对应的基类函数而报错，帮助我们及时发现错误。

13. 宏定义和函数有何区别？

宏定义（#define）和函数是两种常见的在C++中编写代码的方式，但它们有一些重要的区别：

1. 编译阶段：宏定义是在预处理阶段展开的，而函数是在编译阶段处理的。这意味着使用宏定义的代码在编译前就已经被预处理器替换掉了，而函数在编译阶段会生成对应的函数调用。
2. 类型检查：函数在编译时会进行类型检查，而宏定义不会。这可能会导致宏定义在使用时出现错误，而在编译阶段并不会被发现。
3. 效率：由于宏定义在预处理阶段就被替换，因此它没有函数调用的开销（如堆栈操作），所以在某些情况下可能更快。然而，过度使用宏定义可能会导致编译后的代码体积增大，因为每次使用宏都会插入一份宏的代码副本。
4. 封装：函数提供了更好的封装，使得代码更易于阅读和维护。而宏定义由于其替换性质，可能会在复杂的表达式中产生不易察觉的错误。

例如，考虑一个简单的宏定义和函数，它们都用于计算两个值的最大值：

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int max(int a, int b) {
    return a > b ? a : b;
}
1
2
3
4
5

如果我们使用MAX宏定义来计算MAX(i++, j++)，由于宏展开，i和j可能会增加两次，这是一个副作用，可能导致不可预见的结果。而使用函数max(i++, j++)，则不会有这个问题，因为函数参数的求值顺序是确定的，i和j只会增加一次。

14. sizeof 和strlen 的区别

sizeof和strlen是两个在C++中常用的函数，但它们的功能和用途有所不同：

1. sizeof 是一个编译时操作符，它返回一个对象或者类型所占用的字节数。例如，sizeof(int)将返回4（在大多数现代系统中），sizeof(char)将返回1。如果你对一个数组使用sizeof，它将返回整个数组的大小，而不是数组中的元素个数。例如，int arr[10]; sizeof(arr);将返回40（在大多数现代系统中，因为一个int通常占用4个字节，所以10个int占用40个字节）。
2. strlen 是一个运行时函数，它返回一个以空字符终止的字符串的长度。该长度不包括终止的空字符。例如，strlen(“hello”)将返回5。注意，strlen只能用于字符数组，且该字符数组必须以空字符(‘\0’)终止，否则strlen会继续读取内存，直到遇到一个空字符，这可能会导致未定义的行为。

举个例子，如果我们有一个字符数组char arr[10] = “hello”;，那么sizeof(arr)将返回10（因为arr是一个10个字符的数组，每个字符占用1个字节），而strlen(arr)将返回5（因为字符串"hello"的长度是5，不包括终止的空字符）。

15. 简述strcpy、sprintf 与memcpy 的区别

strcpy, sprintf, 和 memcpy 都是 C/C++ 标准库中的函数，用于处理字符串和内存，但它们的作用是不同的：

1. strcpy：这个函数用于将源字符串复制到目标字符串。它会复制源字符串的所有字符，直到遇到终止的空字符，并在目标字符串的末尾添加一个空字符。例如，char dest[10]; strcpy(dest, “hello”);，这将会把字符串 “hello”（包括终止的空字符）复制到 dest 中。需要注意的是，如果源字符串的长度（包括终止的空字符）超过了目标字符串的大小，那么会导致缓冲区溢出，这可能会引发安全问题。
2. sprintf：这个函数用于将格式化的数据写入字符串。它可以接受多个输入参数，并按照指定的格式将这些参数格式化为一个字符串，然后将这个字符串写入目标字符串。例如，char str[50]; sprintf(str, “Hello, %s!”, “world”);，这将会把 “Hello, world!” 写入 str。同样，如果格式化后的字符串长度（包括终止的空字符）超过了目标字符串的大小，那么会导致缓冲区溢出。
3. memcpy：这个函数用于复制内存区域。它会从源内存区域复制指定数量的字节到目标内存区域。例如，char dest[10]; char src[10] = “hello”; memcpy(dest, src, 6);，这将会把 src 的前6个字节（包括终止的空字符）复制到 dest。memcpy 不会因为遇到空字符而停止复制，它总是复制指定的字节数，因此，如果指定的字节数超过了目标内存区域的大小，那么会导致缓冲区溢出。

总的来说，strcpy 和 sprintf 是处理以空字符终止的字符串的函数，而 memcpy 是处理内存的函数。在使用这些函数时，需要特别注意缓冲区溢出的问题。

由于内容太多，更多内容以链接形势给大家，点击进去就是答案了

16. volatile有什么作用(volatile有什么作用)

17. 一个参数可以既是const又是volatile吗(一个参数可以既是const又是volatile吗)

18. 全局变量和局部变量有什么区别？操作系统和编译器是怎么知道的？(全局变量和局部变量有什么区别？操作系统和编译器是怎么知道的？)

19. 什么是C++中的指针和引用？它们有什么区别？(什么是C++中的指针和引用？它们有什么区别？)

20. 数组名和指针（这里为指向数组首元素的指针）区别？(数组名和指针（这里为指向数组首元素的指针）区别？)

21. 一个指针占用多少字节？(一个指针占用多少字节？)

22. 什么是智能指针？智能指针有什么作用？分为哪几种？各自有什么样的特点？(https://www.iamshuaidi.com/?p=22689)

23. shared_ptr是如何实现的？(shared_ptr是如何实现的？)

24. 右值引用有什么作用？(右值引用有什么作用？)

25. 悬挂指针与野指针有什么区别？(悬挂指针与野指针有什么区别？)

26. 指针常量与常量指针区别(指针常量与常量指针区别)

27. 如何避免“野指针”(如何避免“野指针”)

28. 句柄和指针的区别和联系是什么？(句柄和指针的区别和联系是什么？)

29. 说一说extern“C”(说一说extern“C”)

30. 对c++中的smart pointer四个智能指针：shared_ptr,unique_ptr,weak_ptr,auto_ptr的理解(对c++中的smart pointer四个智能指针：shared_ptr,unique_ptr,weak_ptr,auto_ptr的理解)