Top 30 C++面试题及答案

作者头像东城·2026-01-31 23:19:52·
概述
以下是Top 30 C++面试题及答案，从基础到高级分类，非常适合工作面试和技术轮次。
🟢 基础级别 (1–10)
1. 什么是C++？
C++是由Bjarne Stroustrup开发的通用、面向对象编程语言。它支持过程式和面向对象编程，使其成为多范式语言。
2. C++的主要特性是什么？
OOP支持（类、继承、多态）
函数和运算符重载
模板
异常处理
STL（标准模板库）
3. C和C++之间有什么区别？
特性
C
C++
范式
过程式
多范式
OOP
否
是
函数重载
否
是
封装
否
是
4. iostream的用途是什么？
#include <iostream>用于C++中使用cin和cout`进行输入/输出操作。
5. cin和cout之间有什么区别？
cin用于输入。
cout用于输出。
两者都是iostream库的一部分。
6. C++中的数据类型有哪些？
基本类型：int、float、double、char、bool
派生类型：array、pointer
用户定义类型：struct、class、union、enum
7. ==和=之间有什么区别？
=是赋值运算符。
==是比较运算符。
8. C++中的指针是什么？
指针是存储另一个变量内存地址的变量。
9. 什么是引用变量？
引用变量是使用&创建的另一个变量的别名。
  1. int a = 10;
  2. int &ref = a;
cpp
10. 什么是构造函数？
构造函数是在创建对象时自动调用的特殊函数。
🟡 中级级别 (11–20)
11. 什么是函数重载？
函数重载允许具有相同名称但不同参数的多个函数。
12. 什么是运算符重载？
运算符重载允许您为运算符定义自定义行为。
  1. class A {
  2. int x;
  3. public:
  4. A(int i): x(i) {}
  5. A operator+(A a) { return A(x + a.x); }
  6. };
cpp
13. C++中的继承是什么？
继承是一个类（子类）继承另一个类（父类）属性的过程。
14. 继承的类型有哪些？
单继承
多继承
多级继承
层次继承
混合继承
15. 什么是多态？
多态意味着具有多种形式。它允许相同的函数名对不同的输入表现出不同的行为。
16. 编译时多态和运行时多态之间有什么区别？
编译时：函数重载、运算符重载
运行时：虚函数
17. 什么是虚函数？
虚函数允许运行时多态，使用virtual关键字声明。
18. 什么是纯虚函数？
  1. virtual void show() = 0;
cpp
它使类成为抽象类，派生类必须重写它。
19. 什么是封装？
封装是通过将数据和函数包装到单个单元（类）中来隐藏数据。
20. 什么是抽象？
抽象意味着隐藏内部细节，只显示相关信息。
🔴 高级级别 (21–30)
21. 什么是标准模板库（STL）？
STL是通用类和函数的库，如vector、map、set、queue等。
22. 类和结构体之间有什么区别？
特性
类
结构体
默认访问权限
private
public
OOP支持
是
部分
23. 什么是访问说明符？
public：在任何地方都可访问
private：仅在类内可访问
protected：在类内和派生类内可访问
24. 构造函数的类型有哪些？
默认构造函数
参数化构造函数
拷贝构造函数
25. 什么是析构函数？
析构函数是使用~ClassName()的特殊函数，用于释放内存。
26. new和malloc()之间有什么区别？
new调用构造函数；malloc不调用
new是C++；malloc是C
27. 什么是this指针？
它是指向当前对象的指针。
28. C++中的智能指针是什么？
智能指针自动管理内存（shared_ptr、unique_ptr、weak_ptr）。
29. 什么是异常处理？
使用try、catch、throw处理运行时错误的机制。
30. C++中的模板是什么？
模板允许编写通用代码。
  1. template <typename T>
  2. T add(T a, T b) {
  3. return a + b;
  4. }
cpp
详细代码示例
基础概念示例
  1. #include <iostream>
  2. #include <string>
  3. using namespace std;

  5. // 1. 基本数据类型和变量
  6. void basicDataTypes() {
  7. int integer = 10;
  8. float floating = 3.14f;
  9. double doubleNum = 3.14159;
  10. char character = 'A';
  11. bool boolean = true;
  13. cout << "Integer: " << integer << endl;
  14. cout << "Float: " << floating << endl;
  15. cout << "Double: " << doubleNum << endl;
  16. cout << "Char: " << character << endl;
  17. cout << "Bool: " << boolean << endl;
  18. }

  20. // 2. 指针和引用
  21. void pointersAndReferences() {
  22. int x = 10;
  23. int* ptr = &x; // 指针
  24. int& ref = x; // 引用
  26. cout << "Original value: " << x << endl;
  27. cout << "Pointer value: " << *ptr << endl;
  28. cout << "Reference value: " << ref << endl;
  30. // 通过指针修改值
  31. *ptr = 20;
  32. cout << "After pointer modification: " << x << endl;
  34. // 通过引用修改值
  35. ref = 30;
  36. cout << "After reference modification: " << x << endl;
  37. }

  39. // 3. 函数重载
  40. int add(int a, int b) {
  41. return a + b;
  42. }

  44. double add(double a, double b) {
  45. return a + b;
  46. }

  48. string add(string a, string b) {
  49. return a + b;
  50. }
cpp
面向对象编程示例
  1. #include <iostream>
  2. #include <string>
  3. using namespace std;

  5. // 基类
  6. class Animal {
  7. protected:
  8. string name;
  9. int age;
  11. public:
  12. // 构造函数
  13. Animal(string n, int a) : name(n), age(a) {
  14. cout << "Animal constructor called" << endl;
  15. }
  17. // 虚函数
  18. virtual void makeSound() {
  19. cout << "Some animal sound" << endl;
  20. }
  22. // 纯虚函数
  23. virtual void move() = 0;
  25. // 析构函数
  26. virtual ~Animal() {
  27. cout << "Animal destructor called" << endl;
  28. }
  29. };

  31. // 派生类
  32. class Dog : public Animal {
  33. private:
  34. string breed;
  36. public:
  37. // 构造函数
  38. Dog(string n, int a, string b) : Animal(n, a), breed(b) {
  39. cout << "Dog constructor called" << endl;
  40. }
  42. // 重写虚函数
  43. void makeSound() override {
  44. cout << name << " says: Woof!" << endl;
  45. }
  47. // 实现纯虚函数
  48. void move() override {
  49. cout << name << " is running" << endl;
  50. }
  52. // 析构函数
  53. ~Dog() {
  54. cout << "Dog destructor called" << endl;
  55. }
  56. };

  58. // 运算符重载示例
  59. class Complex {
  60. private:
  61. double real, imag;
  63. public:
  64. Complex(double r = 0, double i = 0) : real(r), imag(i) {}
  66. // 运算符重载
  67. Complex operator+(const Complex& c) const {
  68. return Complex(real + c.real, imag + c.imag);
  69. }
  71. Complex operator-(const Complex& c) const {
  72. return Complex(real - c.real, imag - c.imag);
  73. }
  75. // 输出运算符重载
  76. friend ostream& operator<<(ostream& out, const Complex& c) {
  77. out << c.real << " + " << c.imag << "i";
  78. return out;
  79. }
  80. };
cpp
模板和STL示例
  1. #include <iostream>
  2. #include <vector>
  3. #include <map>
  4. #include <set>
  5. #include <algorithm>
  6. #include <memory>
  7. using namespace std;

  9. // 函数模板
  10. template<typename T>
  11. T findMax(T a, T b) {
  12. return (a > b) ? a : b;
  13. }

  15. // 类模板
  16. template<typename T>
  17. class Stack {
  18. private:
  19. vector<T> elements;
  21. public:
  22. void push(const T& element) {
  23. elements.push_back(element);
  24. }
  26. T pop() {
  27. if (elements.empty()) {
  28. throw runtime_error("Stack is empty");
  29. }
  30. T element = elements.back();
  31. elements.pop_back();
  32. return element;
  33. }
  35. bool isEmpty() const {
  36. return elements.empty();
  37. }
  39. size_t size() const {
  40. return elements.size();
  41. }
  42. };

  44. // STL容器使用示例
  45. void stlExamples() {
  46. // Vector
  47. vector<int> numbers = {1, 2, 3, 4, 5};
  48. numbers.push_back(6);
  50. // Map
  51. map<string, int> scores;
  52. scores["Alice"] = 95;
  53. scores["Bob"] = 87;
  54. scores["Charlie"] = 92;
  56. // Set
  57. set<int> uniqueNumbers = {1, 2, 2, 3, 3, 4};
  59. // 算法
  60. sort(numbers.begin(), numbers.end());
  61. auto maxElement = max_element(numbers.begin(), numbers.end());
  63. cout << "Max element: " << *maxElement << endl;
  64. }

  66. // 智能指针示例
  67. void smartPointerExamples() {
  68. // unique_ptr
  69. unique_ptr<int> ptr1(new int(10));
  70. cout << "Unique ptr value: " << *ptr1 << endl;
  72. // shared_ptr
  73. shared_ptr<string> ptr2 = make_shared<string>("Hello");
  74. shared_ptr<string> ptr3 = ptr2; // 引用计数增加
  76. cout << "Shared ptr value: " << *ptr2 << endl;
  77. cout << "Reference count: " << ptr2.use_count() << endl;
  79. // weak_ptr
  80. weak_ptr<string> weakPtr = ptr2;
  81. cout << "Weak ptr expired: " << weakPtr.expired() << endl;
  82. }
cpp
异常处理示例
  1. #include <iostream>
  2. #include <stdexcept>
  3. using namespace std;

  5. // 自定义异常类
  6. class DivisionByZeroException : public exception {
  7. public:
  8. const char* what() const noexcept override {
  9. return "Division by zero is not allowed";
  10. }
  11. };

  13. // 异常处理函数
  14. double divide(double a, double b) {
  15. if (b == 0) {
  16. throw DivisionByZeroException();
  17. }
  18. return a / b;
  19. }

  21. // 异常处理示例
  22. void exceptionHandlingExample() {
  23. try {
  24. double result = divide(10, 0);
  25. cout << "Result: " << result << endl;
  26. }
  27. catch (const DivisionByZeroException& e) {
  28. cout << "Caught exception: " << e.what() << endl;
  29. }
  30. catch (const exception& e) {
  31. cout << "Caught general exception: " << e.what() << endl;
  32. }
  33. catch (...) {
  34. cout << "Caught unknown exception" << endl;
  35. }
  36. }

  38. // RAII（资源获取即初始化）示例
  39. class ResourceManager {
  40. private:
  41. int* resource;
  43. public:
  44. ResourceManager() : resource(new int(0)) {
  45. cout << "Resource acquired" << endl;
  46. }
  48. ~ResourceManager() {
  49. delete resource;
  50. cout << "Resource released" << endl;
  51. }
  53. void useResource() {
  54. cout << "Using resource: " << *resource << endl;
  55. }
  56. };
cpp
高级特性示例
  1. #include <iostream>
  2. #include <functional>
  3. #include <thread>
  4. #include <chrono>
  5. using namespace std;

  7. // Lambda表达式示例
  8. void lambdaExamples() {
  9. // 基本lambda
  10. auto add = [](int a, int b) { return a + b; };
  11. cout << "Lambda result: " << add(5, 3) << endl;
  13. // 捕获列表
  14. int multiplier = 10;
  15. auto multiply = [multiplier](int x) { return x * multiplier; };
  16. cout << "Multiply result: " << multiply(5) << endl;
  18. // 可变lambda
  19. int counter = 0;
  20. auto increment = [&counter]() mutable { return ++counter; };
  21. cout << "Counter: " << increment() << endl;
  22. cout << "Counter: " << increment() << endl;
  23. }

  25. // 函数对象示例
  26. class Adder {
  27. private:
  28. int value;
  30. public:
  31. Adder(int v) : value(v) {}
  33. int operator()(int x) const {
  34. return x + value;
  35. }
  36. };

  38. // 移动语义示例
  39. class MoveExample {
  40. private:
  41. int* data;
  42. size_t size;
  44. public:
  45. // 构造函数
  46. MoveExample(size_t s) : size(s) {
  47. data = new int[size];
  48. cout << "Constructor called" << endl;
  49. }
  51. // 拷贝构造函数
  52. MoveExample(const MoveExample& other) : size(other.size) {
  53. data = new int[size];
  54. for (size_t i = 0; i < size; ++i) {
  55. data[i] = other.data[i];
  56. }
  57. cout << "Copy constructor called" << endl;
  58. }
  60. // 移动构造函数
  61. MoveExample(MoveExample&& other) noexcept
  62. : data(other.data), size(other.size) {
  63. other.data = nullptr;
  64. other.size = 0;
  65. cout << "Move constructor called" << endl;
  66. }
  68. // 析构函数
  69. ~MoveExample() {
  70. delete[] data;
  71. cout << "Destructor called" << endl;
  72. }
  73. };
cpp
面试技巧
1. 准备阶段
复习C++基础语法和概念
练习编写面向对象代码
理解内存管理和指针
熟悉STL容器和算法
练习模板编程
2. 面试中
仔细阅读问题要求
先思考再编码
解释你的设计思路
考虑内存安全和性能
讨论代码的可维护性
3. 常见陷阱
忘记处理内存泄漏
忽略const正确性
不熟悉移动语义
缺乏对RAII的理解
忽略异常安全
总结
这30个C++面试题涵盖了从基础概念到高级特性的各个方面：
基础概念：数据类型、指针、引用、函数
面向对象编程：类、继承、多态、封装
高级特性：模板、STL、智能指针、异常处理
现代C++：Lambda表达式、移动语义、RAII
最佳实践：内存管理、性能优化、代码设计
掌握这些概念将帮助您在C++面试中表现出色，并在实际工作中编写高效、安全的代码。