unique_ptr - weak_ptr example c++




Diferenças entre unique_ptr e shared_ptr (3)

Duplicatas Possíveis:
pimpl: shared_ptr ou unique_ptr
ponteiros inteligentes (boost) explicados

Alguém poderia explicar as diferenças entre shared_ptr e unique_ptr?


Ambas as classes são ponteiros inteligentes, o que significa que eles automaticamente (na maioria dos casos) desalocarão o objeto para o qual apontam quando esse objeto não puder mais ser referenciado. A diferença entre os dois é quantos indicadores diferentes de cada tipo podem se referir a um recurso.

Ao usar unique_ptr , pode haver no máximo um unique_ptr apontando para qualquer recurso. Quando esse unique_ptr é destruído, o recurso é automaticamente recuperado. Como só pode haver um unique_ptr para qualquer recurso, qualquer tentativa de fazer uma cópia de um unique_ptr causará um erro em tempo de compilação. Por exemplo, esse código é ilegal:

unique_ptr<T> myPtr(new T);       // Okay
unique_ptr<T> myOtherPtr = myPtr; // Error: Can't copy unique_ptr

No entanto, unique_ptr pode ser movido usando a nova semântica de movimento:

unique_ptr<T> myPtr(new T);                  // Okay
unique_ptr<T> myOtherPtr = std::move(myPtr); // Okay, resource now stored in myOtherPtr

Da mesma forma, você pode fazer algo assim:

unique_ptr<T> MyFunction() {
    unique_ptr<T> myPtr(/* ... */);

    /* ... */

    return myPtr;
}

Essa expressão significa "Estou retornando um recurso gerenciado para você. Se você não capturar explicitamente o valor de retorno, o recurso será limpo. Se você fizer isso, você terá propriedade exclusiva desse recurso." Dessa forma, você pode pensar em unique_ptr como substituto mais seguro para o auto_ptr .

shared_ptr , por outro lado, permite que vários ponteiros apontem para um determinado recurso. Quando o último shared_ptr para um recurso é destruído, o recurso será desalocado. Por exemplo, esse código é perfeitamente legal:

shared_ptr<T> myPtr(new T);       // Okay
shared_ptr<T> myOtherPtr = myPtr; // Sure!  Now have two pointers to the resource.

Internamente, shared_ptr usa contagem de referência para rastrear quantos ponteiros se referem a um recurso, portanto, é necessário ter cuidado para não introduzir ciclos de referência.

Em resumo:

  1. Use unique_ptr quando você quiser um único ponteiro para um objeto que será recuperado quando esse único ponteiro for destruído.
  2. Use shared_ptr quando quiser vários ponteiros para o mesmo recurso.

Espero que isto ajude!


Ao envolver um ponteiro em um unique_ptr você não pode ter várias cópias de unique_ptr . O shared_ptr contém um contador de referência que conta o número de cópias do ponteiro armazenado. Cada vez que um shared_ptr é copiado, esse contador é incrementado. Cada vez que um shared_ptr é destruído, esse contador é decrementado. Quando este contador atinge 0, o objeto armazenado é destruído.


unique_ptr
é um ponteiro inteligente que possui um objeto exclusivamente.

shared_ptr
é um ponteiro inteligente para propriedade compartilhada. É copyable e movable . Várias instâncias de ponteiro inteligente podem ter o mesmo recurso. Assim que o último ponteiro inteligente que possui o recurso ficar fora do escopo, o recurso será liberado.







unique-ptr