C++ 智能指针使用不当导致内存泄漏问题解析

#include <iostream>
#include <memory>
using namespace std;
class B;
class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed\n"; }
};
class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() { std::cout << "B destroyed\n"; }
};
int main() {
    // 创建 shared_ptr 对象
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    // 相互引用
    a->b_ptr = b;
    b->a_ptr = a;
    cout<<"use_count of a:"<<a.use_count()<<endl;
    cout<<"use_count of b:"<<b.use_count()<<endl;
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;
class B;  // 先声明类 B，使得 A 和 B 可以互相引用。
class A {
public:
    std::shared_ptr<B> b_ptr; // A 拥有 B 的强引用
    ~A() { std::cout << "A destroyed\n"; }
};
class B {
public:
    std::weak_ptr<A> a_ptr; // B 拥有 A 的弱引用
    ~B() { std::cout << "B destroyed\n"; }
    void safeAccess() {
        // 尝试锁定 a_ptr 获取 shared_ptr
        if (auto a_shared = a_ptr.lock()) {
            // 安全访问 a_shared 对象
            std::cout << "Accessing A from B\n";
        } else {
            std::cout << "A is already destroyed, cannot access A from B\n";
        }
    }
};
int main() {
    // 创建 shared_ptr 对象
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    // 互相引用
    a->b_ptr = b;
    b->a_ptr = a;
    // 安全访问
    b->safeAccess();
    cout<<"use_count of a:"<<a.use_count()<<endl;
    cout<<"use_count of b:"<<b.use_count()<<endl;
    return 0; // 在这里，a 和 b 的引用计数将会正确地减少到零，并且它们将会被销毁。
}

shared_ptr<vector<shared_ptr<pair<string, shared_ptr<string>>>>> jsFiles;

#include <iostream>
#include <vector>
#include <memory>
#include <string>
using namespace std;
// 自定义 String 类，模拟 std::string
class MyString {
public:
    std::string data;
    MyString(const std::string& str) : data(str) {
        std::cout << "MyString created: " << data << std::endl;
    }
    ~MyString() {
        std::cout << "MyString destroyed: " << data << std::endl;
    }
    // 添加输出操作符重载
    friend std::ostream& operator<<(std::ostream& os, const MyString& myStr) {
        os << myStr.data;
        return os;
    }
};
// 自定义 Pair 类，模拟 std::pair
template<typename K, typename V>
class MyPair {
public:
    K first;
    V second;
    MyPair(const K& key, const V& value) : first(key), second(value) {
        std::cout << "MyPair created: {" << first << ", " << *second << "}" << std::endl;
    }
    ~MyPair() {
        std::cout << "MyPair destroyed: {" << first << ", " << *second << "}" << std::endl;
    }
};
int main() {
    // 创建 jsFiles，它是一个 shared_ptr，指向 vector
    auto jsFiles = std::make_shared<std::vector<std::shared_ptr<MyPair<std::string, std::shared_ptr<MyString>>>>>();
    // 添加元素
    auto innerPair1 = std::make_shared<MyPair<std::string, std::shared_ptr<MyString>>>("file1", std::make_shared<MyString>("content of file1"));
    auto innerPair2 = std::make_shared<MyPair<std::string, std::shared_ptr<MyString>>>("file2", std::make_shared<MyString>("content of file2"));
    jsFiles->push_back(innerPair1);
    jsFiles->push_back(innerPair2);
    // 访问元素
    for (const auto& pairPtr : *jsFiles) {
        std::cout << "Filename: " << pairPtr->first << ", Content: " << *pairPtr->second << std::endl;
    }
    // 离开作用域时，智能指针会自动销毁它们管理的对象
    return 0;
}

#include <iostream>
#include <memory>
#include <functional>
class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    void setCallback(std::function<void()> cb) {
        callback_ = cb;
    }
    void executeCallback() {
        if (callback_) {
            callback_();
        }
    }
private:
    std::function<void()> callback_;
};
void createNoLeak() {
    auto myObject = std::make_shared<MyClass>();
    myObject->setCallback([=]() {
        std::cout << "Callback executed, myObject use count: " << myObject.use_count() << std::endl;
    });
    myObject->executeCallback();
}
int main() {
    createNoLeak();
    std::cout << "End of program" << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
#include <functional>
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    void setCallback(std::function<void()> cb) {
        callback_ = cb;
    }
    void executeCallback() {
        if (callback_) {
            callback_();
        }
    }
private:
    std::function<void()> callback_;
};
void createNoLeak() {
    auto myObject = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> weakPtr = myObject;
    myObject->setCallback([weakPtr]() {
        if (auto sharedPtr = weakPtr.lock()) {
            std::cout << "Callback executed, object is valid" << std::endl;
        } else {
            std::cout << "Object already destroyed" << std::endl;
        }
    });
    myObject->executeCallback();
    // 这里 myObject 是按 weak_ptr 捕获，当 createNoLeak() 结束时，myObject 的生命周期也就结束了，并且引用计数=0
}
int main() {
    createNoLeak();
    std::cout << "End of program" << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
// 定义 MyClass 继承 std::enable_shared_from_this<MyClass>
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    // 一个成员函数，它需要返回一个指向自身的 shared_ptr
    std::shared_ptr<MyClass> getSharedPtr() {
        // 使用 shared_from_this 返回一个 shared_ptr
        return shared_from_this();
    }
    void doSomething() {
        auto ptr = shared_from_this(); // 获取 shared_ptr
        std::cout << "Doing something with MyClass instance, ref count: " << ptr.use_count() << std::endl;
    }
};
void exampleFunction() {
    // 创建 MyClass 对象的 shared_ptr
    auto myObject = std::make_shared<MyClass>();
    // 调用成员函数获取 shared_ptr
    auto mySharedPtr = myObject->getSharedPtr();
    std::cout << "Reference count after getSharedPtr: " << mySharedPtr.use_count() << std::endl;
    myObject->doSomething();
}
int main() {
    exampleFunction();
    return 0;
}