1. Conceptos relacionados
1.1 Escenarios de uso
• El programa no sabe cuántos objetos necesita usar
• El programa no sabe el tipo exacto de objetos
que necesita • El programa necesita compartir datos entre varios objetos
1.2 Principio de implementación
- El objeto shared_ptr tiene un contador asociado, normalmente llamado recuento de referencia.
- Algunas operaciones incrementarán el contador y
copiarán un shared_ptr, por ejemplo, un shared_ptr inicializa otro shared_ptr (como un parámetro de función, como un valor de retorno de función) - Algunos contadores de operaciones disminuirán y
asignarán un nuevo valor a shared_ptr. Cuando se destruye shared_ptr - Una vez que el contador de un shared_ptr se convierte en 0, liberará automáticamente los objetos que administra.
2. Operaciones principales
| operando | Descripción |
|---|---|
| make_shared (argumentos) | Devuelve un shared_ptr, que apunta a un objeto asignado dinámicamente de tipo T. Inicializar este objeto con argumentos |
| ptr_compartido p (q) | p es una copia de shared_ptr q; esta operación incrementa el contador en q. El puntero inteligente en q debe convertirse a * T |
| p = q | Tanto pyq son shared_ptr, y los punteros guardados deben ser convertibles entre sí. Esta operación disminuirá el recuento de referencia de p e incrementará el recuento de referencia de q; si el recuento de referencia de p se convierte en 0, se liberará la memoria original administrada por él. |
| p.unique () | Si p.use_count () es 1, devuelve verdadero; de lo contrario, devuelve falso |
| p.use_count () | Devuelve el número de punteros inteligentes compartidos con p; puede ser lento, principalmente para depurar |
2.1 Definición
p.ej.
shared_ptr<string> p1; //shared_ptr,可以指向string
shared_ptr<list<int>> p2; //shared_ptr,可以指向int的list
//使用make_shared函数
shared_ptr<int> p3 = make_shared<int>(42);
shared_ptr<string> p4 = make_shared<string>(10, '9');
shared_ptr<int> p5 = make_shared<int>();
auto p6 = make_shared<vector<string>>();
shared_ptr<string>sp;
make_shared<string>(); //动态分配内存默认初始化，必须要有括号, 默认初始化得到的是空指针
make_shared<string>("a"); //动态分配内存值初始化
shared_ptr<string>sp2 = make_shared<string>(); //初始化智能指针
shared_ptr<string>sp3 = make_shared<string>("b");//初始化智能指针
//和new结合
shared_ptr<int> p1=new int(1024); //error
shared_ptr<int> p2(new int(1024)); //ok, 直接初始化形式。
2.2 copia y cesión
auto r = make_shared<int>(42); // r指向的int只有一个引用者
r = q;
// r指向了q所指向的地址
// 递增q所指向对象的引用计数
// 递减r原来所指向对象的引用计数
// r原来所指向对象的引用计数为0，即没有引用者，自动释放
p.ej.
//传递参数会构造一个，计数器递增，函数运行结束后释放
shared_ptr<string> fun1(shared_ptr<string> sp5)
{
auto sp6 = sp5; //创建临时并赋值，计数器递增。
cout << "sp5 use_count:" << sp5.use_count() << endl;
cout << "sp5 is_unique:" << sp5.unique() << endl;
return sp6;
}
int main()
{
shared_ptr<string>sp = make_shared<string>("aa");
//通常使用auto来简化定义一个对象来保存make_shared的结果，这种方式比较简单。
auto sp3 = make_shared<string>(10,'a');
cout << "sp use_count:" << sp.use_count() << endl;
auto sp2(sp); //拷贝sp,count计数会增加
cout << "sp use_count:" << sp.use_count() << endl;
cout << "sp is_unique:" << sp.unique() << endl;
sp2 = sp3; //赋值sp2,计数会减少
cout << "sp use_count:" << sp.use_count() << endl;
cout << "sp is_unique:" << sp.unique() << endl;
auto sp4(sp3);
cout << "sp3 use_count:" << sp3.use_count() << endl;
cout << "sp3 is_unique:" << sp3.unique() << endl;
sp = sp3;//sp指向sp3指向的,sp指向的被销毁。
cout << "sp use_count:" << sp.use_count() << endl;
cout << "sp is_unique:" << sp.unique() << endl;
auto sp7 = fun1(sp);
cout << "sp7 use_count:" << sp.use_count() << endl;
cout << "sp7 is_unique:" << sp.unique() << endl;
}
Resultado de salida:
3. Otros métodos de definición y métodos de reinicio
| operando | Descripción |
|---|---|
| ptr_compartido p (q) | p gestiona el objeto apuntado por el puntero incorporado q; q debe apuntar a la memoria asignada por new y se puede convertir al tipo T * |
| shared_ptr p (u) | p se hace cargo de la propiedad del objeto de unique_ptr u; establece u en nulo |
| ptr_compartido p (q, d) | p asume la propiedad del objeto apuntado por el puntero incorporado q. q debe ser convertible al tipo T *. p usará el objeto invocable d en lugar de eliminar |
| ptr_compartido p (p2, d) | p es una copia de shared_ptr p2, la única diferencia es que p usará el objeto invocable d en lugar de eliminar |
| Preestablecido() | Si p es el único shared_ptr que apunta a su objeto, reset liberará el objeto. |
| p.reset (q) | Mientras se libera el objeto original, si se pasa el puntero de parámetro incorporado opcional q, p apuntará a q; de lo contrario, se establecerá en nulo |
| p.reset (q, d) | Si también se pasa el parámetro d, se llamará a d en lugar de eliminar para liberar q |
Nota: Intente no usar get para inicializar otro puntero inteligente o asignar un valor a un puntero inteligente, porque es fácil cometer errores en caso de eliminarlo.
shared_ptr<int>p(new int(42));
int* q = p.get();
cout << "count:" << p.use_count() << *q << endl;
// delete q; //error:
{
auto t = shared_ptr<int>(q); //转换
cout << "count:" << t.use_count() << endl;
}
int nVal = *p;
cout << nVal << endl;
if(!p.unique())
p.reset(new string(*p)); //我们不是唯一的用户；分配新的拷贝
*p+=newVal; //可以改变对象的值
5. Eliminador personalizado
struct destination {
}; //正在连接什么
struct connection {
};
class test2 {
public:
connection& connect(connection* s)
{
cout << "正在连接..." << endl;
s = new connection();
return *s;
}
void static disconnect(connection* s)
{
cout << "正在断开连接..." << endl;
}
void test()
{
connection p;
connection* d = new connection();
p = connect(d);
//shared_ptr<connection>sp(&p,disconnect);
//error:lambda代表了删除函数。那么参数列表也要和删除函数一致，因为delete内部是free(p)。
//shared_ptr<connection>sp(&p, [&p] { disconnect(&p); });
shared_ptr<connection>sp(&p, [](connection* s) {
disconnect(s); });
}
};