Por que o uso de 'novo' causa vazamentos de memória?

Aprendi C # primeiro e agora estou começando com C ++. Pelo que entendi, o operador newem C ++ não é semelhante ao do C #.

Você pode explicar o motivo do vazamento de memória neste código de exemplo?

class A { ... };
struct B { ... };

A *object1 = new A();
B object2 = *(new B());

O que está acontecendo

Ao escrever, T t;você cria um objeto do tipo Tcom duração de armazenamento automático . Ele será limpo automaticamente quando sair do escopo.

Ao escrever, new T()você cria um objeto do tipo Tcom duração de armazenamento dinâmico . Não será limpo automaticamente.

Você precisa passar um ponteiro para ele deletepara limpá-lo:

No entanto, seu segundo exemplo é pior: você está desreferenciando o ponteiro e fazendo uma cópia do objeto. Dessa forma, você perde o ponteiro para o objeto criado com new, para nunca poder excluí-lo, mesmo que quisesse!

O que você deveria fazer

Você deve preferir a duração do armazenamento automático. Precisa de um novo objeto, basta escrever:

A a; // a new object of type A
B b; // a new object of type B

Se você precisar de duração de armazenamento dinâmico, armazene o ponteiro no objeto alocado em um objeto de duração de armazenamento automático que o exclua automaticamente.

template <typename T>
class automatic_pointer {
public:
    automatic_pointer(T* pointer) : pointer(pointer) {}

    // destructor: gets called upon cleanup
    // in this case, we want to use delete
    ~automatic_pointer() { delete pointer; }

    // emulate pointers!
    // with this we can write *p
    T& operator*() const { return *pointer; }
    // and with this we can write p->f()
    T* operator->() const { return pointer; }

private:
    T* pointer;

    // for this example, I'll just forbid copies
    // a smarter class could deal with this some other way
    automatic_pointer(automatic_pointer const&);
    automatic_pointer& operator=(automatic_pointer const&);
};

automatic_pointer<A> a(new A()); // acts like a pointer, but deletes automatically
automatic_pointer<B> b(new B()); // acts like a pointer, but deletes automatically

Este é um idioma comum que atende pelo nome de RAII não muito descritivo ( Resource Acquisition Is Initialization ). Quando você adquire um recurso que precisa de limpeza, cole-o em um objeto com duração de armazenamento automático para não precisar se preocupar em limpá-lo. Isso se aplica a qualquer recurso, seja memória, arquivos abertos, conexões de rede ou o que você desejar.

Essa automatic_pointercoisa já existe de várias formas, eu apenas a forneci para dar um exemplo. Uma classe muito semelhante existe na biblioteca padrão chamada std::unique_ptr.

Há também um antigo (pré-C ++ 11) nomeado, auto_ptrmas agora está obsoleto porque tem um comportamento estranho de cópia.

E há alguns exemplos ainda mais inteligentes, como std::shared_ptr, que permitem vários ponteiros para o mesmo objeto e apenas o limpam quando o último ponteiro é destruído.

Uma explicação passo a passo:

// creates a new object on the heap:
new B()
// dereferences the object
*(new B())
// calls the copy constructor of B on the object
B object2 = *(new B());

Portanto, ao final disso, você tem um objeto no heap sem ponteiro, portanto, é impossível excluir.

A outra amostra:

A *object1 = new A();

é um vazamento de memória apenas se você esquecer a deletememória alocada:

delete object1;

No C ++, existem objetos com armazenamento automático, aqueles criados na pilha, que são descartados automaticamente e objetos com armazenamento dinâmico, no heap, com os quais você aloca newe precisa se libertar delete. (isso é tudo grosso modo)

Pense que você deve ter um deletepara cada objeto alocado new.

EDITAR

Venha para pensar sobre isso, object2não precisa ser um vazamento de memória.

O código a seguir é apenas para esclarecer, é uma má idéia, nunca goste de códigos como este:

class B
{
public:
    B() {};   //default constructor
    B(const B& other) //copy constructor, this will be called
                      //on the line B object2 = *(new B())
    {
        delete &other;
    }
}

Nesse caso, como otheré passado por referência, será o objeto exato apontado por new B(). Portanto, obter o endereço &othere excluir o ponteiro liberaria a memória.

Mas não posso enfatizar isso o suficiente, não faça isso. É só aqui para fazer um ponto.

Dados dois "objetos":

obj a;
obj b;

Eles não ocuparão o mesmo local na memória. Em outras palavras,&a != &b

Atribuir o valor de um para o outro não mudará sua localização, mas mudará seu conteúdo:

obj a;
obj b = a;
//a == b, but &a != &b

Intuitivamente, os "objetos" ponteiros funcionam da mesma maneira:

obj *a;
obj *b = a;
//a == b, but &a != &b

Agora, vejamos o seu exemplo:

A *object1 = new A();

Isso está atribuindo o valor de new A()a object1. O valor é um ponteiro, significando object1 == new A(), mas &object1 != &(new A()). (Observe que este exemplo não é um código válido, é apenas para explicação)

Como o valor do ponteiro é preservado, podemos liberar a memória para a qual ele aponta: delete object1;Devido à nossa regra, isso se comporta da mesma forma delete (new A());que não tem vazamento.

Para o seu segundo exemplo, você está copiando o objeto apontado. O valor é o conteúdo desse objeto, não o ponteiro real. Como em qualquer outro caso &object2 != &*(new A()),.

B object2 = *(new B());

Perdemos o ponteiro para a memória alocada e, portanto, não podemos liberá-lo. delete &object2;pode parecer que funcionaria, mas porque &object2 != &*(new A())não é equivalente delete (new A())e, portanto, inválido.

Em C # e Java, você usa new para criar uma instância de qualquer classe e não precisa se preocupar em destruí-la posteriormente.

O C ++ também possui a palavra-chave "new", que cria um objeto, mas, diferentemente do Java ou C #, não é a única maneira de criar um objeto.

O C ++ possui dois mecanismos para criar um objeto:

• automático
• dinâmico

Com a criação automática, você cria o objeto em um ambiente com escopo definido: - em uma função ou - como membro de uma classe (ou estrutura).

Em uma função, você a criaria da seguinte maneira:

int func()
{
   A a;
   B b( 1, 2 );
}

Dentro de uma classe, você normalmente a cria dessa maneira:

class A
{
  B b;
public:
  A();
};    

A::A() :
 b( 1, 2 )
{
}

No primeiro caso, os objetos são destruídos automaticamente quando o bloco de escopo é encerrado. Pode ser uma função ou um bloco de escopo dentro de uma função.

No último caso, o objeto b é destruído juntamente com a instância de A na qual ele é um membro.

Os objetos são alocados com new quando você precisa controlar a vida útil do objeto e, em seguida, ele requer exclusão para destruí-lo. Com a técnica conhecida como RAII, você cuida da exclusão do objeto no momento em que o cria, colocando-o em um objeto automático e aguarda a efetivação do destruidor desse objeto automático.

Um desses objetos é um shared_ptr que invocará uma lógica "deleter", mas somente quando todas as instâncias do shared_ptr que estão compartilhando o objeto forem destruídas.

Em geral, embora seu código possa ter muitas chamadas para novas, você deve ter chamadas limitadas para excluir e sempre certificar-se de que elas sejam chamadas de destruidores ou objetos "deletadores" inseridos em ponteiros inteligentes.

Seus destruidores também nunca devem lançar exceções.

Se você fizer isso, terá poucos vazamentos de memória.

B object2 = *(new B());

Essa linha é a causa do vazamento. Vamos separar isso um pouco ..

O objeto2 é uma variável do tipo B, armazenada no endereço 1 (sim, estou escolhendo números arbitrários aqui). No lado direito, você solicitou um novo B ou um ponteiro para um objeto do tipo B. O programa oferece isso de bom grado e atribui seu novo B ao endereço 2 e também cria um ponteiro no endereço 3. Agora, a única maneira de acessar os dados no endereço 2 é através do ponteiro no endereço 3. Em seguida, você desferenciou o ponteiro *para obter os dados que o ponteiro está apontando (os dados no endereço 2). Isso efetivamente cria uma cópia desses dados e os atribui ao objeto2, atribuído no endereço 1. Lembre-se, é uma CÓPIA, não o original.

Agora, aqui está o problema:

Você nunca realmente armazenou esse ponteiro em qualquer lugar em que possa usá-lo! Depois que essa tarefa é concluída, o ponteiro (memória no endereço3, que você usou para acessar o endereço2) fica fora do escopo e está além do seu alcance! Você não pode mais chamar delete e, portanto, não pode limpar a memória no endereço2. O que resta é uma cópia dos dados do endereço2 no endereço1. Duas das mesmas coisas guardadas na memória. Um que você pode acessar, o outro não (porque você perdeu o caminho). É por isso que isso é um vazamento de memória.

Eu sugiro que, a partir do seu background em C #, você leia muito sobre como os ponteiros em C ++ funcionam. Eles são um tópico avançado e podem levar algum tempo para entender, mas o uso deles será inestimável para você.

Se isso facilitar, pense na memória do computador como um hotel e os programas são clientes que contratam quartos quando precisam deles.

A maneira como esse hotel funciona é que você reserve um quarto e informe o porteiro quando sair.

Se você programar uma sala de livros e sair sem avisar o porteiro, o porteiro pensará que a sala ainda está em uso e não permitirá que mais ninguém a use. Nesse caso, há um vazamento na sala.

Se o seu programa alocar memória e não a excluir (ele simplesmente para de usá-la), o computador pensará que a memória ainda está em uso e não permitirá que mais ninguém a utilize. Este é um vazamento de memória.

Essa não é uma analogia exata, mas pode ajudar.

Ao criar, object2você cria uma cópia do objeto que criou com novo, mas também perde o ponteiro (nunca atribuído) (portanto, não há como excluí-lo mais tarde). Para evitar isso, você teria que fazer object2uma referência.

Bem, você cria um vazamento de memória se, em algum momento, não liberar a memória alocada usando o newoperador, passando um ponteiro para essa memória para o deleteoperador.

Nos seus dois casos acima:

A *object1 = new A();

Aqui você não está usando deletepara liberar a memória; portanto, se e quando o object1ponteiro ficar fora do escopo, haverá um vazamento de memória, porque você o perdeu e não poderá usar o deleteoperador nele.

E aqui

B object2 = *(new B());

você está descartando o ponteiro retornado por new B()e, portanto, nunca pode passar esse ponteiro para deleteque a memória seja liberada. Daí outro vazamento de memória.

É essa linha que está vazando imediatamente:

B object2 = *(new B());

Aqui você está criando um novo Bobjeto na pilha e, em seguida, criando uma cópia na pilha. O que foi alocado no heap não pode mais ser acessado e, portanto, o vazamento.

Esta linha não está imediatamente vazando:

A *object1 = new A();

Haveria um vazamento se você nunca deleted object1embora.