C++ 面试高频问题手册 #

本文整理C++的非常高频的相关面试题。

C 和 C++ 之间的区别是什么？ #

C 和 C++ 是两种广泛使用的编程语言，二者既有联系也存在诸多区别.

语言范式 #

C 语言：是一种面向过程的编程语言。它主要关注解决问题的步骤和过程，通过函数将不同的任务模块化。

程序的执行流程是按照函数的调用顺序依次进行。

比如，我们编写一个计算两个数之和的程序，会定义一个求和函数，然后在主函数中调用该函数完成计算。

#include <stdio.h>

// 定义求和函数
int add(int a, int b) {
    return a + b;
}

int main() {
    int num1 = 3, num2 = 5;
    int result = add(num1, num2);
    printf("两数之和为: %d\n", result);
    return 0;
}

C++ 语言：是一种多范式编程语言，支持面向过程、面向对象和泛型编程。面向对象编程是 C++ 的重要特性，它将数据和操作数据的方法封装在类中，通过类的实例（对象）来实现程序的功能。

泛型编程则允许编写与数据类型无关的代码，提高代码的复用性。例如，使用 C++ 的类来实现上述求和功能：

#include <iostream>

// 定义一个求和类
class Adder {
public:
    int add(int a, int b) {
        return a + b;
    }
};

int main() {
    Adder adder;
    int num1 = 3, num2 = 5;
    int result = adder.add(num1, num2);
    std::cout << "两数之和为: " << result << std::endl;
    return 0;
}

数据抽象和封装 #

C 语言：没有内置的机制来实现数据抽象和封装。虽然可以使用结构体来组织数据，但结构体中的成员通常是公开的，外部代码可以直接访问和修改这些成员，这可能导致数据的不一致性和安全性问题。

#include <stdio.h>

// 定义一个结构体
struct Point {
    int x;
    int y;
};

int main() {
    struct Point p;
    p.x = 10;
    p.y = 20;
    printf("点的坐标为: (%d, %d)\n", p.x, p.y);
    return 0;
}

C++ 语言：通过类和访问修饰符（如 private、protected、public）实现了数据抽象和封装。类中的私有成员只能通过类的公有成员函数来访问和修改，从而隐藏了数据的实现细节。

#include <iostream>

// 定义一个类
class Point {
private:
    int x;
    int y;
public:
    void setCoordinates(int a, int b) {
        x = a;
        y = b;
    }
    void printCoordinates() {
        std::cout << "点的坐标为: (" << x << ", " << y << ")" << std::endl;
    }
};

int main() {
    Point p;
    p.setCoordinates(10, 20);
    p.printCoordinates();
    return 0;
}

继承和多态 #

• C 语言：不支持继承和多态的概念。继承是指一个类可以继承另一个类的属性和方法，多态是指不同的对象可以对同一消息做出不同的响应。
• C++ 语言：支持继承和多态。通过继承，子类可以复用父类的代码，并且可以添加自己的特性。多态可以通过虚函数和指针或引用实现，使得程序在运行时能够根据对象的实际类型来调用相应的函数。

#include <iostream>

// 定义基类
class Shape {
public:
    virtual void draw() {
        std::cout << "绘制形状" << std::endl;
    }
};

// 定义派生类
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形" << std::endl;
    }
};

int main() {
    Shape* shape = new Circle();
    shape->draw();
    delete shape;
    return 0;
}

标准库 #

• C 语言：标准库主要提供了一些基本的输入输出、字符串处理、数学运算等函数，如 printf、scanf、strlen、sqrt 等。这些函数以头文件的形式提供，使用时需要包含相应的头文件。

#include <stdio.h>
#include <math.h>

int main() {
    double num = 16.0;
    double result = sqrt(num);
    printf("16的平方根是: %f\n", result);
    return 0;
}

• C++ 语言：除了兼容 C 语言的标准库外，还拥有自己的标准模板库（STL）。STL 提供了丰富的容器（如 vector、list、map 等）、算法（如 sort、find 等）和迭代器，大大提高了开发效率。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9};
    std::sort(numbers.begin(), numbers.end());
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

错误处理 #

• C 语言：通常使用返回错误码的方式来处理错误。函数在执行过程中如果出现错误，会返回一个特定的错误码，调用者需要根据这个错误码来判断函数的执行情况。这种方式比较繁琐，容易出错。

#include <stdio.h>
#include <errno.h>

int divide(int a, int b, int* result) {
    if (b == 0) {
        errno = EDOM;
        return -1;
    }
    *result = a / b;
    return 0;
}

int main() {
    int num1 = 10, num2 = 0;
    int result;
    if (divide(num1, num2, &result) == -1) {
        perror("除法运算出错");
    } else {
        printf("结果为: %d\n", result);
    }
    return 0;
}

• C++ 语言：引入了异常处理机制，使用 try、catch 和 throw 关键字来处理异常。当程序出现异常时，可以抛出一个异常对象，调用者可以在 catch 块中捕获并处理这个异常，使错误处理更加清晰和灵活。（但，平时编程中，还是建议使用错误码方式）

#include <iostream>

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("除数不能为零");
    }
    return a / b;
}

int main() {
    int num1 = 10, num2 = 0;
    try {
        int result = divide(num1, num2);
        std::cout << "结果为: " << result << std::endl;
    } catch (const std::runtime_error& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }
    return 0;
}

C 与 C++ 核心区别对比 #

C++ 中有哪些不同的数据类型？ #

基本数据类型 #

• 整数类型：用于存储整数数值，有不同的长度和符号属性。

  • int：最常用的整数类型，一般占 32 位，可存储范围约为 -21 亿到 21 亿，适合存储日常使用的整数。
  • short：通常为 16 位，存储范围较小，适用于存储数值范围明确且较小的整数，能节省内存。
  • long：一般为 32 位或 64 位，存储范围比 int 更大，用于存储较大的整数。
  • long long：通常占 64 位，可存储非常大的整数，适用于处理大数值计算。
  • 这些类型都有对应的无符号版本（如 unsigned int），只能存储非负整数，存储的正数范围比有符号类型更大。

• 浮点类型：用于存储小数。

  • float：单精度浮点型，占 32 位，精度相对较低，适用于对精度要求不高的计算场景。
  • double：双精度浮点型，占 64 位，精度比 float 高，是处理浮点运算时更常用的类型。
  • long double：扩展精度浮点型，精度更高，占用位数因编译器而异，用于对精度要求极高的科学计算等场景。

• 字符类型：用于存储单个字符。

  • char：通常占 1 个字节，可表示 ASCII 字符集里的字符，是最常用的字符类型。
  • wchar_t：宽字符类型，用于表示宽字符集，如 Unicode 字符，可处理多种语言的字符。
  • char16_t 和 char32_t：分别用于表示 16 位和 32 位的字符，常用于处理 UTF - 16 和 UTF - 32 编码的字符。

• 布尔类型：只有两个取值，true（真）和 false（假），常用于逻辑判断。

  • bool：占一个字节，让代码中的逻辑表达更清晰。

派生数据类型 #

• 数组：由相同类型元素组成的集合，元素存储在连续的内存位置。

  • 例如：int arr[5]; 定义了一个包含 5 个整数的数组，可通过下标访问每个元素。

• 指针：存储变量的内存地址，通过指针可以间接访问和操作内存中的数据。

  • 例如：int* ptr; 定义了一个指向整数的指针，可用于动态内存分配和操作。

• 引用：变量的别名，对引用的操作等同于对被引用变量的操作。

  • 例如：int num = 10; int& ref = num; 这里 ref 就是 num 的引用，改变 ref 的值，num 的值也会改变。

• 函数：实现特定功能的代码块，可通过参数传递数据，执行相应操作并返回结果。

  • 例如：int add(int a, int b) { return a + b; } 定义了一个返回两个整数之和的函数。

用户自定义数据类型 #

• 结构体：可以包含不同类型的数据成员，将相关的数据组织在一起。
  • 例如：

struct Person {
    std::string name;
    int age;
};

这里定义了一个Person结构体，包含姓名和年龄两个成员。

• 类：面向对象编程的核心，类中可包含数据成员和成员函数，用于实现数据的封装和操作。例如：

class Rectangle {
private:
    int length;
    int width;
public:
    Rectangle(int l, int w) : length(l), width(w) {}
    int area() { return length * width; }
};

定义了一个Rectangle类，有长和宽两个私有成员，以及计算面积的成员函数。

• 枚举：定义了一组命名的整数常量，使代码更具可读性。例如：

enum Color { RED, GREEN, BLUE };

定义了一个Color枚举，包含红、绿、蓝三种颜色的常量。

C++ 中的引用是什么？ #

在 C++ 中，引用是为另一个变量创建别名的另一种方式。

引用作为变量的同义词，允许你直接访问变量而不需要任何额外的语法。

它们必须在创建时初始化，并且之后不能改变以引用另一个变量。这个特性使得在函数中操作变量时避免了复制大对象的开销。

引用变量前面有一个 & 符号。

语法：

int tmp = 10; 

// 引用变量
int& ref = tmp;

C++ 中值传递和引用传递的区别？ #

回答重点 #

1）值传递：在函数调用时，会触发一次参数的拷贝动作，所以对参数的修改不会影响原始的值。如果是较大的对象，复制整个对象，效率较低。

2）引用传递：函数调用时，函数接收的就是参数的引用，不会触发参数的拷贝动作，效率较高，但对参数的修改会直接作用于原始的值。

扩展知识 #

看两种传递方式的示例代码：

值传递

void modify_value(int value) {
    value = 100; // 只会修改函数内部的副本，不会影响原始变量
}

int main() {
    int a = 20;
    modify_value(a);
    std::cout << a; // 20，没变
    return 0;
}

引用传递

void modify_value(int& value) {
    value = 100; // 修改引用指向的原始变量
}

int main() {
    int a = 20;
    modify_value(a);
    std::cout << a; // 100，因为是引用传递，所以这里已经改为了100
    return 0;
}

深入理解 #

什么场景下使用引用传递？ #

• 避免不必要的数据拷贝：对于比较大的对象参数（比如 std::vector、std::string、std::list），因为拷贝会导致大量的内存和时间开销。而引用传递可以避免这些开销。
• 允许函数修改实参原始值：有时候，我们就是希望函数能够直接修改传入的变量值，这时使用引用传递很合理。

什么场景下使用值传递？ #

• 小型数据结构：对于 int、char、double、float 这种基础数据类型，可以直接简单的使用值传递。
• 不希望函数修改实参：有时候，我们需要修改变量数据，但是又不希望修改原始值，可以考虑使用值传递。

值定义和引用定义 #

栈和链表，是在栈上分配内存还是堆上分配内存呢？两种情况都有可能，如果我们是在函数内直接创建的话，则是栈分配内存，如果是通过指针创建的话，则是在堆上分配内存，并且需要手动删除

栈上分配

#include<iostream>
int main() {
    int arr[5] = {1, 2, 3, 4, 5}; // 在栈上分配一个包含 5 个整数的数组
    for (int i = 0; i < 5; ++i) {
        std::cout<< arr[i] << " ";
    }
    return 0;
}

堆上分配

#include<iostream>
int main() {
    int* arr = new int[5]{1, 2, 3, 4, 5}; // 在堆上分配一个包含 5 个整数的数组
    for (int i = 0; i < 5; ++i) {
        std::cout<< arr[i] << " ";
    }
    delete[] arr; // 释放堆上分配的数组内存
    return 0;
}

当然链表也可以这样，无论是结构体还是类，都有两种定义方式，值定义和引用定义，值定义则是栈分配内存，引用定义则是堆分配内存。

#include<iostream>
struct MyStruct {
    int x;
};
class MyClass {
public:
    int x;
};
int main() {
    // 结构体的值定义
    MyStruct structVar1{42};
    // 结构体的引用定义
    MyStruct* structVar2 = new MyStruct{42};
    // 类的值定义
    MyClass classVar1{42};
    // 类的引用定义
    MyClass* classVar2 = new MyClass{42};
    // 释放堆上分配的内存
    delete structVar2;
    delete classVar2;
    return 0;
}

C++ 值传递 vs 引用传递对比 #

🌟C++ 中 static 的作用？什么场景下用到 static？ #

谈到 C++ 的 static，可以重点回答以下几个方面：

1）修饰局部变量：当 static 用于修饰局部变量时，这个变量的存储位置会在程序执行期间保持不变，且只在程序执行到该变量的声明处时初始化一次。

即使函数被多次调用，static 局部变量也只在第一次调用时初始化，之后的调用将不会重新初始化它。

2）修饰全局变量或函数：当 static 用于修饰全局变量或函数时，限制了这些变量或函数的作用域，它们只能在定义它们的文件内部访问。有助于避免在不同文件之间的命名冲突。

3）修饰类的成员变量或函数：在类内部，static 成员变量或函数属于类本身，而不是类的任何特定对象。这意味着所有对象共享同一个 static 成员变量，无需每个对象都存储一份拷贝。static 成员函数可以在没有类实例的情况下调用。

static 的用法 #

1. static 局部变量

#include <iostream>
using namespace std;

void func() {
    static int count = 0; // 只在第一次调用func时初始化
    cout << "Count is: " << count << endl;
    count++;
}

int main() {
    for(int i = 0; i < 5; i++) {
        func(); // 每次调用都会显示增加的count值
    }
    return 0;
}

2. static 全局变量或函数

// file1.cpp
static int count = 10; // count变量只能在file1.cpp中访问

static void func() { // func函数只能在file1.cpp中访问
    cout << "Function in file1" << endl;
}

// file2.cpp
extern int count; // 这里会导致编译错误，因为count是static的，不能在file2.cpp中访问

void anotherFunc() {
    func(); // 这里也会导致编译错误，因为func是static的，不能在file2.cpp中访问
}

3. static 类的成员变量或函数

#include <iostream>
using namespace std;

class MyClass {
public:
    static int staticValue; // 静态成员变量
    static void staticFunction() { // 静态成员函数
        cout << "Static function called" << endl;
    }
};

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

int main() {
    MyClass::staticFunction(); // 调用静态成员函数
    cout << MyClass::staticValue << endl; // 访问静态成员变量
    return 0;
}

使用场景总结 #

• static 局部变量：当你需要在函数的多次调用之间保持某个变量的值时。
• static 全局变量或函数：当你想要限制变量或函数的作用域，防止它们在其他文件中被访问时。
• static 类的成员变量或函数：当你想要类的所有对象共享某个变量或函数时，或者当你想要在没有类实例的情况下访问某个函数时。

static 线程安全吗 #

static 局部变量在 C++11 及之后的初始化是线程安全的，在 C++11 之前非线程安全，需要手动加锁。

static 的全局变量在程序启动前（main 之前）完成的，默认就是线程安全的。

而无论初始化是否安全，多线程访问 static 变量都不是线程安全的，都需要显式的处理同步问题。

🌟C++ 中 const 的作用？谈谈你对 const 的理解？ #

回答重点 #

const 最主要的作用就是声明一个变量为常量，即这个变量的值在初始化之后就不能被修改。

但 const 不仅可以用作普通常量，还可以用于指针、引用、成员函数、成员变量等。

具体作用如下：

1）定义普通常量：当修饰基本数据类型的变量时，表示常量含义，对应的值不能被修改。

const int MAX_SIZE = 100; // MAX_SIZE是一个常量，其值不能被修改

2）修饰指针：这里分多种情况，比如指针本身是常量，指针指向的数据是常量，或者指针本身和其指向的数据都是常量。

3）修饰引用：const 修饰引用时，一般用作函数参数，表示函数不会修改传递的参数值。

void func(const int& a) { // a是一个对常量的引用，不能通过a修改其值  
    // ...  
}

4）修饰类成员函数：const 修饰成员函数，表示函数不会修改类的任何成员变量，除非这些成员变量被声明为 mutable。

class MyClass {  
public:  
    void myFunc() const { // myFunc是一个const成员函数，它不会修改类的任何成员变量  
        // ...  
    }  
};

5）修饰类成员变量：const 修饰成员变量，表示生命期内不可改动此值。

class MyClass {  
public:  
    const int a = 5;
};

扩展知识 #

const 修饰指针时，可以分多种情况：

1）指向常量的指针：指针指向的内容是常量，不能通过该指针修改其所指向的值。

const intptr = &x; // ptr是一个指向常量的指针，不能通过ptr修改x的值

2）指针常量：指针本身是常量，指针的值（即指向的地址）不能被修改，但可以通过该指针修改其所指向的值（如果所指向的不是常量）。

int* const ptr = &x; // ptr是一个常量，ptr的值（地址）不能被修改，但x的值可以被修改

3）指向常量的常量指针：指针本身是常量，且指针指向的内容也是常量。

const int* const ptr = &x; // ptr的值和ptr指向的值都不能被修改

解释 C++ 中的构造函数。 #

C++ 中的构造函数是一种特殊的成员函数，与类同名，无返回类型，用于在创建对象时，对对象进行初始化，有默认、带参、拷贝等多种类型，保证对象创建后处于有效状态。

C++ 中的析构函数是什么？ #

析构函数是 C++ 里的一种特殊成员函数，它和类同名，不过前面得加个波浪线 ~，没有返回值，也不能有参数。

它的主要作用是在对象的生命周期结束时，做一些清理工作，像释放对象占用的动态内存、关闭打开的文件之类的。

当对象离开作用域或者用 delete 删除动态分配的对象时，析构函数就会自动被调用，保证资源能被正确释放，避免内存泄漏等问题。就好比你离开房间的时候，要把房间里的东西收拾好，把灯关掉一样。

什么是虚析构函数？ #

虚析构函数就是在基类里用 virtual 关键字声明的析构函数。当用基类指针指向派生类对象，且通过该指针删除对象时，若基类析构函数不是虚拟的，那就只会调用基类析构函数，派生类析构函数不会被调用，可能造成资源泄漏；但如果基类析构函数是虚拟的，程序在运行时会先调用派生类析构函数，再调用基类析构函数，确保派生类对象能被完整地销毁。

析构函数重载是否可能？如果可以，那么解释；如果不可以，那么为什么？ #

答案是不可以，我们不能重载析构函数。每个类中只能有一个析构函数。同样需要提到的是，析构函数既不接受参数，也没有可能帮助重载的参数。

🌟C++ 中都有哪些构造函数？ #

回答重点 #

• 默认构造函数：这就是普通的构造函数，如果没有构建的话，则会默认帮你创建
• 参数构造函数：带有参数的构造函数，允许创建对象时传递参数，以便根据这些参数初始化对象
• 拷贝构造函数：拷贝构造函数用于通过已有对象初始化新对象，接收一个同类型对象的引用作为参数，可以理解为拷贝了一个情况相同的对象，但是分别位于不同的内存块，修改新对象的状态不会影响源对象，反之亦然。
• 委托构造函数：允许在一个构造函数内部调用另一个构造函数，从而减少代码重复，这通过在构造函数的初始化列表中使用 this 指针调用另一个构造函数来实现

扩展知识 #

直接看代码，方便我们理解：

#include<iostream>
class MyClass {
public:
    // 默认构造函数
    MyClass() {
        std::cout << "Default constructor called."<< std::endl;
    }
    // 参数化构造函数
    MyClass(int a) : x(a) {
        std::cout << "Parameterized constructor called."<< std::endl;
    }
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        x = other.x;
        std::cout << "Copy constructor called."<< std::endl;
    }
    // 委托构造函数
    MyClass() : MyClass(0) {
        std::cout << "Delegating constructor called."<< std::endl;
    }
    MyClass(int a) : x(a) {
        std::cout << "Parameterized constructor called."<< std::endl;
    }
private:
    int x;
};
int main() {
    // 使用默认构造函数创建对象
    MyClass obj1;
    // 使用参数化构造函数创建对象
    MyClass obj2(42);
    // 使用拷贝构造函数创建对象
    MyClass obj3(obj2);
    // 使用委托构造函数创建对象
    MyClass obj4;
    return 0;
}

哪些操作允许在指针上进行？ #

在 C++ 里，指针允许进行下面这些操作：

赋值操作 #

可以把一个变量的地址赋给指针，或者让一个指针指向另一个指针所指向的地址。比如：

int num = 10;
int* ptr = # // 把num的地址赋给ptr
int* anotherPtr = ptr; // anotherPtr指向ptr所指向的地址

解引用操作 #

使用解引用操作符 * 能访问指针所指向的变量的值。例如：

int num = 10;
int* ptr = #
cout << *ptr; // 输出10

指针算术运算 #

• 指针加整数：可以让指针向后移动若干个元素的位置。假设 ptr 是指向数组元素的指针，ptr + n 就表示向后移动 n 个元素。

int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr;
int* newPtr = ptr + 2; // newPtr指向arr[2]

• 指针减整数：和加整数相反，是让指针向前移动若干个元素的位置。
• 指针减指针：两个指向同一个数组元素的指针相减，得到的是它们之间元素的个数。

比较操作 #

可以对指针进行比较，比如判断两个指针是否指向同一个地址，或者一个指针是否大于、小于另一个指针。

int arr[5] = {1, 2, 3, 4, 5};
int* ptr1 = &arr[0];
int* ptr2 = &arr[2];
if (ptr1 < ptr2) {
    cout << "ptr1在ptr2前面";
}

类型转换 #

能把指针从一种类型转换为另一种类型，但要注意这样做可能会带来风险，得谨慎使用。

int num = 10;
int* intPtr = #
char* charPtr = reinterpret_cast<char*>(intPtr); // 强制类型转换

delete 运算符的目的是什么？ #

delete 运算符用于释放通过 new 运算符在堆上动态分配的内存，调用对象的析构函数完成资源清理，防止内存泄漏。

delete []与 delete 的区别是什么？ #

delete 用于释放单个由 new 分配的对象的内存并调用其析构函数，而 delete [] 用于释放由 new[] 分配的数组对象的内存，会依次调用数组中每个对象的析构函数。

C++ 中 char*、const char*、char* const、const char* const 的区别？ #

回答重点 #

一个小技巧，从后往前读：

1）char*：这是一个指向 char 类型数据的指针，指针以及它指向的数据都是可变的。可以改变指针的指向和指向的数据。

2）const char*：*指向 const char，这是一个指向 const char 类型数据的指针。指针本身是可变的，但指针指向的数据是不可变的。简单来说，可以改变指针的指向，但不能改变它指向的数据内容。

3）char* const：const 修饰 char*，这是一个指向 char 类型数据的常量指针。指向的数据是可变的，但指针本身是不可变的。也就是说，不能改变指针的指向，但能修改指向的数据。

4）const char* const：这是一个指向 const char 类型数据的常量指针。指针和指向的数据都是不可变的，也就是既不能改变指针的指向，也不能修改指针指向的数据。

扩展知识 #

看一些代码示例。

1）char*:

char data[] = "Hello";
char* p = data;
p[0] = 'h'; // 修改数据内容，是允许的
p = nullptr; // 改变指针指向，是允许的

2）const char*:

const char* p = "Hello";
p[0] = 'h'; // 错误：不能修改数据内容
p = "World"; // 允许：改变指针指向

3）char* const:

char data[] = "Hello";
char* const p = data;
p[0] = 'h'; // 允许：修改数据内容
p = nullptr; // 错误：不能改变指针指向

4）const char* const:

const char* const p = "Hello";
p[0] = 'h'; // 错误：不能修改数据内容
p = "World"; // 错误：不能改变指针指向

除了这些类型修饰符，理解指针和引用在函数参数中的应用也很重要。

比如在接口设计中，通过使用 const char* 可以保证函数不会修改传入的字符串数据，从而提高代码的安全性。

合理使用 const 也有助于避免潜在的错误。例如，较为复杂的类和对象也可以通过 const 修饰，来确保在调用成员函数时不会意外修改对象的状态。

🌟C++ 中数组和指针的区别？ #

详见：数组不是指针，指针也不是数组

回答重点 #

主要的区别可以总结为以下几点：

1）内存分配：

• 数组：编译器会在栈上为数组的所有元素分配连续的内存空间。
• 指针：指针本身只占用一个内存单元（通常是 4 或 8 字节），它存储的是一个地址。初始化指针之后，可以通过动态内存分配（例如使用 new 或 malloc）来分配内存。

2）固定与动态大小：

• 数组：数组的大小在声明时就确定了，数组的大小需要是常量，无法在运行时改变。
• 指针：指针比较灵活，它指向的内存如果是堆内存，可以在运行时动态分配和释放内存，灵活性更好。

3）类型安全性：

• 数组：数组在声明时绑定了具体的类型，编译器在访问数组时可以进行类型检查。
• 指针：指针声明时也有类型，但指针所指向的内存地址可以重新赋值，容易引起类型不匹配的问题，可能导致运行时错误，特别是指针类型经常转换的场景，比如 int* 转 void* 等等。

4）运算操作：

• 数组：数组名可以看作是数组首元素的常量指针，但不能直接进行算术运算（如 ++ 或 --）。
• 指针：指针变量可以直接进行算术运算，比如递增、递减操作，从而访问不同的位置。

扩展知识 #

我们可以从几个方面进一步探讨：

1）数组和指针的转换：

• 在表达式中，数组名会被自动转换为指向数组首元素的地址。例如，假设 int arr[5]，则 arr 会被转换为 &arr[0]。

2）动态数组：

• 动态数组的实现需要使用指针。例如，int* arr = new int[5]; 这种方式在运行时分配的内存可以随意调整大小。

3）内存管理：

• 编程时需要注意内存泄漏问题。使用指针分配的内存（例如使用 new）需要显式地释放（例如使用 delete 或 delete[]），否则会导致内存泄漏。

4）多维数组与指针：

• 多维数组在内存中是按行优先顺序存储的，理解这一点有助于使用指针遍历多维数组。

5）高效代码：

• 在写高性能代码时，指针有时可以比数组更高效，因为指针的算术运算更加灵活。

🌟C++ 中 sizeof 和 strlen 的区别？ #

回答重点 #

两者的功能其实有很大区别：

1）sizeof 是一个编译时运算符，用于获取一个类型或者对象的大小（以字节为单位）。sizeof 在编译时计算结果，不涉及实际内容。

2）strlen 是一个库函数，用于计算 C 风格字符串的长度（不包括终止字符’\0’）。strlen 是在运行时计算结果的，因为它需要遍历字符串内容。

扩展知识 #

1）sizeof 的应用：

• 用于计算基础类型的大小，比如 sizeof(int)。
• 用来计算结构体或类的内存占用，比如 sizeof(MyClass)。
• 对于静态数组，可以获取整个数组的内存大小，比如 sizeof(arr)，其中 arr 是一个静态数组。

注意，对于指针，sizeof 返回的是指针本身的大小，而不是指针所指向的内存区域的大小。例如：

int *p = new int[10];
std::cout << sizeof(p); // 这会返回指针的大小，通常是4或8个字节，具体取决于系统架构。

2）strlen 的应用：

• 常用于计算 C 风格字符串的长度。注意，strlen 是不包括字符串末尾的终止符’\0’的。
• 对于一些特定字符数组，strlen 非常有用，比如 char arr[] = "Hello";，strlen(arr) 返回的是 5。

注意，strlen 不能用于未以 \0 结尾的字符数组，否则会导致未定义行为。例如：

char arr[5] = {'H', 'e', 'l', 'l', 'o'};
std::cout << strlen(arr); // 这会导致未定义行为，因为没有终止符'\0'。

3）获取动态分配内存的大小：

对于使用 new 动态分配的内存，sizeof 不能直接获取分配的内存大小。在这种情况下，需要在分配内存时显式记录内存大小。

int main() {
    int n = 10;
    int* arr = new int[n];
    // std::cout << "Size of dynamic array: "<< sizeof(arr) << " bytes"<< std::endl; // 错误：这将输出指针的大小，而不是数组的大小
    std::cout << "Size of dynamic array: " << n * sizeof(int) << " bytes"<< std::endl; // 正确：手动计算数组大小
    delete[] arr;
    return 0;
}

4）空类的大小

即使是一个空类（不包含任何数据成员和成员函数的类），sizeof 返回的值也至少为一个字节。这是为了确保在不同的编译器和平台上，空类的对象具有唯一标识。

class EmptyClass {};
int main() {
    std::cout << "Size of EmptyClass: "<< sizeof(EmptyClass) << " bytes"<< std::endl;
    return 0;
}

总结，sizeof 和 strlen 有其各自的用途和使用场景，一个用于计算类型大小，一个用于计算字符串长度。

🌟C++ 中四种类型转换的使用场景？ #

回答重点 #

在 C++ 中，有四种常用的类型转换：

1）static_cast：用于在有明确定义的类型之间进行转换，如基本数据类型之间的转换以及指针或引用的上行转换（从派生类到基类）。

2）dynamic_cast：主要用于多态类型的指针或引用转换，特别适用于需要安全地执行下行转换（从基类到派生类）。

3）const_cast：用于移除对象的 const 或添加 const 属性，这在需要更改常量数据时非常有用。

4）reinterpret_cast：提供了一种最底层的转换方式，类似于 C 语言中的强转，通常用于指针类型之间的转换。

扩展知识 #

我们详细地讨论下每种类型转换的更多细节和注意事项。

1）static_cast：

• 用法：主要用于已知类型之间的转换，比如 int 转换为 float 或者从派生类指针转换为基类指针。
• 示例：

int a = 10;
float b = static_cast<float>(a);  // 将 int 转换为 float

• 注意事项：static_cast 进行的类型转换在编译时检查，但不会进行运行时检查。

2）dynamic_cast：

• 用法：主要用于多态基类，能够基于运行时类型信息将基类指针或引用转换为派生类指针或引用。
• 示例：

Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);  // 运行时检查并转换

• 注意事项：只有在类包含虚函数时才能使用 dynamic_cast，而如果转换失败，指针会返回 nullptr，引用则会抛出 std::bad_cast 异常。

3）const_cast：

• 用法：移除或者添加常量修饰，通常在需要修改被标记为 const 的数据时使用。
• 示例：

const int a = 10;
int *b = const_cast<int*>(&a);  // 移除 const 属性
*b = 20;  // 修改原本为 const 的值

• 注意事项：const_cast 仅影响底层 const 属性，而并不影响顶层 const。同样，修改原本为 const 的变量可能会引发未定义行为，应该谨慎使用。

4）reinterpret_cast：

• 用法：主要用于在几乎无关的类型之间进行转换，比如将指针类型转换为整型，或相反。这通常用于底层操作，比如硬件编程，或某些预期内的操作。
• 示例：

long p = 0x12345678;
inti = reinterpret_cast<int*>(p);  // 将 long 转换为 int 指针

• 注意事项：这种转换不会进行类型安全检查，可能会改变位模式，应尽量避免使用，除非确实需要进行底层操作。

C++ 中 struct 和 class 的区别？ #

回答重点 #

在 C++ 中，struct 和 class 的主要区别就在于它们的默认访问级别：

1）struct 的默认成员访问级别是 public。

2）class 的默认成员访问级别是 private。

扩展知识 #

虽然默认访问级别是 struct 和 class 之间的主要区别，但在实际编程中，还有一些方面也值得注意：

1）内存布局和性能：

• 在大多数情况下，struct 和 class 的内存布局是一样的，因为它们本质上除了访问级别之外，其他都是相同的。
• 在访问级别相同的情况下，二者的性能并无区别。

2）习惯用法：

• struct 一般用于表示简单的数据结构或 POD（Plain Old Data） 类型。POD 类是所有非静态数据成员共享相同访问级别、没有虚函数、没有继承的类。
• class 一般用于表示复杂的数据类型，特别是在对象需要封装和抽象，以及需要使用功能性的成员函数时。

3）继承模型：

• 类可以有继承关系，通过 private、protected 和 public 指定继承的访问级别，默认是 private 继承。
• 结构体同样可以有继承关系，默认是 public 继承。
• 上述特指在 C++ 中，在 C 语言中的 struct 是没有继承能力的。

4）编程风格：

• 代码风格和团队规范可能对 struct 和 class 的使用有明确的指示。例如，在一个面向对象的项目中，使用 class 定义所有对象可能更为规范，而 struct 则更多地用于数据传输对象（DTO）。

5）友元函数：

• 友元函数或友元类在 struct 和 class 中都适用，用法完全一样，唯一的区别是，如果你在 struct 里通常不需要那么多封装，在这种情况下友元可能用的不多。

🌟C++ 中 new 和 malloc 的区别？delete 和 free 的区别？ #

回答重点 #

在 C++ 中，new 和 malloc 以及 delete 和 free 是内存管理的两对主要操作符和函数。它们虽然都有分配和释放内存的功能，但在很多方面都有区别。

1. new vs malloc:

   • new 是 C++ 的操作符，而 malloc 是 C 标准库的函数。
   • new 分配内存并调用构造函数，而 malloc 仅仅分配内存，不调用构造函数。
   • new 返回一个类型安全的指针，而 malloc 返回 void*，需要显式类型转换。
   • new 在分配失败时抛出 std::bad_alloc 异常，而 malloc 返回 NULL。

2. delete vs free:

   • delete 是 C++ 的操作符，而 free 是 C 标准库的函数。
   • delete 销毁对象并调用析构函数，然后释放内存，而 free 仅仅释放内存，不调用析构函数。
   • delete 必须与 new 配对使用，而 free 必须与 malloc 配对使用。
   • delete 和 delete[] 是不同的，前者用于单一对象，后者用于数组。free 没有这种区分。

扩展知识 #

1. 更多关于new和malloc的不同:

   • 异常处理: 在 new 语句中，如果内存分配失败，会抛出 std::bad_alloc 异常，你可以使用 try-catch 块处理这个异常。相比之下，malloc 返回 NULL 值，需要程序员手动检查并处理。
   • 类型兼容: new 更适合 C++ 中的类对象，因为它自动调用构造函数进行初始化，而 malloc 更适合简单的数据类型或 C 风格编程。

2. 更多关于delete和free的不同:

   • 使用安全性: 使用 delete 时，不会像 free 那样导致未定义行为，因为它会调用析构函数来清理对象。在涉及复杂对象管理时，这种自动调用析构函数的特性非常有用。
   • 灵活性和匹配: 使用不同类型的 delete 操作符（delete 和 delete[]）来区分释放单个对象和对象数组。free 函数则没有这种灵活性。

3. 开发建议:

   • 建议尽量使用智能指针（如 std::unique_ptr 和 std::shared_ptr），它们可以自动管理内存，减少内存泄漏和其他潜在的内存管理问题。

🌟 左值和右值的区别？ #

回答重点 #

什么是左值？什么是右值？

• 左值：可以出现在赋值运算符的左边，并且可以被取地址，通常是有名字的变量
• 右值：不能出现在赋值运算符的左边，不可以被取地址，表示一个具体的数据值，通常是常量、临时变量

一般可以从两个方向区分左值和右值。

方向 1：

• 左值：可以放到等号左边的东西叫左值。
• 右值：不可以放到等号左边的东西就叫右值。

方向 2：

• 左值：可以取地址并且有名字的东西就是左值。
• 右值：不能取地址的没有名字的东西就是右值。

示例：

int a = b + c;

a 是左值，有变量名，可以取地址，也可以放到等号左边, 表达式 b+c 的返回值是右值，没有名字且不能取地址，&(b+c)不能通过编译，而且也不能放到等号左边。

int a = 4; // a是左值，4作为普通字面量是右值

扩展知识 #

左值引用 #

可以理解为是对左值的引用。对于左值引用，等号右边的值必须可以取地址，如果不能取地址，则会编译失败，或者可以使用 const 引用形式，但这样就只能通过引用来读取输出，不能修改数组，因为是常量引用。

示例代码：

int a = 5;
int &b = a; // b是左值引用
b = 4;
int &c = 10; // error，10无法取地址，无法进行引用
const int &d = 10; // ok，因为是常引用，引用常量数字，这个常量数字会存储在内存中，可以取地址

右值引用 #

可以理解为是对右值的引用。即对一个临时对象或者即将销毁的对象的引用，开发者可以利用这些临时对象，却不需要复制它们。

如果使用右值引用，那表达式等号右边的值需要是右值，可以使用 std::move 函数强制把左值转换为右值。

int a = 4;
int &&b = a; // error, a是左值
int &&c = std::move(a); // ok

左值引用和右值引用的使用场景 #

• 左值引用：当你需要修改对象的值，或者需要引用一个持久对象时使用。
• 右值引用：当你需要处理一个临时对象，并且想要避免复制，或者实现移动语义时使用。

纯右值 #

纯右值属于右值。运算表达式产生的临时变量、不和对象关联的原始字面量、非引用返回的临时变量、lambda 表达式等都是纯右值。

举例：

• 除字符串字面值外的字面值
• 返回非引用类型的函数调用
• 后置自增自减表达式 i++、i–
• 算术表达式(a+b, a*b, a&&b, a==b 等)
• 取地址表达式等(&a)

介绍下移动语义与完美转发 #

回答重点 #

移动语义和完美转发都是 C++11 引入的新特性。

移动语义 #

一种优化资源管理的机制。常规的资源管理是拷贝别人的资源。而移动语义是转移所有权，转移了资源而不是拷贝资源，性能会更好。

移动语义通常用于那些比较大的对象，搭配移动构造函数或移动赋值运算符来使用。

示例代码：

class A {
public:
    A(int size) : size_(size) {
        data_ = new int[size];
    }
    A(){}
    A(const A& a) {
        size_ = a.size_;
        data_ = new int[size_];
        cout << "copy " << endl;
    }
    A(A&& a) {
        this->data_ = a.data_;
        a.data_ = nullptr;
        cout << "move " << endl;
    }
    ~A() {
        if (data_ != nullptr) {
         delete[] data_;
        }
    }
    int *data_;
    int size_;
};
int main() {
    A a(10);
    A b = a;
    A c = std::move(a); // 调用移动构造函数
    return 0;
}

如果不使用 std::move，会有很大的拷贝代价，使用移动语义可以避免很多无用的拷贝，提供程序性能，C++ 所有的 STL 都实现了移动语义，方便我们使用。例如：

std::vector<string> vecs;
...
std::vector<string> vecm = std::move(vecs); // 免去很多拷贝

完美转发 #

完美转发指可以写一个接受任意实参的函数模板，并转发到其它函数，目标函数会收到与转发函数完全相同的实参，转发函数实参是左值那目标函数实参也是左值，转发函数实参是右值那目标函数实参也是右值。

那如何实现完美转发呢？答案是使用 ``std::forward，可参考以下代码：

void PrintV(int &t) {
    cout << "lvalue" << endl;
}

void PrintV(int &&t) {
    cout << "rvalue" << endl;
}

template<typename T>
void Test(T &&t) {
    PrintV(t);
    PrintV(std::forward<T>(t));

    PrintV(std::move(t));
}

int main() {
    Test(1); // lvalue rvalue rvalue
    int a = 1;
    Test(a); // lvalue lvalue rvalue
    
    Test(std::forward<int>(a)); // lvalue rvalue rvalue
    
    Test(std::forward<int&>(a)); // lvalue lvalue rvalue
    
    Test(std::forward<int&&>(a)); // lvalue rvalue rvalue
    return 0;
}

分析：

• Test(1)：1 是右值，模板中 T &&t 这种为万能引用，右值 1 传到 Test 函数中变成了右值引用，但是调用 PrintV() 时候， t 变成了左值，因为它变成了一个拥有名字的变量，所以打印 lvalue ，而 PrintV(std::forward(t)) 时候，会进行完美转发，按照原来的类型转发，所以打印 rvalue ， PrintV(std::move(t)) 毫无疑问会打印 rvalue 。
• Test(a)：a 是左值，模板中 T && 这种为万能引用，左值 a 传到 Test 函数中变成了左值引用，所以有代码中打印。
• Test(std::forward(a))：转发为左值还是右值，依赖于 T，T 是左值那就转发为左值，T 是右值那就转发为右值。

扩展知识 #

深拷贝与浅拷贝

示例代码：

class A {
public:
    A(int size) : size_(size) {
        data_ = new int[size];
    }
    A(){}
    A(const A& a) {
        size_ = a.size_;
        data_ = a.data_;
        cout << "copy " << endl;
    }
    ~A() {
        delete[] data_;
    }
    int *data_;
    int size_;
};
int main() {
    A a(10);
    A b = a;
    cout << "b " << b.data_ << endl;
    cout << "a " << a.data_ << endl;
    return 0;
}

上面代码中，两个输出的是相同的地址，a 和 b 的 data_ 指针指向了同一块内存，这就是浅拷贝，只是数据的简单赋值，那在析构时 data_ 内存会被释放两次，如何消除这种隐患呢，可以使用如下深拷贝：

class A {
public:
    A(int size) : size_(size) {
        data_ = new int[size];
    }
    A(){}
    A(const A& a) {
        size_ = a.size_;
        data_ = new int[size_];
        cout << "copy " << endl;
    }
    ~A() {
        delete[] data_;
    }
    int *data_;
    int size_;
};
int main() {
    A a(10);
    A b = a;
    cout << "b " << b.data_ << endl;
    cout << "a " << a.data_ << endl;
    return 0;
}

深拷贝就是在拷贝对象时，如果被拷贝对象内部还有指针引用指向其它资源，自己需要重新开辟一块新内存存储资源，而不是简单的赋值。

🌟C++ 中 move 有什么作用？它的原理是什么？ #

回答重点 #

move 是 C++11 引入的一个新特性，用来实现移动语义。它的主要作用是将对象的资源从一个对象转移到另一个对象，而无需进行深拷贝，减少了资源内存的分配，可提高性能。

它的原理很简单，我们直接看它的源码实现：

// move
template <class T>
LIBC_INLINE constexpr cpp::remove_reference_t<T> &&move(T &&t) {
  return static_cast<typename cpp::remove_reference_t<T> &&>(t);
}

源码取自：https://github.com/llvm/llvm-project/blob/cceedc939a43c7c732a5888364251775bffc2dba/libc/src/__support/CPP/utility/move.h#L19

从源码中你可以看到，std::move 的作用只有一个，无论输入参数是左值还是右值，都强制转成右值。

扩展知识 #

1）move 转成右值有什么好处？

这就涉及到移动语义的概念，右值可以触发移动语义，那什么是移动语义？我们可以理解为在对象转换的时候，通过右值可以触发到类的移动构造函数或者移动赋值函数。

因为触发了移动构造函数 或者 移动赋值函数，我们就默认，原对象后面已经不会再使用了（包括内部的某些内存），这样我们就可以在新对象中直接使用原对象的那部分内存，减少了数据的拷贝操作，昂贵的拷贝转为了廉价的移动，提升了程序的性能。

2）是不是 std::move 后的对象就没法使用了？

其实不是，还是取决于搭配的移动构造函数 和 移动赋值函数是如何实现的。

如果在移动构造函数 + 移动赋值函数中，还是使用了拷贝动作，那原对象还是可以使用的，见下面示例。

#include <chrono>
#include <functional>
#include <future>
#include <iostream>
#include <string>

class A {
public:
    A() {
        std::cout << "A() \n";
    }
    
    ~A() {
        std::cout << "~A() \n";
    }
    A(const A& a) {
        count_ = a.count_;
        std::cout << "A copy \n";
    }
    A& operator=(const A& a) {
        count_ = a.count_;
        std::cout << "A = \n";
        return *this;
    }
    
    A(A&& a) {
        count_ = a.count_;
        std::cout << "A move \n";
    }
    
    A& operator=(A&& a) {
        count_ = a.count_;
        std::cout << "A move = \n";
        return *this;
    }
    
    std::string count_;
};


int main() {
    A a;
    a.count_ = "12345";
    A b = std::move(a);
    std::cout << a.count_ << std::endl;
    std::cout << b.count_ << std::endl;
    return 0;
}

如果我们在移动构造函数 + 移动赋值函数中，将原对象内部内存废弃掉，新对象使用原对象内存，那原对象的内存就不可以用了，示例代码如下：

#include <chrono>
#include <functional>
#include <future>
#include <iostream>
#include <string>

class A {
public:
    A() {
        std::cout << "A() \n";
    }
    
    ~A() {
        std::cout << "~A() \n";
    }
   
    A(const A& a) {
        count_ = a.count_;
        std::cout << "A copy \n";
    }
    
    A& operator=(const A& a) {
        count_ = a.count_;
        std::cout << "A = \n";
        return *this;
    }
    
    A(A&& a) {
        count_ = std::move(a.count_);
        std::cout << "A move \n";
    }
    
    A& operator=(A&& a) {
        count_ = std::move(a.count_);
        std::cout << "A move = \n";
        return *this;
    }
    
    std::string count_;
};


int main() {
    A a;
    a.count_ = "12345";
    A b = std::move(a);
    std::cout << a.count_ << std::endl;
    std::cout << b.count_ << std::endl;
    return 0;
}

总结：

• std::move 函数的作用是将参数强制转换为右值。而且，只是转换为右值，并不会对对象进行任何操作。
• 转换为右值可以触发移动语义，减少数据的拷贝操作，提升程序的性能。
• 在使用 std::move 函数后，原对象是否可以继续使用取决于移动构造函数和移动赋值函数的实现。

介绍 C++ 中三种智能指针的使用场景？ #

回答重点 #

C++ 中的智能指针主要用于管理动态分配的内存，避免内存泄漏。

C++11 标准引入了三种主要的智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr：

1. std::unique_ptr #

std::unique_ptr 是一种独占所有权的智能指针，意味着同一时间内只能有一个 unique_ptr 指向一个特定的对象。当 unique_ptr 被销毁时，它所指向的对象也会被销毁。

使用场景：

• 当你需要确保一个对象只被一个指针所拥有时。
• 当你需要自动管理资源，如文件句柄或互斥锁时。

示例代码：

#include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test::Test()"; }
    ~Test() { std::cout << "Test::~Test()"; }
    void test() { std::cout << "Test::test()"; }
};

int main() {
    std::unique_ptr<Test> 
    ptr(new Test());
    ptr->test();
    // 当ptr离开作用域时，它指向的对象会被自动销毁return 0;
}

2. std::shared_ptr #

std::shared_ptr 是一种共享所有权的智能指针，多个 shared_ptr 可以指向同一个对象。内部使用引用计数来确保只有当最后一个指向对象的 shared_ptr 被销毁时，对象才会被销毁。

使用场景：

• 当你需要在多个所有者之间共享对象时。
• 当你需要通过复制构造函数或赋值操作符来复制智能指针时。

示例代码：

#include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test::Test()"; }
    ~Test() { std::cout << "Test::~Test()"; }
    void test() { std::cout << "Test::test()"; }
};

int main() {
    std::shared_ptr<Test> ptr1(new Test());
    std::shared_ptr<Test> ptr2 = ptr1;
    ptr1->test();
    // 当ptr1和ptr2离开作用域时，它们指向的对象会被自动销毁
    return 0;
}

3. std::weak_ptr #

std::weak_ptr 是一种不拥有对象所有权的智能指针，它指向一个由 std::shared_ptr 管理的对象。weak_ptr 用于解决 shared_ptr 之间的循环引用问题。

是另外一种智能指针，它是对 shared_ptr 的补充，std::weak_ptr 是一种弱引用智能指针，用于观察 std::shared_ptr 指向的对象，而不影响引用计数。它主要用于解决循环引用问题，从而避免内存泄漏，另外如果需要追踪指向某个对象的第一个指针，则可以使用 weak_ptr。

可以考虑在对象本身中维护一个指向第一个 shared_ptr 的弱引用（std::weak_ptr）。当创建对象的第一个 shared_ptr 时，将这个 shared_ptr 赋值给对象的 weak_ptr 成员。这样，在需要时，可以通过检查对象的 weak_ptr 成员来获取指向对象的第一个 shared_ptr（如果仍然存在的话）.

使用场景：

• 当你需要访问但不拥有由 shared_ptr 管理的对象时。
• 当你需要解决 shared_ptr 之间的循环引用问题时。
• 注意 weak_ptr 肯定要和 shared_ptr 搭配使用。

示例代码：

#include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test::Test()"; }
    ~Test() { std::cout << "Test::~Test()"; }
    void test() { std::cout << "Test::test()"; }
};

int main() {
    std::shared_ptr<Test> sharedPtr(new Test());
    std::weak_ptr<Test> weakPtr = sharedPtr;
    
    if (auto lockedSharedPtr = weakPtr.lock()) {
        lockedSharedPtr->test();
    }// 当sharedPtr离开作用域时，它指向的对象会被自动销毁
    return 0;
}

这三种智能指针各有其用途，选择哪一种取决于你的具体需求。

扩展知识 #

1）智能指针方面的建议：

• 尽量使用智能指针，而非裸指针来管理内存，很多时候利用 RAII 机制管理内存肯定更靠谱安全的多。
• 如果没有多个所有者共享对象的需求，建议优先使用 unique_ptr 管理内存，它相对 shared_ptr 会更轻量一些。
• 在使用 shared_ptr 时，一定要注意是否有循环引用的问题，因为这会导致内存泄漏。
• shared_ptr 的引用计数是安全的，但是里面的对象不是线程安全的，这点要区别开。

2）为什么 std::unique_ptr 可以做到不可复制，只可移动？

因为把拷贝构造函数和赋值运算符标记为了 delete，见源码：

template <typename _Tp, typename _Tp_Deleter = default_delete<_Tp> > 
class unique_ptr {
        // Disable copy from lvalue.
        unique_ptr(const unique_ptr&) = delete;
       
        template<typename _Up, typename _Up_Deleter> 
        unique_ptr(const unique_ptr<_Up, _Up_Deleter>&) = delete;
        
        unique_ptr& operator=(const unique_ptr&) = delete;
    
     template<typename _Up, typename _Up_Deleter> 
     unique_ptr& operator=(const unique_ptr<_Up, _Up_Deleter>&) = delete;
};

3）shared_ptr 的原理：

每个 std::shared_ptr 对象包含两个成员变量：一个指向被管理对象的原始指针，一个指向引用计数块的指针（control block pointer）。

引用计数块是一个单独的内存块，引用计数块允许多个 std::shared_ptr 对象共享相同的引用计数，从而实现共享所有权。

当创建一个新的 std::shared_ptr 时，引用计数初始化为 1，表示对象当前被一个 shared_ptr 管理。

1. 拷贝 std::shared_ptr：当用一个 shared_ptr 拷贝出另一个 shared_ptr 时，需要拷贝两个成员变量（被管理对象的原始指针和引用计数块的指针），并同时将引用计数值加 1。这样，多个 shared_ptr 对象可以共享相同的引用计数。
2. 析构 std::shared_ptr：当 shared_ptr 对象析构时，引用计数值减 1。然后检测引用计数是否为 0。如果引用计数为 0，说明没有其他 shared_ptr 对象指向该资源，因此需要同时删除原始对象（通过调用自定义删除器，如果有的话）。

4）智能指针的缺点

1. 性能开销，需要额外的内存来存储他们的控制块，控制块包括引用计数，以及运行时的原子操作来增加或减少引用技术，这可能导致裸指针的性能下降。
2. 循环引用问题，如果两个对象通过成员变量 shared_ptr 相互引用，并且没有其他指针指向这两个对象中的任何一个，那么这两个对象的内存将永远不会被释放，导致内存泄露。

#include<iostream>
#include<memory>
class B; // 前向声明
class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() {
        std::cout << "A has been destroyed."<< std::endl;
    }
};
class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() {
        std::cout << "B has been destroyed."<< std::endl;
    }
};
int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b_ptr = b; // A 引用 B
    b->a_ptr = a; // B 引用 A
    // 由于存在循环引用，A 和 B 的析构函数将不会被调用，从而导致内存泄漏
    return 0;
}

1. 不一定适用于所有场景：有一些容器类，内部实现依赖于裸指针，另外在考虑某些性能关键场景下，使用裸指针可能更合适。

🌟C++11 中有哪些常用的新特性？ #

回答重点 #

C++11 新特性几乎是面试必问的一个话题，可以主要回答以下几个特性：

• auto 类型推导
• 智能指针
• RAII lock
• std::thread
• 左值右值
• std::function 和 lambda 表达式

auto 类型推导 #

auto 可以让编译器在编译时就推导出变量的类型，看代码：

auto a = 10; // 10是int型，可以自动推导出a是int

int i = 10;
auto b = i; // b是int型

auto d = 2.0; // d是double型
auto f =  { // f是啥类型？直接用auto就行
    return std::string("d");
}

利用 auto 可以通过=右边的类型推导出变量的类型。

什么时候使用 auto 呢？简单类型其实没必要使用 auto，某些复杂类型就有必要使用 auto，比如 lambda 表达式的类型，async 函数的类型等，例如：

auto func = [&] {
    cout << "xxx";
}; // 对于func你难道不使用auto吗，反正我是不关心lambda表达式究竟是什么类型。
auto asyncfunc = std::async(std::launch::async, func);

智能指针 #

C++11 新特性中主要有两种智能指针 std::shared_ptr 和 std::unique_ptr。

那什么时候使用 std::shared_ptr，什么时候使用 std::unique_ptr 呢？

• 当所有权不明晰的情况，有可能多个对象共同管理同一块内存时，要使用 std::shared_ptr；
• 而 std::unique_ptr 强调的是独占，同一时刻只能有一个对象占用这块内存，不支持多个对象共同管理同一块内存。

两类智能指针使用方式类似，拿 std::unique_ptr 举例：

using namespace std;

struct A {
   ~A() {
       cout << "A delete" << endl;
   }
   void Print() {
       cout << "A" << endl;
   }
};

int main() {
    auto ptr = std::unique_ptr<A>(new A);
    auto tptr = std::make_unique<A>(); // error, c++11还不行，需要c++14
    std::unique_ptr<A> tem = ptr; // error, unique_ptr不允许移动，编译失败
    ptr->Print();
    return 0;
}

RAII lock #

C++11 提供了两种锁封装，通过 RAII 方式可动态的释放锁资源，防止编码失误导致始终持有锁。

这两种封装是 std::lock_guard 和 std::unique_lock，使用方式类似，看下面的代码：

#include <iostream>
#include <mutex>
#include <thread>
#include <chrono>

using namespace std;
std::mutex mutex_;

int main() {
   auto func1 = [](int k) {
       // std::lock_guard<std::mutex> lock(mutex_);
       std::unique_lock<std::mutex> lock(mutex_);
       for (int i = 0; i < k; ++i) {
           cout << i << " ";
      }
      cout << endl;
  };
   std::thread threads[5];
   for (int i = 0; i < 5; ++i) {
       threads[i] = std::thread(func1, 200);
  }
   for (auto& th : threads) {
       th.join();
  }
   return 0;
}

普通情况下建议使用 std::lock_guard，因为 std::lock_guard 更加轻量级，但如果用在条件变量的 wait 中环境中，必须使用 std::unique_lock。

std::thread #

什么是多线程这里就不过多介绍，新特性关于多线程最主要的就是 std::thread 的使用，它的使用也很简单，看代码：

#include <iostream>
#include <thread>

using namespace std;

int main() {
    auto func =  {
        for (int i = 0; i < 10; ++i) {
            cout << i << " ";
      }
        cout << endl;
  };
   std::thread t(func);
   if (t.joinable()) {
       t.detach();
  }
   auto func1 = [](int k) {
       for (int i = 0; i < k; ++i) {
          cout << i << " ";
      }
       cout << endl;
  };
   std::thread tt(func1, 20);
   if (tt.joinable()) { // 检查线程可否被join
       tt.join();
  }
   return 0;
}

这里记住，std::thread 在其对象生命周期结束时必须要调用 join() 或者 detach()，否则程序会 terminate()，这个问题在 C++20 中的 std::jthread 得到解决，但是 C++20 现在多数编译器还没有完全支持所有特性，先暂时了解下即可，项目中没必要着急使用。

左值右值 #

关于左值和右值，有两种方式理解：

概念 1：

左值：可以放到等号左边的东西叫左值。

右值：不可以放到等号左边的东西就叫右值。

概念 2：

左值：可以取地址并且有名字的东西就是左值。

右值：不能取地址的没有名字的东西就是右值。

std::function 和 lambda 表达式 #

这两个可以说是很常用的特性，使用它们会让函数的调用相当方便。使用 std::function 可以完全替代以前那种繁琐的函数指针形式。

还可以结合 std::bind 一起使用，直接看一段示例代码：

std::function<void(int)> f; // 这里表示function的对象f的参数是int，返回值是void
#include <functional>
#include <iostream>

struct Foo {
   Foo(int num) : num_(num) {}
   void print_add(int i) const { std::cout << num_ + i << '\n'; }
   int num_;
};

void print_num(int i) { std::cout << i << '\n'; }

struct PrintNum {
   void operator()(int i) const { std::cout << i << '\n'; }
};

int main() {
   // 存储自由函数
   std::function<void(int)> f_display = print_num;
   f_display(-9);
  
   // 存储 lambda
   std::function<void()> f_display_42 =  { print_num(42); };
   f_display_42();
   
   // 存储到 std::bind 调用的结果
   std::function<void()> f_display_31337 = std::bind(print_num, 31337);
   f_display_31337();
   
   // 存储到成员函数的调用
   std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;const Foo foo(314159);
   f_add_display(foo, 1);
   f_add_display(314159, 1);
   
   // 存储到数据成员访问器的调用
   std::function<int>(Foo const&)> f_num = &Foo::num_;std::cout << "num_: " << f_num(foo) << '\n';
   
   // 存储到成员函数及对象的调用
   using std::placeholders::_1;std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
   f_add_display2(2);
   
   // 存储到成员函数和对象指针的调用
   std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
   f_add_display3(3);
   
   // 存储到函数对象的调用
   std::function<void(int)> f_display_obj = PrintNum();
   f_display_obj(18);
}

从上面可以看到 std::function 的使用方法，当给 std::function 填入合适的参数表和返回值后，它就变成了可以容纳所有这一类调用方式的函数封装器。std::function 还可以用作回调函数，或者在 C++ 里如果需要使用回调那就一定要使用 std::function，特别方便。

lambda 表达式可以说是 C++11 引入的最重要的特性之一，它定义了一个匿名函数，可以捕获一定范围的变量在函数内部使用，一般有如下语法形式：

auto func = [capture] (params) opt -> ret { func_body; };

其中 func 是可以当作 lambda 表达式的名字，作为一个函数使用，capture 是捕获列表，params 是参数表，opt 是函数选项(mutable 之类)， ret 是返回值类型，func_body 是函数体。

看下面这段使用 lambda 表达式的示例：

auto func1 = [](int a) -> int { return a + 1; }; 
auto func2 = [](int a) { return a + 2; }; 
cout << func1(1) << " " << func2(2) << endl;

std::function 和 std::bind 使得我们平时编程过程中封装函数更加的方便，而 lambda 表达式将这种方便发挥到了极致，可以在需要的时间就地定义匿名函数，不再需要定义类或者函数等，在自定义 STL 规则时候也非常方便，让代码更简洁，更灵活，提高开发效率。

扩展知识 #

std::chrono #

chrono 很强大，平时的打印函数耗时，休眠某段时间等，都可使用 chrono。

在 C++11 中引入了 duration、time_point 和 clocks，在 C++20 中还进一步支持了日期和时区。这里简要介绍下 C++11 中的这几个新特性。

duration

std::chrono::duration 表示一段时间，常见的单位有 s、ms 等，示例代码：

// 拿休眠一段时间举例，这里表示休眠100ms
std::this_thread::sleep_for(std::chrono::milliseconds(100));

sleep_for 里面其实就是 std::chrono::duration，表示一段时间，实际是这样：

typedef duration<int64_t, milli> milliseconds;
typedef duration<int64_tseconds;

duration 具体模板如下：

template <class Rep, class Period = ratio<1> > class duration;

Rep 表示一种数值类型，用来表示 Period 的数量，比如 int、float、double，Period 是 ratio 类型，用来表示【用秒表示的时间单位】比如 second，常用的 duration 已经定义好了，在 std::chrono::duration 下：

• ratio<3600, 1>：hours
• ratio<60, 1>：minutes
• ratio<1, 1>：seconds
• ratio<1, 1000>：microseconds
• ratio<1, 1000000>：microseconds
• ratio<1, 1000000000>：nanosecons

ratio 的具体模板如下：

template <intmax_t N, intmax_t D = 1class ratio;

N 代表分子，D 代表分母，所以 ratio 表示一个分数，我们可以自定义 Period，比如 ratio<2, 1> 表示单位时间是 2 秒。

time_point

表示一个具体时间点，如 2020 年 5 月 10 日 10 点 10 分 10 秒，拿获取当前时间举例：

std::chrono::time_point<std::chrono::high_resolution_clock> Now() {return std::chrono::high_resolution_clock::now();
}
// std::chrono::high_resolution_clock为高精度时钟，下面会提到

clocks

时钟，chrono 里面提供了三种时钟：

1）steady_clock

稳定的时间间隔，表示相对时间，相对于系统开机启动的时间，无论系统时间如何被更改，后一次调用 now()肯定比前一次调用 now()的数值大，可用于计时。

2）system_clock

表示当前的系统时钟，可以用于获取当前时间：

int main() {
   using std::chrono::system_clock;
   system_clock::time_point today = system_clock::now();
   std::time_t tt = system_clock::to_time_t(today);
   std::cout << "today is: " << ctime(&tt);
   return 0;
}
// today is: Sun May 10 09:48:36 2020

3）high_resolution_clock

high_resolution_clock 表示系统可用的最高精度的时钟，实际上就是 system_clock 或者 steady_clock 其中一种的定义，官方没有说明具体是哪个，不同系统可能不一样，之前看 gcc chrono 源码中 high_resolution_clock 是 steady_clock 的 typedef。

条件变量 #

条件变量是 C++11 引入的一种同步机制，它可以阻塞一个线程或多个线程，直到有线程通知或者超时才会唤醒正在阻塞的线程，条件变量需要和锁配合使用，这里的锁就是上面介绍的 std::unique_lock。

这里使用条件变量实现一个 CountDownLatch：

class CountDownLatch {
   public:
    explicit CountDownLatch(uint32_t count) : count_(count);

    void CountDown() {
        std::unique_lock<std::mutex> lock(mutex_);
        --count_;
        if (count_ == 0) {
            cv_.notify_all();
        }
    }
    
void Await(uint32_t time_ms = 0) {std::unique_lock<std::mutex> lock(mutex_);while (count_ > 0) {if (time_ms > 0) {
                cv_.wait_for(lock, std::chrono::milliseconds(time_ms));
            } else {
                cv_.wait(lock);
            }
        }
    }
    
    uint32_t GetCount() const {
        std::unique_lock<std::mutex> lock(mutex_);
     return count_;
    }
   
    private:
    std::condition_variable cv_;
    mutable std::mutex mutex_;
    uint32_t count_ = 0;
};

🌟C++ 中 inline 的作用？它有什么优缺点？ #

回答重点 #

inline 的作用是建议编译器将函数调用替换为函数体，以减少函数调用的开销，和宏比较类似。

使用 inline 函数的目的一定是希望可以提高程序的运行效率，特别是那些频繁调用的小函数。

优点：

• 降低函数调用的开销，原理就是因为省去了调用和返回的指令开销。
• 如果函数体较小，可以提高代码执行的效率。

缺点：

• 容易导致代码膨胀，整个可执行程序体积变大，特别是当 inline 函数体较大且被多次调用时。
• 内联是一种建议，编译器可以选择忽略 inline 关键字。

扩展知识 #

下面深入了解下 inline 函数。

• 内联函数的典型应用场景：

  • 内联函数不仅适用于短小的函数，例如简单的 getter 和 setter，它还适合一些占用时间较短的算法，很多算法都会在语言层面考虑内联来提升性能。
  • 需要频繁调用而且内联能显著提高性能的地方。

• 内联函数与宏的区别：宏是在预处理阶段进行文本替换，而内联函数是在编译阶段展开。内联函数有类型安全和作用域控制，宏没有这一特性。内联函数可以更好地报告调试信息，相对来说调试比较方便。

• 在优化级别较高时，即使未加 inline 关键字，编译器也可能自动将频繁调用的小函数设为内联。

• inline 的作用不仅仅是优先内联，它逐渐演变成了允许多重定义的含义。

C++ 中 explicit 的作用？ #

回答重点 #

关键字 explicit 的主要作用是防止构造函数或转换函数在不合适的情况下被隐式调用。

例如，如果有一个只有一个参数的构造函数，加上 explicit 关键字后，编译器就不会自动用该构造函数进行隐式转换。这可以避免由于意外的隐式转换导致的难以调试的行为。

class Foo {
public:
    explicit Foo(int x) : value(x) {}
private:
    int value;
};

void func(Foo f) {
    // ...
}

int main() {
    Foo foo = 10;  // 错误，必须使用 Foo foo(10) 或 Foo foo = Foo(10)
    func(10);      // 错误，必须使用 func(Foo(10))
}

如果没有 explicit 关键字，Foo foo = 10; 以及 func(10); 这样的代码是可以通过编译的，这会导致一些意想不到的隐式转换。

扩展知识 #

1）历史背景

explicit 关键字在 C++98 标准中引入，用来增强类型安全，防止不经意的隐式转换。从 C++11 开始，explicit 可以用于 conversion operator。

2）使用场景

• 防止单参数构造函数隐式转换
• 如果一个类的构造函数接受一个参数，而你并不希望通过隐式转换来创建这个类的实例，就应该在构造函数前加 explicit。这也是它最主要的作用。

class Bar {
public:
    explicit Bar(int x) : value(x) {}
private:
   int value;
};

Bar bar = 10;  // 错误，无法隐式转换

• 防止 conversion operator 隐式转换
• 类中有时会定义一些转换操作符，但有些转换是需要显式调用的，这时也可以使用 explicit。

class Double {
public:
    explicit operator int() const {
        return static_cast<int>(value);
    }
private:
   double value;
};

Double d;
int i = d;               // 错误，无法隐式转换
int j = static_cast<int>(d);  // 正确，显式转换

3）复杂构造函数

对于那些带有默认参数的复杂构造函数，explicit 尤其重要，它们可能会被意外地调用。

class Widget {
public:explicit Widget(int x = 0, bool flag = true) : value(x), flag(flag) {}
private:int value;bool flag;
};

这种情况下，如果不加 explicit，没有任何参数传递给构造函数也可能会进行隐式转换，引发难以察觉的错误。

🌟C++ 中野指针和悬挂指针的区别？ #

回答重点 #

两者都可能导致程序产生不可预测的行为。但它们有明显的区别：

1）野指针：一种未被初始化的指针，通常会指向一个随机的内存地址。这个地址不可控，使用它可能会导致程序崩溃或数据损坏。

int *p;
std::cout<< *p << std::endl;

2）悬挂指针：一个原本合法的指针，但指向的内存已被释放或重新分配。当访问此指针指向的内存时，会导致未定义行为，因为那块内存数据可能已经不是期望的数据了。

int main(void) {
  int * p = nullptr;
  int* p2 = new int;

  p = p2;
  delete p2;
}

扩展知识 #

展开说一说，弄清楚这两个概念不难，但如何避免和处理它们才是关键，这直接关系到写出更健壮的代码。

1）如何避免野指针

• 初始化指针：在声明一个指针时，立即赋予它一个明确的数值，可以是一个有效的地址，也可以是 nullptr。

int *ptr = nullptr; // 初始化

• 使用智能指针：C++ 中的智能指针（如 std::unique_ptr 和 std::shared_ptr）可以帮助自动管理指针的生命周期，减少手动管理的错误。

std::unique_ptr<int> ptr(new int(10));

2）如何避免悬挂指针

• 在删除对象后，将指针设置为 nullptr，确保指针不再指向已经释放的内存。

delete ptr;
ptr = nullptr;

• 尽量使用智能指针，它们会自动处理指针的生命周期，减少悬挂指针的产生。

std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
{
    std::shared_ptr<int> ptr2 = ptr1;
    // 当 ptr2 离开作用域后，资源仍然被 ptr1 管理
}
// 仍然可以使用 ptr1

3）检测工具

• 静态分析工具（如 Clang-Tidy、cppcheck）和动态分析工具（Valgrind、AddressSanitizer）可以帮助检测这些错误，确保代码质量。

🌟 什么是内存对齐？为什么要内存对齐？ #

回答重点 #

内存对齐是指计算机在访问内存时，会根据一些规则来为数据指定一个合适的起始地址。

计算机的内存是以字节为基本单位进行编址，但是不同类型的数据所占据的内存空间大小是不一样的，在 C++ 语言中可以用 sizeof()来获得对应数据类型的字节数，一些计算机硬件平台要求存储在内存中的变量按照自然边界对齐，也就是说必须使数据存储的起始地址可以整除数据实际占据内存的字节数，这叫做内存对齐。

通常，这些地址是固定数字的整数倍。这样做，可以提高 CPU 的访问效率，尤其是在读取和写入数据时。

为什么要内存对齐？主要有以下几个原因：

1）性能提升：对齐的数据操作可以让 CPU 在一次内存周期内更高效地读取和写入，减少内存访问次数。通过内存布局优化技术，可以提高程序的运行效率和可靠性，这是因为可以减少 CPU 访问内存的次数，提高计算机新能，计算机在每次访问内存的时候，每次读取到的一定长度，就是操作系统的默认对齐系数，或者其系数的整数倍。

以 32 位 Intel CPU 为例（16 和 64 位类同），一次可以对一个 32 位的数进行运算，它的数据总线的宽度是 32 位，即 CPU 字长为 32 位。

假设 long1 和 long2 变量内存分配结构如下： long1，long2 类型都为 long，long1 在内存中的位置正好与内存字边界对齐，CPU 存取这个数只需访问内存 1 次，而 long2 在内存中跨越字边界，导致 CPU 存取这个数则需访问内存 2 次。由此可以看出，字节对齐主要提高 CPU 访问内存的效率。内存对齐之后，存取 long2 ，一次访问即可。

2）硬件限制：某些架构要求数据必须对齐，否则可能会引发硬件异常或需要额外的处理时间。有些 CPU 可以访问任意地址上的任意数据，而有些 CPU 只能在特定地址访问数据，因此不同硬件平台具有差异性，这样的代码就不具有移植性。

3）可移植性：代码在不同架构上运行时，遵从内存对齐规则可以减少潜在的问题。

扩展知识 #

内存对齐虽然看起来只是一个约定或者优化策略，其实背后还是有不少细致的讲究的：

1）对齐要求：不同的数据类型有不同的对齐要求。例如，在大多数 32 位系统中，int 通常要求 4 字节对齐，而 double 可能要求 8 字节对齐。编译器会根据这些对齐要求调整结构体或类的成员变量的布局。

2）填充字节：为了确保对齐，编译器有时会在数据成员之间插入一些“填充字节”（padding bytes），这些字节本身不保存有用的数据，只是为了使下一个成员变量满足对齐要求。例如，如果一个结构体的成员变量有 int 和 char，编译器可能会在 char 后面插入几个字节的填充，以确保下一个 int 的对齐。

3）控制内存对齐：在 C/C++ 中，我们可以使用编译器提供的关键字或扩展来控制数据的对齐方式，例如通过 #pragma pack 控制。

4）与缓存一致性相关：内存对齐有时候还与缓存一致性联系在一起。CPU 有自己的缓存系统，合理的内存对齐往往能使缓存更高效地工作，减少 cache miss 的概率。

结构体内存对齐 #

例子 1：假设 32 位系统，long 占 4 个字节。

struct AlignA
{
    char a;
    long b;
    int c;
}

该结构体，占用内存为 4+ 4+ 4 =12 个字节，这就是内存对齐的原因。

例子 2

struct AlignB
{
    int b;
    char c[10];
    double a;
}

成员变量布局调整 #

通过上面了解了结构体的内存对齐，是不是就可以想到，如果修改了结构体内变量的位置，就可以减少结构体的大小了。

C++ 中静态多态，动态多态是什么？ #

静态多态也叫编译时多态，它是在编译阶段就确定要调用哪个函数。

实现方式主要有函数重载和模板，函数重载就是在一个类或者同一个作用域里有好几个同名函数，但它们的参数列表不同，编译器会根据你调用函数时传的实参类型和数量，在编译的时候就选好要调用哪个函数。

模板则是可以创建通用的函数或者类，根据不同的模板参数，编译器在编译时生成不同的代码，静态多态的优点是速度快，因为编译时就确定了调用，没有额外的运行时开销。

动态多态也叫运行时多态，它是在程序运行的时候才确定要调用哪个函数。主要通过虚函数和继承来实现。在基类里把函数声明成虚函数，派生类可以重写这个虚函数。

当用基类的指针或者引用去调用这个虚函数时，程序在运行时会根据指针或者引用实际指向的对象类型，来决定调用基类的函数还是派生类重写后的函数。动态多态的好处是灵活性高，能让代码更有扩展性，但因为要在运行时做判断，会有一些额外的开销。

打个比方，静态多态就像你出门前就根据天气决定穿什么衣服；动态多态就像你出门了，到地方才根据实际情况换衣服。

🌟C++ 中虚函数的原理？ #

回答重点 #

虚函数是 C++ 中实现多态的一个关键机制。简单来说，虚函数允许你在基类里通过 virtual 声明一个函数，然后在派生类里对其进行重新定义。

通过使用虚函数，C++ 可以根据对象的实际类型（而不是引用或指针的静态类型）调用派生类的函数实现。实现虚函数的关键在于虚函数表（vtable）和虚函数表指针（vptr）。

每个含有虚函数的类都有一张虚函数表，表中存有该类的虚函数的地址。每个对象都有一个虚函数表指针，指向这个类的虚函数表。当调用虚函数时，程序会通过对象的虚函数表指针找到相应的虚函数地址，然后进行函数调用。

扩展知识 #

1）虚函数的实现原理：

• 虚函数表（vtable）：是一个存储虚函数地址的数组。每个包含虚函数的类会有一个虚函数表。表里存有该类或者基类中重写虚函数的实际地址。
• 虚函数表指针（vptr）：每个对象在内存布局中会有一个指向虚函数表的指针。编译器会自动管理这个指针的初始化和赋值。

2）多态的实现：

虚函数是实现多态的一种手段，允许程序在运行时决定调用哪个类的函数，实现动态绑定。当基类指针或引用指向派生类对象时，调用虚函数会根据实际对象类型选择合适的函数实现，下面是示例代码：

class Base {
public:virtual void show() {
        cout << "Base class show" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class show" << endl;
    }
};

// 用例
Base *b;
Derived d;
b = &d;
b->show();  // 将会调用 Derived 的 show 方法

3）注意点：

• 虚函数的调用比普通函数多了一个 vtable 查找过程，运行时略有开销。
• 析构函数如果需要在派生类中被正确的调用，应该声明为虚函数。

4）虚函数和纯虚函数：

• 如果类中包含纯虚函数，那么这个类就是一个抽象类，不能实例化，只能被继承。

class Abstract {
public:virtual void pure_virtual_func() = 0;  // 纯虚函数
};

5）常见误区：

• 静态绑定的成员函数（static 关键字）不能是虚函数。

🌟C++ 中构造函数可以是虚函数吗？ #

回答重点 #

构造函数不能是虚函数。

虚函数的机制依赖于虚函数表，而虚表对象的建立需要在调用构造函数之后才能完成。因为构造函数是用来初始化对象的，而在对象的初始化阶段虚表对象还没有被建立，如果构造函数是虚函数，就会导致对象初始化和多态机制的矛盾，因此，构造函数不能是虚函数。

扩展知识 #

1） 析构函数可以是虚函数

虽然构造函数不能是虚函数，但是析构函数应当是虚函数，特别是在基类中。这样做的目的是为了确保在删除一个指向派生类对象的基类指针时，能正确调用派生类对象的析构函数，从而避免资源泄露。

2） 其他特殊成员函数也不是虚函数

除了构造函数外，静态成员函数和友元函数也不能是虚函数。静态成员函数与类而不是与某个对象相关联，而友元函数则不属于类的成员函数，它们不具备多态性所需的对象上下文。

3） 解决方案

如果需要在对象创建时实现多态性，可以考虑工厂模式等设计模式来间接实现多态性。这些设计模式可以通过一些间接的手段，在对象创建过程中提供多态行为。

🌟C++ 中析构函数一定要是虚函数吗？ #

回答重点 #

C++ 中析构函数并不一定要是虚函数，但在多态条件下，我是建议一定将其声明为虚函数。

如果一个类可能会被继承，并且你需要在删除指向派生类对象的基类指针时确保正确调用派生类的析构函数，那么基类的析构函数必须是虚函数。如果没有这样做，可能会导致资源泄漏或者未能正确释放派生类对象的资源。

扩展知识 #

1）虚函数的机制及其应用场景

当一个类的成员函数被声明为虚函数时，C++ 会为该类生成一个虚函数表，这个表存储指向虚函数的指针。在运行时，基于当前对象的实际类型，虚函数表指针用于动态绑定，调用正确的函数版本。

场景：假设有一个基类 Base 和一个派生类 Derived：

class Base {
public:
    virtual ~Base() { std::cout << "Base destructor" << std::endl; }
};

class Derived : public Base {
public:
    ~Derived() { std::cout << "Derived destructor" << std::endl; }
};

如果基类的析构函数不是虚函数，那么以下代码可能会产生问题：

Base *obj = new Derived();
delete obj;  // 只调用了 Base 的析构函数，可能导致内存泄漏或未释放资源

2）默认情况下析构函数的行为

如果基类的析构函数不是虚函数，当你通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这种情况下，派生类中分配的资源可能不会及时释放，导致资源泄漏。

3）什么时候不需要虚析构函数

如果一个类不设计为基类，或者不会通过基类指针删除派生类对象，那么就不需要将析构函数声明为虚函数。

深入理解 #

首先我们先来理解一下什么是多态，多态性允许我们通过基类指针或引用来操作派生类对象。

这使得我们可以编写更通用、可扩展的代码，因为我们可以将派生类对象视为基类对象，并使用相同的接口处理它们。多态性主要通过虚函数实现。

将析构函数设计为虚函数主要是保证多态性，当我们使用基类指针或引用操作派生类对象时，如果基类的析构函数不是虚函数，此时则只会调用基类的析构函数，这样则有可能会导致未定义行为或者内存泄露。

但是当我们设置成虚函数时，并 override 之后，销毁派生类对象时，将自动调用相应的派生类析构函数，已实现派生类资源的释放。

#include<iostream>
class Base {
public:
    Base() {
        std::cout << "Base constructor"<< std::endl;
    }
    virtual ~Base() {
        std::cout << "Base destructor"<< std::endl;
    }
};
class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor"<< std::endl;
    }
    ~Derived() {
        std::cout << "Derived destructor"<< std::endl;
    }
};
int main() {
    Base* basePtr = new Derived(); // 使用基类指针操作派生类对象
    delete basePtr; // 销毁对象时调用正确的派生类析构函数
    return 0;
}

🌟 什么是 C++ 的函数重载？它的优点是什么？和重写有什么区别？ #

回答重点 #

在 C++ 中，函数重载是指在同一个作用域内允许存在多个同名函数，它们的参数个数不同或者参数类型不同，注意函数的返回类型不同不能算作重载。

函数重载的优点是：

1. 增强了代码的可读性。使用同名的函数，而不用为不同的功能选择完全不同的函数名，程序员可以更直观地理解代码。
2. 改善了程序的可维护性。函数重载让我们可以定义一个通用接口，让同名函数实现不同的功能，减轻了函数命名的负担。

函数重载和函数重写（覆盖）的区别：

1. 函数重载可以发生在同一个类中，而函数重写发生在继承关系的子类中。
2. 函数重载要求参数列表必须不同，而函数重写要求方法签名（包括参数列表和返回类型）必须与父类方法一致。
3. 函数重载在编译时决定调用哪个函数（静态绑定），而函数重写在运行时决定调用哪个函数（动态绑定）。

扩展知识 #

下面是函数重载的实例代码：

#include <iostream>  
#include <string>  

// 重载print函数以打印整数  
void print(int i) {  
    std::cout << "Printing int: " << i << std::endl;  
}  
  
// 重载print函数以打印浮点数
void print(double f) {  
    std::cout << "Printing float: " << f << std::endl;  
}  
  
// 重载print函数以打印字符串  
void print(const std::string& s) {  
    std::cout << "Printing string: " << s << std::endl;  
}  
  
// 重载print函数以打印字符  
void print(char c) {  
    std::cout << "Printing char: " << c << std::endl;  
}  
  
int main() {    
    print(5);          // 调用打印整数的print  
    print(500.263);    // 调用打印浮点数的print  
    print("Hello");    // 调用打印字符串的print  
    print('A');        // 调用打印字符的print  
    return 0;  
}

函数重载在实际应用中非常广泛，比如标准库中的 std::cout 就是很多重载的运算符 << 实现的，使我们可以打印不同类型的变量。而且，C++ STL（标准模板库）中的许多算法和容器类方法如 std::sort 和 std::vector 也采用了重载函数，以此来处理不同类型的输入。

除了函数重载和重写外，C++ 还支持运算符重载，允许对用户自定义的类型重载内置运算符，从而使自定义类型的使用和内置类型一样直观便捷。这个特性在实现复杂数据结构（如矩阵、复数等）时特别有用，使代码更易读、更自然。

🌟C++ 中 using 和 typedef 的区别？ #

回答重点 #

using 在 C++11 中引入，using 和 typedef 都可以用来为已有的类型定义一个新的名称。最主要的区别在于，using 可以用来定义模板别名，而 typedef 不能。

1）typedef 主要用于给类型定义别名，但是它不能用于模板别名。

typedef unsigned long ulong;
typedef int (*FuncPtr)(double);

2）using 可以取代 typedef 的功能，语法相对简洁。

using ulong = unsigned long;
using FuncPtr = int (*)(double);

3）对于模板别名，using 显得非常强大且直观。

template<typename T>
using Vec = std::vector<T>;

总之，更推荐使用 using，尤其是当你处理模板时。

扩展知识 #

1）模板别名（Template Aliases）：using 在处理模板时，如定义容器模板别名，非常方便。假如我们需要一个模板类 std::vector 的别名：

template<typename T>
using Vec = std::vector<T>;
Vec<int> vecInt; // 相当于 std::vector<int> vecInt;

2）作用范围：using 还可以用于命名空间引入，typedef 没有此功能。

namespace LongNamespaceName {
    int value;
}

using LNN = LongNamespaceName;
LNN::value = 42; // 相当于 LongNamespaceName::value

3）可读性与调试：using 相对 typedef 更易读。

typedef void (*Func)(int, double);
using FuncAlias = void(*)(int, double);

在这个例子中，using 显然定义和解释都更加直观。

4）现代 C++ 代码规范：在 C++11 之后，许多代码规范建议优先使用 using 而不是 typedef。这证明了在实际应用和代码维护中，using 更具有优势。

🌟C++ 中 map 和 unordered_map 的区别？分别在什么场景下使用？ #

回答重点 #

两者都是常用的关联容器。但有一些区别：

1）底层实现：

• map：基于有序的红黑树（具体实现依赖于标准库）。
• unordered_map：基于哈希表。

2）时间复杂度：

• map：插入、删除、查找的时间复杂度为 O(log n)。
• unordered_map：插入、删除、查找的时间复杂度为 O(1)（摊销）。

3）元素顺序：

• map：元素按键值有序排列。
• unordered_map：元素无序排列。

4）内存使用：

• map：由于底层是红黑树，内存使用较少。
• unordered_map：需要额外的空间存储哈希表，但在处理大量数据时，可能具有更好的表现。

场景选择 #

1）map：当需要按键值有序访问元素时，适合使用 map，例如按顺序遍历键值对。 2）unordered_map：当主要关注查找速度、不关心元素顺序时，使用 unordered_map 会更高效，例如需要高效的键值存储和快速查找的场景。

扩展知识 #

1）迭代器稳定性：在 map 中，由于基于红黑树，其迭代器在插入和删除元素时通常依然有效（除了指向被删除元素的迭代器），但 unordered_map 中，插入和删除操作可能会使所有迭代器失效。

2）复杂数据类型的键：如果键是复杂数据类型（需要自定义比较函数），可以在 map 中利用自定义键比较器的排序规则：

struct MyKey {
 int id;
 std::string name;
 bool operator<(const MyKey& other) const {
     return id < other.id; // 按id排序
 }
};
std::map<MyKey, int>m;

3）哈希函数的定制：在 unordered_map 中，如果键类型是用户自定义类型，需要自行提供哈希函数和比较器：

struct MyKey {
 int id;
 std::string name;
};
struct HashFunction {
 std::size_t operator()(const MyKey& k) const {
     return std::hash<int>()(k.id) ^ std::hash<std::string>()(k.name);
 }
};
struct KeyEqual {
 bool operator()(const MyKey& lhs, const MyKey& rhs) const {
     return lhs.id == rhs.id && lhs.name == rhs.name;
 }
};
std::unordered_map<MyKey, int, HashFunction, KeyEqual> um;

什么是 C++ 中的 RAII？它的使用场景？ #

回答重点 #

RAII，全称是 “Resource Acquisition Is Initialization”（资源获取即初始化）。

它的核心思想是将资源的获取与对象的生命周期绑定，通过构造函数获取资源（如内存、文件句柄、网络连接等），通过析构函数释放资源。这样，即使程序在执行过程中抛出异常或多路径返回，也能确保资源最终得到正确释放，特别是可以避免内存泄漏。

扩展知识 #

1）使用场景：

• 内存管理：标准库中的 std::unique_ptr 和 std::shared_ptr 是 RAII 的经典实现，用于智能管理动态内存。
• 文件操作：std::fstream 类在打开文件时获取资源，在析构函数中关闭文件。
• 互斥锁：std::lock_guard 和 std::unique_lock 用于在多线程编程中自动管理互斥锁的锁定和释放。

2）示例代码：

#include <iostream>
#include <fstream>

class FileHandler {
public:
    FileHandler(const std::string& filename) : file(filename) { // 资源获取
        if (!file.is_open()) {
           throw std::runtime_error("Unable to open file");
        }
    }
    
    ~FileHandler() {
        file.close(); // 资源释放
    }
    
    void write(const std::string& data) {
        if (file.is_open()) {
            file << data << std::endl;
        }
    }

private:
    std::ofstream file;
};

int main() {
    try {
        FileHandler fh("example.txt");
        fh.write("Hello, RAII!");
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }return 0;
}

在这个示例中，FileHandler 类在构造函数中打开文件，在析构函数中关闭文件。即使 main 函数中发生异常或提前返回，析构函数也会自动调用，确保文件被正确关闭。

3）RAII 的好处：

• 异常安全：使用 RAII 能够确保在异常发生时自动释放资源，避免资源泄漏。
• 简化资源管理：将资源的获取和释放逻辑封装在类内，使代码更加简洁且方便维护。

4）与智能指针的结合：

std::unique_ptr<int> ptr(new int(5));

5）扩展应用：

• 锁管理：通过 std::lock_guard 对锁进行管理，确保锁在作用范围内被正确释放。

std::mutex mtx;
{
   std::lock_guard<std::mutex> lock(mtx);
   // 临界区代码
} // mtx 在此处自动释放

C++ 的 function、bind、lambda 都在什么场景下会用到？ #

回答重点 #

三者都用于处理函数和可调用对象：

1）std::function：用于存储和调用任意可调用对象（函数指针、Lambda、函数对象等）。常用场景包括回调函数、事件处理、作为函数参数和返回值。

2）std::bind：用于绑定函数参数，生成函数对象，特别是当函数参数不完全时。常见于将已有函数适配为接口要求的回调、将成员函数与对象绑定。

3）Lambda 表达式：用于定义匿名函数，通常在短期和局部使用函数时比如一次性回调函数、算法库中的自定义操作等。

扩展知识 #

std::function #

std::function 在 C++11 中引入，它是一个类模板，用于封装任何形式的可调用对象。使用 std::function 可以很方便地存储各种不同类型的函数，以便后面调用。

常见使用场景：

1）回调函数：在图形用户界面程序或网络编程中，经常需要定义回调函数。

2）事件处理：在观察者模式中，可以用 std::function 存储和调用事件处理函数。

3）作为函数参数和返回值：方便传递函数或存储函数以在其他地方调用。

示例：

#include <functional>
#include <iostream>
#include <vector>

void exampleFunction(int num) {
    std::cout << "Number: " << num << std::endl;
}

int main() {
    std::function<void(int)> 
    func = exampleFunction;func(42);
    return 0;
}

std::bind #

std::bind 是一个函数模板，用于从一个可调用对象（如函数或成员函数）和其部分参数创建新的函数对象。这在处理不完全的函数参数或需要绑定特定对象的时候特别有用。

常见使用场景：

1）适配接口：当接口要求的函数签名与现有函数不匹配时，可以通过 std::bind 进行参数适配。

2）绑定成员函数：通过 std::bind 可以绑定类的成员函数与具体的实例对象，从而创建可以调用的对象。

示例：

#include <functional>
#include <iostream>

void exampleFunction(int a, int b) {
    std::cout << "Sum: " << a + b << std::endl;
}

int main() {
    auto boundFunction = std::bind(exampleFunction, 10, std::placeholders::_1);
    boundFunction(32); // Output: Sum: 42
    return 0;
}

Lambda 表达式 #

Lambda 表达式是一种匿名函数，它可以在定义的地方直接使用，通常用于简单的计算。如果某个函数逻辑仅在某个特定范围内有用，使用 Lambda 表达式可以使代码更简洁。

常见使用场景：

1）一次性回调函数：与算法和容器一起使用，以简化代码。

2）自定义操作：在标准库算法（如 std::for_each, std::transform 等）中，使用 Lambda 表达式进行自定义操作。

示例：

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::for_each(vec.begin(), vec.end(), [](int &n) { n *= 2; });

    for (int n : vec) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}

🌟C++ 中堆内存和栈内存的区别？ #

回答重点 #

堆内存和栈内存的区别主要体现在分配方式、管理方式、生命周期和性能等方面：

1）分配方式：

• 栈内存：由编译器在程序运行时自动分配和释放。典型的例子是局部变量的分配。
• 堆内存：需要程序员手动分配和释放，使用 new 和 delete 操作符。在 C++11 之后，也可以使用智能指针来管理堆内存。

2）管理方式：

• 栈内存：由编译器自动管理，程序员无需担心内存泄漏，生命周期由作用域决定。
• 堆内存：由程序员手动管理，如果没有正确释放内存，会导致内存泄漏。

3）生命周期：

• 栈内存：变量在离开作用域之后自动销毁。
• 堆内存：只要不手动释放，内存会持续存在，直到程序终止。

4）性能：

• 栈内存：内存分配和释放速度极快，性能上优于堆内存。
• 堆内存：涉及到复杂的内存管理和分配机制，性能上较慢。

扩展知识 #

1）内存分配函数：

• 除了 new 和 delete，堆内存还可以使用 malloc 和 free 来管理。区别在于 new 会调用构造函数，而 malloc 只是纯粹的内存分配。

2）内存溢出和内存泄漏：

• 内存溢出：栈空间是有限的，如果递归过深或者分配的局部变量太大，可能导致栈溢出。
• 内存泄漏：堆内存如果没有正确释放，会导致内存泄漏，尤其在长时间运行的程序中，会影响系统性能。

3）智能指针：

• C++11 引入了智能指针 std::unique_ptr 和 std::shared_ptr，可以自动管理堆内存，大大降低了内存泄漏的风险。

4）虚拟内存：

• 虚拟内存机制，使物理内存和逻辑内存独立，程序可以看到的是一个巨大的连续地址空间，但实际上可能是分散的物理内存和硬盘上的交换空间。

5）栈与堆的容量：

• 栈的容量往往较小，通常为几 MB，主要用于局部变量和函数调用管理。
• 堆的容量通常较大，依赖于系统可用内存，适合动态分配大量内存。

C++ 堆内存与栈内存对比表 #

什么是 C++ 的回调函数？为什么需要回调函数？ #

回答重点 #

回调函数是一种通过函数指针或者函数对象（例如 std::function 或 lambda 表达式）将一个函数作为参数传递给另一个函数的机制。

实际上，就是把函数的调用权从一个地方转移到另一个地方，这个调用会在未来某个时刻进行，而不是立即执行。之所以称为“回调”，可以理解为某种倒叙执行：先安排好函数的调用，不立即执行，等到合适的时机再“回头”执行。

需要回调函数的主要原因包括：

1）异步编程：在异步操作中，比如网络请求、文件读取、事件处理等，可以在操作完成后调用回调函数，而主程序可以继续执行其它任务，避免等待操作完成。

2）解耦代码：回调函数有助于将代码模块化和解耦，允许我们创建更灵活和可复用的代码。例如，一个通用的排序算法可以接受一个比较函数，允许用户自定义排序逻辑。

3）事件驱动编程：在 GUI 或者其他事件驱动程序中，回调函数经常用于处理用户输入事件，如点击、鼠标移动、键盘输入等。

扩展知识 #

回调函数的实际应用：

1）使用函数指针作为回调函数：

在 C 风格接口中，最常见的回调函数形式就是使用函数指针。例如：

#include <iostream>

// 定义一个函数指针类型
typedef void (*CallbackFunc)(int);

void RegisterCallback(CallbackFunc cb) {
 // 模拟某些操作
 std::cout << "Registering callback...\n";
 cb(42); // 调用回调函数
}

void MyCallback(int value) {
 std::cout << "Callback called with value: " << value << std::endl;
}

int main() {
 RegisterCallback(MyCallback); // 传递回调函数
 return 0;
}

2）使用 C++11 之后的 std::function 和 lambda 表达式：

#include <iostream>
#include <functional>

void RegisterCallback(
 std::function<void(int)> cb) {
 std::cout << "Registering callback...\n";
 cb(42); // 调用回调函数
}

int main() {
 auto myCallback = [](int value) {
     std::cout << "Callback called with value: " << value << std::endl;
 };
 RegisterCallback(myCallback); // 传递 lambda 回调函数
 return 0;
}

3）GUI 编程中的回调：

在图形用户界面编程中，回调函数常用于处理用户事件。例如，在一个按钮点击事件中调用用户提供的回调函数。

例如，使用一个假设的 GUI 库：

class Button {
 public:
 void setOnClick(std::function<void()> cb) {
     onClick = cb;
 }

void simulateClick() {
    if (onClick) {
        onClick();
     }
 }
 
private:
 std::function<void()> onClick;
};

int main() {
 Button button;
 button.setOnClick([]() {
     std::cout << "Button clicked!" << std::endl;
 });
 button.simulateClick(); // 模拟一次点击事件
 return 0;
}

🌟C++ 中为什么要使用 nullptr 而不是 NULL？ #

回答重点 #

主要原因是 nullptr 有明确的类型，它是 std::nullptr_t 类型，可以避免代码中出现类型不一致的问题。

扩展知识 #

1）类型安全：NULL 通常被定义为数字 0（在 C++ 代码中一般是 #define NULL 0），它实际上是整型值。这就可能会带来类型不一致的问题，比如传递参数时，编译器无法准确判断是整数 0 还是空指针。而 nullptr 则是 std::nullptr_t 类型的，能够明确表示空指针，使编译器更容易理解代码。

2）代码可读性：使用 nullptr 使得代码更具有可读性和可维护性。它明确传达了变量是用作指针而非整数值，例如：

void process(int x) {
    std::cout << "Integer: " << x << std::endl;
}

void process(voidptr) {
    std::cout << "Pointer: " << ptr << std::endl;
}

int main() {
    process(NULL);     // int 还是指针？
    process(nullptr);  // 指针
    return 0;
}

在上面的代码中，可以看出 nullptr 能让编译器和程序员清楚地知道调用哪个函数。

3）避免潜在的错误：在函数重载和模板中使用 NULL 可能导致编译器选择错误的重载版本。另外，模板编程中特别是涉及类型推断时，NULL 会带来一些不期望的效果。

template<typename T>
void foo(T x) {
    std::cout << typeid(x).name() << std::endl;
}

int main() {
    foo(0);         // 0 是int型
    foo(NULL);      // 你希望是int还是指针呢
    foo(nullptr);   // std::nullptr_t
    return 0;
}

在上面的代码中，使用 nullptr 可以让我们精确控制模板的类型。

C++ 中 nullptr 与 NULL 对比表 #

🌟C++ 中什么是深拷贝？什么是浅拷贝？ #

回答重点 #

1）浅拷贝：浅拷贝只是简单地复制对象的值，而不复制对象所拥有的资源或内存。也就是说，两个对象共享同一个资源或内存。当一个对象修改了该资源或内存，另一个对象也会受到影响。这种情况通常发生在默认的拷贝构造函数或赋值操作中。

2）深拷贝：深拷贝不仅复制对象的值，还会新分配内存并复制对象所拥有的资源。这样两个对象之间就不会共享同一个资源或内存，修改其中一个对象的资源或内存不会影响到另一个对象。

C++ 中友元类和友元函数有什么作用？ #

回答重点 #

两者主要用于提供访问私有成员和保护成员的权限。

友元关系是一种单向的访问权限，并不会破坏封装性，同时也不会牵涉到类之间的继承关系。友元的使用在以下情况下特别有用：

1） 友元函数：允许一个函数访问某个类的私有成员和保护成员。

class MyClass {
 private:
 int privateMember;

 public:
 MyClass() : privateMember(0) {}
 //声明友元函数friend void 
 friendFunction(MyClass &obj);
};

void friendFunction(MyClass &obj) {
//访问 privateMember
 obj.privateMember = 10;
}

2） 友元类：允许另一个类访问某个类的私有成员和保护成员。

class B; //前向声明

class A {
 private:
 int privateMember;
 
 public:
 A() : privateMember(0) {}
 //声明B为友元类
 friend class B;
};

class B {
 public:
 void accessA(A &obj) {
     //访问 A 的 privateMember
     obj.privateMember = 20;
 }
};

扩展知识 #

下面进一步讨论下它们的作用场景和设计考量：

1） 封装与开放：

• 封装是面向对象编程的基本原则之一，它将数据和操作数据的方法绑定到一起，防止外部代码直接访问对象的内部状态。友元的引入让类在需要的时候能够部分地开放它的内部状态，通常不会滥用。
• 友元函数和友元类提供了一种在不破坏封装性的条件下，安全访问私有成员的方式。

2） 友元的替代方案：

• 如果友元机制的使用本质上意味着违反封装性或设计初衷，那么可能需要重新考量类的设计。
• 你可以选择通过公开接口提供访问权限（如 getter/setter 方法），或利用继承、多态等其他 OOP 特性来实现同样的目的。

3） 访问控制复杂度：

• 使用友元可能会增加代码的复杂度，因为它打破了类的封装性，代码的维护变得相对困难。所以，在维护代码时，需要非常小心，确保友元使用的合理性和必要性。

友元是一种方便但需要慎用的工具，合理使用能够简化代码，但滥用则会破坏类的封装性，增加代码维护的难度。建议在实际编程中能够权衡利弊，合理利用这一机制。

C++ 如何调用 C 语言的库？ #

回答重点 #

可以使用 extern "C" 来告诉编译器按照 C 语言的链接方式处理某些代码：

1）在 C++ 代码中包含 C 语言头文件时，用 extern "C" 进行声明，比如：

extern "C" {
    #include "your_c_library.h"
}

2）需要在链接阶段确保 C++ 项目和 C 语言库都被正确链接。可通过编写合适的 CMakeLists.txt 或 Makefile 来实现。

3）也可以不使用 extern “C”，源文件后缀名改为.c 也行。

扩展知识 #

说到 extern "C"，得从 C 和 C++ 的兼容性说起。C++ 是 C 的增强版本，但它们的编译方式还是有些差异的。C++ 支持函数的重载，而 C 语言不支持。C++ 编译器会对函数进行“名字修饰”（Name Mangling）。

extern "C" 的作用是让编译器按 C 方式编译，避免函数名被修饰，保证 C 语言库里的函数能被正确调用。

举个例子： 假设有一个简单的 C 库 math_library.c：

// math_library.c
int add(int a, int b) {
    return a + b;
}

你先编写一个头文件 math_library.h：

// math_library.h
#ifndef MATH_LIBRARY_H
#define MATH_LIBRARY_H
int add(int a, int b);
#endif

然后在你的 C++ 项目中这么用：

// main.cpp
#include <iostream>
extern "C" {
    #include "math_library.h"
}

int main() {
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

最后，确保编译和链接。可以使用以下命令：

g++ -o main main.cpp math_library.c

另外，有几点需要注意：

1）如果你的 C 库里有 C++ 不支持的特性，比如变量长度数组（VLA），需要仔细考虑兼容性。

2）如果 C 库包含了结构体，尤其是那些带有复杂数据类型或指针的结构体，要确保它们在 C++ 中能够正确处理。

3）最好是 C 和 C++ 不要混用，如果要混用，建议做一个封装层，对 C 做一层 C++ 的封装，然后上层的业务代码还是统一使用 C++。

指针和引用的区别 #

回答重点 #

1. 引用必须在声明时初始化，指针可以不需要初始化

// 引用示例
int a = 10;
int& ref_a = a; // 引用初始化
// int& ref_b; // 错误：引用必须在声明时初始化
// 指针示例
int b = 20;
int* ptr_b = &b; // 指针初始化
int* ptr_c = nullptr; // 指针可以为空

1. 指针是一个变量，存储的是一个地址，引用跟原来的变量实质上是同一个东西，是原变量的别名，引用本身并不存储地址，而是在底层通过指针来实现对原变量的访问
2. 引用被创建之后，就不可以进行更改，指针可以更改

#include<iostream>
int main() {
    int a = 10;
    int b = 20;
    // 引用
    int& ref_a = a; // ref_a 是 a 的引用
    // ref_a = b; // 错误：引用不能被重新绑定
    // 指针
    int* ptr_a = &a; // ptr_a 是一个指针，指向 a
    ptr_a = &b; // 指针可以被重新赋值，现在指向 b
    std::cout << "a: " << a << ", b: " << b << std::endl;
    // 如果取消注释 ref_a = b; 这行代码，将会导致编译错误
    // 输出 "a: 10, b: 20"，因为引用不能被重新绑定
    *ptr_a = 30; // 通过指针修改 b 的值
    std::cout << "a: " << a << ", b: " << b << std::endl; // 输出 "a: 10, b: 30"
    return 0;
}

1. 不存在指向空值的引用，必须有具体实体；但是存在指向空值的指针。

public 继承、protected 继承、private 继承的区别 #

回答重点 #

重点说明三种继承方式的区别：

什么是静态数据成员和静态成员函数？ #

在 C++ 里，静态数据成员和静态成员函数是类的特殊成员，下面分别介绍它们：

静态数据成员 #

静态数据成员是用 static 关键字修饰的类的数据成员。它不属于类的某个具体对象，而是被类的所有对象共享，在内存中只有一份拷贝。

所有对象都能访问和修改同一个静态数据成员，可用于记录类相关的公共信息。

必须在类外进行初始化，且初始化时不使用 static 关键字。

#include <iostream>
class MyClass {
public:
    static int staticData; // 声明静态数据成员
};

// 在类外初始化静态数据成员
int MyClass::staticData = 10;

int main() {
    MyClass obj1, obj2;
    std::cout << "obj1的静态数据成员值: " << obj1.staticData << std::endl;
    std::cout << "obj2的静态数据成员值: " << obj2.staticData << std::endl;

    // 修改静态数据成员的值
    obj1.staticData = 20;
    std::cout << "修改后obj2的静态数据成员值: " << obj2.staticData << std::endl;

    return 0;
}

在这个例子中，staticData 是 MyClass 类的静态数据成员，obj1 和 obj2 共享这一成员，修改 obj1 的 staticData 后，obj2 的 staticData 也会改变。

静态成员函数 #

静态成员函数是用 static 关键字修饰的类的成员函数，它不依赖于类的具体对象，可直接通过类名调用。

没有 this 指针，因为它不与特定对象关联，不能访问非静态数据成员和非静态成员函数。

主要用于处理类的静态数据成员，提供与类相关的通用功能。

#include <iostream>
class MyClass {
private:
    static int staticData;
public:
    static void setStaticData(int value) {
        staticData = value;
    }
    static int getStaticData() {
        return staticData;
    }
};

// 在类外初始化静态数据成员
int MyClass::staticData = 0;

int main() {
    // 直接通过类名调用静态成员函数
    MyClass::setStaticData(30);
    std::cout << "静态数据成员的值: " << MyClass::getStaticData() << std::endl;

    return 0;
}

静态成员变量为什么要在类外初始化？ #

回答重点 #

1. 存储空间分配：

   • 因为静态变量不属于任何特定对象，而是类的共享成员，需要在全局范围内分配存储空间。静态变量的存储空间在程序启动时分配，生命周期贯穿整个程序运行。类内声明仅告知编译器该变量的存在，而类外定义则实际分配内存。

2. 避免重复定义：

   • 如果在类内初始化静态变量，可能会导致多个编译单元中包含该变量的定义，导致链接错误。类外定义确保静态变量只在一个编译单元中定义，避免重复。

扩展知识 #

1. 静态成员函数：

   • 静态成员函数只能访问静态成员变量，不能访问非静态成员变量，因为它们没有 this 指针。

2. 静态常量成员：

   • 静态常量成员（如 static const int）可以在类内直接初始化，因为它们在编译时已知，并且不需要额外的存储空间。

3. 内联静态成员：

   • C++17 引入了内联静态成员，可以在类内直接初始化静态变量，编译器会自动处理存储和链接问题。

class MyClass {
public:
    static int staticVar; // 类内声明
    static const int staticConstVar = 10; // 静态常量整型成员，类内初始化
};

int MyClass::staticVar = 0; // 类外定义和初始化

int main() {
    MyClass::staticVar = 5; // 访问静态变量
    return 0;
}

C++ 进阶篇 #

🌟C++ 动态库和静态库的区别？ #

回答重点 #

动态库（也称为共享库）和静态库是常用的两种库形式，它们有以下主要区别：

1）动态库在运行时加载，提供共享的库文件，如 .dll（Windows）或 .so（Linux），而静态库在编译时被直接合并到可执行文件中，通常是 .lib（Windows）或 .a（Linux）。

2）动态库在内存中可以被多个程序共享，因此节省了内存和磁盘空间，但会引入一些加载开销。对于静态库，每个使用它的程序都会有一份拷贝，二进制文件较大，但启动速度通常较快。

3）重点：动态库可以在库升级时无需重新编译依赖该库的程序，只需要更新库文件即可。而静态库由于依赖程序直接包含了库的代码，所以需要重新编译依赖程序进行更新。

4）在调试和部署方面，动态库更复杂，因为它们需要在运行时找到所需的库文件。如果库文件不存在或版本不匹配，程序可能无法正常运行。静态库则不会有这种问题，因为所有依赖都已经编译进了可执行文件。

扩展知识 #

除了上面提到的主要区别，动态库和静态库在开发过程中还有一些其他注意事项和优化技巧，可以进一步了解：

1）符号解析：静态链接在编译时就解析了符号，这意味着所有函数和变量的引用都在编译期解决，而动态链接在运行时解析符号，这会略微增加加载时间。

2）版本控制：动态库通常可以使用版本号来管理不同版本的库同时存在，例如在 Linux 系统中，库文件名中可以包含版本号，如 libxyz.so.1.2.3。这可以允许旧版程序继续使用旧版本的库，而新版程序使用新版本的库。

3）编译选项：在创建动态库时，通常需要使用如 -fPIC（Position Independent Code，位置无关代码）选项来生成可以在任意内存地址运行的代码。而静态库通常不需要考虑这一点，因为它们最终会被编译进可执行文件。

4）链接顺序：在链接静态库时，链接顺序可能会影响到最终的可执行文件，尤其是在处理有依赖关系的多个库时。动态库则相对宽松，因为它们的依赖关系可以在运行时解决。

5）打包和分发：动态库通常需要一并打包分发，确保目标系统中存在正确版本的库。常见的方法包括使用容器（如 Docker）或者打包系统（如 Windows 安装包及 Linux 的 .deb 和 rpm 包）。

🌟 介绍下 C++ 程序从编写到可执行的整个过程？ #

回答重点 #

总共分 5 步：

1）编写代码：编写 C++ 源代码，保存为 .cpp 、.cc .h 文件。

2）预处理：预处理器根据源代码中的预处理指令（如 #include 替换、#define 替换等）对代码进行处理，生成纯净的源代码。

3）编译：编译器（如 g++ 或 clang++）将预处理后的源代码翻译成汇编代码。

4）汇编：汇编器（如 as）将汇编代码转换成机器码，生成目标文件（.o 文件）。

5）链接：链接器（如 ld）将多个目标文件和库文件链接在一起，生成最终的可执行文件。

扩展知识 #

下面深入理解各个步骤：

1）编写代码

开发者主要参与的就是这个步骤，通过 C++ 编写逻辑业务代码，这部分代码是高级语言编写的，人类易读易写。

2）预处理

预处理器主要做以下工作：

• 处理头文件：如 #include 指令会替换为头文件内容。
• 宏替换：如 #define 指令用相应的代码替换宏。
• 条件编译：根据条件指令（如 #ifdef、#ifndef 等）决定是否编译部分代码。
• 去除注释：清理掉所有注释。
• 添加行号：添加行号和文件名标识，方便编译器产生警告和调试信息

预处理的输出仍是 C++ 代码，但没有了预处理指令。

3）编译

编译器将预处理后的代码转化为汇编代码，主要做以下工作：

• 词法分析：语法扫描，利用有限状态机的算法将源码中的字符串分割成一系列记号，如加减乘除数字括号等。
• 语法分析：检查代码语法，将源代码转为语法树。
• 语义分析：检查变量类型、函数调用是否合法等，比如浮点型整数赋值给指针，编译器就会报错。
• 优化：对中间代码进行优化，提高代码运行效率，比如 3+4=7。
• 生成汇编：根据优化后的中间代码生成汇编代码。

汇编代码是与硬件无关的低级代码。

4）汇编

汇编器将汇编代码转化为与目标机器相关的机器码，生成目标文件。每个 .cpp 源文件（模块）通常会生成一个对应的 .o 目标文件。这些文件包含机器指令以及一些符号表信息，用于后续链接。

5）链接

链接器将所有目标文件和所需的库文件链接起来，生成最终的可执行文件。主要做以下工作：

• 符号解析：找到所有外部符号（如函数、变量）在目标文件和库文件中的定义。
• 地址分配：将目标代码放置在内存中的适当位置。
• 重定位：调整程序内所有的地址引用，使它们指向正确的内存位置。

🌟 谈一谈你对面向对象的理解 #

回答重点 #

四大核心特性（3 + 1）：

1. 封装：将数据（属性）和操作数据的方法（函数）绑定到类中，通过访问控制（public/private/protected）隐藏实现细节。可提高安全性（防止外部直接修改数据），简化接口使用。
2. 继承：通过派生类（子类）复用基类（父类）的代码，来支持层次化设计。
3. 多态：同一接口在不同上下文中表现出不同行为，分为编译时多态（函数重载、模板）和运行时多态（虚函数）。运行时多态主要是通过虚函数表和虚函数指针，实现动态绑定。
4. 抽象：仅暴露必要接口，隐藏复杂实现细节。主要通过纯虚函数定义抽象类（接口）。

扩展知识 #

• 菱形继承：C++ 支持一个类继承多个基类，但需注意菱形继承问题（通过虚继承解决）：

class A {};
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {}; // 虚继承避免 A 的重复拷贝

• 虚函数与多态成本：虚函数通过虚函数表实现，会带来额外内存和间接调用开销，但提供了灵活的运行时多态。

🌟介绍下C++常用的容器以及特点？ #

如下表：

🌟详细介绍C++中的constexpr #

回答重点 #

constexpr是C++11引入的关键字，用于声明常量表达式，在编译时就能确定值的表达式，两个用途：

• 编译时计算：编译时就可以计算出表达式的值，提高运行时性能

• 常量表达式上下文：可用于哪些需要常量的表达式，比如数组大小、模板参数等。

扩展知识 #

1）constexpr变量：声明时必须初始化，且初始值必须是常量表达式。

constexpr int size = 10; // size 是编译时常量
int arr[size];

2）constexpr 函数：在编译期求值的函数，它的参数必须是常量表达式。

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
constexpr int val = factorial(5); // val 在编译时计算为 120

3）constexpr 与 const 的区别：

• const：运行时不可修改，但不保证编译时求值
• constexpr：编译时求值

🌟 请介绍 C++ 多态的实现原理？ #

回答重点 #

整体流程如下：

回答多态的实现原理，主要可以围绕在 虚函数、虚函数表 和 虚函数表指针 方向上。

多态通过虚函数实现。通过虚函数，子类可以重写父类的方法，当通过基类指针或引用调用时，会根据对象的实际类型调用对应的函数实现。

而这更深层次的原理，是通过虚表（vtable）和虚表指针（vptr）机制实现的。虚表是一个函数指针数组，包含了该类所有虚函数的地址，而虚表指针存储在对象实例中，指向属于该对象的虚表。

扩展知识 #

可以从以下几个方面，更全面的了解多态：

1）虚函数和重写：在基类中使用关键字 virtual 声明虚函数后，在子类中可以重写这个函数。

class Base {
public:
 virtual void show() {
     std::cout << "Base show" << std::endl;
 }
};

class Derived : public Base {
public:
 void show() override {
     std::cout << "Derived show" << std::endl;
 }
};