C++面试：对象生命周期 & 垃圾回收

Thomas_Lbw2024-01-12 14:12

在C++中，理解对象的生命周期和垃圾回收是非常重要的，尤其是在准备面试腾讯等大型科技公司的C++开发岗位时。这些概念涉及内存管理，是C++编程中的核心部分。

目录

对象生命周期

垃圾回收

手动内存管理

智能指针

[std::unique_ptr 示例](#std::unique_ptr 示例)

[std::shared_ptr 示例](#std::shared_ptr 示例)

资源获取即初始化 (RAII)

文件句柄的RAII示例

面试准备

理解和实践

案例分析

[案例 1: 使用智能指针](#案例 1: 使用智能指针)

[案例 2: 避免内存泄漏的异常处理](#案例 2: 避免内存泄漏的异常处理)

[案例 3: 使用工厂函数管理资源](#案例 3: 使用工厂函数管理资源)

[案例 4: 遵循RAII原则](#案例 4: 遵循RAII原则)

最新特性

C++20中的内存管理和对象生命周期改进

对象生命周期

  1. 创建和构造：对象的生命周期开始于对象在内存中的创建。这可能通过直接声明、动态分配或其他方式完成。对象构造时，其构造函数被调用。

  2. 存活期：对象在其被创建后，直到被销毁之前的这段时间内处于存活状态。在这段时间内，对象可以被访问和操作。

  3. 销毁和析构 ：对象的生命周期结束于对象的销毁。对于栈分配的对象，当它们的作用域结束时自动销毁；对于堆分配的对象，需要显式地使用delete操作来销毁。对象销毁时，其析构函数被调用。

cpp 复制代码 
#include <iostream>
using namespace std;

class Sample {
public:
    // 构造函数
    Sample() {
        cout << "对象被创建并构造" << endl;
    }

    // 析构函数
    ~Sample() {
        cout << "对象被销毁并析构" << endl;
    }

    // 成员函数
    void doSomething() {
        cout << "对象处于活跃状态，执行操作" << endl;
    }
};

int main() {
    cout << "程序开始" << endl;

    // 创建和构造阶段
    Sample* samplePtr = new Sample(); // 动态分配

    // 存活期
    samplePtr->doSomething(); // 调用成员函数

    // 销毁和析构阶段
    delete samplePtr; // 显式销毁动态分配的对象

    // 局部对象的生命周期
    {
        Sample localSample; // 栈分配的对象
        localSample.doSomething(); // 调用成员函数
    } // localSample的作用域结束，自动销毁

    cout << "程序结束" << endl;
    return 0;
}

执行结果：

程序开始

对象被创建并构造

对象处于活跃状态，执行操作

对象被销毁并析构

对象被创建并构造

对象处于活跃状态，执行操作

对象被销毁并析构

程序结束

垃圾回收

C++ 不提供内置的垃圾回收机制，与像Java或Python这样的语言不同。C++程序员需要手动管理内存。

手动内存管理

在C++中，你需要显式地分配和释放内存。使用new分配内存，使用delete释放内存。不正确地管理内存会导致内存泄漏和其他问题。

智能指针

C++11引入了智能指针（如std::unique_ptr和std::shared_ptr），以帮助自动化内存管理。这些智能指针可以在对象不再需要时自动释放内存，降低内存泄漏的风险。

std::unique_ptr 示例

std::unique_ptr是一种独占所有权的智能指针，意味着同一时间内只有一个unique_ptr可以指向一个给定的对象。

cpp 复制代码 
#include <iostream>
#include <memory> // 包含智能指针的库

class Sample {
public:
    Sample() {
        std::cout << "Sample Created" << std::endl;
    }
    ~Sample() {
        std::cout << "Sample Destroyed" << std::endl;
    }
    void doSomething() {
        std::cout << "Doing Something" << std::endl;
    }
};

int main() {
    {
        std::unique_ptr<Sample> uPtr(new Sample()); // 创建unique_ptr
        uPtr->doSomething(); // 使用智能指针
    } // uPtr离开作用域，自动销毁Sample对象

    std::cout << "Unique Pointer out of scope" << std::endl;
    return 0;
}
std::shared_ptr 示例

std::shared_ptr是一种共享所有权的智能指针，允许多个shared_ptr实例共同拥有同一个对象。

cpp 复制代码 
#include <iostream>
#include <memory>

class Sample {
public:
    Sample() {
        std::cout << "Sample Created" << std::endl;
    }
    ~Sample() {
        std::cout << "Sample Destroyed" << std::endl;
    }
    void doSomething() {
        std::cout << "Doing Something" << std::endl;
    }
};

int main() {
    std::shared_ptr<Sample> sPtr1;
    {
        std::shared_ptr<Sample> sPtr2 = std::make_shared<Sample>(); // 使用make_shared创建
        sPtr1 = sPtr2; // sPtr1和sPtr2共享对象
        sPtr2->doSomething();
        std::cout << "Shared Pointer sPtr2 out of scope" << std::endl;
    } // sPtr2离开作用域，但对象不会被销毁，因为sPtr1仍然拥有它

    sPtr1->doSomething();
    std::cout << "Shared Pointer sPtr1 out of scope" << std::endl;
    // sPtr1离开作用域，对象会被自动销毁
    return 0;
}

资源获取即初始化 (RAII)

这是一种编程技巧，用于管理资源（如内存、线程、文件句柄等）。在RAII中，资源的生命周期与拥有它的对象绑定，当对象销毁时资源也随之释放。

文件句柄的RAII示例

在这个例子中，我们将创建一个类来封装对文件的操作。当实例化该类的对象时，它将打开一个文件；当对象的生命周期结束时，它将自动关闭文件。

cpp 复制代码 
#include <iostream>
#include <fstream>
#include <string>

class FileHandler {
private:
    std::fstream file;

public:
    // 构造函数：打开文件
    FileHandler(const std::string& filename) {
        file.open(filename, std::ios::out | std::ios::in);
        if (!file.is_open()) {
            std::cerr << "Error opening file: " << filename << std::endl;
        } else {
            std::cout << "File opened successfully: " << filename << std::endl;
        }
    }

    // 向文件写入内容
    void write(const std::string& content) {
        if (file.is_open()) {
            file << content;
        }
    }

    // 读取文件内容
    std::string read() {
        std::string content;
        if (file.is_open()) {
            file.seekg(0, std::ios::beg);
            content.assign((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        }
        return content;
    }

    // 析构函数：关闭文件
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed successfully" << std::endl;
        }
    }
};

int main() {
    {
        FileHandler fh("example.txt"); // 文件在这里被打开
        fh.write("Hello, RAII!");      // 写入内容
    } // fh对象离开作用域，自动调用析构函数，文件被关闭

    return 0;
}

在这个例子中，FileHandler类负责管理一个文件。当创建FileHandler对象时，文件被打开；当FileHandler对象的生命周期结束（如函数返回时），其析构函数会被调用，文件会被自动关闭。这就是RAII技术的核心：利用对象的生命周期管理资源。这种方法不仅代码清晰，而且能有效避免资源泄漏，特别是在遇到异常情况时。

面试准备

理解和实践

确保你理解这些概念，并在编码练习中实践它们。

案例分析

准备一些关于如何有效管理内存和避免内存泄漏的案例。

案例 1: 使用智能指针

在现代C++编程中，智能指针是管理动态分配内存的首选方式。它们自动管理内存，减少内存泄漏的风险。

cpp 复制代码 
#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    void doSomething() { std::cout << "Doing something" << std::endl; }
};

void process() {
    std::unique_ptr<MyClass> myClassPtr(new MyClass());
    myClassPtr->doSomething();
} // myClassPtr在这里离开作用域并自动释放内存

int main() {
    process();
    return 0;
}

案例 2: 避免内存泄漏的异常处理

当异常发生时，手动管理的内存可能不会被正确释放，导致内存泄漏。可以通过RAII或智能指针来防止这种情况。

cpp 复制代码 
#include <iostream>
#include <memory>
#include <stdexcept>

void riskyOperation() {
    std::unique_ptr<int> ptr(new int(10)); // 使用智能指针
    // ...执行一些操作...

    // 如果发生错误
    throw std::runtime_error("Error occurred");

    // 智能指针会自动清理资源，即使发生异常
}

int main() {
    try {
        riskyOperation();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

案例 3: 使用工厂函数管理资源

创建工厂函数来封装资源的创建和管理逻辑，确保资源总是在安全的环境下被分配和释放。

cpp 复制代码 
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource acquired" << std::endl; }
    ~Resource() { std::cout << "Resource released" << std::endl; }
};

Resource* createResource() {
    return new Resource();
}

void deleteResource(Resource* resource) {
    delete resource;
}

int main() {
    Resource* res = createResource();
    // 使用资源
    deleteResource(res);
    return 0;
}

案例 4: 遵循RAII原则

创建RAII类来封装资源，确保其在构造时被分配，在析构时被释放。

cpp 复制代码 
#include <iostream>
#include <vector>

class RAIIWrapper {
private:
    std::vector<int>* myVector;

public:
    RAIIWrapper() : myVector(new std::vector<int>()) {}
    ~RAIIWrapper() {
        delete myVector;
    }
    // 提供其他必要的方法和操作符重载
};

void process() {
    RAIIWrapper wrapper;
    // 使用wrapper
} // wrapper在这里离开作用域，自动释放资源

int main() {
    process();
    return 0;
}

在这些示例中，我们展示了如何使用智能指针、异常安全编程、工厂模式和RAII原则来有效管理内存并防止内存泄漏。在准备面试时，了解这些方法并能在面试中展示你如何在实际代码中应用它们是非常重要的。

最新特性

了解C++的最新版本中对内存管理和对象生命周期的改进。

截至我最后更新的时间（2023年4月），C++最新的主要版本是C++20，它带来了一些对内存管理和对象生命周期的改进和新特性。以下是一些关键点：

C++20中的内存管理和对象生命周期改进

  1. 概念（Concepts）: C++20引入了概念，它是一种模板参数的约束机制。虽然概念本身不直接涉及内存管理，但它们可以帮助创建更清晰、易于理解的模板代码，间接提高内存管理的安全性和效率。

  2. 协程（Coroutines）: C++20正式引入了协程支持。协程是函数的一种，可以暂停和恢复执行，而不是一次性运行到结束。它们提供了一种更灵活的方式来处理异步操作和懒惰生成，影响了对象的生命周期和内存管理。

  3. 改进的std::shared_ptr : C++20增加了对std::shared_ptr的功能，比如支持自定义的分配器。这允许更灵活的内存管理策略，特别是在需要特定类型的内存分配时。

  4. std::atomic和std::memory_order的改进: 对于并发编程，C++20提供了更多控制原子操作和内存顺序的能力。这些改进帮助开发者更精确地控制多线程环境中的资源访问和内存管理。

  5. std::span : std::span是一个新的STL容器，提供了对数组和类数组数据结构（如std::vector和C数组）的视图。这意味着它可以在不拥有数据的情况下提供对这些数据的访问，从而提供了更灵活的方式来处理现有数据，而不需要担心内存管理。

  6. std::latch和std::barrier: 这些是C++20中引入的新的同步原语，用于协调多个线程间的操作。正确使用这些工具可以避免线程间的资源竞争和潜在的内存管理问题。

  7. std::bit_cast: 这个新的转换函数允许安全地在不同类型之间转换数据，而不违反严格的别名规则。这对于涉及低级内存操作的程序是有益的。

在准备面试时，了解并能够讨论这些新特性是有帮助的。你可以强调如何利用这些特性来编写更高效、更安全的代码，特别是在内存管理和对象生命周期管理方面。记住，C++的每个新版本都旨在提高语言的表达力、安全性和性能，而这些目标在内存管理和对象生命周期方面尤为关键。

相关推荐
别NULL3 小时前
机试题——疯长的草
数据结构·c++·算法
CYBEREXP20084 小时前
MacOS M3源代码编译Qt6.8.1
c++·qt·macos
yuanbenshidiaos5 小时前
c++------------------函数
开发语言·c++
yuanbenshidiaos5 小时前
C++----------函数的调用机制
java·c++·算法
tianmu_sama5 小时前
[Effective C++]条款38-39 复合和private继承
开发语言·c++
羚羊角uou5 小时前
【C++】优先级队列以及仿函数
开发语言·c++
姚先生975 小时前
LeetCode 54. 螺旋矩阵 (C++实现)
c++·leetcode·矩阵
FeboReigns5 小时前
C++简明教程（文章要求学过一点C语言）（1）
c语言·开发语言·c++
FeboReigns5 小时前
C++简明教程（文章要求学过一点C语言）（2）
c语言·开发语言·c++
码农爱java6 小时前
设计模式--抽象工厂模式【创建型模式】
java·设计模式·面试·抽象工厂模式·原理·23种设计模式·java 设计模式
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍