使用stl容器时，内存泄漏主要源于指针管理不当，解决方法如下：1. 使用智能指针如std::unique_ptr或std::shared_ptr管理内存，确保对象生命周期与容器同步；2. 根据所有权模型选择合适的智能指针，std::unique_ptr适用于独占所有权，std::shared_ptr适用于共享所有权；3. 避免循环引用导致的内存泄漏，可使用std::weak_ptr打破循环；4. 对于资源管理，还可以采用raii原则，在对象构造时获取资源、析构时释放资源，从而自动管理资源生命周期。
STL容器使用不当确实容易造成内存泄漏，尤其是在容器中存放指针时。核心在于确保容器中每个元素的生命周期得到妥善管理，防止对象在不再使用时仍然占用内存。
解决方案
最直接的策略是使用智能指针，例如
std::unique_ptr或
std::shared_ptr，来管理容器中的元素。
std::unique_ptr适用于独占所有权的情况，而
std::shared_ptr适用于多个对象需要共享所有权的情况。
例如，假设我们有一个
Widget类，并且想在一个
std::vector中存储指向
Widget对象的指针，可以这样做：
#include <iostream>
#include <vector>
#include <memory>
class Widget {
public:
Widget(int id) : id_(id) {
std::cout << "Widget " << id_ << " created." << std::endl;
}
~Widget() {
std::cout << "Widget " << id_ << " destroyed." << std::endl;
}
private:
int id_;
};
int main() {
std::vector<std::unique_ptr<Widget>> widgets;
widgets.push_back(std::make_unique<Widget>(1));
widgets.push_back(std::make_unique<Widget>(2));
// 当 widgets 离开作用域时，其包含的 Widget 对象也会被自动销毁。
return 0;
}当
widgets向量离开作用域时，
std::unique_ptr的析构函数会被调用，从而自动删除其指向的
Widget对象，避免内存泄漏。
如何选择合适的智能指针类型？
选择
std::unique_ptr还是
std::shared_ptr取决于你的所有权模型。如果只有一个容器拥有对象，并且对象的生命周期应该与容器同步，那么
std::unique_ptr是最佳选择。如果多个容器或对象需要共享对同一对象的所有权，那么
std::shared_ptr更合适。需要注意的是，过度使用
std::shared_ptr可能会导致循环引用，从而阻止对象被正确释放，因此需要仔细设计对象之间的关系。
如何处理容器中对象的复制？
在使用智能指针时，复制容器可能会带来一些挑战。对于
std::unique_ptr，由于其独占所有权的特性，直接复制容器会导致编译错误。你需要使用移动语义（
std::move）来转移所有权。对于
std::shared_ptr，复制容器会增加引用计数，只有当所有
std::shared_ptr都离开作用域时，对象才会被销毁。
#include <iostream>
#include <vector>
#include <memory>
class Widget {
public:
Widget(int id) : id_(id) {
std::cout << "Widget " << id_ << " created." << std::endl;
}
~Widget() {
std::cout << "Widget " << id_ << " destroyed." << std::endl;
}
private:
int id_;
};
int main() {
std::vector<std::unique_ptr<Widget>> widgets;
widgets.push_back(std::make_unique<Widget>(1));
widgets.push_back(std::make_unique<Widget>(2));
// 使用移动语义转移所有权
std::vector<std::unique_ptr<Widget>> widgets2 = std::move(widgets);
// 现在 widgets2 拥有 Widget 对象，而 widgets 为空。
return 0;
}如何避免循环引用导致std::shared_ptr
内存泄漏？
循环引用是
std::shared_ptr常见的问题。例如，如果两个对象互相持有对方的
std::shared_ptr，那么它们的引用计数永远不会降为零，从而导致内存泄漏。解决这个问题的方法是使用
std::weak_ptr。
std::weak_ptr是一种弱引用，它不会增加对象的引用计数。你可以使用
std::weak_ptr来打破循环引用。
#include <iostream>
#include <memory>
class A; // 前置声明
class B {
public:
std::shared_ptr<A> a_ptr;
~B() { std::cout << "B destroyed" << std::endl; }
};
class A {
public:
std::weak_ptr<B> b_ptr; // 使用 weak_ptr
~A() { std::cout << "A 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;
b->a_ptr = a;
// A 和 B 都离开作用域，由于 A 中使用了 weak_ptr，循环引用被打破，A 和 B 都会被销毁。
return 0;
}除了智能指针，还有其他避免内存泄漏的方法吗？
当然，除了智能指针，还可以使用RAII（Resource Acquisition Is Initialization）原则来管理资源。RAII的核心思想是将资源的获取和释放绑定到对象的生命周期。当对象被创建时获取资源，当对象被销毁时释放资源。这可以通过在类的构造函数中获取资源，并在析构函数中释放资源来实现。虽然RAII通常与智能指针一起使用，但它也可以应用于其他类型的资源管理，例如文件句柄、网络连接等。
