186道C++面试八股文（答案、分析和深入提问）整理

标签：std 八股文 提示 C++ constexpr 186 使用 ptr

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

回答

全局变量和局部变量在C++中有几个主要的区别：

1. 作用域 (Scope)

• 全局变量：定义在所有函数外部，可以在所有函数和代码块中访问。其作用域是整个程序，直至程序结束。
• 局部变量：定义在函数或代码块内部，只能在该函数或代码块中访问。其作用域仅限于被定义的区域。

2. 生命周期 (Lifetime)

• 全局变量：在程序运行时创建，直到程序结束才被销毁。全局变量在整个程序的生命周期内始终存在。
• 局部变量：在定义其的函数调用时创建，函数调用结束后被销毁。局部变量的生命周期只在函数执行期间。

3. 存储类型 (Storage Class)

• 全局变量：通常存储在数据区 (Data Segment) 中。
• 局部变量：一般存储在栈 (Stack) 中。

操作系统和编译器是如何知道的？

1. 变量定义位置：编译器使用变量的定义位置来判断其作用域。全局变量在所有函数外部定义，而局部变量在某个函数内部定义。

2. 符号表 (Symbol Table)：在编译时，编译器维护一个符号表，记录变量名及其对应的作用域和存储类型。不同的符号在全局和局部作用域中具有不同的条目。

3. 编译阶段：在编译阶段，编译器会分析代码结构，通过语法分析和语义分析阶段来确定变量的作用域和生存期。

4. 链接器：全局变量在编译后的目标文件中会保存其地址信息，链接器在链接多个目标文件时，能够确保所有函数可以访问到全局变量。

示例

#include <iostream>

int globalVar = 10; // 全局变量

void function() {
    int localVar = 5; // 局部变量
    std::cout << "Local Variable: " << localVar << std::endl;
    std::cout << "Global Variable: " << globalVar << std::endl;
}

int main() {
    function();
    // std::cout << localVar; // 这行会导致编译错误，因为 localVar 是局部变量
    std::cout << "Global Variable: " << globalVar << std::endl;
    return 0;
}

在这个例子中：

• globalVar 是全局变量，能在整个程序中访问。
• localVar 是局部变量，只能在 function() 函数内部访问。

通过以上分析，操作系统和编译器能够清楚地理解全局变量和局部变量的区别。

注意点和建议：

在回答全局变量和局部变量的区别时，建议面试者从以下几个方面进行阐述：

1. 作用域：强调全局变量在整个程序中都是可见的，而局部变量只在定义它的函数或代码块中有效。可以提供简单的示例代码来加深理解。

2. 生命周期：全局变量在程序的整个运行期间都存在，而局部变量的生命周期仅限于其所在的代码块。

3. 存储区域：全局变量通常存储在数据段，而局部变量则存储在栈上。解释这些存储区域的基本概念可能有助于面试官理解。

在涉及操作系统和编译器如何识别变量时，建议面试者注意以下几点：

1. 符号表：编译器使用符号表来管理变量的作用域。全局变量会被记录在全局符号表中，而局部变量则会在函数调用时记录在栈帧中。

2. 静态分配与动态分配：全局变量的内存分配是静态的，而局部变量的内存分配通常是动态的（在栈上分配）。这两个概念可以帮助理解变量如何被管理和存取。

常见误区和错误：

1. 混淆作用域和生命周期：有些人可能会混淆这两个概念，要明确两者的差异，并在回答中加以区分。

2. 忽略初始化：局部变量在使用前如果没有初始化，其值是不可预测的，面试者应该注意提及这一点，以避免错误的假设。

3. 不提及线程安全：在多线程环境下，使用全局变量可能导致数据竞争，面试者可以简要提及这一点，以显示对实际编程环境的理解。

4. 缺乏实例：没有提供代码示例可能使得回答不够生动，给人一种抽象的感觉。加上简单的代码演示可以帮助面试官更好地理解。

总之，全面而清晰地涵盖相关概念，同时注意常见的误区，可以帮助面试者在回答中突出自己的理解和思考能力。

面试官可能的深入提问：

面试官可能会进一步问：

1. 详细解释作用域：请描述一下变量的作用域是什么？局部变量和全局变量的作用域有什么具体的例子？

2. 生命周期区别：全局变量和局部变量的生命周期是怎样的？分别在何时被创建和销毁？

3. 内存分配：全局变量和局部变量在内存中的分配差异是什么？它们各自存储在哪里（堆、栈等）？

4. 命名冲突：如果局部变量和全局变量同名，编译器如何处理这种情况？请举例说明。

5. 静态变量的作用：C++中的static关键字对局部变量和全局变量有何影响？如何理解静态变量的作用域和生命周期？

6. 多线程环境中的变量：在多线程编程中，局部变量和全局变量的使用有什么注意事项？会引发什么问题吗？

7. 命名空间的使用：命名空间的引入对全局变量的管理有什么影响？如何有效地组织代码中的全局变量？

8. 优化和编译器：编译器在优化全局变量和局部变量时会做什么，如何帮助提高性能？

9. 对程序可维护性的影响：在设计程序时，如何选择使用全局变量和局部变量从而提高代码的可维护性？

10. 不同编程语言的比较：与其他编程语言（如Python或Java）相比，C++中全局变量和局部变量的处理有什么显著不同？

2. 谈谈C++11中的用户定义字面量（user-defined literals）及其用途。

回答

C++11 引入了用户定义字面量（user-defined literals），这一特性允许开发者定义新的字面量类型，以提升代码的可读性与可维护性。

什么是用户定义字面量

在 C++ 中，字面量是直接在代码中写出的值，例如整数、浮点数、字符、字符串等。用户定义字面量允许开发者为基本类型（如整数、浮点数、字符等）添加后缀，从而创建自定义对象。

定义方式

用户定义字面量通常定义在命名空间内，格式如下：

// 定义一个字面量后缀
constexpr long double operator"" _km(long double val) {
    return val * 1000.0; // 将千米转换为米
}

constexpr long long operator"" _kg(unsigned long long val) {
    return val; // 返回千克
}

用途

1. 代码可读性：通过使用字面量后缀，可以使代码更加直观。例如，distance = 10.0_km; 看起来比 distance = 10000.0; 更加清晰。

2. 单位处理：用户定义字面量尤其适用于物理测量单位的处理，比如长度、重量等，防止单位错误。例如，可以定义不同单位的字面量，确保在字符串中直接表示相应的数据类型。

3. 数量级控制：可以在字面量中定制数量级，比如定义千、百万、十亿等单位的后缀。

4. 增强类型安全性：由于字面量的返回类型可以是用户定义的类，因此可以提供额外的类型检查以避免错误。

示例

下面是一个完整的示例，演示如何使用用户定义字面量来处理单位转换：

#include <iostream>

constexpr long double operator"" _km(long double val) {
    return val * 1000.0; // 千米转米
}

constexpr long double operator"" _m(long double val) {
    return val; // 米
}

int main() {
    auto distance1 = 5.0_km; // 5000 米
    auto distance2 = 300.0_m; // 300 米

    std::cout << "Distance in meters: " << distance1 + distance2 << " m" << std::endl;

    return 0;
}

结论

用户定义字面量为 C++ 提供了更高的灵活性和可读性，有助于减少错误并提升代码的可维护性。它特别适合在涉及单位转换、特殊格式化或特定需求的场景中使用，帮助程序员更清晰地表达意图。

注意点和建议：

在回答用户定义字面量的问题时，有几个关键点和建议可以帮助面试者更清晰、准确地阐述这一概念。

1. 理解基础：首先，面试者应确保对字面量（literal）及其在C++中的基本概念有清晰的理解，包括基本的内置字面量（如整数、浮点数、字符串等）。他们应该能够解释什么是用户定义字面量，以及它们是如何扩展C++语言的。

2. 语法与结构：面试者应该能清晰地阐述如何定义和使用用户定义字面量，他们可以简要描述语法结构，例如后缀（suffix）和如何通过operator""重载函数来实现。具备实际的代码示例会使他们的回答更加生动。

3. 应用场景：在讨论用户定义字面量的用途时，面试者可以提到一些具体的应用场景，比如用于表示特定单位（如距离、时间、货币等），以及如何提高代码的可读性。提及真实项目中应用用户定义字面量的例子将增加他们回答的分量。

4. 避免过于笼统的回答：面试者应该避免给出空泛的解释，而不深入细节。例如，仅仅提到“用户定义字面量可以用来美化代码”就不够。他们需要展示出对其实现机制和实际效果的理解。

5. 不要忽视限制和注意事项：面试者应提到在使用用户定义字面量时可能遇到的限制或注意事项，例如过度使用可能导致代码的可读性下降，或如何在用户定义的情况下避免与系统定义的字面量冲突。

6. 对比其他特性：面试者可以考虑将用户定义字面量与其他C++特性（如普通函数、模板等）进行对比，以展示他们对语言特性的整体理解，但应避免变得过于复杂而失去重点。

7. 保持简洁和清晰：在回答时，逻辑要清晰，尽量避免术语过多而导致的疏离感，以便让面试官能够轻松跟上他们的思路。

总之，强调理解、应用和注意事项，将有助于面试者更好地展示自己对用户定义字面量的全面把握。

面试官可能的深入提问：

面试官可能会进一步问：

1. 用户定义字面量的语法
   提示：你能描述一下用户定义字面量的基本语法结构吗？有什么具体的例子吗？

2. 用户定义字面量的实际应用
   提示：能否分享一些实际项目中使用用户定义字面量的场景？解决了什么问题？

3. 自定义字面量与传统字面量的区别
   提示：用户定义字面量与普通字面量相比，有哪些优缺点或局限性？

4. 字面量后缀的命名约定
   提示：你有什么建议或最佳实践来命名用户定义字面量的后缀？为什么重要？

5. 在类中使用用户定义字面量
   提示：如何在类中实现用户定义字面量？你能给出一个示例吗？

6. 用户定义字面量和模板的结合
   提示：能否讨论下用户定义字面量如何与模板结合使用？这种组合带来了什么样的灵活性？

7. 性能考虑
   提示：使用用户定义字面量是否会影响性能？在性能敏感的应用中，它们是否值得使用？

8. 与其他C++11特性的结合
   提示：用户定义字面量可以与哪些其他C++11特性结合使用？这种结合的效果如何？

9. 跨模块使用用户定义字面量的挑战
   提示：在多模块或多文件项目中使用用户定义字面量时，有哪些潜在的问题或挑战？

10. 如何调试用户定义字面量
    提示：在调试中遇到字面量相关的问题时，你有什么好的调试技巧？

3. final和override关键字

回答

在C++中，final和override是两个与类继承和虚函数相关的关键字，用于帮助开发者处理多态性和虚函数的重写。

override

• 用途: override关键字用于指定一个虚函数是用于重写基类中的虚函数。这提供了一种编译器检查机制，确保基类中的虚函数的签名与派生类中的重写函数匹配。
• 示例:

  class Base {
  public:
      virtual void func() { /* ... */ }
  };
  
  class Derived : public Base {
  public:
      void func() override { /* ... */ } // 正确
      // void func(int) override { /* ... */ } // 错误，签名不匹配
  };
  

final

• 用途: final关键字用于防止类被进一步派生或防止某个虚函数被重写。它可以应用于类和虚函数。
• 示例:

  // final用于类
  class Base final {
      // ...
  };
  
  // 这会导致错误，因为Base类不能被继承
  class Derived : public Base { // 错误
  };
  
  // final用于虚函数
  class Base {
  public:
      virtual void func() final { /* ... */ }
  };
  
  class Derived : public Base {
  public:
      // void func() override { /* ... */ } // 错误，不能重写
  };
  

小结

• 使用override确保你确实是在重写一个基类的虚函数，避免因为函数签名不匹配而导致的错误。
• 使用final可以确保某个类不能被继承或某个虚函数不能被重写，从而提供更好的设计控制。

这两个关键字在C++11及之后的版本中被引入，帮助程序员编写更安全、更清晰的面向对象代码。

注意点和建议：

在回答有关 final 和 override 关键字的问题时，有几个关键点可以帮助面试者更准确地表达自己的理解：

1. 基本概念清晰：确保对这两个关键字的定义非常清楚。override 用于表示一个虚函数重写了基类中的同名虚函数，而 final 用于阻止子类重写某个虚函数。

2. 避免模糊的术语：使用准确的术语，避免模糊的说法。例如，不要仅仅说“它是一个关键字”，而应该具体说明它的用途和适用场景。

3. 示例的有效性：提供具体的代码示例可以增强回答的说服力。确保所用示例应用了这两个关键字的正确场景，以便更清晰地展示其功能。

4. 理解与使用情境：面试者应能够讨论何时使用 final 和 override，以及这些关键字对于代码可读性和维护性的影响。

5. 错误警觉：警惕关于这些关键字的常见错误，比如错误理解 final 的作用，认为它仅适用与类而非方法等。

6. 扩展讨论：能够进一步讨论与这两个关键字相关的概念，比如多态性、虚函数和类的继承层次等，显示出对C++更深层次的理解。

总之，回答时应注重内容的准确性、条理的清晰性和代码示例的相关性，这有助于给面试官留下深刻的印象。

面试官可能的深入提问：

面试官可能会进一步问：

1. 虚函数的实现机制
   提示：请解释一下虚函数表（vtable）和虚指针（vptr）的工作原理，它们如何支持多态。

2. override 与 守护模式的区别
   提示：除了使用 override 关键字，是否有其他方式可以确保重写了基类的方法？能否提供例子？

3. final 与 继承的限制
   提示：使用 final 关键字后，继承类是否能够再次重写该方法？能否举例说明？

4. 多重继承的影响
   提示：在多个基类中定义相同的方法时，override 和 final 的使用有哪些不同的考虑？

5. 虚析构函数的重要性
   提示：在类继承中，为什么需要使用虚析构函数？关联到 final 时会有什么影响？

6. 编译器优化与性能
   提示：在使用 final 关键字时，编译器可能会做哪些优化？你认为这会对性能产生怎样的影响？

7. 设计模式中的应用
   提示：你能否举出在设计模式中经典应用了 final 或 override 的例子，如模板方法模式？

8. 类型安全性
   提示：使用 override 如何提高了代码的类型安全性？请说明其对维护性的影响。

9. 对比其他语言
   提示：在其他编程语言中（如Java或C#）是如何处理方法重写的？类似的机制是否存在？

10. 衍生类的设计考虑
    提示：在设计一个类时，你会在什么情况下考虑将某个方法声明为 final？考虑的因素有哪些？

4. 请你来说一下C++中struct和class的区别

回答

在C++中，struct和class都用于定义用户自定义的数据类型，并且它们在很多方面是相似的，但也有一些关键的区别：

1. 默认访问修饰符：

   • struct：默认成员的访问权限是公有（public）。
   • class：默认成员的访问权限是私有（private）。

   示例：

   struct MyStruct {
       int x; // 默认公有
   };
   
   class MyClass {
       int y; // 默认私有
   };
   

2. 继承的默认访问修饰符：

   • struct：默认继承权限是公有（public）。
   • class：默认继承权限是私有（private）。

   示例：

   struct Base {};
   struct Derived : Base {}; // 默认为公有继承
   
   class Base {};
   class Derived : Base {}; // 默认为私有继承
   

3. 用途：

   • struct：通常用于表示简单的数据结构，尤其是与 C 语言兼容的结构体，通常数据成员较多，成员函数较少。
   • class：通常用于表示复杂的对象，强调封装、继承和多态等面向对象的特性。

4. 功能：

   • struct 和 class 在功能上几乎没有区别，都可以包含数据成员和成员函数，都支持继承、封装和多态。

5. 风格：

   • 在实践中，程序员常常用 struct 来表示数据结构，而用 class 来表示对象，以便于代码的可读性和维护性。但这个区分并不是强制的，偶尔也会在 struct 中定义成员函数。

总的来说，选择使用 struct 还是 class 更像是风格问题，具体选择取决于代码的上下文和个人喜好。

注意点和建议：

当回答关于C++中struct和class的区别时，有几个关键点需要注意，避免常见的误区：

1. 访问修饰符：很多人容易忽视struct和class最明显的区别就是默认的访问修饰符。struct的成员默认是公有的，而class的成员默认是私有的。面试者应该清晰地说明这一点。

2. 用途的误解：一些人可能认为struct只适合于简单的数据结构，而class则用于复杂对象。其实，struct和class在本质上功能上是相同的，二者都可以包含函数和成员变量，适用场合不应有所偏见。

3. 继承时的区别：提到继承时，有些面试者可能会混淆访问控制。在继承时，class的默认继承方式是私有继承，而struct则是公有继承。确保在讨论继承时明确这一点。

4. 关于语法：注意语法上如何使用二者。有些面试者可能会纠结于struct和class在语法上的微小差别，实际上在使用方法上是一样的，核心是理解它们的设计目的。

5. 使用场景：讨论具体使用场景时，建议明确给出实例。比如在一些需要数据聚合的简单场合，用struct更为合适，而在需要封装和数据隐藏的情况下，使用class会更好。避免停留在抽象层面，要能够结合实际情况进行举例。

6. 过于简化或复杂：有些人可能会将问题简化为“struct和class没有区别”，或者将其复杂化到超出面试范围的程度。保持简洁明了，将重点放在核心区别上会更有助于传达理解。

最后，回答时保持逻辑清晰，例子具体，能够展现出对C++语言深刻的理解。此外，对方是否能用准确的语言表达自己的想法也是很重要的。

面试官可能的深入提问：

面试官可能会进一步问：

1. 构造函数和析构函数的作用和区别是什么？

   • 提示：讨论何时调用、用途以及它们在资源管理中的重要性。

2. C++中的访问修饰符有哪些，分别有什么作用？

   • 提示：区分public、protected和private的用法，以及它们对封装的影响。

3. 在C++中可以将struct和class相互转换吗？

   • 提示：考虑隐式和显式转换，以及它们在实践中的应用。

4. 请解释C++中的继承和多态性。

   • 提示：讨论基类与派生类的关系，以及如何实现多态性。

5. 如何实现运算符重载？请解释一个具体的例子。

   • 提示：考虑重载一个常用运算符，例如+或=，并讨论实现细节。

6. 什么是虚函数？为什么要使用虚函数？

   • 提示：讨论虚函数在实现多态性和继承层次中的作用。

7. 请解释RAII原则及其在C++中的重要性。

   • 提示：探讨资源管理和对象生存期的关系。

8. C++11引入的智能指针有什么类型，分别有什么不同？

   • 提示：区分unique_ptr、shared_ptr和weak_ptr的使用场景。

9. C++中的模板是什么，如何用模板实现代码复用？

   • 提示：举例说明函数模板或类模板的定义和用途。

10. 在C++中如何处理异常？请简单介绍try-catch机制。

    • 提示：讨论异常处理的重要性以及基本的使用方法。

5. 在设计高性能的C++程序时，你会如何使用STL?

回答

在设计高性能的C++程序时，合理使用STL（标准模板库）非常重要。以下是一些建议，可以帮助你在使用STL时提高性能：

1. 选择合适的容器

• 数组和向量：
  • 使用std::vector而不是std::list，因为std::vector在内存中是连续的，有助于缓存局部性。
• 关联容器：
  • 如果数据需要快速查找，使用std::unordered_map而不是std::map，因为前者基于哈希表，平均时间复杂度为O(1)。
• 避免不必要的容器：
  • 根据数据的访问模式选择最优的容器，并避免额外的封装和间接性。

2. 合理使用算法

• 使用STL算法（如std::sort、std::for_each）可以减少代码量，提高可读性。在许多情况下，STL的算法会经过优化，能比手写的循环更高效。
• 考虑使用并行算法（C++17引入的std::_execution）来充分利用多核CPU。

3. 避免不必要的复制

• 使用std::move和右值引用来避免不必要的复制，特别是在处理大型对象时。
• 使用std::shared_ptr和std::unique_ptr等智能指针时要小心，过度使用会导致性能开销。

4. 预分配内存

• 对于std::vector等动态数组，在知道元素数量时，可以使用reserve方法预分配内存，从而避免多次重新分配。
• 对于std::map和std::unordered_map，也可以使用reserve来预分配桶的数量。

5. 避免频繁的内存分配

• 在性能关键的部分，尽量减少内存分配和释放的次数，使用内存池和自定义分配器来管理内存。

6. 迭代和访存模式

• 使用STL时要注意迭代的顺序与数据访问模式，以提高缓存命中率。
• 避免在循环中进行重大的迭代模式切换。

7. 编译器优化

• 鼓励启用编译器优化选项，例如使用-O2或-O3。
• 用constexpr引导编译器在编译时计算常量，减少运行时开销。

8. 性能分析与测试

• 使用性能分析工具（如gprof、Valgrind、Perf等）监控程序性能，找到瓶颈，调整容器和算法。

9. 最小化头文件依赖

• 通过前向声明和使用实现文件减少头文件的依赖，以加快编译速度。

10. 阅读和理解STL的实现

• 深入理解STL的实现细节可以帮助你更好地利用其性能特性，避免误用造成的瓶颈。

通过这些策略，能够有效地提升C++程序的性能，同时保持代码的可读性和可维护性。

注意点和建议：

在回答关于如何在高性能的C++程序中使用STL（标准模板库）的问题时，面试者可以考虑以下几点，以确保他们的回答既全面又准确：

1. 理解STL的优势：首先，面试者应能清楚地解释STL为程序员带来的便利，比如数据结构的多样性、算法的丰富性以及代码的可读性和可维护性。这些都是STL的核心优势。

2. 选择合适的容器：面试者应展示对各种STL容器（如vector、list、map、set等）的理解，并能够内容明确地指出在不同场景下选择何种容器。例如，vector适合随机访问，但在频繁插入和删除操作时性能较差，list则在这些操作中表现更好。

3. 算法的使用：面试者可以提到STL提供的算法（如sort、find等）以及如何利用这些算法来提升代码的效率和简洁性。他们应当能够说明算法的时间复杂度，这可以反映出他们的性能意识。

4. 避免过度使用：面试者还可以讨论避免使用STL的某些方面，比如在极端性能要求的场景下，可能需要使用自定义数据结构，其性能能更好地满足特定需求。

5. 友好的Copy和Move语义：现代C++中，理解和使用移动语义（move semantics）能够在使用STL容器时减少不必要的拷贝，提高性能。

6. 注意迭代器的使用：面试者应注意避免在使用STL迭代器时的常见错误，例如在遍历容器时对容器进行修改可能导致不确定的行为。

避免的常见误区：

1. 过度依赖STL：面试者应避免只强调STL的使用，而忽略了底层性能优化和资源管理的重要性。

2. 忽略复杂度分析：在提到STL时，未能分析其时间复杂度和空间复杂度，可能会表明他们对性能的理解不够深入。

3. 没有具体例子：仅仅谈论理论而没有具体的代码示例或应用场景，可能让回答显得空泛。

4. 缺乏对内存管理的关注：使用STL时，如果不提及内存使用的注意事项，可能会给人一种对资源管理缺乏关注的印象。

5. 对STL的局限性缺乏认识：没有提到STL在某些高性能场景下的局限性，例如，在需要极致性能时，可能需要手动优化的数据结构。

综上所述，面试者在回答时应该全面、具体并具备深刻的理解，而避免掉入上述常见误区与错误之中。这不仅能展示其专业知识，也能体现出解决问题的能力。

面试官可能的深入提问：

面试官可能会进一步问：

• 你会选择哪些 STL 容器，为什么？
  提示：考虑时间复杂度、空间复杂度等因素。

• STL 算法的使用，你有哪些经验？
  提示：可以提及常用的算法如 sort、find 等和它们的效率。

• 在使用 STL 时，你如何处理性能瓶颈？
  提示：考虑是否会涉及容器选择、算法优化或是自定义数据结构。

• 你对 STL 的内存管理有什么看法？
  提示：考虑使用智能指针与普通指针的区别。

• 如果 STL 容器需要扩展或自定义，你会如何处理？
  提示：讨论容器的特性和适用的设计模式。

• 并发编程下，你如何安全地使用 STL？
  提示：考虑线程安全、锁机制等。

• 在高负载场景下，如何评估 STL 的性能？
  提示：可以讨论基准测试或其他评估方法。

• 你会如何利用 STL 实现设计模式？
  提示：举例说明某个设计模式如何与 STL 结合使用。

• 在多线程环境中，STL 的哪些特性可能导致问题？
  提示：考虑 STL 容器的并发访问及其影响。

6. 谈谈C++11中的constexpr关键字及其用途。

回答

在C++11中，constexpr关键字引入了编译时常量的概念，它用于指示某个变量或函数的值可以在编译时计算。这使得编程可以在更高的抽象层次上进行优化，促进了代码的性能和可读性。以下是constexpr关键字的一些主要用途和特性：

1. 用于变量

使用constexpr声明的变量，必须在编译时就能被确定其值。示例：

constexpr int max_value = 100;

2. 用于函数

constexpr可以修饰函数，使得这些函数可以在编译时求值。这些函数必须满足一定的条件：

• 函数体必须是一个简单的表达式。
• 所有参数必须是常量表达式。

示例：

constexpr int square(int x) {
    return x * x;
}

在编译时可以进行求值：

constexpr int result = square(10); // result 在编译时计算为 100

3. 用于类成员函数

C++11 允许将类的成员函数定义为 constexpr，使得这些成员函数可以在编译时进行求值。例如：

class Point {
public:
    constexpr Point(int x, int y) : x_(x), y_(y) {}
    constexpr int getX() const { return x_; }
    constexpr int getY() const { return y_; }
private:
    int x_;
    int y_;
};

// 使用
constexpr Point p(1, 2);
constexpr int x = p.getX(); // x 在编译时被计算为 1

4. 使用编译时常量作为数组大小

在C++11中，constexpr变量可以用于指定数组的大小：

constexpr int size = 5;
int arr[size]; // 合法，size 在编译时已知

5. 对于模板编程

constexpr与模板结合使用，可以更灵活地生成编译时常量。通过 constexpr 函数，能够增加模板编程的能力，使得更多的代码在编译时被计算。

总结

constexpr使得定义常量和在编译时计算函数成为可能，促进了性能优化，增强了代码的可维护性和清晰性。在后续的C++标准中，constexpr的功能得到了进一步扩展（如C++14、C++17等），使得编译时常量的实现更加全面和灵活。

注意点和建议：

当谈论C++11中的constexpr关键字时，有几个关键点需要注意。以下是一些建议，能帮助面试者更清晰且准确地表达自己的理解：

1. 定义与基本用途：应清楚地定义constexpr，强调它用于指示一个表达式可以在编译时计算出来。要提及它通常用于函数和变量的声明。

2. 编译时常量与运行时常量：阐明constexpr与传统的常量定义（如const）的区别，即constexpr必须在编译时求值，而const则可以在运行时求值。

3. 函数限制：提到使用constexpr定义函数时，函数体内部只能包含返回一个常量表达式的简单代码，避免提及过于复杂的逻辑。

4. 使用场景：举例说明constexpr在模板编程、编译时计算和提高程序性能方面的应用。

5. C++11与后续版本：如果补充提到C++14及之后版本的改进，注意不要偏离问题焦点，可以简要说明扩展的内容，比如在C++14中允许constexpr函数包含更多的复杂逻辑。

6. 避免技术细节过多：避免深入到底层实现和过于技术细节的讨论，保持回答的简洁性和清晰性，确保听众能跟上。

7. 常见误区：

   • 不能认为所有constexpr定义的函数都能在编译时计算，必须符合条件。
   • 应避免混淆const和constexpr，尽量明确两者之间的差异。
   • 不要忽视错误处理或异常，因为constexpr函数不能抛出异常。

8. 实际练习的重要性：建议多参加实际代码的练习，可能会加深对constexpr的理解和应用。

综上所述，面试者在回答时应展示对constexpr的全面理解，避免偏离主题，同时举出清晰的例子和实际应用场景，以增强自己的论点。

面试官可能的深入提问：

面试官可能会进一步问：

1. 请解释constexpr函数的限制是什么？
   提示：思考constexpr能够支持的语法和特性，以及在constexpr函数中不可用的内容。

2. constexpr与常规函数有什么实际区别？
   提示：关注编译时求值和运行时求值的不同影响。

3. 可以在constexpr中使用哪些标准库类型？
   提示：思考哪些C++标准库组件支持constexpr，以及其使用时的限制。

4. 如何在C++11中定义一个constexpr构造函数？
   提示：提示定义构造函数的规则和限制，并考虑其在类中的用途。

5. 请解释一下constexpr与模板元编程的关系。
   提示：考虑两者如何结合使用来进行编译时计算。

6. 能否将constexpr用于非平凡的类？举例说明。
   提示：思考哪些类构造较复杂时，constexpr的使用限制。

7. C++14相较于C++11对constexpr做了哪些改进？
   提示：了解C++14对constexpr的扩展，比如支持更多语法和语义。

8. 如何在constexpr上下文中处理异常？
   提示：思考在编译时求值过程中异常处理的可能性和限制。

9. 如果在constexpr函数中使用动态内存分配，会发生什么？
   提示：考虑编译时和运行时内存分配的不同影响。

10. 你如何在实际项目中评估使用constexpr的适用性？
    提示：从性能、可读性和代码维护的角度考虑。

7. 如何使用stringstream进行字符串的格式化输出？

回答

在C++中，std::stringstream 是一个非常方便的工具，用于字符串的格式化输出。它允许你像使用 printf 那样格式化数据，但更加类型安全且可以方便地处理字符串。

基本用法

1. 包含头文件：
   首先，你需要包含 <sstream> 头文件。

   #include <iostream>
   #include <sstream>
   

2. 创建 stringstream 对象：
   可以创建一个 std::stringstream 对象来进行输出。

   std::stringstream ss;
   

3. 格式化输出：
   你可以使用流操作符 << 向 stringstream 写入不同类型的数据。

   int num = 42;
   double pi = 3.14159;
   std::string name = "Alice";
   
   ss << "Name: " << name << ", Age: " << num << ", Pi: " << pi;
   

4. 获取格式化后的字符串：
   使用 str() 方法来获取最终的字符串。

   std::string result = ss.str();
   std::cout << result << std::endl; // 输出: Name: Alice, Age: 42, Pi: 3.14159
   

5. 清空 stringstream：
   如果需要重新使用同一个 stringstream 对象，可以调用 str("") 方法清空内容。

   ss.str("");    // 清空内容
   ss.clear();    // 清空状态
   

完整示例

下面是一个完整的示例，将多个类型的数据格式化为一个字符串：

#include <iostream>
#include <sstream>

int main() {
    std::stringstream ss;

    int num = 25;
    double pi = 3.14159;
    std::string name = "Alice";

    ss << "Name: " << name << ", Age: " << num << ", Pi: " << pi;

    std::string result = ss.str();
    std::cout << result << std::endl; // 输出: Name: Alice, Age: 25, Pi: 3.14159

    // 清空 stringstream，写入其他内容
    ss.str("");
    ss.clear();
    ss << "Another data: " << 2023 << " and " << (pi + 1.0);
    std::cout << ss.str() << std::endl; // 输出: Another data: 2023 and 4.14159

    return 0;
}

总结

std::stringstream 提供了一种灵活且类型安全的方式来格式化和构建字符串，适合在许多场合使用。通过流操作，可以轻松地将不同类型的数据组合成单个字符串。

注意点和建议：

在回答关于如何使用 stringstream 进行字符串格式化输出的问题时，有几个要点可以帮助你增强回答的质量，同时避免一些常见的误区和错误：

1. 基本理解：首先，确保你对 stringstream 的基本概念有清晰的理解。它是 C++ 标准库中的一部分，在使用和理解 iostream 的概念时尤为重要。如果不能解释 stringstream 的基本用途，可能会让面试官对你的基础知识产生疑虑。

2. 示例代码：提供一个简单的示例代码可以让你的回答更具说服力。虽然概念性解释很重要，但实际的代码示例能够更直观地展示你的能力。确保示例简洁明了，重点突出。

3. 提到格式化选项：解释如何使用各种格式化选项，比如设置精度、填充字符以及对齐方式等。如果能提及这些细节，将显示出你对 stringstream 声明字符串的灵活性和能力的深入理解。

4. 与其他方法比较：如果可能，可以提及 stringstream 与其他格式化方法（如使用 printf 或其他格式化库）的优缺点。这表明你不仅能使用 stringstream，还了解其上下文和适用场景。

5. 避免常见错误：确保明确说明在使用 stringstream 时的一些常见陷阱，例如忘记调用 str() 方法以获取最终字符串，或者在混合使用不同类型时可能导致的类型转换问题。

6. 上线后测试：如果时间允许，提到调试或测试代码的方法。当你在面试中能够提及对代码的验证步骤，这表明你不仅能编写代码，还关注代码的正确性和可维护性。

通过以上这些建议，你的回答将更加全面和深入，同时避免了常见的误区，比如单纯的理论阐述或缺乏实践示例。这样可以提升你在面试中的表现，给面试官留下深刻的印象。

面试官可能的深入提问：

面试官可能会进一步问：

1. 请解释一下stringstream和ostringstream的区别。
   提示：考虑它们的用途和性能差异。

2. 如何处理stringstream中的异常情况，例如数据转换失败？
   提示：讨论异常处理机制和如何验证输入。

3. 能否通过stringstream实现类型安全的字符串拼接？
   提示：考虑如何利用模板或其他技术确保类型安全。

4. 在使用stringstream时，如何管理内存和效率问题？
   提示：讨论缓冲区大小和性能优化。

5. 请介绍一下std::to_string的使用场景及其与stringstream的比较。
   提示：考虑在什么情况下选择一种方法而不是另一种。

6. 你能否举例说明在多线程环境中使用stringstream可能遇到的问题？
   提示：讨论线程安全和数据竞争的概念。

7. 在C++11及以上版本中，有没有更好的替代方案来处理字符串格式化？
   提示：思考使用std::format等新特性。

8. 如何对复杂数据类型（如自定义结构体）进行格式化输出？
   提示：考虑重载输出运算符或使用辅助函数。

9. 有没有你在实际项目中使用stringstream的案例？可以分享一下吗？
   提示：分享具体情境和解决的问题。

10. 请讨论一下stringstream在性能方面的问题，比如与C风格字符串处理相比。
    提示：考虑不同场景下的性能差异。

8. STL容器是线程安全的吗？

回答

在C++中，STL（标准模板库）容器本身并不是线程安全的。这意味着如果多个线程同时对同一个容器进行读写操作（例如插入、删除或修改元素），则可能会导致未定义行为。

具体来说：

1. 单一线程安全：在单线程环境中，使用STL容器是安全的。
2. 多线程环境：在多线程环境中，如果多个线程同时访问同一容器，并且至少有一个线程在写入（修改、插入或删除元素），那么你需要采取同步措施（如使用互斥锁）来保护对容器的访问。
3. 只读访问：如果多个线程只进行读操作，而没有线程进行写操作，那么这样的访问是线程安全的。

因此，当使用STL容器时，需要根据应用场景和多线程访问模式，合理使用锁或其他同步机制来确保线程安全。

注意点和建议：

在讨论STL容器的线程安全性时，有几个重要建议和常见误区需要注意。

首先，可以考虑线程安全的定义。线程安全通常意味着在多线程环境下，对同一资源的并发访问不会导致数据损坏或状态不一致。在回答这个问题时，面试者可以清晰地定义什么是线程安全，然后再逐步讲述STL容器的线程安全性。

接下来，STL容器本身并不是线程安全的。可以借此机会提醒面试者要避免以下误区：

1. 误解线程安全性：很多人会混淆“可重入”（reentrant）和“线程安全”（thread-safe）。可重入意味着单线程可以安全地暂停和恢复，而线程安全则是指在多线程环境中不发生数据竞争。

2. 未提及同步机制：在多线程环境中，使用STL容器时，面试者应该提到需要使用同步机制（如互斥锁）来保护对容器的访问。如果只是简单地说明容器本身是否线程安全而没有提及如何实现线程安全的策略，可能会给人留下不全面的印象。

3. 忽略不同操作的安全性：某些操作可能具有不同的线程安全性。例如，读取操作在某些情况下是线程安全的，但写入操作可能不是。面试者在回答时可以讨论不同操作的影响。

4. 没有例子：面对这样的问题，实际例子能够加强回答的说服力。举个例子，可以谈谈在多线程环境中如何使用std::mutex或std::lock_guard来保护容器的操作。

5. 不考虑标准库实现的差异：不同编译器和标准库实现可能在细节上有所不同。提到这一点可以显示出面试者对C++标准的深刻理解。

最后，要鼓励面试者展示他们的思维过程，而不仅仅是给出结论。探讨相关概念和提供例子可以让他们的回答更有深度和说服力。

面试官可能的深入提问：

面试官可能会进一步问：

1. 请解释一下为什么STL容器不是线程安全的。
   提示：考虑竞争条件和数据一致性。

2. 在什么情况下可以安全地在多线程环境中使用STL容器？
   提示：考虑锁机制、操作的原子性等。

3. 你能介绍一下C++标准库中有没有提供线程安全的容器吗？
   提示：思考C++11及后续标准中所引入的并发特性。

4. 如何使用互斥锁（mutex）来保护STL容器的访问？
   提示：考虑锁的使用时机、锁的粒度等。

5. 如果你需要实现一个线程安全的队列，你会选择何种方式？
   提示：考虑自定义实现或使用现有库的方案。

6. 在多线程环境中，如果多个线程同时访问一个STL容器，可能出现哪些问题？
   提示：考虑具体的并发问题，如死锁、数据损坏等。

7. 如何使用条件变量（condition variable）来实现生产者-消费者模型？
   提示：考虑生产者和消费者之间的协调。

8. STL中的哪些算法可能也是线程不安全的？你如何评估它们的安全性？
   提示：讨论并发执行的潜在影响。

9. 如何评估在多线程环境下使用STL容器的性能？
   提示：考虑锁的开销、上下文切换等因素。

10. 如果需要存储不同类型的数据，你会如何选择容器？
    提示：考虑使用std::variant或std::any等类型安全的选项。

9. unique_ptr、shared_ptr和weak_ptr有什么区别？

回答

在C++中，unique_ptr、shared_ptr和weak_ptr都是智能指针的类型，用于管理动态分配的内存，避免内存泄漏并简化资源管理。它们各自有不同的用途和特性。

1. unique_ptr

• 独占所有权：unique_ptr 是一种独占所有权的智能指针，意味着同一个时刻只能有一个 unique_ptr 指向某个对象。
• 不能复制：unique_ptr 不能被复制，但可以通过移动（move）语义来转移所有权。
• 资源保证：当 unique_ptr 被销毁时，它所管理的对象会被自动释放。
• 性能：因为它没有引用计数的开销，unique_ptr 更轻量，效率高。

示例：

#include <memory>

void example() {
    std::unique_ptr<int> ptr1(new int(10));
    std::unique_ptr<int> ptr2 = std::move(ptr1); // 所有权转移
    // ptr1 现在是 nullptr
}

2. shared_ptr

• 共享所有权：shared_ptr 允许多个指针实例共享对同一对象的所有权。引用计数机制确保对象在最后一个 shared_ptr 被销毁时才会被释放。
• 可复制：shared_ptr 是可复制的，每次复制都会增加内部引用计数。
• 性能开销：由于维护引用计数，shared_ptr 的性能相比 unique_ptr 稍低。

示例：

#include <memory>

void example() {
    std::shared_ptr<int> ptr1(new int(10));
    std::shared_ptr<int> ptr2 = ptr1; // 共享所有权
    // 两个指针可以共享同一对象
}

3. weak_ptr

• 弱引用：weak_ptr 是一种不拥有对象的智能指针，主要用来辅助 shared_ptr。它用于解决循环引用的问题。
• 避免循环引用：weak_ptr 不会增加引用计数，因此不会阻止对象的销毁。
• 提升安全性：当使用 weak_ptr 访问共享的对象时，可以通过 lock 方法获取与之关联的 shared_ptr，这样在对象被销毁后就不会悬挂。

示例：

#include <memory>
#include <iostream>

void example() {
    std::shared_ptr<int> ptr1(new int(10));
    std::weak_ptr<int> weakPtr = ptr1; // weak_ptr 不增加引用计数

    if (auto sharedPtr = weakPtr.lock()) { // 尝试获取 shared_ptr
        std::cout << *sharedPtr << std::endl; // 访问对象
    } else {
        std::cout << "对象已被销毁" << std::endl;
    }
}

总结

• unique_ptr：唯一拥有者，不能共享，适用于可独占资源的情况。
• shared_ptr：可共享的，允许多个指针共同拥有一个对象，便于多个所有者的场景。
• weak_ptr：不拥有者，用于打破循环引用和避免悬挂指针。

选择哪种智能指针，取决于具体的内存管理需求和所有权模型。

注意点和建议：

在回答关于 unique_ptr、shared_ptr 和 weak_ptr 的区别时，可以考虑以下几点建议，以确保你的答案清晰、全面且准确。

1. 明确类型和用途：

   • 先简要介绍每种智能指针的基本特征。unique_ptr 用于独占拥有对象的指针，shared_ptr 允许多个指针共享同一个对象，weak_ptr 是针对 shared_ptr 的一个辅助指针，用来解决循环引用问题。
   • 避免模糊的表述，比如将它们都称为“智能指针”而不加以区分。

2. 强调内存管理机制：

   • 说明 unique_ptr 使用“独占所有权”模型，不能复制，但可以移动；而 shared_ptr 使用引用计数来管理对象的生命周期。
   • 避免遗漏引用计数的细节，尤其是对 shared_ptr 生命周期的影响。

3. 案例说明：

   • 尽量用较简单的代码片段来演示三者各自的用法和适用场景，这可以帮助面试官更好地理解你的观点。
   • 注意不要使用过于复杂的例子，以免使听众难以跟上。

4. 讨论使用场景和性能：

   • 可以提到在需要确保资源独占的情况下，unique_ptr 是更优选择，而在需要共享资源的情况下，shared_ptr 更合适。weak_ptr 则适用在需要防止循环引用的场景。
   • 避免忽略性能开销，shared_ptr 的引用计数管理可能会引入额外的开销。

5. 常见误区：

   • 不要混淆指针的类型，比如声称 weak_ptr 拥有资源，而实际上它不拥有任何对象。
   • 提醒自己在讨论时不要 undervalue weak_ptr 的重要性，它在避免资源泄露中扮演着关键角色。

6. 深入讨论：

   • 如果面试官有进一步问题，准备讨论如何安全地转换这些指针（例如从 shared_ptr 到 weak_ptr）。
   • 避免过于表面的回答，确保能展开讨论，展示出你对内存管理的深入理解。

通过了解这些要点，你能更有效地传达对智能指针的理解，同时避免一些常见的误区。希望这些建议能帮助你在面试中表现得更加出色！

面试官可能的深入提问：

面试官可能会进一步问：

1. 内存管理的责任
   提示：在使用不同智能指针时，如何有效管理内存，避免内存泄漏和双重释放？

2. 共享与独占语义
   提示：在多线程环境下，使用shared_ptr时需要注意哪些线程安全问题？

3. 循环引用
   提示：shared_ptr如何可能导致循环引用？weak_ptr又是如何解决这个问题的？

4. 自定义删除器
   提示：如何在unique_ptr和shared_ptr中使用自定义删除器？有什么场景需要这样做？

5. 性能考虑
   提示：在性能方面，使用unique_ptr和shared_ptr的差异是什么？何时选择使用它们？

6. 与原始指针的转换
   提示：如何在智能指针与原始指针之间进行转换？这种转换有什么风险？

7. 异常安全
   提示：在使用智能指针时，如何确保代码在异常发生时仍然安全？

8. 容器与智能指针
   提示：如何将智能指针存储在标准库容器中？需要注意什么？

9. 自定义类型与智能指针
   提示：如果你有一个自定义类型对象，如何确保它的生命周期和智能指针配合得当？

10. 场景选择
    提示：给定一个具体场景，何时选择unique_ptr而非shared_ptr，反之亦然？

10. C++11中引入了哪些新的智能指针类型？请描述它们的用法和区别。

回答

C++11引入了三种主要的智能指针类型：std::unique_ptr、std::shared_ptr和std::weak_ptr。它们各自有不同的用法和特点。

1. std::unique_ptr

• 描述：std::unique_ptr 是一种独占所有权的智能指针。它确保同一个对象只能被一个 unique_ptr 管理，即一个 unique_ptr 不能被复制。
• 用法：

  #include <memory>
  
  std::unique_ptr<int> ptr1(new int(5)); // 创建一个独占的智能指针
  std::unique_ptr<int> ptr2 = std::move(ptr1); // 使用std::move转移所有权，ptr1现在为nullptr
  

• 特点：
  • 不支持复制（拷贝构造和拷贝赋值被删除）。
  • 支持移动语义，可以通过 std::move 转移所有权。
  • 适用于独占资源的场景，如 RAII。

2. std::shared_ptr

• 描述：std::shared_ptr 允许多个指针共享同一个动态分配的对象。它使用引用计数来管理资源，当最后一个 shared_ptr 被销毁时，资源才会被释放。
• 用法：

  #include <memory>
  
  std::shared_ptr<int> ptr1(new int(10)); // 创建一个共享的智能指针
  std::shared_ptr<int> ptr2 = ptr1; // 共享所有权，引用计数加1
  

• 特点：
  • 支持复制（拷贝构造和拷贝赋值保持增加引用计数）。
  • 当最后一个 shared_ptr 被销毁或重置时，所指向的对象会被释放。
  • 适用于需要共享所有权的资源管理场景。

3. std::weak_ptr

• 描述：std::weak_ptr 是一种弱引用智能指针，用于解决shared_ptr中的循环引用问题。它不会增加对象的引用计数，主要用来观察但不拥有资源。
• 用法：

  #include <memory>
  
  std::shared_ptr<int> ptr1(new int(20)); // 创建一个共享的智能指针
  std::weak_ptr<int> weakPtr = ptr1; // 创建一个弱引用智能指针
  if (auto sharedPtr = weakPtr.lock()) { // 尝试获取一个shared_ptr
      // 访问资源
  } else {
      // 资源已被释放
  }
  

• 特点：
  • 不控制对象的生命周期，避免循环引用导致的内存泄漏。
  • 通过 lock() 方法可以尝试获取一个 shared_ptr，如果资源已被释放返回 nullptr。
  • 适用于需要观察 shared_ptr 拥有的对象但不想影响其生命周期的场景。

总结

• 如果需要独占资源使用 std::unique_ptr。
• 如果需要共享资源使用 std::shared_ptr。
• 如果需要观察而不拥有资源使用 std::weak_ptr。

注意点和建议：

在回答C++11中智能指针类型的问题时，有几个关键点是很重要的，下面是一些建议和常见误区需要避免：

1. 明确区分智能指针类型：

   • 确保清楚区分std::unique_ptr、std::shared_ptr和std::weak_ptr三种智能指针。每种指针的用途和特点不同，回答时应尽量逐一说明。

2. 使用场景的理解：

   • 解释每种智能指针何时应该使用，并给出实际的使用场景。例如，std::unique_ptr适用于独占所有权的场景，适合对象生命周期管理；std::shared_ptr则用于多个对象共享所有权的时机；std::weak_ptr则用于打破循环引用的情况。

3. 内存管理的原理：

   • 对于std::shared_ptr，需要提及引用计数的概念，并解释在对象的生命周期管理中可能引发的问题，如循环引用。

4. 常见错误：

   • 避免简单地列举智能指针而不深入其实现和用法。这可能表明对C++11智能指针的理解不深。
   • 不要忽视内存管理的原则，比如自动化的内存回收机制，智能指针的优势在于它们可以防止内存泄漏。
   • 注意不要混淆智能指针和原始指针的概念，强调使用智能指针的原因以及它们如何改善代码的可维护性和安全性。

5. 最新标准的了解：

   • 尽量反映出对C++11以后的变化及其引入的智能指针的影响，比如性能优化和安全性增强。

6. 总结及复习：

   • 清晰总结每种智能指针的特性，可以帮助面试官快速了解你的思路。
   • 可以考虑复习相关代码示例，准备一些简单的示例代码来解释如何使用这些智能指针。

总之，讲述智能指针的回答应包括特性、使用场景、内存管理策略，以及它们如何在现代C++中提高代码安全性和可维护性。在面试时候保持思路清晰，有助于更好地展示你对此深度理解的信心。

面试官可能的深入提问：

面试官可能会进一步问：

1. 请解释一下 std::unique_ptr 的特性和使用场景。

   • 提示：关注其独占性、内存管理和作用域管理。

2. std::shared_ptr 和 std::weak_ptr 的关系是什么？

   • 提示：讨论共享所有权和循环引用的问题。

3. 在使用 std::shared_ptr 时，什么情况下需要用到自定义删除器？

   • 提示：考虑资源管理和特殊清理需求的场景。

4. 能否描述 std::shared_ptr 和 std::unique_ptr 的性能差异？

   • 提示：涉及引用计数、内存管理的开销。

5. 如何防止 std::shared_ptr 引发循环引用？

   • 提示：讨论使用 std::weak_ptr 和设计模式。

6. 在多线程环境下，使用智能指针有哪些注意事项？

   • 提示：考虑线程安全和共享资源的使用。

7. 你会选择使用 std::unique_ptr，std::shared_ptr 还是裸指针？为什么？

   • 提示：考虑性能、安全性和适用场景。

8. 请描述如何将智能指针与自定义类型结合使用。

   • 提示：讨论对象的构造、析构和资源管理。

9. 在传递智能指针到函数时，应该使用引用，值还是指针？

   • 提示：考虑性能和所有权的转移。

10. 能否举例说明在实际项目中使用智能指针的误区或者问题？

    • 提示：关注使用不当导致的内存泄漏或异常行为。

---

由于篇幅限制，查看全部题目，请访问：C++面试题库

标签：std,八股文,提示,C++,constexpr,186,使用,ptr
From： https://blog.csdn.net/ocean2103/article/details/142678815