Dlaczego użycie "nowego" bo wycieki pamięci?

Wyjaśnienie krok po kroku:

// 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());

Więc pod koniec tego, masz Obiekt na stercie bez wskaźnika do niego, więc nie można go usunąć.

Druga próbka:

A *object1 = new A();

Jest wyciekiem pamięci tylko wtedy, gdy zapomnisz delete przydzielonej pamięci:

delete object1;

W C++ są obiekty z automatycznym przechowywaniem, te utworzone na stosie, które są automatycznie usuwane, oraz obiekty z dynamicznym przechowywaniem, na stosie, które przydzielasz za pomocą new i są zobowiązani do uwolnienia się z delete. (to wszystko jest z grubsza powiedziane)

Pomyśl, że powinieneś mieć delete dla każdego obiektu przydzielonego new.

EDIT

Poniższy kod jest po prostu do rzeczy, to zły pomysł, nigdy nie lubię kodu takiego jak ten:

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;
    }
}

W tym przypadku, ponieważ {[10] } jest przekazywana przez odniesienie, będzie to dokładny obiekt wskazywany przez new B(). Dlatego uzyskanie jego adresu przez &other i usunięcie wskaźnika uwolniłoby pamięć.

Ale nie mogę tego wystarczająco podkreślić, nie rób tego. Chodzi o to, żeby coś powiedzieć.

Podane dwa "obiekty":

obj a;
obj b;

Przypisanie wartości jednego do drugiego nie zmieni ich lokalizacji, ale zmieni ich zawartość:

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

Intuicyjnie wskaźnik "obiekty" działa w ten sam sposób:

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

A *object1 = new A();

To przypisanie wartości new A() do object1. Wartość jest wskaźnikiem, co oznacza object1 == new A(), ale &object1 != &(new A()). (Zauważ, że to przykład nie jest poprawnym kodem, służy tylko do wyjaśnienia)

Ponieważ wartość wskaźnika jest zachowana, możemy zwolnić pamięć, do której wskazuje: delete object1; ze względu na naszą regułę, zachowuje się ona tak samo jak delete (new A());, która nie ma wycieku.

W drugim przykładzie kopiujesz obiekt wskazywany na obiekt. Wartością jest zawartość tego obiektu, a nie rzeczywisty wskaźnik. Jak w każdym innym przypadku, &object2 != &*(new A()).

B object2 = *(new B());

Straciliśmy wskaźnik do przydzielonej pamięci, a więc nie możemy uwolnij go. delete &object2; może wydawać się, że to zadziała, ale ponieważ &object2 != &*(new A()), nie jest równoważne delete (new A()) i jest tak nieważne.

W C# i Javie, używasz new do tworzenia instancji dowolnej klasy i nie musisz się martwić o jej późniejsze zniszczenie.

C++ ma również słowo kluczowe "new", które tworzy obiekt, ale w przeciwieństwie do Javy lub C#, nie jest to jedyny sposób na utworzenie obiektu.

C++ posiada dwa mechanizmy tworzenia obiektu:

• automatyczny
• dynamiczne

Z automatycznym tworzeniem tworzysz obiekt w środowisku o zasięgu: - w funkcji lub - jako członek klasy (lub struct).

W funkcji stworzyłbyś ją w ten sposób:

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

Wewnątrz klasy normalnie tworzysz ją w ten sposób:

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

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

W pierwszym przypadku obiekty są niszczone automatycznie po zakończeniu bloku zakresu. Może to być funkcja lub blok zakresu wewnątrz funkcji.

W tym ostatnim przypadku obiekt b jest niszczony wraz z instancją a, w której jest członkiem.

Obiekty są przydzielane z new, gdy trzeba kontrolować żywotność obiektu, a następnie wymaga usunięcia, aby go zniszczyć. Dzięki technice znanej jako RAII, zajmujesz się usuwaniem obiektu w miejscu, w którym go tworzysz, umieszczając go w automatycznym obiekcie i czekasz na efekt destruktora tego automatycznego obiektu.

Jednym z takich obiektów jest shared_ptr, który wywoła logikę "deleter", ale tylko wtedy, gdy wszystkie instancje shared_ptr, które dzielą obiekt, zostaną zniszczone.

Ogólnie, podczas gdy twój kod może mieć wiele wywołań do new, powinieneś mieć ograniczone wywołania do usunięcia i zawsze upewnij się, że są one wywoływane z destruktorów lub obiektów "deleter", które są umieszczane w inteligentnych wskaźnikach.

Twoje destruktory nie powinny również wyrzucać WYJĄTKÓW.

B object2 = *(new B());

Object2 jest zmienną typu B, przechowywaną pod adresem powiedzmy 1 (tak, wybieram tutaj dowolne liczby). Po prawej stronie poprosiłeś o nowe B, lub wskaźnik do obiektu typu B. program chętnie Ci to daje i przypisuje twoje nowe B do adresu 2, a także tworzy wskaźnik w adresie 3. Teraz jedynym sposobem dostÄ ™ pu do danych w adresie 2 jest wskaĺşnik w adresie 3. Następny, ty dereferenced wskaźnik za pomocą *, Aby uzyskać dane, na które wskazuje wskaźnik (dane w adresie 2). To skutecznie tworzy kopię tych danych i przypisuje je obiektowi2, przypisanemu w adresie 1. Pamiętaj, to kopia, nie oryginał.

Oto problem:

Nigdy nie przechowywałeś tego wskaźnika w dowolnym miejscu, w którym możesz go użyć! Gdy to zadanie zostanie zakończone, wskaźnik (pamięć w adresa3, której użyłeś do uzyskania dostępu do adresa2) jest poza zasięgiem i poza twoim zasięgiem! Możesz nie wywołuje już delete na nim i dlatego nie może wyczyścić pamięci w adres2. To, co ci zostało, to kopia danych z address2 w address1. Dwie takie same rzeczy są w pamięci. Do jednego masz dostęp, do drugiego nie możesz (ponieważ zgubiłeś ścieżkę do niego). Dlatego to wyciek pamięci.

Sugerowałbym zaczerpnięcie z twojego C# tła, abyś dużo poczytał o tym, jak działają wskaźniki W C++. Są to zaawansowane tematy i mogą zająć trochę czasu, aby zrozumieć, ale ich użycie będzie bądź dla Ciebie bezcenny.

Jeśli to ułatwi, pomyśl o pamięci komputera jak o hotelu, a programy są klientami, którzy wynajmują pokoje, gdy ich potrzebują.

Jeśli zaprogramujesz rezerwację pokoju i wyjedziesz bez mówienia portierowi, portier pomyśli, że pokój jest nadal używany i nie pozwoli nikomu z niego korzystać. W tym przypadku jest przeciek pokoju.

Jeśli twój program przydziela pamięć i robi nie usuwa go (po prostu przestaje go używać), a następnie komputer myśli, że pamięć jest nadal używana i nie pozwoli nikomu innemu jej używać. To wyciek pamięci.

To nie jest dokładna analogia, ale może pomóc.

Podczas tworzenia object2 tworzysz kopię obiektu, który utworzyłeś za pomocą new, ale tracisz również (nigdy nie przypisany) wskaźnik (więc nie ma sposobu, aby go później usunąć). Aby tego uniknąć, musisz zrobić object2 odniesienie.

Cóż, tworzysz wyciek pamięci, jeśli w pewnym momencie nie uwolnisz pamięci przydzielonej za pomocą operatora new, przekazując wskaźnik do tej pamięci operatorowi delete.

W dwóch powyższych przypadkach:

A *object1 = new A();

Tutaj nie używasz delete do uwolnienia pamięci, więc jeśli i kiedy twój wskaźnik object1 wyjdzie poza zasięg, będziesz miał wyciek pamięci, ponieważ straciłeś wskaźnik i nie możesz na nim użyć operatora delete.

I tutaj

B object2 = *(new B());

Jesteś odrzucenie wskaźnika zwracanego przez new B(), a więc nigdy nie może przekazać tego wskaźnika do delete, aby pamięć została uwolniona. Stąd kolejny wyciek pamięci.

To ta linia od razu przecieka:

B object2 = *(new B());

Tutaj tworzysz nowy obiekt B na stosie, a następnie tworzysz kopię na stosie. Ten, który został przydzielony na stercie, nie może być już dostępny, a tym samym wyciek.

Ta linia nie jest od razu przeciekająca:

A *object1 = new A();