C++面试题

有些题目是重复的

1.C和C++的区别
2.C++中指针和引用的区别
3.结构体struct和联合体union的区别
4.#define和const的区别
5.重载、重写和隐藏的区别
6.delete和delete[]的区别
7.STL库用过吗？常见的STL容器有哪些？算法用过几个？
8.说说多态
9.深拷贝和浅拷贝的区别
10.什么情况会调用拷贝构造函数？
11.强制转换有哪些？
12.typedef和define的区别
13.引用作为函数以及返回值的好处
14.说说野指针和悬空指针
15.函数库algorithm中一些使用的函数
16.C++ 程序编译过程
17.C++ 内存管理
18.栈和堆的区别
19.变量的区别
20.全局变量定义在头文件中有什么问题？
21.如何限制类的对象只能在堆上创建？
22.限制对象只能建立在栈上
23.内存对齐
24.类的大小
25.什么是内存泄露
26.怎么防止内存泄漏？
27.内存泄漏检测工具的原理
28.智能指针的实现原理？
29.一个 unique_ptr 个 怎么赋值给另一个 unique_ptr 对象？
30.使用智能指针会出现什么问题？怎么解决？
31.C++ 11 新特性
32.C和C++ 的区别
33.Java和C++ 的区别
34.Python和C++ 的区别
35.什么是面向对象？
36.重载、重写、隐藏的区别
37.sizeof 和 和 strlen 的区别
38.lambda 表达式（匿名函数）的具体应用和使用场景
39.explicit 的作用
40.C和C++ static的区别
41.static 的作用
42.static在类中使用的注意事项
43.static 全局变量和普通全局变量的异同
44.const 作用及用法
45.define和const的区别
46.define和typedef的区别
47.用宏实现比较大小，以及两个数中的最小值
48.inline作用及使用方法
49.inline函数工作原理
50.define和inline的区别
51.new和malloc的区别，delete和free的区别
52.C和C++ struct 的区别？
53.struct和union的区别
54.class和struct 的异同
55.volatile的作用？
56.什么情况下一定要用 volatile，能否和 const一起使用？
57.返回函数中静态变量的地址会发生什么？
58.extern "C"的作用？
59.sizeof(1==1) 在C和C++ 中分别是什么结果？
60.strcpy 函数有什么缺陷？
61.虚函数的实现机制
62.单继承和多继承的虚函数表结构
63.构造函数、析构函数是否需要定义成虚函数？为什么？
64.为什么拷贝构造函数必须为引用？
65.C++类对象的初始化顺序
66.如何禁止一个类被实例化？
67.为什么用成员初始化列表会快一些？
68.实例化一个对象需要哪几个阶段
69.友元函数的作用及使用场景
70.静态绑定和动态绑定是怎么实现的？
71.编译时多态和运行时多态的区别
72.如何让类不能被继承？
73.左值和右值的区别？
74.如何将左值转换成右值？
75.std::move() 函数的实现原理
76.C++11 nullptr比 NULL 优势
77.指针和引用的区别？
78.switch 的 的 case 里为何不能定义变量
79.常量指针和指针常量的区别
80.函数指针和指针函数的区别
81.参数传递时，值传递、引用传递、指针传递的区别？
82.什么是模板？如何实现？
83.函数模板和类模板的区别？
84.什么是可变参数模板？
85.什么是模板特化？为什么特化？
86.include " " 和 和 <> 的区别？
87.迭代器的作用？
88.泛型编程如何实现？
89.什么是类型萃取？
90.怎么解决哈希冲突？
91.说说迭代器会失效？
92.说说RAII原则

1.C和C++的区别

(1)C是一种面向过程的编程语言，而C++则是一种面向对象的编程语言。C++具有更强大的抽象能力和封装性，使得开发者可以更方便地组织和管理代码。

(2)C++在C的基础上增加了许多新的特性和功能，包括类和对象、继承和多态性、模板和异常处理等。这些特性使得C++更适合大型项目的开发，并且能够提供更高的代码复用性和可维护性。

(3)C和C++对于编程风格和编程习惯也有一些不同。C通常更注重代码的效率和性能，而C++则更注重代码的可读性和可扩展性。这意味着在编写C++代码时，我们可以更多地使用面向对象的设计思想和编程范式，使得代码更清晰、更易于理解和维护。

总结：C和C++虽然有一些共同点，但它们在语言特性、编程范式和使用场景等方面存在明显的区别。对于不同的项目需求和开发目标，可以选择适合的语言来进行开发。

2.C++中指针和引用的区别

(1)指针是一个变量，存储着内存地址。通过指针，我们可以访问和修改指向的变量。而引用则是一个别名，它是被引用变量的一个别名，与被引用变量共享同一块内存地址，因此对引用的操作直接影响被引用的变量。

(2)指针可以为空或者指向任意的内存地址，而引用必须在声明时进行初始化，并且不能为null。这意味着引用在使用时更加安全，避免了空指针引用的错误。

(3)指针可以被重新赋值指向其他变量或释放内存，而引用一旦初始化后就不能再改变指向。这使得引用在某些情况下更适合作为函数参数，可以避免不必要的内存操作。

(4)指针可以进行指针运算（如加法、减法），而引用不支持指针运算。

总结：指针和引用在C++中都是用于处理变量和内存的重要概念，它们在定义、使用和功能上有一些区别。

3.结构体struct和联合体union的区别

(1)结构体是一种用户定义的数据类型，可以包含不同数据类型的成员变量。结构体的成员在内存中是按照定义的顺序依次存储的，每个成员都占据自己的内存空间。结构体的大小等于所有成员变量的大小之和。(需要注意内存对齐)

而联合体也是一种用户定义的数据类型，但它的成员变量共享同一块内存空间。联合体的大小等于最大成员变量的大小。联合体的特点是不同成员变量可以共用一段内存，但在任意时刻只能有一个成员变量处于有效状态。

(2)结构体的成员变量可以同时被访问和使用，而联合体的成员变量只能访问和使用一个。这意味着结构体可以存储和处理多个不同类型的数据，而联合体更适合用于节省内存和处理一组相互排斥的数据。

(3)结构体的成员变量可以通过成员运算符".“来访问，而联合体的成员变量可以通过成员运算符”->“或”."来访问。

总结：结构体和联合体是C++中用于组织和存储数据的用户定义类型，它们在数据存储方式、成员变量访问方式和内存占用等方面有一些区别。

4.#define和const的区别

(1)#define是一个预处理指令，它在编译前进行处理，将标识符替换为定义的常量值。#define没有类型检查，它只是简单的文本替换。而const是一个关键字，它在编译时进行类型检查，可以指定常量的类型。

(2)#define定义的常量没有作用域的限制，它在定义的位置后的整个代码中都有效。而const定义的常量有作用域的限制，它只在定义的作用域内有效。

(3)#define定义的常量可以重新定义或者取消定义，而const定义的常量是只读的，不能被修改。

(4)#define可以定义宏，可以进行复杂的文本替换，而const只能定义常量。

总结：#define和const都可以用来定义常量，但它们在定义方式、作用域和类型安全性等方面有一些区别。

5.重载、重写和隐藏的区别

(1)重载（Overloading）：重载指的是在同一个作用域)内，根据函数的参数类型、参数个数或者参数顺序的不同，定义多个同名函数。重载可以实现函数的多态性，提高代码的可读性和可维护性。重载的函数在编译时会根据调用的参数类型来确定具体调用哪个函数。

(2)重写（Override）：重写指的是在派生类中重新定义基类的虚函数。重写发生在继承关系中，子类可以对父类的虚函数进行重新实现，以满足自己的需求。重写的函数在运行时会根据对象的实际类型来确定具体调用哪个函数。

(3)隐藏（Hiding）：隐藏指的是在派生类中定义了与基类同名的非虚函数。隐藏发生在继承关系中，子类可以定义与父类同名的非虚函数，但是不会影响基类中同名函数的调用。隐藏的函数在编译时会根据对象的编译时类型来确定具体调用哪个函数。

6.delete和delete[]的区别

(1)delete用于释放通过new运算符分配的单个对象的内存，而delete[]用于释放通过new运算符分配的数组对象的内存。

(2)delete只能释放单个对象的内存，它会调用对象的析构函数来进行善后操作。而delete[]可以释放数组对象的内存，它会调用数组中每个元素的析构函数。

(3)delete和delete[]都需要指向动态分配的内存的指针作为参数。使用delete释放数组对象的内存会导致未定义的行为，而使用delete[]释放单个对象的内存也是错误的。

总结：delete和delete[]都是用于释放动态分配的内存的操作符，它们在释放的对象类型和调用的析构函数等方面有一些区别。
优化提问

7.STL库用过吗？常见的STL容器有哪些？算法用过几个？

(1)vector：动态数组，支持快速的随机访问和尾部插入，但在插入和删除元素时可能需要移动其他元素。
(2)list：双向链表，支持在任意位置进行插入和删除操作，但随机访问的效率较低。
(3)deque：双端队列，支持在两端进行快速的插入和删除操作，同时也支持随机访问。
(4)stack：栈，遵循后进先出（LIFO）的原则，只允许在栈顶进行插入和删除操作。
(5)queue：队列，遵循先进先出（FIFO）的原则，只允许在队尾插入，在队头删除。
(6)priority_queue：优先队列，按照一定的优先级进行插入和删除操作，最大（或最小）优先级的元素总是在队列的前部。
(7)set：有序集合，存储唯一的元素，并按照一定的排序规则进行自动排序。
(8)ap：键值对集合，存储唯一的键和对应的值，并按照键的排序规则进行自动排序。
(9)unordered_set：无序集合，类似于set，但不进行自动排序。
(10)unordered_map：无序键值对集合，类似于map，但不进行自动排序。

算法

(1)排序算法：例如sort函数，用于对容器中的元素进行排序。
(2）查找算法：例如find函数，用于在容器中查找指定的元素。
(3)唯一化算法：例如unique函数，用于去除容器中的重复元素。
(4)拷贝和替换算法：例如copy函数和replace函数，用于在容器之间进行元素的复制和替换。
(5)算术和集合操作算法：例如accumulate函数和set_union函数，用于进行数值计算和集合操作。

8.说说多态

C++的多态是面向对象编程的重要概念之一，它允许在运行时根据实际的对象类型来调用相应的函数。多态性通过虚函数和基类指针或引用来实现。

在C++中，通过在基类中声明虚函数，并在派生类中对其进行重写（覆盖），可以实现多态性。当使用基类指针或引用指向派生类对象时，调用虚函数时会根据实际的对象类型来决定调用哪个函数。

多态性的一个重要好处是实现了代码的灵活性和可扩展性。通过定义适当的基类和派生类，我们可以在不修改现有代码的情况下，增加新的派生类并调用其特定的实现。

另外，多态性还能实现接口的统一和代码的重用。通过使用基类指针或引用来操作一组不同的派生类对象，我们可以编写通用的算法和函数，从而提高代码的可维护性和复用性。

总结：C++的多态性通过虚函数和基类指针或引用来实现，在运行时根据实际的对象类型来调用相应的函数。

9.深拷贝和浅拷贝的区别

浅拷贝是指在复制对象时，只复制对象的成员变量的值，而不会复制对象中的指针指向的内存区域。这意味着当原对象和副本对象中的指针指向同一块内存时，修改其中一个对象的指针指向的值，会影响到另一个对象，因为它们共享同一块内存。

而深拷贝则是在复制对象时，会同时复制对象的成员变量以及指针指向的内存区域。这样，原对象和副本对象拥有各自独立的内存空间，修改其中一个对象的指针指向的值，不会影响到另一个对象。

10.什么情况会调用拷贝构造函数？

(1)对象的初始化：当使用一个已经存在的对象来初始化一个新对象时，会调用拷贝构造函数。例如，通过拷贝构造函数来初始化一个对象的副本。

(2)函数参数传递：当将对象作为参数传递给函数时，如果没有使用引用或指针，会进行对象的拷贝。这里就会调用拷贝构造函数来创建副本。

(3)函数返回值：当函数返回一个对象时，会调用拷贝构造函数来创建返回值的副本。

(4)对象赋值：当将一个对象赋值给另一个对象时，如果没有重载赋值运算符，会调用拷贝构造函数来进行对象的拷贝。

11.强制转换有哪些？

(1)静态转换（static_cast）：用于基本类型的转换，以及具有继承关系的指针或引用类型之间的转换。静态转换在编译时进行类型检查，不提供运行时的检查。

(2)动态转换（dynamic_cast）：用于具有继承关系的指针或引用类型之间的转换。动态转换在运行时进行类型检查，可以检查转换是否合法，如果转换不合法则返回空指针或抛出bad_cast异常。

(3)常量转换（const_cast）：用于去除指针或引用的常量属性，可以将常量指针或引用转换为非常量指针或引用。

(4)重新解释转换（reinterpret_cast）：用于将一个指针类型转换为另一个不相关的指针类型，或将整数类型转换为指针类型，或将指针类型转换为整数类型。重新解释转换的安全性由程序员自己负责，不进行类型检查。

(5)还可以使用C风格的强制类型转换（例如使用圆括号进行强制类型转换），但这种方式没有提供类型检查，容易引发错误。因此，在C++中建议使用合适的强制转换操作符来进行类型转换，以提高代码的可读性和安全性。"

12.typedef和#define的区别

typedef用于定义类型别名，通过给一个已有类型取一个新的名字，使得代码更具可读性和可维护性。例如，我们可以使用typedef定义一个别名来代替复杂的类型名称，使代码更加简洁明了。typedef还可以用于给结构体、枚举等自定义类型取别名。

而#define是C++中的预处理指令，用于在编译之前对代码进行文本替换。它可以用来定义常量、宏、函数等。定义的宏会在编译过程中直接进行文本替换，没有类型检查和作用域的概念。这使得#define更加灵活，可以用于在代码中定义简单的宏来进行代码的替换和扩展。

总结：typedef主要用于定义类型别名，以提高代码的可读性和可维护性；而#define用于在编译之前进行文本替换，可以用于定义常量、宏等，以实现代码的替换和扩展。在实际使用中，我们需要根据具体的需求和场景来选择使用typedef还是#define。"

13.引用作为函数以及返回值的好处

(1)避免对象的拷贝：通过使用引用作为函数参数，可以避免在函数调用时进行对象的拷贝。这可以提高程序的性能，特别是当对象较大或者拷贝操作较耗时时更加明显。同时，使用引用作为函数返回值，可以避免返回值的拷贝，直接返回对象的引用。

(2)修改实参的值：通过使用引用作为函数参数，函数可以直接修改实参的值，而不需要通过指针来间接修改。这可以使函数的调用更加简洁和直观。

(3)返回多个值：使用引用作为函数返回值，可以方便地返回多个值。通过引用返回值，可以直接修改调用者提供的变量，而不需要使用指针或者返回结构体等方式。

(4)代码更加清晰：使用引用作为函数参数和返回值，可以使代码更加清晰和易读。通过传递引用，可以明确地表达函数对对象的操作，而不需要通过指针或者拷贝来传递和操作对象。

需要注意的是，使用引用作为函数参数和返回值时，需要注意引用的生命周期和作用域，以避免引用悬空和使用非法的引用。同时，也需要注意引用的使用场景和适用性，不适合所有的情况下都使用引用。"

14.说说野指针和悬空指针

野指针是指未初始化或者指向无效内存地址的指针。野指针的出现通常是由于没有给指针正确地赋初值或者在指针释放后没有将其置为nullptr。当使用野指针时，程序可能会访问无效的内存地址，导致程序崩溃或者产生未知的结果。

悬空指针是指指向已释放的内存地址的指针。当我们释放了一块内存后，如果不将指向该内存地址的指针置为nullptr，那么这个指针就成为悬空指针。使用悬空指针可能会导致访问到已经释放的内存，可能会读取到无效的数据，甚至修改其他内存区域的内容，出现严重的错误。

为了避免野指针和悬空指针的问题，我们应该在使用指针之前将其初始化并赋予有效的地址。在释放指针所指向的内存后，及时将指针置为nullptr，以避免悬空指针的出现。同时，尽量使用智能指针等RAII（资源获取即初始化）的方式来管理内存，以避免手动管理内存带来的问题。在使用指针的过程中，要谨慎使用、检查和验证指针的有效性，以保证程序的正确性和安全性。"

15.函数库algorithm中一些使用的函数

(1)sort：用于对容器中的元素进行排序，可以按照默认的升序排序，也可以通过自定义的比较函数进行排序。

(2)find：用于在容器中查找指定元素的位置，可以返回指定元素的迭代器，或者返回容器末尾的迭代器表示未找到。

(3)count：用于统计容器中指定元素的个数，返回该元素在容器中出现的次数。

(4)accumulate：用于计算容器中元素的累加值，可以通过提供的初始值和自定义的二元操作函数来进行计算。

(5)transform：用于对容器中的元素进行转换操作，可以通过提供的一元或二元操作函数来对元素进行处理，并将结果存储到另一个容器中。

(6)reverse：用于反转容器中元素的顺序，可以将容器中的元素从后往前进行排列。

16.C++ 程序编译过程

C++程序的编译过程主要包括四个步骤：预处理、编译、汇编和链接。

(1)预处理：在预处理阶段，预处理器会处理源代码中的预处理指令，如#include、#define等。它会将头文件插入到源代码中，展开宏定义，并去除注释等。预处理的结果是生成一个包含了所有源代码和头文件的单个文件。

(2)编译：在编译阶段，编译器将预处理阶段生成的文件翻译成汇编语言。它会进行词法分析、语法分析和语义分析，生成相应的中间代码。编译器还会进行一些优化操作，如常量折叠、循环展开等，以提高程序的执行效率。

(3)汇编：在汇编阶段，汇编器将编译阶段生成的中间代码翻译成机器语言指令。它将使用特定的汇编语言来描述程序的操作和数据，生成与目标机器相关的目标文件。

(4)链接：在链接阶段，链接器将目标文件与所需的库文件进行链接，生成最终的可执行程序。链接器会解析函数和变量的引用，将其与定义进行匹配，并将其地址进行绑定。链接还包括地址重定位、符号解析和重复定义等处理。

这四个步骤组成了C++程序的编译过程。每个步骤都有其特定的作用和功能，并且按照特定的顺序进行。编译过程中的优化和错误检查等操作会对最终的可执行程序产生影响。了解和理解程序的编译过程对于程序员来说是非常重要的，可以帮助我们更好地理解程序的执行和调试过程，提高代码的效率和质量。"

17.C++ 内存管理

C++中的内存管理主要包括静态内存管理和动态内存管理。

(1)静态内存管理：静态内存是在编译时分配的，包括全局变量和静态变量。这些变量的内存空间在程序启动时分配，在程序结束时释放。静态内存的管理由编译器和操作系统来完成，程序员无需手动进行管理。

(2)动态内存管理：动态内存是在运行时分配的，使用new运算符申请内存空间，使用delete运算符释放内存空间。动态内存的管理由程序员负责，需要注意以下几点：

• 在使用new运算符分配内存后，要及时使用delete运算符释放内存，以避免内存泄漏。
• 使用delete运算符释放内存后，要将指针置为nullptr，以避免出现悬空指针。
• 对于数组的动态内存分配，应使用delete[]运算符释放内存。
• 谨慎使用动态内存分配，避免过度依赖动态内存，以减少内存管理的复杂性。

此外，C++提供了一些内存管理的工具和技术，如RAII（资源获取即初始化）和智能指针等。RAII是一种编程范式，通过在对象的构造函数中获取资源，在析构函数中释放资源，实现了资源的自动管理。智能指针（如unique_ptr、shared_ptr和weak_ptr）是C++标准库提供的类模板，用于管理动态内存的自动释放，避免了手动释放的繁琐和可能引发的内存泄漏问题。

18.栈和堆的区别

(1)分配方式：栈是由编译器自动分配和释放的，而堆是由程序员手动分配和释放的。

(2)内存管理：栈的内存管理是自动的，遵循先进后出（LIFO）的原则。当函数调用时，函数的局部变量和函数参数等信息会被压入栈中，当函数返回时，这些信息会被自动从栈中弹出。而堆的内存管理则需要程序员手动分配和释放，使用new和delete或malloc和free等操作。

(3)大小和生命周期：栈的大小是有限的，通常比较小，且由系统自动分配。栈上的变量的生命周期与其所在的函数有关，一旦函数返回，栈上的变量将被自动释放。而堆的大小通常比较大，取决于系统内存的剩余空间。堆上分配的内存由程序员手动释放，如果不释放，会导致内存泄漏。

(4)访问速度：栈上分配的内存访问速度较快，因为栈是在CPU的高速缓存中，访问效率高。而堆上分配的内存访问速度较慢，因为需要通过指针在内存中进行查找。

(5)分配方式：栈采用静态内存分配，编译器在编译时确定所需的内存空间大小。而堆采用动态内存分配，程序运行时根据需要进行分配和释放。

在实际编程中，栈主要用于存储局部变量、函数参数和函数调用的上下文信息等，适用于存储生命周期短暂的数据。而堆主要用于存储动态分配的数据，如对象、数组和数据结构等，适用于需要长时间保留的数据。

19.变量的区别

在C++中，我们可以根据变量的类型、作用域和存储位置等方面来区分各种变量。以下是一些常见的变量类型和它们的区别：

(1)局部变量和全局变量：

• 局部变量是在函数内部或代码块内部定义的变量，其作用域仅限于所在的函数或代码块。
• 全局变量是在函数外部定义的变量，可以在整个程序中访问和使用。全局变量的作用域是整个程序。

(2)自动变量和静态变量：

• 自动变量是在函数内部或代码块内部定义的变量，默认情况下具有自动存储期和自动存储类别。它们在函数或代码块的执行过程中创建和销毁。
• 静态变量是在函数内部或代码块内部定义的变量，但使用static关键字进行修饰。它们具有静态存储期和静态存储类别，意味着它们在程序的整个执行过程中都存在。

(3)值类型和引用类型：

• 值类型变量存储的是实际的值，而引用类型变量存储的是对象的引用或地址。
• 值类型变量直接存储数据，而引用类型变量存储的是指向堆上对象的指针。

(4)成员变量和局部变量：

• 成员变量是在类或结构体内部定义的变量，每个对象都有自己的一份成员变量。
• 局部变量是在函数内部或代码块内部定义的变量，仅在所在的函数或代码块内可见。

(5)堆变量和栈变量：

• 栈变量是在程序的栈上分配内存的变量，其内存管理由编译器自动完成。
• 堆变量是通过动态内存分配函数（如new）在堆上分配内存的变量，需要手动管理其生命周期和释放内存。

20.全局变量定义在头文件中有什么问题？

(1)重复定义：如果多个源文件都包含了该头文件，那么每个源文件都会有一份全局变量的定义，这会导致重复定义的错误。在链接阶段，编译器会报错，提示重复定义的问题。

(2)跨文件命名冲突：如果多个头文件中都定义了同名的全局变量，那么在包含这些头文件的源文件中，会出现命名冲突的问题。这会导致编译错误，因为编译器无法判断使用哪个全局变量。

(3)编译时间增加：如果全局变量的定义放在头文件中，每次包含该头文件时，都会将全局变量的定义复制到源文件中。这会导致编译时间的增加，特别是在大型项目中，全局变量的定义可能会很多，造成编译时间的明显增加。

为了避免以上问题，一般推荐将全局变量的声明放在头文件中，将定义放在一个源文件中。这样可以避免重复定义和命名冲突的问题，并减少编译时间。可以通过使用extern关键字在头文件中声明全局变量，然后在源文件中进行定义。

另外，全局变量的使用也要谨慎，尽量避免过多地使用全局变量，以减少全局变量带来的副作用和代码可维护性的问题。可以考虑使用命名空间、类成员变量或者局部变量等方式来替代全局变量的使用。"

21.限制对象只能建立在堆上 ？

(1)将构造函数设置为private：将对象的构造函数设置为private，这样外部的代码就无法直接通过构造函数来创建对象。然后在类中提供一个静态成员函数，用于实例化对象并返回指针。在这个静态成员函数中，可以使用new关键字来在堆上分配对象，并返回指向对象的指针。

(2)使用工厂模式：通过工厂模式来创建对象，将对象的创建逻辑封装在工厂类中。在工厂类中，使用new关键字在堆上分配对象，并返回指向对象的指针。

(3)使用智能指针：通过使用智能指针，如shared_ptr或unique_ptr，来管理对象的生命周期。将对象的构造函数设置为private，并在工厂函数中使用make_shared或make_unique函数来创建对象。这样可以确保对象只能由智能指针管理，并在不再需要时自动释放内存。

需要注意的是，虽然我们可以限制对象只能建立在堆上，但并不意味着这是一个绝对的限制。在C++中，仍然可以通过一些手段绕过这种限制，如使用placement new来在栈上创建对象。因此，限制对象只能建立在堆上只是一种约定和规范，并没有完全杜绝在栈上创建对象的可能性。

在实际项目中，限制对象只能建立在堆上有时是有必要的，特别是对于那些需要动态分配内存、需要跨模块共享的对象。但在一般情况下，我们应该权衡使用堆和栈来创建对象，并根据具体需求来决定使用哪种方式。

22.限制对象只能建立在栈上

(1)将析构函数设置为private：将对象的析构函数设置为private，这样外部的代码就无法直接删除对象。然后在类中提供一个静态成员函数，用于实例化对象并返回对象的引用。在这个静态成员函数中，可以使用对象的地址来创建对象，并返回对象的引用。

(2)使用placement new：使用placement new操作符可以在指定的内存地址上构造对象。可以将对象的构造函数设置为private，并在类的静态成员函数中使用placement new来在栈上分配内存并创建对象。

(3)使用禁用的operator new：重载类的operator new操作符并将其设置为私有，这样就可以阻止对象在堆上被分配。这种方法会导致编译错误，因为无法在堆上分配对象。

需要注意的是，虽然我们可以限制对象只能建立在栈上，但并不意味着这是一个绝对的限制。在C++中，仍然可以通过一些手段绕过这种限制，如使用全局变量或者跨模块的静态对象等。因此，限制对象只能建立在栈上只是一种约定和规范，并没有完全杜绝在堆上创建对象的可能性。

在实际项目中，限制对象只能建立在栈上有时是有必要的，特别是对于那些不需要动态分配内存、不需要跨模块共享的对象。但在一般情况下，我们应该权衡使用堆和栈来创建对象，并根据具体需求来决定使用哪种方式。

23.内存对齐

什么是内存对齐？

内存对齐是指变量在内存中的存放位置需要满足特定的规则。这个规则要求变量的地址必须是某个值的倍数，这个值被称为对齐值或对齐边界。它的作用是优化内存访问的效率和性能。

在C++中，内存对齐是由编译器自动完成的。当我们定义一个变量时，编译器会根据变量的类型和平台的要求来确定它的对齐方式。不同的平台和编译器可能有不同的对齐规则。

内存对齐的好处在于它可以减少内存访问的时间和成本。当变量按照对齐要求存放在内存中时，CPU可以更高效地读取和写入这些变量的值。此外，内存对齐还可以避免一些潜在的问题，比如数据被错误地解释或访问。

总结来说，内存对齐是为了提高内存访问的效率和性能，在C++中由编译器自动完成。它是通过将变量按照特定的规则存放在内存中来实现的。

内存对齐的原则

内存对齐的原则是根据变量的类型和平台的要求，确保变量的存放位置满足对齐边界的要求。以下是内存对齐的一些原则：

(1)对齐边界：每个变量都有一个对齐边界，它决定了变量在内存中的存放位置必须是该对齐边界的倍数。对齐边界的大小通常与变量的大小有关，比如对于8字节的double类型变量，对齐边界通常为8字节。

(2)默认对齐：编译器会为每个类型设置一个默认的对齐边界。通常，较小的类型（如char、short）的默认对齐边界为它们的大小，而较大的类型（如int、double）的默认对齐边界可能是它们大小的倍数。

(3)结构体对齐：结构体的对齐边界通常等于成员变量中最大的对齐边界。这是为了保证结构体的每个成员都能满足对齐要求。

(4)指定对齐：在C++11之后，我们可以使用特殊的语法来指定变量的对齐边界。比如，可以使用alignas关键字来指定变量的对齐边界。

内存对齐的优点

内存对齐的优点主要体现在以下几个方面，你可以这样回答：

(1)提高访问效率：内存对齐可以使得变量按照对齐要求存放在内存中，这样CPU在访问变量时可以更高效地读取和写入数据。因为对于按照对齐要求存放的变量，CPU可以直接读取或写入整个变量，而不需要分多次进行访问。

(2)提高性能：内存对齐可以减少内存访问的时间和成本，从而提高程序的执行效率和性能。当变量按照对齐要求存放在内存中时，CPU可以更快地访问这些变量，从而加快程序的执行速度。

(3)避免潜在问题：内存对齐可以避免一些潜在的问题，比如数据被错误地解释或访问。如果变量没有按照对齐要求存放在内存中，可能会导致数据解释错误，或者引发访问违例等问题。通过内存对齐，可以保证变量被正确地访问和解释。

(4)平台兼容性：内存对齐是跨平台编程中的重要考虑因素之一。不同的平台和编译器可能有不同的对齐规则，但通过合理地进行内存对齐，可以增加程序在不同平台上的兼容性和可移植性。

总结：内存对齐的优点包括提高访问效率、提高性能、避免潜在问题和增加平台兼容性。

24.类的大小

(1)非静态成员变量：类的大小会包括所有非静态成员变量的大小。通常，每个非静态成员变量的大小是其类型的大小。

(2)继承关系：如果类继承了其他类，那么类的大小也会受到继承关系的影响。对于单一继承情况，类的大小通常等于基类的大小加上派生类自身的大小，其中基类的大小指的是基类中的成员变量大小。对于多重继承情况，类的大小会根据继承顺序和对齐要求进行调整。

(3)对齐要求：类的大小还受到内存对齐的要求影响。编译器会根据成员变量的类型和平台的要求来确定对齐方式，从而影响类的大小。对齐要求可能会导致类的大小大于成员变量的总和。

需要注意的是，类的大小可能会因为编译器的优化策略而发生变化，比如对成员变量进行优化对齐，或者使用空间填充来满足对齐要求。

25.什么是内存泄露

内存泄漏是指在程序运行过程中，动态分配的内存没有被正确释放造成的内存资源浪费。

内存泄漏在C++中是一个常见的问题，它会导致程序运行时占用的内存逐渐增加，最终导致内存耗尽。当程序中的对象或数据动态分配了内存空间，但在不再使用时没有被正确释放，就会发生内存泄漏。

内存泄漏的主要原因有以下几个：

(1)忘记释放内存：在使用new、new[]、malloc等操作分配内存后，如果忘记使用对应的delete、delete[]、free等操作来释放内存，就会发生内存泄漏。

(2)引用计数错误：当使用引用计数技术管理内存时，如果没有正确地更新引用计数，或者发生了计数错误，就会导致内存泄漏。

(3)循环引用：循环引用指的是对象之间相互持有对方的引用，导致无法释放彼此所占用的内存。如果存在循环引用，就会造成内存泄漏。

内存泄漏会导致程序运行时占用的内存逐渐增加，最终可能导致程序出现崩溃或者性能下降等问题。为了避免内存泄漏，我们需要及时释放不再使用的内存，可以使用智能指针、遵循RAII原则、手动释放动态分配的内存等方式来管理内存，确保资源能够正确释放。

26.怎么防止内存泄漏？

(1)使用智能指针：C++提供了智能指针的概念，如std::shared_ptr、std::unique_ptr和std::weak_ptr。智能指针可以自动管理内存的释放，通过引用计数或独占所有权的方式，确保在不再需要时及时释放内存，避免内存泄漏。

(2)遵循资源获取即初始化（RAII）原则：RAII是一种C++编程的重要原则，它通过在对象的构造函数中获取资源，在析构函数中释放资源，确保资源的正确释放。通过使用RAII，可以有效地防止内存泄漏，例如使用std::fstream来管理文件资源。

(3)释放动态分配的内存：在使用new、new[]、malloc等动态分配内存的操作后，一定要对应使用delete、delete[]、free等操作来释放内存。确保在不再需要时，手动释放动态分配的内存，以防止内存泄漏。

(4)避免循环引用：循环引用指的是对象之间相互持有对方的引用，导致无法释放彼此所占用的内存。为了避免循环引用，可以使用弱引用（std::weak_ptr）来打破循环引用关系，或者使用其他设计模式来解决对象之间的依赖关系。

(5)注意异常安全：在处理异常时，需要保证资源能够得到正确的释放。可以使用try-catch块来捕获异常，并在捕获到异常后正确处理资源的释放操作，以避免因为异常导致内存泄漏。

(6)使用工具进行内存泄漏检测：可以使用一些工具来检测内存泄漏，如Valgrind、ASAN（AddressSanitizer）等。这些工具可以帮助我们发现潜在的内存泄漏问题，并进行修复。

27.内存泄漏检测工具的原理

内存泄漏检测工具的原理可以大致分为两个方面：运行时检测和统计分析。

(1)运行时检测：内存泄漏检测工具会在程序运行过程中，截获动态内存分配的操作，跟踪记录每个分配的内存块的地址和大小。当程序结束时，工具会检查是否有分配的内存没有被释放，从而发现内存泄漏问题。工具会输出相关的报告，指示哪些内存块没有被正确释放。

(2)统计分析：内存泄漏检测工具还可以通过统计分析的方式来检测内存泄漏。工具会记录每个动态内存分配的操作，以及相关的上下文信息，如分配的位置、分配操作的调用栈等。通过分析这些信息，工具可以检测到内存分配与释放的不匹配，进而发现内存泄漏问题。

内存泄漏检测工具通常会使用一些技术来实现上述原理，如重载new和delete运算符、插桩机制、堆栈跟踪等。工具可能会在运行时插入额外的代码来记录分配和释放操作，并维护相关的数据结构来跟踪内存使用情况。工具还可以通过在运行时进行内存访问检查，来检测非法的内存操作。

28.智能指针的实现原理？

智能指针的实现原理主要基于两种机制：引用计数和独占所有权。

(1)引用计数机制：智能指针通过维护一个引用计数，记录有多少个指针指向同一块内存。当一个智能指针被创建或者拷贝时，引用计数会增加；当一个智能指针被销毁或者赋值给其他对象时，引用计数会减少。当引用计数为0时，表示没有指针指向该内存块，可以安全地释放内存。使用引用计数机制可以实现多个智能指针共享同一块内存，并确保在不再需要时及时释放。

(2)独占所有权机制：智能指针还可以通过独占所有权的方式管理内存。它通过禁止其他指针对同一块内存进行访问，从而确保在不再需要时能够安全地释放内存。独占所有权机制可以使用一些额外的标记来判断是否只有一个指针拥有内存的所有权，例如使用一个布尔值或者一个空指针来标记。

智能指针通常是作为一个类模板来实现的，包括构造函数、析构函数、拷贝构造函数和赋值运算符等成员函数。在实现过程中，可以使用引用计数或独占所有权等机制来管理内存。同时，智能指针还可以提供一些额外的功能，如自定义删除器、自动类型转换等。

29.一个 unique_ptr 个 怎么赋值给另一个 unique_ptr 对象？

当我们将一个 unique_ptr 赋值给另一个 unique_ptr 对象时，可以使用std::move()函数来进行转移。std::move()函数是C++11中引入的一个函数模板，用于将一个对象转为右值引用，从而实现资源所有权的转移。

具体的操作步骤如下：

(1)使用std::move()函数将要转移的 unique_ptr 对象转为右值引用。例如，如果有一个名为ptr1的 unique_ptr 对象，我们可以使用std::move(ptr1)将其转为右值引用。

(2)将转移后的右值引用赋值给目标 unique_ptr 对象。例如，如果有一个名为ptr2的 unique_ptr 对象，我们可以将转移后的右值引用赋值给ptr2，即ptr2 = std::move(ptr1)。

这样，原来的 unique_ptr 对象ptr1将失去对内存的所有权，而新的 unique_ptr 对象ptr2将接管这块内存的所有权。

需要注意的是，转移后的原来的 unique_ptr 对象不再拥有对内存的所有权，使用它来访问内存将导致未定义行为。而新的 unique_ptr 对象则成为这块内存的唯一所有者，负责在适当的时候释放内存。

30.使用智能指针会出现什么问题？怎么解决？

使用智能指针可能会遇到以下几个问题：

(1)循环引用导致内存泄漏：当存在循环引用时，智能指针的引用计数无法归零，导致内存无法及时释放，从而出现内存泄漏。

(2)删除器的正确使用：智能指针可以使用自定义的删除器来释放资源，但需要确保删除器正确地释放资源，并避免潜在的资源泄漏或者未定义行为。

(3)多线程下的竞争条件：如果多个线程同时访问同一个智能指针对象，可能会出现竞争条件，导致不确定的行为和内存错误。

为了解决这些问题，我们可以采取以下几种方法：

(1)手动破坏循环引用：通过手动断开循环引用，使得智能指针的引用计数归零，从而能够及时释放内存。例如，使用弱引用（weak_ptr）来打破循环引用。

(2)使用智能指针的删除器：当需要自定义资源释放的方式时，可以通过智能指针提供的删除器来执行自定义的释放操作。确保删除器正确地释放资源，避免资源泄漏。

(3)使用互斥锁或原子操作：当多个线程同时访问同一个智能指针对象时，可以使用互斥锁或原子操作来保证线程安全，避免竞争条件和内存错误。

此外，还可以使用智能指针的其他功能来进一步增强内存管理的安全性，例如使用unique_ptr来确保独占所有权，使用shared_ptr来实现多个智能指针共享资源等。

31.说说C++ 11 新特性

auto 类型推导
decltype 类型推导
lambda 表达式
范围 for 语句
右值引用
准库 move() 函数
智能指针
delete 函数和 default 函数

32.C和C++ 的区别

(1)编程范式：C是一种过程式编程语言，而C++是一种多范式编程语言，支持面向对象编程、泛型编程和函数式编程。

(2)语法差异：C++是C的超集，意味着C++可以完全兼容C的语法和标准库。但是C++还引入了一些新的语法和特性，如命名空间、类和对象、构造函数和析构函数、运算符重载等。

(3)标准库：C++标准库比C标准库更加丰富和强大，包括了大量的容器类、算法、输入输出流、异常处理等功能，使得C++更加方便和高效。

(4)内存管理：C++引入了智能指针和RAII（资源获取即初始化）的概念，使得内存管理更加安全和方便。而C则需要手动进行内存管理，容易出现内存泄漏和悬挂指针等问题。

(5)异常处理：C++引入了异常处理机制，可以通过try-catch块捕获和处理异常。而C则通常使用错误码或者返回值来处理错误。

(6)名字空间：C++引入了名字空间的概念，可以将代码组织到不同的命名空间中，避免命名冲突和提供更好的代码模块化。

(7)兼容性：C++可以调用C的函数库，并且C++代码可以通过C的编译器进行编译和执行，保持了与C的兼容性。

33.Java和C++ 的区别

(1)编程范式：Java是一种面向对象的编程语言，而C++是一种多范式编程语言，支持面向对象编程、泛型编程和过程式编程。

(2)内存管理：Java使用自动垃圾回收机制（Garbage Collection）来管理内存，程序员无需手动释放内存。而C++需要手动进行内存管理，通过new和delete操作符来分配和释放内存。

(3)平台无关性：Java是一种平台无关的语言，可以在不同的操作系统上运行。而C++则依赖于特定的编译器和操作系统，需要进行适当的调整和编译。

(4)异常处理：Java有强制的异常处理机制，要求程序员在代码中显式地处理异常情况。而C++的异常处理机制是可选的，程序员可以选择是否使用异常处理。

(5)标准库：Java的标准库（Java SE库）提供了丰富的功能，包括网络编程、图形界面、多线程等。C++的标准库也很强大，但相对较小，需要依赖第三方库来实现一些高级功能。

(6)安全性：由于Java的内存管理是自动的，因此更容易避免内存泄漏和悬挂指针等问题。而C++的手动内存管理可能导致内存错误和安全漏洞。

(7)执行效率：C++通常比Java执行效率更高，因为C++是一种编译型语言，而Java是一种解释型语言。但是Java通过即时编译器（Just-In-Time Compilation）提供了动态优化，可以在运行时提高执行效率。

34.Python和C++ 的区别

(1)编程范式：Python是一种解释型的、面向对象的编程语言，而C++是一种多范式的编程语言，支持面向对象编程、泛型编程和过程式编程。

(2)语法差异：Python的语法相对简洁易读，而C++的语法较为复杂。Python使用缩进来表示代码块，而C++使用大括号。此外，Python具有动态类型，而C++是静态类型的语言。

(3)内存管理：Python使用自动垃圾回收机制（Garbage Collection）来管理内存，程序员无需手动释放内存。而C++需要手动进行内存管理，通过new和delete操作符来分配和释放内存。

(4)执行效率：C++通常比Python执行效率更高，因为C++是一种编译型语言，而Python是一种解释型语言。C++通过直接编译成机器码来执行，而Python通过解释器逐行解释执行。

(5)应用领域：由于Python具有简洁易读的语法和强大的标准库，适合用于快速开发和脚本编程。而C++则适用于开发性能要求高、底层系统、游戏引擎、嵌入式设备等领域。

(6)生态系统：Python拥有众多的第三方库和框架，如NumPy、Pandas、Django等，使得开发更加便捷。而C++的生态系统相对较小，需要依赖第三方库来实现一些高级功能。

(7)学习曲线：Python的学习曲线较为平缓，上手容易。而C++需要对语言的复杂性和底层机制有更深入的了解，学习曲线较陡。

35.什么是面向对象？

面向对象是一种软件开发的方法论，它将现实世界中的事物抽象为对象，并通过封装、继承和多态等机制来描述对象之间的关系和行为。面向对象可以提供更高的代码重用性、可维护性和扩展性。

(1)对象：面向对象的核心思想是对象，对象是现实世界中具有独立身份和状态的实体，可以拥有属性和行为。例如，对于一个汽车类，每辆汽车都是该类的一个对象，拥有独立的属性（颜色、型号、速度等）和行为（加速、刹车等）。

(2)封装：封装是将数据和方法封装在一个对象中，对象的内部实现对外部是隐藏的，只暴露出一些公共接口供其他对象访问。这种封装性可以提高代码的安全性和可维护性，并且可以隐藏实现细节。

(3)继承：继承是一种机制，允许一个类继承另一个类的属性和方法。继承可以通过创建子类来扩展或修改父类的行为，使得代码的重用性更高。例如，可以创建一个子类"SUV"，继承自父类"汽车"，并在子类中添加一些特定的属性和行为。

(4)多态：多态是一种能力，允许不同的对象对相同的消息做出不同的响应。通过多态，可以在不了解对象具体类型的情况下，通过统一的接口来调用对象的方法。多态提高了代码的灵活性和可扩展性。

(5)类和对象：类是一个抽象的概念，描述了一类具有相同属性和行为的对象。对象是类的一个实例，具有独立的状态和行为。

(6)优点：面向对象编程具有代码重用性高、可维护性好、扩展性强、易于理解和调试等优点。它可以提高开发效率，降低代码的复杂度。

36.重载、重写、隐藏的区别

重载（Overloading）、重写（Overriding）和隐藏（Hiding）是面向对象编程中的三个重要概念，用于描述类和对象之间的关系和行为。

(1)重载（Overloading）：重载是指在同一个作用域内，可以定义多个名称相同但参数列表不同的函数。重载函数可以根据参数的类型、个数或顺序来进行区分。编译器会根据调用时的参数匹配最合适的重载函数。重载函数可以提高代码的可读性和灵活性。

(2)重写（Overriding）：重写是指子类重新定义父类的虚函数（在C++中使用关键字"virtual"来定义虚函数）。子类重写的函数必须与父类的函数具有相同的签名（返回类型、函数名和参数列表）。重写函数可以改变父类函数的行为，实现多态性。在运行时，根据对象的实际类型来调用相应的重写函数。

(3)隐藏（Hiding）：隐藏是指子类定义了与父类同名的非虚函数（或静态函数），从而隐藏了父类的同名函数。隐藏函数与重载和重写不同，它们在不同的作用域内定义，不具有多态性。在静态绑定中（编译时确定函数调用的对象类型），将会调用隐藏函数；在动态绑定中（运行时确定函数调用的对象类型），将会调用重写函数。

(4)区别总结：

• 重载是在同一作用域内定义多个同名但参数列表不同的函数，根据参数的类型、个数或顺序来区分。
• 重写是子类重新定义父类的虚函数，改变父类函数的行为，实现多态性。
• 隐藏是子类定义与父类同名的非虚函数，从而隐藏了父类的同名函数，不具有多态性。

37.sizeof 和 和 strlen 的区别

sizeof和strlen是C++中的两个重要的操作符，它们用于获取对象的大小和字符串的长度。

(1)sizeof操作符：

• 作用：sizeof操作符用于获取对象或类型的字节大小（即占用内存空间的大小）。
• 用法：sizeof操作符可以用于获取任意类型的大小，包括基本数据类型、自定义数据类型和数组等。
• 结果：sizeof操作符返回的是一个常量表达式，在编译时就可以确定大小。

(2)strlen函数：

• 作用：strlen函数用于获取以空字符’\0’结尾的字符串的长度，即字符数组的有效字符个数（不包括空字符’\0’）。
• 用法：strlen函数需要传入一个以空字符结尾的字符数组作为参数。
• 结果：strlen函数返回的是一个整数，表示字符串的长度。

(3)区别总结：

• 返回类型：sizeof操作符返回的是一个常量表达式的结果，类型为size_t，表示字节大小；strlen函数返回的是一个整数，表示字符串的长度。
• 适用对象：sizeof操作符可以用于任意类型的对象，包括基本数据类型、自定义数据类型和数组等；strlen函数仅适用于以空字符结尾的字符数组。
• 编译时与运行时：sizeof操作符在编译时就可以确定对象的大小；strlen函数需要在运行时通过遍历字符串来计算长度。

38.lambda 表达式（匿名函数）的具体应用和使用场景

Lambda表达式（匿名函数）是C++11引入的一种函数对象，可以在需要函数的地方以更简洁的方式定义和使用函数。

(1)应用场景：

• 简化代码：Lambda表达式可以用来替代繁琐的函数定义，使代码更简洁、清晰。
• 函数对象：Lambda表达式可以作为函数对象传递给STL算法，如排序、查找、遍历等。
• 回调函数：Lambda表达式可以作为回调函数传递给其他函数，在特定条件下执行相应的操作。
• 事件处理：Lambda表达式可以用于处理事件，如按钮点击、鼠标移动等。
• 并行编程：Lambda表达式可以在多线程或并行编程中简化任务的定义和调度。

(2)使用场景：

• STL算法：使用Lambda表达式可以更方便地定义排序、查找等算法的比较函数。
• STL容器：使用Lambda表达式可以更简洁地定义集合中元素的处理方式，如遍历、筛选、转换等。
• GUI编程：使用Lambda表达式可以更方便地处理用户界面的事件，如按钮点击、菜单选择等。
• 并行编程：使用Lambda表达式可以更容易地定义并行任务的执行方式和结果处理。

(3)优点：

• 简洁：Lambda表达式可以在需要函数的地方直接定义，使代码更简洁、易读。
• 灵活：Lambda表达式可以捕获外部变量，使得函数的行为更加灵活和自适应。
• 可读性：Lambda表达式可以将函数的定义和使用放在一起，提高代码的可读性和可维护性。
• 性能：Lambda表达式可以避免创建临时函数对象，提高代码的执行效率。

39.explicit 的作用

explicit是C++中的关键字，用于修饰类的构造函数，表示该构造函数只能用于显式地创建对象，禁止隐式地进行类型转换。

(1)作用：

• 防止隐式类型转换：使用explicit关键字修饰构造函数可以防止隐式类型转换，避免不必要的类型转换和意外行为。
• 显式地创建对象：使用explicit关键字修饰构造函数可以强制要求使用构造函数的显式调用语法，提高代码的可读性和可维护性。
• 避免意外行为：使用explicit关键字可以避免因隐式类型转换引发的意外行为和潜在的安全隐患。

(2)使用场景：

• 单参数构造函数：一般情况下，explicit关键字常用于只有一个参数的构造函数，避免隐式类型转换。
• 类型安全：当构造函数的参数和类的数据成员之间存在明显的类型差异时，使用explicit关键字可以保证类型安全。

(3)注意事项：

• explicit关键字只能用于类的构造函数，不能用于其他类成员函数或普通函数。
• explicit关键字只对单参数构造函数有效，如果构造函数有多个参数，则无论是否使用explicit关键字，都不能进行隐式类型转换。

40.C和C++ static的区别

(1)C中的static：

• 局部变量：在函数内部使用static修饰的变量是静态局部变量，其作用域仅限于定义它的函数内部，但生命周期贯穿整个程序运行过程，只会初始化一次。
• 全局变量和函数：在全局变量和函数前使用static修饰，表示它们的作用范围限制在当前文件内，不会被其他文件访问到，具有文件作用域（internal linkage）。
• 注意：C中的static不会改变变量的存储方式，只会改变变量的作用范围和生命周期。

(2)C++中的static：

• 静态成员变量：在类中使用static修饰的成员变量是静态成员变量，属于类的属性而不是对象的属性，所有类的对象共享同一份静态成员变量，且需要在类外初始化。
• 静态成员函数：在类中使用static修饰的成员函数是静态成员函数，它只能访问静态成员变量和其他静态成员函数，不依赖于具体的对象，可以直接通过类名调用。
• 静态局部变量：在函数内部使用static修饰的变量是静态局部变量，类似于C中的静态局部变量，具有静态存储期，但作用域仅限于定义它的函数内部。
• 注意：C++中的static修饰的成员变量和成员函数与具体的类对象无关，属于类本身。

(3)区别总结：

• 作用范围：C中的static改变变量或函数的作用范围为文件作用域；C++中的static改变成员变量和成员函数的作用范围为类作用域。
• 共享性：C中的static变量在不同函数之间共享；C++中的静态成员变量在所有类对象之间共享。
• 存储方式：C中的static不会改变变量的存储方式；C++中的静态成员变量和静态局部变量都具有静态存储期。

41.static 的作用

(1)作用：

• 静态成员变量：将static关键字用于类的成员变量时，表示该成员变量属于类本身，而不是类的对象。静态成员变量在所有类对象之间共享，只有一份拷贝，可以通过类名直接访问。
• 静态成员函数：将static关键字用于类的成员函数时，表示该成员函数属于类本身，而不是类的对象。静态成员函数只能访问静态成员变量和其他静态成员函数，不依赖于具体的对象，可以通过类名直接调用。
• 静态局部变量：将static关键字用于函数内部的局部变量时，表示该变量具有静态存储期，其生命周期贯穿整个程序运行过程，但作用域仅限于定义它的函数内部。静态局部变量只会初始化一次，并且在函数调用结束后仍然保留其值。

(2)使用场景：

• 静态成员变量：适用于需要在所有类对象之间共享数据的场景，如计数器、全局配置等。
• 静态成员函数：适用于不依赖于具体对象的操作，如工具函数、工厂方法等。
• 静态局部变量：适用于需要在函数调用之间保留状态的场景，如缓存、记忆化等。

(3)注意事项：

• 静态成员变量和静态成员函数属于类本身，不依赖于具体的对象，因此无法访问非静态成员变量和非静态成员函数。
• 静态局部变量的生命周期贯穿整个程序运行过程，但作用域仅限于定义它的函数内部。

42.static在类中使用的注意事项

第一个区别

(1)定义：

• 在类中声明静态成员变量或静态成员函数时，需要在类的声明中进行定义，但不可在类的声明中初始化。
• 静态成员变量的定义通常在类的实现文件（.cpp文件）中进行，而不是在头文件（.h文件）中。
• 静态成员函数的定义可以在类的声明内部或实现文件中进行。

(2)初始化：

• 静态成员变量需要在类外部进行初始化，通常在实现文件中使用类名加作用域解析运算符来初始化。
• 静态成员变量只能在类外部初始化一次，因为它们在所有类对象之间共享。
• 静态成员变量的初始化可以是常量表达式或其他静态成员变量的值。

(3)使用：

• 静态成员变量可以通过类名加作用域解析运算符来访问，也可以通过类的对象来访问。但建议使用类名来访问，以强调静态成员变量属于类本身。
• 静态成员函数只能访问静态成员变量和其他静态成员函数，因为它们不依赖于具体的对象。
• 静态成员函数可以通过类名加作用域解析运算符来调用，也可以通过类的对象来调用。但建议使用类名来调用，以强调静态成员函数属于类本身。

(4)注意事项：

• 静态成员变量必须在类外部初始化，否则会导致链接错误。
• 静态成员变量的初始化顺序与它们在类中声明的顺序无关，而与它们在实现文件中的定义顺序相关。
• 静态成员变量和静态成员函数属于类本身，不依赖于具体的对象，因此无法访问非静态成员变量和非静态成员函数。

第二个区别

(1)静态成员变量的注意事项：

• 静态成员变量属于类本身，而不是类的对象。因此，它们在所有类对象之间共享，只有一份拷贝。
• 静态成员变量需要在类外部进行初始化，并且只能初始化一次。通常在实现文件中使用类名加作用域解析运算符来初始化。
• 静态成员变量的初始化顺序与它们在实现文件中的定义顺序相关，而与它们在类中声明的顺序无关。

(2)静态成员函数的注意事项：

• 静态成员函数属于类本身，而不是类的对象。因此，它们不依赖于具体的对象，只能访问静态成员变量和其他静态成员函数。
• 静态成员函数可以通过类名加作用域解析运算符来调用，也可以通过类的对象来调用。但建议使用类名来调用，以强调静态成员函数属于类本身。

(3)静态成员变量和静态成员函数的作用范围：

• 静态成员变量和静态成员函数的作用范围为类作用域，而不是对象作用域。因此，它们可以在类的任何成员函数内部访问，无需通过对象名或指针来访问。

(4)静态成员变量和静态成员函数的访问权限：

• 静态成员变量和静态成员函数的访问权限遵循类的访问控制规则，可以是public、protected或private。
• 即使类的对象不能访问私有的静态成员变量或静态成员函数，其他具有访问权限的类和函数仍然可以访问它们。

43.static 全局变量和普通全局变量的异同

(1)相同点：

• 都是定义在全局作用域的变量，即在所有函数之外声明的变量。
• 都具有静态存储期，即在程序的整个运行期间都存在。

(2)不同点：

• 初始化：普通全局变量在定义时会自动初始化为默认值，而static全局变量默认初始化为0或空指针，除非显式指定其他值。
• 作用域：普通全局变量在声明它的源文件中可见，其他源文件无法访问。而static全局变量只能在声明它的源文件中可见，其他源文件无法访问。
• 链接性：普通全局变量具有外部链接性，即可以在其他源文件中通过extern关键字声明后使用。而static全局变量具有内部链接性，只能在声明它的源文件中使用。
• 名称冲突：由于普通全局变量具有外部链接性，可能会导致不同源文件中的同名全局变量冲突。而static全局变量具有内部链接性，不会与其他源文件中的同名全局变量冲突。

44.const 作用及用法

(1)const关键字的作用：

• const用于声明一个常量，即一个不可修改的值。通过使用const关键字，可以告诉编译器某个变量的值不应该被修改。
• const还可以用于指定函数的参数和返回值，以确保函数不会修改参数的值并且返回一个不可修改的结果。

(2)const关键字的用法：

• 用于声明常量：在变量声明前加上const关键字来声明一个常量。例如：const int MAX_VALUE = 100;表示MAX_VALUE是一个常量，其值为100，不能被修改。
• 用于修饰函数参数：在函数的参数列表中使用const关键字来指定参数为常量，表示函数不会修改该参数的值。例如：void print(const int num);表示print函数不会修改num的值。
• 用于修饰函数返回值：在函数的返回类型前加上const关键字来指定返回值为常量，表示返回的值不可修改。例如：const int getValue();表示getValue函数返回一个不可修改的整数值。

(3)const关键字的好处：

• 提高代码的可读性和可维护性：通过使用const关键字，可以明确地表达某个变量是一个常量，无法被修改，使代码更容易理解和维护。
• 防止意外的修改：通过将变量声明为常量，可以防止在编程过程中意外地修改变量的值，减少了错误的发生。
• 优化编译器的优化能力：编译器可以根据变量是否为常量进行一些优化，提高程序的性能。

45.define和const的区别

(1)宏定义（define）：

• 宏定义是C++中的预处理指令，使用#define关键字定义。宏定义将一个标识符和一个值关联起来，并在程序编译之前进行简单的文本替换。
• 宏定义没有类型检查，仅仅是简单的文本替换。它没有作用域，是全局的。它是在预处理阶段进行替换的，不进行类型检查，也不进行编译器优化。
• 宏定义可以定义常量、函数、代码片段等。

(2)const关键字：

• const关键字用于声明一个常量，即一个不可修改的值。通过使用const关键字可以告诉编译器某个变量的值不应该被修改。
• const关键字具有类型检查，可以确保变量的类型安全。它有作用域，可以限定变量的可见性。
• const关键字在编译过程中进行类型检查，并且可能会对其进行优化。

(3)区别：

• 类型和检查：宏定义没有类型检查，而const关键字具有类型检查，可以确保变量的类型安全。
• 作用域：宏定义是全局的，没有作用域限制，而const关键字可以限定变量的作用域。
• 编译器优化：宏定义在预处理阶段进行替换，不进行编译器优化，而const关键字在编译过程中进行类型检查，并且可能会对其进行优化。

46.define和typedef的区别

(1)宏定义（define）：

• 宏定义是C++中的预处理指令，使用#define关键字定义。宏定义将一个标识符和一个值关联起来，并在程序编译之前进行简单的文本替换。
• 宏定义没有类型检查，仅仅是简单的文本替换。它没有作用域，是全局的。它是在预处理阶段进行替换的，不进行类型检查，也不进行编译器优化。
• 宏定义可以定义常量、函数、代码片段等。

(2)typedef关键字：

• typedef关键字用于为现有的类型创建一个新的类型别名。它使用typedef关键字后面跟着原有类型和新的类型别名来定义一个新类型。
• typedef定义的新类型是具有实际类型的，具有类型检查和作用域的特性。它可以用来简化类型的书写并提高代码的可读性。

(3)区别：

• 类型和检查：宏定义没有类型检查，而typedef关键字创建的类型别名是具有实际类型的，具有类型检查的能力。
• 作用域：宏定义是全局的，没有作用域限制，而typedef关键字创建的类型别名可以限定其作用域。
• 使用场景：宏定义通常用于定义常量、函数、代码片段等，而typedef主要用于为现有的类型创建一个新的类型别名，增加代码的可读性和可维护性。

47.用宏实现比较大小，以及两个数中的最小值

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

#define MIN(a, b) ((a) < (b) ? (a) : (b))

48.inline作用及使用方法

(1)inline关键字的作用：

• inline关键字用于告诉编译器将函数的定义直接插入到调用处，而不是通过函数调用的方式执行。这样可以减少函数调用的开销，提高程序的执行效率。
• inline关键字可以用于修饰函数的声明和定义，但它的作用是在编译器决定是否进行内联展开。

(2)inline关键字的使用方法：

• 在函数声明和定义之前加上inline关键字来指示编译器进行内联展开。
• 通常将函数的实现放在头文件中，以便编译器能够在调用处进行内联展开。
• 内联函数的定义通常放在头文件中，以便在每个使用该函数的文件中能够进行内联展开。

49.inline函数工作原理

(1)内联函数的工作原理：

• 内联函数的工作原理是通过将函数的定义插入到函数调用的地方来实现，而不是通过函数调用的方式执行。
• 当编译器遇到内联函数的调用时，它会将函数的定义直接插入到调用处，这样就避免了函数调用的开销。
• 内联函数在编译阶段进行展开，不会像普通函数一样在运行时进行函数调用。

(2)内联函数的特点：

• 内联函数通常适用于函数体较小且频繁调用的情况，例如简单的getter和setter函数。
• 内联函数的定义通常放在头文件中，以便编译器能够在每个使用该函数的地方进行内联展开。
• 内联函数可以提高程序的执行效率，减少函数调用的开销，但也可能导致代码膨胀和可维护性的降低。

50.define和inline的区别

(1)编译时机：

• 宏定义是在预处理阶段进行文本替换，编译器不会对宏进行类型检查和语法分析。
• 内联函数在编译阶段进行展开，编译器会对内联函数进行类型检查和语法分析。

(2)类型和作用域：

• 宏定义没有类型检查和作用域限制，它只是进行简单的文本替换。
• 内联函数具有实际的类型和作用域，它可以进行类型检查和作用域限制，提高代码的可读性和可维护性。

(3)使用场景：

• 宏定义通常用于定义常量、函数、代码片段等，例如实现简单的比较大小、最小值等功能。
• 内联函数适用于函数体较小且频繁调用的情况，可以提高程序的执行效率。

51.new和malloc的区别，delete和free的区别

(1)new和malloc的区别：

• new是C++中的运算符，malloc是C语言中的函数。
• new和malloc都用于在堆上动态分配内存，但它们的用法和功能有一些区别。
• new会调用构造函数来初始化分配的内存，而malloc只会返回分配内存的指针，不会进行初始化。
• new返回的是分配的对象类型的指针，而malloc返回的是void类型的指针。

(2)delete和free的区别：

• delete是C++中的运算符，free是C语言中的函数。
• delete和free都用于释放动态分配的内存，但它们的用法和功能有一些区别。
• delete会调用对象的析构函数来释放内存，并且可以正确处理对象数组的释放，而free只是简单地释放内存。
• delete需要与new配对使用，而free需要与malloc配对使用。

52.C和C++ struct 的区别？

(1)C和C++ struct的共同点：

• 在C和C++中，struct都是一种自定义数据类型，用于封装多个不同类型的变量。
• struct可以包含成员变量和成员函数（在C++中称为成员方法）。
• struct的成员变量可以是不同的数据类型，包括基本数据类型和其他自定义数据类型。

(2)C和C++ struct的区别：

• 在C中，struct只能包含成员变量，不能包含成员函数。
• 在C++中，struct除了可以包含成员变量外，还可以包含成员函数，即可以有自己的行为和操作。
• C++ struct中的成员函数可以访问struct的成员变量，也可以进行其他的操作。
• 在C++中，struct的默认访问修饰符是public，而在C中默认为private。

53.struct和union的区别

(1)数据类型：struct是一种用户自定义数据类型，用于组合多个不同类型的变量，每个变量都有自己的内存地址。而union也是一种用户自定义数据类型，但它的所有成员共享同一块内存地址，只能同时存储一个成员的值。

(2)内存分配：struct的内存分配是根据各个成员的大小和对齐方式来确定的，每个成员都会占用独立的内存空间。而union的内存分配只取决于最大成员的大小，所有成员共享同一块内存空间，节省了内存。

(3)成员访问：struct的各个成员可以同时访问，每个成员都有自己的内存地址和值。而union的各个成员共享同一块内存空间，只能访问存储在其中的一个成员的值。

(4)用途：struct常用于表示一组相关的数据，例如定义一个学生的结构体，包含姓名、年龄、成绩等信息。而union常用于节省内存，当某些变量只会在不同时间段内使用其中的一个时，可以使用union来共享内存，提高内存利用率。

总结：struct适用于需要同时存储多个不同类型的数据的情况，而union适用于需要节省内存、同时只存储一个成员值的情况。

54.class和struct 的异同

(1)默认访问权限：在struct中，默认的成员访问权限是public，而在class中，默认的成员访问权限是private。这意味着在struct中的成员可以被外部访问和修改，而在class中的成员只能通过public成员函数进行访问和修改。

(2)继承方式：在struct中，默认的继承方式是公有继承(public inheritance)，即派生类的所有成员都对外可见。而在class中，默认的继承方式是私有继承(private inheritance)，即派生类的所有成员都对外不可见。

(3)类型的语义：struct通常用于表示一种数据结构，强调数据的组合和访问。而class通常用于实现面向对象编程，强调数据和操作的封装。

(4)构造函数和析构函数：在struct中，可以有默认的构造函数和析构函数，如果没有提供，编译器会自动生成。而在class中，如果没有显式提供构造函数和析构函数，编译器也会自动生成默认的构造函数和析构函数。

(5)类型的默认继承权限：如果没有显式指定继承权限，struct继承的成员变量和成员函数的默认继承权限是public，而class继承的成员变量和成员函数的默认继承权限是private。

总结：struct和class在语法上非常相似，但默认的访问权限、继承方式和类型的语义等方面有一些不同。在实际使用中，选择使用struct还是class主要取决于数据的组织方式和访问控制的需求。

55.volatile的作用？

(1)保证可见性：volatile关键字用于告诉编译器，对于被volatile修饰的变量，在使用或修改时必须直接读取或写入内存，而不是使用寄存器缓存。这样可以保证变量的修改对于其他线程或中断的可见性，避免了编译器对变量的优化可能导致的意外行为。

(2)禁止优化：volatile关键字可以防止编译器对被修饰的变量进行优化。例如，当变量被多次读取时，编译器可能会认为变量的值不会发生变化，从而将变量的值缓存在寄存器中。但如果该变量是volatile修饰的，编译器就必须每次都直接读取内存中的值，而不是使用寄存器缓存。

(3)与硬件交互：在嵌入式系统或并发编程中，volatile关键字常用于与硬件或其他线程进行交互。当需要读取或写入硬件寄存器或共享变量时，使用volatile可以确保操作的顺序和结果符合预期。

需要注意的是，volatile关键字并不能保证线程安全，它只能保证可见性和禁止编译器优化。如果需要实现线程安全，还需要使用其他机制，例如互斥锁或原子操作。

56.什么情况下一定要用 volatile，能否和 const一起使用？

(1)多线程环境下访问共享变量：当多个线程同时访问同一个共享变量时，且其中至少一个线程对该变量进行了写操作，就需要使用volatile来确保对变量的读写操作不被编译器优化，以保证多个线程之间的可见性。

(2)中断处理：在嵌入式系统中，当变量被中断处理程序和主程序同时访问时，需要使用volatile来确保对变量的读写操作不被优化，以保证中断处理程序和主程序之间的正确交互。

(3)与硬件寄存器交互：当与硬件寄存器进行交互时，需要使用volatile来确保对寄存器的读写操作不被优化，以保证与硬件的正确通信。

至于volatile和const是否可以一起使用，答案是可以。volatile和const修饰符可以同时用于同一个变量。使用volatile修饰的变量表示该变量可能会被其他线程或中断修改，而使用const修饰的变量表示该变量的值是不可修改的。在某些特定场景下，可能会需要同时保证变量的可见性和不可修改性，这时候可以使用volatile const来修饰变量。这样可以确保变量的值不会被修改，并且对其他线程或中断的修改是可见的。

57.返回函数中静态变量的地址会发生什么？

返回函数中静态变量的地址可能会导致潜在的问题，主要体现在以下两个方面：

(1)生存期问题：静态变量的生存期是整个程序的运行期间，而函数内部的局部变量的生存期是在函数执行期间。当函数返回一个静态变量的地址时，虽然可以在函数外部继续访问该变量，但需要注意的是，该变量是在函数内部定义的，函数返回后，该变量的生存期已经结束了。因此，在使用返回的静态变量地址时，需要确保函数返回后该静态变量仍然有效。

(2)线程安全问题：如果多个线程同时调用该函数并返回静态变量的地址，那么这些线程将会共享同一个静态变量，可能会导致线程安全问题。如果多个线程同时对共享的静态变量进行写操作，可能会导致数据不一致或竞争条件的问题。因此，在多线程环境下，需要额外考虑对共享的静态变量进行线程安全的处理。

为了避免上述问题，可以考虑采用以下几种方式解决：

(1)将静态变量的定义放在函数外部，这样可以确保静态变量的生存期长于函数的执行期间。

(2)使用局部变量来存储需要返回的值，而不是返回静态变量的地址。这样可以避免生存期和线程安全问题。

(3)在多线程环境下，通过加锁或使用原子操作等手段来保证对静态变量的访问的线程安全性。

总之，返回函数中静态变量的地址需要谨慎处理，需要考虑生存期和线程安全问题，以及合适的解决方案来避免潜在的问题。

58.extern "C"的作用？

extern "C"是用于指定函数或变量的C链接约定，其作用主要有两个方面：

(1)C++和C语言的混合编程：在C++中调用C语言的函数时，由于C++对函数名进行了重载和名称修饰，导致C++编译器生成的函数名与C语言的函数名不一致，无法直接调用。使用extern "C"修饰函数声明时，可以告诉C++编译器按照C语言的链接约定来处理函数，从而实现C++和C语言的混合编程。

(2)链接库的兼容性：在编写链接库时，为了保证链接库在不同的编译环境中能够正常链接和使用，需要使用extern "C"来指定链接库中的函数和变量的链接约定为C。这样可以确保链接库的函数名和变量名在不同的编译环境中保持一致，避免链接错误或符号冲突。

需要注意的是，extern "C"只能用于函数和变量的声明，而不能用于类的声明。当使用extern "C"修饰函数或变量时，编译器将按照C语言的链接约定来处理其名称，包括名称修饰、调用约定等，以实现与C语言的兼容性。

总结：extern "C"的主要作用是实现C++和C语言的混合编程以及保证链接库的兼容性，通过指定函数和变量的C链接约定来实现名称的一致性和可链接性。

59.sizeof(1==1) 在C和C++ 中分别是什么结果？

在C和C++中，sizeof(1==1)的结果分别是：

• 在C中，sizeof(1==1)的结果是int类型的大小，通常为4字节。

• 在C++中，sizeof(1 == 1)的结果是bool类型的大小，通常为1字节。

这是因为在C中，(1 == 1) 表达式的结果是int类型的1，所以sizeo(1 == 1)等于sizeof(int)。而在C++中，(1 == 1)表达式的结果是bool类型的true，所以sizeof(1 == 1)等于sizeof(bool)。

需要注意的是，sizeof操作符返回的是表达式或类型的字节大小，而不是该表达式或类型的值。所以无论表达式的结果是什么，sizeof操作符都只返回其字节大小。

总结：sizeof(1==1)在C中返回int类型的大小，在C++中返回bool类型的大小。这是由于C和C++对表达式的类型推导规则不同所导致的。

60.strcpy 函数有什么缺陷？

strcpy函数是用于将一个字符串复制到另一个字符串的函数，但它存在以下几个缺陷：

(1)内存溢出：strcpy函数没有对目标字符串的长度进行检查，如果源字符串的长度超过了目标字符串的空间大小，会导致目标字符串的内存溢出，可能会破坏其他内存数据或导致程序崩溃。

(2)字符串结束符问题：strcpy函数只会复制源字符串中的字符，但不会复制源字符串的结束符’\0’。如果目标字符串没有足够的空间来存储源字符串的结束符，会导致目标字符串没有正确的结束标志，可能会引发字符串处理的错误。

(3)不安全的字符串操作：由于strcpy函数没有对目标字符串的长度进行检查，容易造成缓冲区溢出漏洞。这种漏洞可能会被恶意利用，导致程序的安全性问题。

为了避免strcpy函数的缺陷，可以采用更安全的字符串操作函数，如strncpy函数，它可以指定复制的最大长度，并自动添加字符串结束符。另外，在C++中，可以使用更安全和方便的字符串类（如std::string）来代替C风格字符串的操作，它提供了更好的安全性和易用性。

总结：strcpy函数存在内存溢出、字符串结束符问题和不安全的字符串操作等缺陷。为了避免这些问题，可以使用更安全的字符串操作函数或C++中的字符串类。

61.虚函数的实现机制

在C++中，虚函数是实现多态性的关键机制之一。虚函数的实现通过虚函数表（vtable）和虚函数指针（vptr）来实现。

(1)虚函数表（vtable）：每个包含虚函数的类都会创建一个虚函数表，其中存储了该类的虚函数的地址。虚函数表是一个指针数组，每个元素对应一个虚函数。对于每个对象，都会有一个指向虚函数表的虚函数指针。

(2)虚函数指针（vptr）：每个类的对象都会自动添加一个隐藏的虚函数指针vptr。vptr指向该类的虚函数表。当通过对象调用虚函数时，实际上是通过vptr找到对应的虚函数表，然后根据函数在表中的位置调用相应的虚函数。

(3)动态绑定：通过虚函数的实现，可以实现动态绑定。即在运行时根据对象的实际类型来确定调用哪个虚函数，而不仅仅是根据指针或引用的静态类型。这样可以实现多态性，让不同的派生类对象调用相同的虚函数时，根据实际类型执行相应的函数。

需要注意的是，虚函数的使用需要满足一定的条件，包括函数声明为虚函数、通过指针或引用来调用虚函数等。

总结：虚函数的实现机制通过虚函数表和虚函数指针来实现，通过动态绑定实现运行时多态性。这是C++中实现面向对象编程中的重要机制之一。

62.单继承和多继承的虚函数表结构

单继承无虚函数覆盖的情况：
单继承有虚函数覆盖的情况：
多继承无虚函数覆盖的情况：
多继承有虚函数覆盖的情况：

63.构造函数、析构函数是否需要定义成虚函数？为什么？

构造函数和析构函数一般不需要定义为虚函数，因为虚函数的主要作用是实现运行时多态性，而构造函数和析构函数具有特殊的语义和用途，与多态性的需求不同。

(1)构造函数：构造函数用于创建对象并初始化其成员变量。构造函数在对象创建时自动调用，且在对象的生命周期中只调用一次。由于构造函数的调用是在对象的内存空间分配之前进行的，因此无法通过虚函数的机制来实现多态性。而且，将构造函数定义为虚函数可能导致一些潜在的问题，如虚函数表的指针在对象创建过程中可能无法正确初始化，可能导致程序的行为不可预测。

(2)析构函数：析构函数用于在对象被销毁时执行清理操作，如释放资源或删除对象的相关数据。析构函数在对象销毁时自动调用，且在对象的生命周期中只调用一次。由于析构函数的调用是在对象的内存空间释放之后进行的，与构造函数相似，也无法通过虚函数的机制来实现多态性。而且，将析构函数定义为虚函数可能会导致不必要的性能开销，因为在析构对象时需要查找并调用正确的析构函数。

需要注意的是，在某些情况下，如果存在基类指针指向派生类对象，并且需要通过基类指针来删除派生类对象时，可以将析构函数定义为虚函数，以确保正确调用派生类的析构函数。

总结：构造函数和析构函数一般不需要定义为虚函数，因为它们的特殊语义和用途与多态性的需求不同。在一些特定情况下，需要通过基类指针删除派生类对象时，可以将析构函数定义为虚函数。

64.为什么拷贝构造函数必须为引用？

拷贝构造函数必须使用引用作为参数，因为拷贝构造函数的主要目的是创建一个新对象并将其初始化为已有对象的副本。通过使用引用作为参数，可以避免无限递归的拷贝构造函数调用。

如果将拷贝构造函数的参数声明为非引用类型，那么每次调用拷贝构造函数时，会触发另一次拷贝构造函数的调用，这将导致无限递归，最终导致栈溢出或程序崩溃。

拷贝构造函数的参数使用引用类型可以实现以下两点：

(1)避免无限递归：使用引用作为参数可以确保在拷贝构造函数的调用过程中，只会进行一次拷贝构造操作，而不会进入无限递归的循环。

(2)传递对象的地址而不是值：通过引用，可以传递对象的地址而不是对象的值，这样可以避免创建新的临时对象，提高了拷贝构造函数的效率。

需要注意的是，拷贝构造函数的参数使用const引用是一种常见的做法，因为在拷贝构造函数中通常不会修改原始对象的值。使用const引用可以确保拷贝构造函数不会对原始对象进行修改。

总结：拷贝构造函数必须使用引用作为参数，以避免无限递归的调用和提高效率。常见的做法是使用const引用作为拷贝构造函数的参数，以确保不会对原始对象进行修改。

65.C++类对象的初始化顺序

在C++中，类对象的初始化顺序是由其成员变量在类中声明的顺序决定的。具体来说，类对象的初始化分为两个阶段：成员变量的初始化和构造函数的执行。

(1)成员变量的初始化：成员变量按照它们在类中声明的顺序进行初始化。如果成员变量是基本类型或具有默认构造函数的类类型，它们会在进入构造函数之前被默认初始化。如果成员变量是具有自定义构造函数的类类型，它们会在进入构造函数之前调用相应的构造函数进行初始化。这意味着，在进入构造函数之前，成员变量的构造顺序与它们在类中的声明顺序一致。

(2)构造函数的执行：一旦成员变量初始化完成，就会调用类的构造函数。构造函数按照其被调用的顺序执行，与成员变量的初始化顺序无关。

需要注意的是，如果类中存在继承关系，派生类的构造函数在初始化列表中会先调用基类的构造函数，然后再执行自身的构造函数体。这保证了基类在派生类之前完成初始化。

总结：类对象的初始化顺序取决于成员变量在类中声明的顺序。成员变量按照声明顺序进行初始化，然后调用构造函数。在继承关系中，派生类的构造函数会先调用基类的构造函数，然后再执行自身的构造函数体。

66.如何禁止一个类被实例化？

在C++中，可以通过以下几种方法来禁止一个类被实例化：

(1)将构造函数声明为私有：将类的构造函数声明为私有（private），这样外部代码就无法直接创建类的实例。可以通过声明一个静态成员函数或友元函数来提供对该类的访问和实例化控制。

(2)将构造函数声明为删除（deleted）：C++11引入了删除函数（deleted function）的语法，可以通过在构造函数声明后添加= delete来将其声明为删除的。这样一来，任何尝试实例化该类的代码都会在编译时产生错误。

(3)使用抽象基类（纯虚函数）：将类定义为抽象基类，即至少包含一个纯虚函数。抽象基类无法被实例化，只能被继承，并重写纯虚函数以实现子类的具体功能。

(4)使用命名空间：将类放在命名空间中，然后将构造函数声明为私有。通过这种方式，类只能通过命名空间中的其他函数进行访问和实例化。

需要根据具体的需求和设计目标选择合适的方法来禁止类的实例化。其中，将构造函数声明为私有是一种常见的做法，因为它可以在类内部控制实例化的条件和方式。而使用抽象基类或将构造函数声明为删除的方式则更加明确地表达了禁止实例化的意图。

总结：禁止一个类被实例化的方法包括将构造函数声明为私有、将构造函数声明为删除、使用抽象基类或将类放在命名空间中。根据具体的需求和设计目标选择合适的方法来确保类无法被实例化。

67.为什么用成员初始化列表会快一些？

使用成员初始化列表可以提高代码的效率和性能，主要有以下几个原因：

(1)避免不必要的默认构造和赋值操作：成员初始化列表可以在对象创建时直接初始化成员变量，而不是先调用默认构造函数创建一个临时对象，然后再调用赋值运算符进行赋值操作。通过避免不必要的构造和赋值操作，可以减少了临时对象的创建和销毁，提高代码的性能。

(2)直接初始化成员变量：成员初始化列表可以直接初始化成员变量，而不是在构造函数体中对成员变量进行赋值。这样可以避免了两次对成员变量的操作，提高了代码的效率。

(3)初始化顺序控制：成员初始化列表可以控制成员变量的初始化顺序，而不是依赖于它们在类中的声明顺序。这对于某些依赖于其他成员变量的成员初始化非常重要，可以确保正确的初始化顺序，避免了潜在的错误。

需要注意的是，成员初始化列表只能在构造函数中使用，且只能用于初始化成员变量，不能用于初始化静态成员变量或局部变量。

总结：使用成员初始化列表可以避免不必要的默认构造和赋值操作，直接初始化成员变量，并且可以控制初始化顺序。这样可以提高代码的效率和性能。在编写构造函数时，应该优先考虑使用成员初始化列表来进行成员变量的初始化。

68.实例化一个对象需要哪几个阶段

在C++中，实例化一个对象通常包括以下几个阶段：

(1)分配内存：在实例化对象之前，需要先为对象分配内存空间。这个过程由C++运行时系统自动完成，根据类的大小分配合适的内存空间。

(2)调用构造函数：分配内存后，会调用对象的构造函数进行对象的初始化。构造函数是一种特殊的成员函数，用于初始化对象的成员变量和执行其他必要的操作。构造函数的调用由编译器自动完成，无需手动调用。

(3)执行构造函数体：在构造函数被调用后，会执行构造函数体中的代码。构造函数体是构造函数的一部分，用于执行用户自定义的初始化操作。

(4)返回对象实例：构造函数执行完成后，会返回一个完全初始化的对象实例。这样就完成了对象的实例化过程。

需要注意的是，实例化一个对象的过程由C++编译器和运行时系统自动完成，无需手动干预。在对象实例化过程中，构造函数起着重要的作用，它负责对象的初始化和必要的操作。

总结：实例化一个对象包括分配内存、调用构造函数、执行构造函数体和返回对象实例等阶段。构造函数起着重要的作用，负责对象的初始化和必要的操作。在使用对象时，我们只需关注对象的实例化和使用，而不需要手动进行对象的内存分配和构造函数的调用。

69.友元函数的作用及使用场景

友元函数是一种特殊的函数，可以访问类的私有成员和保护成员。友元函数的作用是增强了类的灵活性和封装性，同时也提供了一种特殊的访问权限。

友元函数的使用场景主要有以下几种：

(1)访问类的私有成员：友元函数可以访问类的私有成员，这样可以在需要访问私有成员的函数中直接使用，而无需通过公有成员函数进行间接访问。这在一些特殊情况下很有用，例如需要重载运算符时，可以使用友元函数来访问类的私有成员。

(2)提供类与类之间的非成员函数接口：友元函数可以被多个类声明为友元，从而实现类与类之间的非成员函数接口。这样可以在不违反封装性的前提下，实现类之间的通信和协作。

(3)简化代码逻辑：有时候，某个函数需要访问多个类的私有成员，如果不使用友元函数，就需要在每个类中都提供公有成员函数来访问其他类的私有成员。而使用友元函数可以将这些操作集中在一个函数中，简化了代码逻辑，提高了代码的可读性和可维护性。

需要注意的是，友元函数的使用应该谨慎，避免滥用。过多使用友元函数可能会破坏类的封装性和抽象性，导致代码难以维护和理解。因此，在使用友元函数时，应该根据具体的需求和设计目标，合理地选择和使用。

总结：友元函数的作用是增强了类的灵活性和封装性，可以访问类的私有成员，提供类与类之间的非成员函数接口，简化代码逻辑。在使用友元函数时，应该谨慎使用，避免滥用，保持类的封装性和抽象性。

70.静态绑定和动态绑定是怎么实现的？

静态绑定和动态绑定是面向对象编程中的两种不同的方法来确定函数的调用。

(1)静态绑定（静态多态）：静态绑定是在编译时确定函数的调用。它是通过函数的静态类型来确定要调用的函数。静态类型是指变量或表达式在编译时所声明的类型。在静态绑定中，编译器根据变量或表达式的静态类型来选择调用哪个函数。静态绑定主要用于非虚函数和静态成员函数。

(2)动态绑定（动态多态）：动态绑定是在运行时确定函数的调用。它是通过函数的动态类型来确定要调用的函数。动态类型是指变量或表达式在运行时所实际指向的对象的类型。在动态绑定中，编译器先根据变量或表达式的静态类型找到对应的虚函数表，然后在虚函数表中查找要调用的函数。动态绑定主要用于虚函数和纯虚函数。

实现静态绑定和动态绑定的关键在于虚函数表（vtable）和虚函数指针（vptr）的机制。虚函数表是一个存储虚函数地址的表格，每个对象都有一个虚函数表。虚函数指针是一个指向虚函数表的指针，它被添加到每个对象的内存布局中。通过虚函数指针和虚函数表的配合，可以在运行时动态地确定要调用的函数。

需要注意的是，静态绑定和动态绑定是相对的概念，它们都是多态的不同表现形式。静态绑定适用于编译时已知的类型，而动态绑定适用于运行时确定的类型。

总结：静态绑定是在编译时确定函数的调用，动态绑定是在运行时确定函数的调用。静态绑定通过静态类型来确定函数，动态绑定通过动态类型和虚函数表机制来确定函数。静态绑定适用于非虚函数和静态成员函数，动态绑定适用于虚函数和纯虚函数。

71.编译时多态和运行时多态的区别

编译时多态和运行时多态是多态的两种不同表现形式，它们在多态的实现方式和发生的时间点上有所不同。

(1)编译时多态：也称为静态多态，是在编译时确定函数的调用。通过函数的静态类型来确定要调用的函数。在编译时多态中，编译器根据变量或表达式的静态类型来选择调用哪个函数。这种多态是通过函数的重载、模板和宏等机制实现的。编译时多态的特点是效率高，因为函数的调用在编译时已经确定，无需在运行时进行查找。

(2)运行时多态：也称为动态多态，是在运行时确定函数的调用。通过函数的动态类型来确定要调用的函数。在运行时多态中，编译器先根据变量或表达式的静态类型找到对应的虚函数表，然后在虚函数表中查找要调用的函数。这种多态是通过虚函数和纯虚函数机制实现的。运行时多态的特点是灵活性高，因为函数的调用是在运行时根据对象的实际类型来确定的。

需要注意的是，编译时多态和运行时多态是相对的概念，它们都是多态的不同表现形式。编译时多态适用于函数重载、模板和宏等静态多态的机制，函数的调用在编译时已经确定。运行时多态适用于虚函数和纯虚函数机制，函数的调用是在运行时根据对象的实际类型来确定的。

总结：编译时多态是在编译时确定函数的调用，运行时多态是在运行时确定函数的调用。编译时多态通过静态类型来确定函数，运行时多态通过动态类型和虚函数表机制来确定函数。编译时多态适用于函数重载、模板和宏等静态多态的机制，运行时多态适用于虚函数和纯虚函数机制。

72.如何让类不能被继承？

要让类不能被继承，可以使用C++中的关键字final来修饰该类。final关键字可以放在类的声明中，在类的声明中使用final修饰的类不能被其他类继承。

73.左值和右值的区别？

在C++中，左值和右值是表达式的两种不同类型，它们在赋值和求值的过程中有所不同。

(1)左值（Lvalue）：指的是具有标识符的表达式，或者说是可以被取地址的表达式。左值可以出现在赋值语句的左边或右边。左值可以被读取和修改，且具有持久的状态。例如，变量、数组元素、对象成员等都是左值。

(2)右值（Rvalue）：指的是不能被取地址的表达式，或者说是临时的、无法被保存的值。右值只能出现在赋值语句的右边。右值可以被读取，但不能被修改。例如，常量、字面量、临时对象等都是右值。

在C++11中，引入了右值引用（Rvalue reference）的概念，它与左值引用（Lvalue reference）相对应。右值引用允许我们绑定到右值，并且可以通过移动语义来实现高效的资源管理和移动语义。

需要注意的是，C++11还引入了移动语义和转移构造函数等特性，它们可以通过右值引用来实现对资源的高效转移。

总结：左值是具有标识符的表达式，可以被取地址，具有持久状态；右值是临时的、无法被保存的值，不能被取地址。右值引用可以绑定到右值，并通过移动语义实现高效的资源管理和转移。

74.如何将左值转换成右值？

在C++中，可以通过以下几种方式将左值转换为右值：

(1)移动语义：通过使用std::move函数，可以将一个左值强制转换为右值。std::move函数将传入的左值引用转换为右值引用，从而允许对其进行移动操作而不是拷贝操作。这在处理动态分配的内存、资源所有权转移等情况下非常有用。

(2)前缀自增运算符：通过前缀自增运算符（++）可以将左值转换为右值。当对一个左值应用前缀自增运算符时，运算符会返回一个右值，其值为运算前的原始左值。

(3)函数返回值：当一个函数返回一个非引用类型的左值时，该左值会被转换为右值。这是因为函数返回值是一个临时对象，没有与其绑定的名称，因此它可以被当作右值使用。

需要注意的是，将左值转换为右值是为了更高效地进行资源管理和移动操作。

75.std::move() 函数的实现原理

std::move()函数是C++11引入的一个标准库函数，其作用是将传入的左值引用转换为右值引用。std::move()的实现原理其实很简单，它本质上只是一个强制类型转换。

std::move()函数的定义如下：

template <class T>
typename std::remove_reference<T>::type&& move(T&& arg) noexcept
{
    return static_cast<typename std::remove_reference<T>::type&&>(arg);
}

该函数使用了模板和类型萃取技术。主要包括以下几个步骤：

通过typename std::remove_reference::type，获取arg的实际类型，去除了可能存在的引用。

使用static_cast，将arg转换为右值引用。这里使用了右值引用的语法&&。

最后，将转换后的结果作为函数的返回值返回。

需要注意的是，std::move()函数并不进行任何实质性的移动操作，它只是将传入的左值引用强制转换为右值引用，从而允许对其进行移动操作而不是拷贝操作。

std::move()函数的实现原理本质只是一个类型转换，并非进行实际的移动操作。同时，C++11引入std::move()函数的目的是为了支持移动语义，提高代码性能和效率。

76.C++11 nullptr比 NULL 优势

在C++11中引入的nullptr是一个空指针常量，用于表示空指针。相比于早期C++中使用的NULL宏，nullptr具有以下几个优势：

(1)类型安全：nullptr是一个特殊的空指针常量，它被定义为指针类型nullptr_t的字面值。与NULL宏相比，nullptr具有明确的类型，可以通过类型检查来避免一些潜在的错误。

(2)可重载性：nullptr是一个真正的常量，可以进行重载。这意味着可以根据需要为nullptr定义自定义的行为，例如重载比较操作符，使得空指针的比较更加灵活。

(3)清晰明了：nullptr更加清晰明了地表示空指针的概念。与NULL相比，nullptr更符合语义，更易于理解和阅读代码。

(4)与模板的兼容性：nullptr可以与模板一起使用，而NULL宏可能会导致一些模板实例化的问题。因为nullptr具有明确的类型，并且可以进行类型推导，所以在使用模板时更加灵活和安全。

需要注意的是，nullptr只能用于指针类型，而不能用于整数类型。如果需要表示空整数，仍然需要使用NULL或者字面值0。

总结：nullptr比NULL具有类型安全、可重载性、清晰明了和与模板的兼容性等优势。它是一个特殊的空指针常量，可以更好地表示空指针的概念，并且在语法和语义上更加清晰和灵活。

77.指针和引用的区别？

指针和引用都是C++中用于处理内存和变量的重要工具，它们之间有以下几个区别：

(1)定义和初始化：指针是一个变量，用于存储某个对象的内存地址。它需要通过取地址符&来获取对象的地址，并使用指针运算符*来访问对象。而引用是一个别名，用于绑定到已经存在的对象。引用在定义时必须进行初始化，并且不能改变绑定的对象。

(2)空值：指针可以具有空值（nullptr或NULL），表示指针没有指向任何对象。而引用必须始终绑定到一个有效的对象，不能为空。

(3)可重新赋值性：指针可以在其生命周期内重新指向不同的对象，可以通过重新赋值来改变指针指向的对象。而引用在初始化后不能再绑定到其他对象，一旦绑定后就不能改变绑定的对象。

(4)空间占用：指针本身需要占用内存空间来存储地址值。而引用不需要额外的内存空间，它只是作为已经存在的对象的别名。

(5)空间操作：通过指针可以进行指针运算（比如指针加减、指针比较等），可以方便地访问数组和动态内存分配等。而引用没有指针运算的能力，只能直接访问绑定对象的成员。

(6)使用场景：指针通常用于需要动态分配内存、需要在函数间传递对象、或者需要在函数内部修改对象的情况下。而引用通常用于作为函数参数、返回值、或者用于遍历容器等情况下。

需要注意的是，指针和引用都是C++中非常重要的语言特性，它们各自有自己的用途和适用场景。在具体的编程任务中，需要根据具体情况选择使用指针或引用来处理对象和内存。

78.switch 的 的 case 里为何不能定义变量

在C++中，switch语句是一种条件语句，用于根据不同的情况执行不同的代码块。在switch的case语句中，我们只能执行一系列语句，而不能定义变量。

这是因为switch的case语句中的代码块并不是一个独立的作用域，它们共享相同的作用域。在同一个作用域中定义多个具有相同名称的变量是非法的，因为这会导致冲突和不确定的行为。

为了避免这种冲突和不确定性，C++标准规定在switch的case语句中不能定义变量。如果需要在case语句中使用变量，可以事先在外部作用域中定义该变量，然后在case语句中进行使用。

需要注意的是，在C++17之后，我们可以在case语句中使用初始化语句，但该语句只能用于初始化已经在外部作用域中定义的变量，而不能定义新的变量。

79.常量指针和指针常量的区别

常量指针和指针常量是C++中用于描述指针的两种不同的类型修饰方式。

常量指针（const pointer）：常量指针是指指针本身是不可修改的，但可以通过该指针来修改所指向的数据。即指针指向的内容可以被修改，但指针本身不能指向其他地址。

const int* ptr;

在上述示例中，ptr是一个指向常量的指针，即ptr所指向的数据是常量，不能通过ptr来修改所指向的数据。

指针常量（pointer to const）：指针常量是指指针所指向的数据是不可修改的，但可以修改指针本身的值，即可以指向其他地址。

int* const ptr;

在上述示例中，ptr是一个常量指针，即ptr本身是常量，不能指向其他地址，但可以通过ptr来修改所指向的数据。

需要注意的是，常量指针和指针常量的区别在于修饰的是指针本身还是指针所指向的数据。常量指针强调不能通过指针来修改所指向的数据，而指针常量强调指针本身的值是不可修改的。

80.函数指针和指针函数的区别

函数指针和指针函数是C++中用于描述函数的两种不同的类型修饰方式。

函数指针（function pointer）：函数指针是指指向函数的指针变量。通过函数指针，我们可以在程序运行时动态地调用不同的函数。函数指针的类型与所指向的函数的返回类型和参数类型相匹配。

int (*funcPtr)(int, int);

在上述示例中，funcPtr是一个函数指针，指向一个返回类型为int、有两个int类型参数的函数。

指针函数（pointer to function）：指针函数是指函数本身返回一个指针。指针函数可以根据调用的参数动态地生成并返回一个指针。指针函数的类型与返回的指针类型匹配。

int* ptrFunc(int, int);

在上述示例中，ptrFunc是一个指针函数，返回一个指向int类型的指针。

需要注意的是，函数指针和指针函数的区别在于修饰的是指针变量还是函数本身的返回值。函数指针用于指向函数，并通过指针调用相应的函数，而指针函数则是函数本身返回一个指针。

81.参数传递时，值传递、引用传递、指针传递的区别？

值传递、引用传递和指针传递是三种常见的参数传递方式，它们之间的主要区别如下：

(1)值传递：将参数的值拷贝给函数的形参。在函数内部修改形参的值不会影响原始参数的值。值传递适用于参数较小的基本类型或不希望修改原始参数的情况。

(2)引用传递：将参数的引用作为函数的形参。通过引用传递，函数可以直接访问并修改原始参数的值。引用传递适用于需要修改原始参数的值，但不需要额外的内存开销的情况。

(3)指针传递：将参数的指针作为函数的形参。通过指针传递，函数可以通过解引用操作来访问和修改原始参数的值。指针传递适用于需要修改原始参数的值，并且可能需要进行动态内存分配或者在函数内部修改指针的情况。

需要注意的是，值传递会进行一次拷贝，可能会产生额外的开销，特别是在传递较大的对象时。而引用传递和指针传递可以避免拷贝，可以更高效地传递参数。

在选择参数传递方式时，可以根据以下几个因素来决定：

• 对于基本类型或小型对象，可以选择值传递，因为拷贝的开销相对较小。
• 对于需要修改原始参数的值，且不希望拷贝开销的情况，可以选择引用传递。
• 对于需要动态内存分配或者在函数内部修改指针的情况，可以选择指针传递。

需要根据具体的需求和场景，选择合适的参数传递方式，以达到性能和功能上的最佳平衡。

总结：值传递、引用传递和指针传递是三种常见的参数传递方式。值传递进行值的拷贝，不会修改原始参数的值；引用传递通过引用直接访问和修改原始参数的值；指针传递通过指针来访问和修改原始参数的值。在选择参数传递方式时，可以根据对象大小、是否需要修改参数值以及是否需要动态内存分配等因素来决定。

82.什么是模板？如何实现？

模板是C++中的一种特殊机制，它允许我们编写通用的代码，可以根据不同的数据类型来生成对应的具体代码。通过使用模板，我们可以在不重复编写相似代码的情况下，实现对不同数据类型的支持。

在C++中，模板可以用于函数模板和类模板两种形式。

函数模板（Function Template）：函数模板是一种通用的函数定义，它使用了一个或多个类型参数，这些类型参数可以在函数定义中使用。通过编译器在代码实例化时根据传入的实际类型来生成具体的函数。

函数模板的定义方式如下：

template <typename T>
void myFunction(T arg) {
    // 函数定义
}

在上述示例中，T是一个类型参数，它可以在函数定义中使用。通过在调用时传入不同的类型，编译器会自动生成对应类型的具体函数。

类模板（Class Template）：类模板是一种通用的类定义，它使用了一个或多个类型参数，这些类型参数可以在类定义中使用。通过编译器在代码实例化时根据传入的实际类型来生成具体的类。

类模板的定义方式如下：

template <typename T>
class MyClass {
    // 类定义
};

在上述示例中，T是一个类型参数，它可以在类定义中使用。通过在实例化时传入不同的类型，编译器会自动生成对应类型的具体类。

需要注意的是，模板的实现需要放在头文件中，因为编译器需要在每个使用模板的地方进行实例化。

83.函数模板和类模板的区别？

函数模板和类模板是C++中用于实现通用代码的两种不同的模板形式。

函数模板（Function Template）：函数模板是一种通用的函数定义，它使用了一个或多个类型参数，这些类型参数可以在函数定义中使用。通过编译器在代码实例化时根据传入的实际类型来生成具体的函数。

函数模板的定义方式如下：

template <typename T>
void myFunction(T arg) {
    // 函数定义
}

在上述示例中，T是一个类型参数，它可以在函数定义中使用。通过在调用时传入不同的类型，编译器会自动生成对应类型的具体函数。

类模板（Class Template）：类模板是一种通用的类定义，它使用了一个或多个类型参数，这些类型参数可以在类定义中使用。通过编译器在代码实例化时根据传入的实际类型来生成具体的类。

类模板的定义方式如下：

template <typename T>
class MyClass {
    // 类定义
};

在上述示例中，T是一个类型参数，它可以在类定义中使用。通过在实例化时传入不同的类型，编译器会自动生成对应类型的具体类。

函数模板和类模板的区别主要在于其定义的对象不同。函数模板定义的是函数，通过在调用时传入不同的类型来生成具体的函数。而类模板定义的是类，通过在实例化时传入不同的类型来生成具体的类。

此外，函数模板和类模板还有一些使用上的差异，比如函数模板可以使用模板特化和模板偏特化等技术，而类模板则可以使用成员模板和模板友元等特性。

84.什么是可变参数模板？

可变参数模板是C++11引入的一种特性，它允许我们编写能够接受任意数量和任意类型参数的模板函数或模板类。

在C++中，可变参数模板通过使用…语法来实现。通过在模板参数列表中添加…，我们可以将参数列表定义为可变长度的。

可变参数模板可以用于函数模板和类模板两种形式。

可变参数函数模板（Variadic Function Template）：可变参数函数模板是一种能够接受任意数量和任意类型参数的函数模板。通过使用参数包（parameter pack）的语法，我们可以在函数定义中处理这些可变参数。

可变参数函数模板的定义方式如下：

template <typename... Args>
void myFunction(Args... args) {
    // 函数定义
}

在上述示例中，Args是一个参数包，它可以代表任意数量和任意类型的参数。我们可以通过展开参数包的方式，在函数定义中处理这些可变参数。

可变参数类模板（Variadic Class Template）：可变参数类模板是一种能够接受任意数量和任意类型参数的类模板。通过使用参数包的语法，我们可以在类定义中处理这些可变参数。

可变参数类模板的定义方式如下：

template <typename... Args>
class MyClass {
    // 类定义
};

在上述示例中，Args是一个参数包，它可以代表任意数量和任意类型的参数。我们可以通过展开参数包的方式，在类定义中处理这些可变参数。

可变参数模板的使用非常灵活，我们可以在模板定义中使用递归、展开参数包等技术来实现对可变参数的处理。

85.什么是模板特化？为什么特化？

模板特化（Template Specialization）是C++中一种特殊的模板机制，它允许我们为特定的类型或特定的模板参数提供特定的实现。

模板特化是通过使用template <>语法来定义的，其中<>中可以指定特定的类型或模板参数。

模板特化的目的是为了处理某些特定类型或特定参数的情况，因为对于特定的类型或参数，通用的模板实现可能不够有效或不符合预期。

模板特化有两种形式：全特化（Full Specialization）和偏特化（Partial Specialization）。

全特化（Full Specialization）：全特化是对特定类型或特定参数提供完全独立的特化实现。在全特化中，我们需要完整地重新定义模板，并为特定的类型或参数提供具体的实现。

全特化的定义方式如下：

template <>
void myFunction<int>(int arg) {
    // 特化实现
}

在上述示例中，我们通过template <>语法来指定了特化的类型为int，然后在函数定义中提供了该类型的特化实现。

偏特化（Partial Specialization）：偏特化是对特定模板参数的特化实现。在偏特化中，我们通过使用部分参数的形式来提供特化实现。

偏特化的定义方式如下：

template <typename T>
class MyClass<T*> {
    // 偏特化实现
};

在上述示例中，我们通过<T*>的形式来指定了偏特化的模板参数为指针类型，然后在类定义中提供了该参数的特化实现。

模板特化的目的是为了处理某些特定的类型或参数情况，因为对于这些情况，通用的模板实现可能无法满足需求或不够高效。通过针对特定的类型或参数提供特化实现，我们可以在这些特定情况下获得更好的性能或更精确的行为。

86.include " " 和 和 <> 的区别

在C++中，#include是用来包含头文件的预处理指令。头文件是一种包含声明和定义的文件，它通常包含了函数、类、变量等的声明和定义。

在#include中，我们可以使用两种不同的方式来指定要包含的头文件：使用双引号""和使用尖括号<>。它们之间有以下几个区别：

(1)使用双引号""：当我们使用双引号""来包含头文件时，编译器会首先在当前源文件所在的目录中查找该头文件。如果找不到，则会继续在编译器指定的系统路径中查找。

#include "myheader.h"

在上述示例中，编译器会首先在当前源文件所在目录中查找myheader.h头文件。

(2)使用尖括号<>：当我们使用尖括号<>来包含头文件时，编译器会直接在编译器指定的系统路径中查找该头文件。通常，这些路径是由编译器配置的系统路径或用户自定义的路径。

#include <iostream>

在上述示例中，编译器会在系统路径中查找iostream头文件。

总结：使用双引号""用于包含自定义的头文件，而使用尖括号<>用于包含系统提供的头文件。

87.迭代器的作用？

迭代器（Iterator）是C++中一种用于遍历和操作容器（如数组、链表、向量等）元素的对象。它提供了一种统一的访问容器元素的方式，无论容器的具体类型如何，我们都可以通过迭代器来遍历和修改容器中的元素。

迭代器的作用有以下几个方面：

(1)遍历容器：迭代器允许我们按顺序遍历容器中的元素，从而可以对容器中的每个元素执行相同的操作或获取相应的值。

(2)访问容器元素：通过迭代器，我们可以访问容器中的元素，无论是读取元素的值还是修改元素的值。

(3)插入和删除元素：迭代器提供了插入和删除元素的功能，我们可以在指定位置插入新元素或删除指定位置的元素。

(4)支持泛型编程：迭代器是C++中泛型编程的重要组成部分。通过使用迭代器，我们可以编写通用的算法，而不需要知道容器的具体类型。

(5)提供容器操作的一致接口：迭代器为不同类型的容器提供了一种统一的访问方式，使得我们可以使用相同的语法和操作来访问不同类型的容器。

总结：迭代器提供了一种统一的访问容器元素的方式，通过迭代器，我们可以遍历容器、访问容器元素、插入和删除元素，支持泛型编程，并提供了一致的容器操作接口。

88.泛型编程如何实现？

(1)模板：泛型编程的核心概念是使用模板（template）。C++中的模板是一种用于生成通用代码的机制，它可以根据不同的类型参数来生成具体的代码。
(2)类模板：类模板可以通过参数化类型来创建通用的类。通过将类型参数化，可以实现在不同类型上执行相同操作的代码。
(3)函数模板：函数模板是一种将函数定义为通用代码的方式。通过使用模板参数，可以在不同类型上实现相同的操作，提高代码的复用性。
(4)模板特化：模板特化是一种对特定类型或特定类型组合的模板进行特殊处理的机制。通过为特定类型提供特定的实现，可以使代码更加灵活和高效。
5. 模板元编程：模板元编程是一种使用模板和编译时计算的技术，可以在编译时进行复杂的计算和类型检查。这种技术可以用于实现元编程、静态多态性等高级功能。

89.什么是类型萃取？

(1)类型萃取的概念：类型萃取是一种在编译时获取类型信息的技术。它允许我们根据类型的特性或属性来进行特定的操作或处理。

(2)类型特征萃取：类型特征萃取（type traits）是一种通过模板和特化来获取类型信息的技术。C++标准库提供了一些类型特征类模板（如std::is_same、std::is_integral等），可以用于检查类型的特征，比如是否相同类型、是否为整数类型等。

(3)SFINAE（Substitution Failure Is Not An Error）：SFINAE是一种在模板参数替换过程中，如果发生错误不会导致编译错误的机制。通过利用SFINAE，我们可以根据类型的特征来选择特定的模板重载，从而实现类型萃取的效果。

(4)std::enable_if：std::enable_if是C++标准库提供的一个工具模板，可以根据条件来启用或禁用特定的函数模板。它常用于根据类型特征来选择模板重载，从而实现类型萃取的功能。

90.怎么解决哈希冲突？

(1)开放地址法（Open Addressing）：开放地址法是一种处理哈希冲突的方法，当发生冲突时，可以通过探测到其他空槽位来解决冲突。常见的开放地址法包括线性探测、二次探测和双重哈希等。

(2)链地址法（Chaining）：链地址法是一种处理哈希冲突的方法，它使用链表来存储具有相同哈希值的元素。当发生冲突时，将冲突的元素插入到对应链表的末尾。这种方法可以有效地解决冲突，但需要额外的链表操作和内存空间。

(3)再哈希法（Rehashing）：再哈希法是一种通过多次哈希函数来解决冲突的方法。当发生冲突时，使用另一个哈希函数来计算新的哈希值，并尝试将元素插入到新的位置。这种方法可以减少冲突的概率，但需要选择合适的哈希函数和适当的再哈希策略。
(4)建立公共溢出区（Public Overflow Area）：当发生哈希冲突时，公共溢出区充当一个备用的存储区域，用于存储无法在主哈希表中找到位置的元素。

91.说说迭代器会失效？

(1)数组型容器（如 vector、deque、array）：
该数据结构的元素是分配在连续的内存中，insert和erase操作，都会使得删除点和插入点之后的元素挪位置，所以，插入点和删除掉之后的迭代器全部失效，也就是说insert(*iter)(或erase(*iter))，然后在iter++，是没有意义的。解决方法：erase(*iter)的返回值是下一个有效迭代器的值。 iter =cont.erase(iter);

(2)链表型容器（如 list、forward_list）：
对于链表型的数据结构，使用了不连续分配的内存，删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.解决办法两种，erase(*iter)会返回下一个有效迭代器的值，或者erase(iter++).

(3)树型容器（如 set、map、multiset、multimap）：
使用红黑树来存储数据，插入不会使得任何迭代器失效；删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器。

92.说说RAII原则

RAII原则的核心思想：RAII是一种C++的编程范式，它利用对象的构造和析构过程来管理资源的获取和释放。资源可以是内存、文件句柄、互斥锁等，通过将资源的获取和释放与对象的生命周期绑定，可以确保资源在不再使用时被正确释放，从而避免资源泄漏和错误。

资源获取：RAII通过在对象的构造函数中获取资源，可以是通过调用系统API、打开文件、分配内存等方式获取资源。资源获取的过程应该是安全的，如果获取失败，可以抛出异常或采取其他错误处理方式。

资源释放：RAII通过在对象的析构函数中释放资源，确保资源在对象生命周期结束时被正确释放。析构函数会在对象销毁时自动调用，无论是正常的作用域结束，还是异常引发的栈展开。

资源管理类：为了实现RAII原则，可以使用资源管理类（也称为智能指针或包装类）来封装资源的获取和释放逻辑。这些类通常实现了构造函数、析构函数和重载了指针操作符，以模拟指针的行为。常见的资源管理类有unique_ptr、shared_ptr、lock_guard等。

优点和应用：RAII原则可以提高代码的可靠性和可维护性，避免资源泄漏和错误，减少手动管理资源的复杂性。它广泛应用于C++中，特别是在处理动态内存分配、文件操作和多线程同步等方面。