C++智能指针shared_ptr是一种可以自动管理内存的智能指针,它是C++11新增的特性之一。与传统指针不同,shared_ptr可以自动释放所管理的动态分配对象的内存,并避免了手动释放内存的繁琐操作,从而减少了内存泄漏和野指针的出现。
shared_ptr是一个模板类,通过引用计数器实现多个智能指针共享对一个对象的所有权。每次复制一个shared_ptr对象时,该对象的引用计数器会增加1,当最后一个shared_ptr对象被销毁时,引用计数器减1,如果引用计数器变为0,则释放所管理的对象的内存。
使用shared_ptr需要包含头文件,并且可以通过以下方式创建:
std::shared_ptr<int> p(new int(10));
上面的代码创建了一个shared_ptr对象p,它指向一个动态分配的int类型对象,初始值为10。
在使用shared_ptr时,需要注意以下几点:
不要使用裸指针来初始化shared_ptr,否则可能导致多次删除同一个对象的情况。
避免在shared_ptr中存储数组,因为shared_ptr只能处理单个对象的释放,而不能正确地处理数组的销毁。
可以通过自定义删除器(deleter)来实现对对象的特定方式的释放。
shared_ptr可以作为函数参数传递,但要注意避免循环引用的问题,否则会导致内存泄漏。
shared_ptr是一种方便且安全的内存管理工具,能够有效地避免内存泄漏和野指针的出现。
shared_ptr的核心是引用计数技术。在每个shared_ptr对象中,都有一个指向所管理对象的指针和一个整型计数器。这个计数器统计有多少个shared_ptr对象指向该所管理对象。当一个新的shared_ptr对象指向同一块内存时,该内存的引用计数就会增加1。当一个shared_ptr对象不再指向该内存时,该内存的引用计数就会减少1。当引用计数为0时,说明没有任何shared_ptr对象指向该内存,此时该内存将会被自动释放。
shared_ptr的构造函数需要一个指针作为参数,该指针指向要被管理的对象。当一个新的shared_ptr对象被创建时,它会尝试增加所管理对象的引用计数。如果该对象还未被其他shared_ptr对象管理,则会创建一个新的引用计数,并将其设置为1。否则,它会与已经存在的shared_ptr对象共享同一个引用计数。
shared_ptr的析构函数会尝试减少所管理对象的引用计数。如果引用计数变成0,则会自动释放所管理对象的内存。
shared_ptr的控制块(包含引用计数和删除器等信息)会在最后一个指向所管理对象的shared_ptr析构时被释放。当引用计数减为0时,就说明没有任何shared_ptr对象指向该所管理对象了,此时shared_ptr会自动调用删除器,并释放掉控制块。由于shared_ptr可以共享同一个控制块,因此只有所有shared_ptr对象都析构后,控制块才能被释放。如果一个shared_ptr对象使用reset()方法手动解除与所管理对象的关联,也会相应地减少引用计数,当引用计数变成0时,控制块也会被释放。
shared_ptr可以与其他shared_ptr对象共享同一个指向对象的指针。当一个shared_ptr对象被复制时,它所管理的对象的引用计数也会增加1。因此,任何一个持有相同指针的shared_ptr对象都可以通过更改其所管理对象的状态来影响所有其他shared_ptr对象。
如果一个对象A包含指向另一个对象B的shared_ptr,而对象B也包含指向对象A的指针,则这两个对象将形成循环引用。在这种情况下,可能会出现内存泄漏。
shared_ptr 循环引用问题是指两个或多个对象之间通过shared_ptr相互引用,导致对象无法被正确释放,从而造成内存泄漏。
常见的情况是两个对象A和B,它们的成员变量互相持有了对方的shared_ptr。当A和B都不再被使用时,它们的引用计数不会降为0,无法被自动释放。
解决这个问题的方法有以下几种:
1.打破循环引用:可以通过将shared_ptr改为weak_ptr来解决。weak_ptr是一种弱引用,不会增加对象的引用计数,在对象释放时会自动设置为nullptr。可以使用weak_ptr.lock()方法来获取对象的shared_ptr,当对象已经释放时会返回一个空shared_ptr。
2.使用std::enable_shared_from_this:如果其中一个对象A需要获取对另一个对象B的shared_ptr,可以让对象B继承std::enable_shared_from_this,并在A中使用shared_from_this()方法获取B的shared_ptr,这样就不会形成循环引用。
3.手动析构:如果无法修改代码结构或者无法使用前两种方法解决问题,可以使用手动析构的方式来释放对象。通过调用reset()方法手动释放shared_ptr,确保引用计数降为0,对象会被正确释放。
4.使用weak_ptr和shared_ptr组合:将两个对象的循环引用中的一个改为weak_ptr,另一个仍使用shared_ptr。这样可以避免循环引用导致的内存泄漏。
创建shared_ptr
对象的语法有以下几种方式:
std::shared_ptr<int> p(new int);
std::shared_ptr<int> p = std::make_shared<int>();
void my_deleter(int* p) {
delete p;
}
std::shared_ptr<int> p(new int, my_deleter);
void my_deleter(int* p) {
delete p;
}
struct MyAllocator {
void* allocate(size_t size);
void deallocate(void* ptr, size_t size);
};
MyAllocator my_allocator;
std::shared_ptr<int> p(new int, my_deleter, my_allocator);
shared_ptr
对象创建std::shared_ptr<int> p1(new int);
std::shared_ptr<int> p2(p1);
shared_ptr
对象创建std::shared_ptr<int> p1(new int);
std::shared_ptr<int> p2(std::move(p1));
使用shared_ptr创建一个智能指针非常简单,只需要将一个指向动态分配内存的裸指针作为参数传递给shared_ptr的构造函数即可:
// 创建一个int类型的智能指针
std::shared_ptr<int> p(new int(10));
shared_ptr可以与其他shared_ptr对象共享同一个指向对象的指针,这样就可以避免多次动态分配内存和释放内存的问题。共享一个shared_ptr可以通过复制构造函数和赋值运算符实现:
// 复制构造函数
std::shared_ptr<int> p1(new int(10));
std::shared_ptr<int> p2(p1);
// 赋值运算符
std::shared_ptr<int> p3(new int(10));
std::shared_ptr<int> p4;
p4 = p3;
注意:共享一个shared_ptr会增加所管理对象的引用计数。因此,任何一个持有相同指针的shared_ptr对象都可以通过更改其所管理对象的状态来影响所有其他shared_ptr对象。
除了管理所分配的内存外,shared_ptr还可以使用删除器(deleter)来管理对象。删除器是一个函数或者函数对象,用于在shared_ptr释放所管理对象时执行特定的操作。删除器可以通过shared_ptr的模板参数指定:
// 使用Lambda表达式作为删除器
std::shared_ptr<int> p(new int(10), [](int* p){ delete[] p; });
如果需要解除shared_ptr与所管理对象的关联,可以使用reset()方法:
std::shared_ptr<int> p(new int(10));
p.reset();
注意:当调用reset()方法后,所管理对象的引用计数会减少1。如果引用计数变成0,则会自动释放所管理对象的内存。
#include
#include
using namespace std;
class MyClass {
public:
MyClass() { cout << "MyClass constructor" << endl; }
~MyClass() { cout << "MyClass destructor" << endl; }
void printInfo() { cout << "This is MyClass" << endl; }
};
int main() {
shared_ptr<MyClass> p1(new MyClass()); // 创建一个shared_ptr指向MyClass对象
shared_ptr<MyClass> p2 = p1; // p1和p2都指向同一个MyClass对象
p1->printInfo(); // 访问MyClass对象的成员函数
p2.reset(); // 释放p2所指向的MyClass对象
p1->printInfo(); // 由于p1仍然指向MyClass对象,所以此处输出"This is MyClass"
return 0;
}
上述代码中,通过调用shared_ptr
构造函数创建了两个指针p1和p2,并且它们都指向一个MyClass
对象。我们调用reset()
函数来释放p2所指向的MyClass
对象,但是由于p1仍然指向该对象,所以在调用p1->printInfo()
时仍然输出"This is MyClass"。当程序结束时,p1所指向的MyClass
对象会被自动释放。
可以看到,使用shared_ptr
可以很方便地避免内存泄漏和悬空指针等问题。另外,需要注意的是,shared_ptr
指针之间的赋值和拷贝操作都会增加指向对象的引用计数,即使一个指针已经释放了它所指向的对象,只要其他指针还在使用该对象,该对象就不会被自动删除。因此,在使用shared_ptr
时需要注意对象的生命周期,避免产生意外的副作用。
假设存在这样的循环引用:
#include
class B; //前向声明
class A {
public:
std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr
~A() {
std::cout << "A destructor" << std::endl;
}
};
class B {
public:
std::shared_ptr<A> a_ptr; // B类持有A类的shared_ptr
~B() {
std::cout << "B destructor" << 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之间形成了循环引用,导致其引用计数一直不为0
return 0;
}
解决方法:
(1)使用weak_ptr打破循环引用: 将A类和B类中的shared_ptr改为weak_ptr,将对象引用改为弱引用,这样不会增加对象的引用计数,从而避免循环引用导致的内存泄漏。在需要使用对象的地方,可以通过lock()方法将weak_ptr转换为shared_ptr来进行使用,如果对象已被释放,则返回空shared_ptr。
#include
class B; //前向声明
class A {
public:
std::weak_ptr<B> b_ptr; // A类持有B类的weak_ptr
~A() {
std::cout << "A destructor" << std::endl;
}
};
class B {
public:
std::weak_ptr<A> a_ptr; // B类持有A类的weak_ptr
~B() {
std::cout << "B destructor" << 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之间形成了循环引用,但由于使用了weak_ptr,不会形成内存泄漏
return 0;
}
(2)修改对象的引用关系: 考虑是否需要A类和B类之间互相持有shared_ptr的引用关系。如果某一方只需要单向引用,可以将其引用改为裸指针或者weak_ptr。这样可以避免形成循环引用。
#include
class B; //前向声明
class A {
public:
std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr
~A() {
std::cout << "A destructor" << std::endl;
}
};
class B {
public:
std::weak_ptr<A> a_ptr; // B类持有A类的weak_ptr
~B() {
std::cout << "B destructor" << 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->b_ptr改为shared_ptr,b->a_ptr改为weak_ptr,不会形成内存泄漏
return 0;
}
(3)手动析构: 如果无法修改代码结构或者无法使用前两种方法解决问题,可以使用手动析构的方式来释放对象。通过调用reset()方法手动释放shared_ptr,确保引用计数降为0,对象会被正确释放。
#include
class B; //前向声明
class A {
public:
std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr
~A() {
std::cout << "A destructor" << std::endl;
}
};
class B {
public:
std::shared_ptr<A> a_ptr; // B类持有A类的shared_ptr
~B() {
std::cout << "B destructor" << 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.reset(); // 手动释放A对象
b.reset(); // 手动释放B对象
return 0;
}
(4)使用weak_ptr和shared_ptr组合: 将两个对象的循环引用中的一个改为weak_ptr,另一个仍使用shared_ptr。这样可以避免循环引用导致的内存泄漏。
#include
class B; //前向声明
class A {
public:
std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr
~A() {
std::cout << "A destructor" << std::endl;
}
};
class B {
public:
std::weak_ptr<A> a_ptr; // B类持有A类的weak_ptr
~B() {
std::cout << "B destructor" << 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->b_ptr使用shared_ptr,b->a_ptr使用weak_ptr,不会形成内存泄漏
return 0;
}
智能指针是C++中一种重要的语言机制,其中shared_ptr是最常用和最经典的智能指针之一。
shared_ptr是一种引用计数的智能指针,可以共享同一个对象。
使用shared_ptr时,需要包含头文件< memory >。
创建shared_ptr对象时,可以直接将原始指针作为参数传递给构造函数,也可以使用make_shared函数进行创建。
对象的引用计数会在shared_ptr对象初始化、复制、释放时自动更新。
当某个shared_ptr对象被销毁时,它所指向的对象的引用计数会减少,如果引用计数为0,则该对象会被自动删除。
通过get函数可以获取shared_ptr对象所管理的原始指针。
通过reset函数可以重新绑定shared_ptr对象所管理的原始指针。
可以使用unique函数判断shared_ptr对象是否唯一拥有原始指针。
通常情况下,shared_ptr对象应该在栈上创建,而不是使用new运算符在堆上创建。
在多线程环境下使用shared_ptr时需要注意,需要采取线程安全措施,比如使用锁来保证引用计数的正确性。
shared_ptr是C++11中STL的一部分,它是一个模板类,用于管理动态地分配对象的内存。shared_ptr可以自动完成内存管理,确保内存被正确释放,并且非常易于使用。
shared_ptr是一个强大的智能指针类,它利用引用计数技术来管理动态分配的对象的内存。shared_ptr可以避免循环引用和内存泄漏等问题,并且易于使用,是C++程序员必不可少的工具之一。