怎样避免C++中的内存泄漏 智能指针与RAII技术实践指南

#include <memory>
#include <iostream>

class MyData {
public:
    MyData() { std::cout << "MyData created\n"; }
    ~MyData() { std::cout << "MyData destroyed\n"; }
    void doSomething() { std::cout << "Doing something...\n"; }
};

void processUniqueData() {
    // 使用unique_ptr，无需手动delete
    std::unique_ptr<MyData> dataPtr = std::make_unique<MyData>();
    dataPtr->doSomething();
    // dataPtr超出作用域时，MyData会被自动销毁
} // MyData destroyed

void processSharedData() {
    // shared_ptr实现共享所有权
    std::shared_ptr<MyData> sharedData1 = std::make_shared<MyData>();
    {
        std::shared_ptr<MyData> sharedData2 = sharedData1; // 共享所有权
        std::cout << "Shared count inside scope: " << sharedData1.use_count() << "\n"; // 通常是2
    } // sharedData2超出作用域，但MyData不会被销毁，因为sharedData1还在
    std::cout << "Shared count outside scope: " << sharedData1.use_count() << "\n"; // 通常是1
} // MyData destroyed (当最后一个shared_ptr超出作用域)

int main() {
    std::cout << "--- Processing Unique Data ---\n";
    processUniqueData();
    std::cout << "\n--- Processing Shared Data ---\n";
    processSharedData();
    return 0;
}

#include <memory>
#include <iostream>
#include <vector>

class Node {
public:
    std::string name;
    // shared_ptr用于指向子节点，表示拥有关系
    std::vector<std::shared_ptr<Node>> children;
    // weak_ptr用于指向父节点，避免循环引用
    std::weak_ptr<Node> parent; 

    Node(const std::string& n) : name(n) {
        std::cout << "Node " << name << " created.\n";
    }
    ~Node() {
        std::cout << "Node " << name << " destroyed.\n";
    }

    void addChild(std::shared_ptr<Node> child) {
        children.push_back(child);
        child->parent = shared_from_this(); // 让子节点弱引用父节点
    }

    // 注意：shared_from_this() 要求类必须继承 std::enable_shared_from_this<T>
    // 否则在对象尚未被shared_ptr管理时调用会出错
    std::shared_ptr<Node> getParent() {
        return parent.lock(); // 提升为shared_ptr
    }
};

// 为了让Node可以使用shared_from_this()
class MyNode : public std::enable_shared_from_this<MyNode> {
public:
    std::string name;
    std::vector<std::shared_ptr<MyNode>> children;
    std::weak_ptr<MyNode> parent;

    MyNode(const std::string& n) : name(n) {
        std::cout << "MyNode " << name << " created.\n";
    }
    ~MyNode() {
        std::cout << "MyNode " << name << " destroyed.\n";
    }

    void addChild(std::shared_ptr<MyNode> child) {
        children.push_back(child);
        child->parent = shared_from_this(); 
    }
};

void testNodeLifecycle() {
    std::shared_ptr<MyNode> root = std::make_shared<MyNode>("Root");
    std::shared_ptr<MyNode> child1 = std::make_shared<MyNode>("Child1");
    std::shared_ptr<MyNode> child2 = std::make_shared<MyNode>("Child2");

    root->addChild(child1);
    root->addChild(child2);

    // 此时，root持有child1和child2的shared_ptr
    // child1和child2弱引用root
    // 如果没有weak_ptr，child1和root会互相持有，导致循环引用，无法释放

    std::cout << "Root parent (should be null): " << (root->getParent() ? root->getParent()->name : "null") << "\n";
    std::cout << "Child1 parent: " << (child1->getParent() ? child1->getParent()->name : "null") << "\n";

} // 所有MyNode对象在离开作用域后正确销毁，因为weak_ptr打破了循环引用

int main() {
    std::cout << "--- Testing Node Lifecycle with weak_ptr ---\n";
    testNodeLifecycle();
    std::cout << "--- End of test ---\n";
    return 0;
}

#include <mutex>
#include <thread>
#include <iostream>
#include <fstream> // For file operations example

std::mutex mtx;
int shared_resource = 0;

void increment_shared_resource() {
    // 使用std::lock_guard，确保互斥锁在函数退出时自动释放
    std::lock_guard<std::mutex> lock(mtx); 
    shared_resource++;
    std::cout << std::this_thread::get_id() << " incremented to " << shared_resource << "\n";
    // 即使这里抛出异常，锁也会被正确释放
} // lock_guard超出作用域，自动解锁mtx

void writeToFile(const std::string& filename, const std::string& content) {
    // std::ofstream是RAII的体现，文件在对象销毁时自动关闭
    std::ofstream outFile(filename); 
    if (outFile.is_open()) {
        outFile << content;
        std::cout << "Content written to " << filename << "\n";
    } else {
        std::cerr << "Failed to open file: " << filename << "\n";
    }
} // outFile超出作用域，文件自动关闭

int main() {
    std::cout << "--- Testing Mutex with RAII ---\n";
    std::thread t1(increment_shared_resource);
    std::thread t2(increment_shared_resource);
    t1.join();
    t2.join();
    std::cout << "Final shared resource value: " << shared_resource << "\n\n";

    std::cout << "--- Testing File IO with RAII ---\n";
    writeToFile("example.txt", "Hello, RAII!");

    return 0;
}