Dlaczego programiści C ++ powinni zminimalizować użycie „nowego”?

Natknąłem się na pytanie o przepełnienie stosu Przeciek pamięci ze std :: string przy użyciu std :: list <std :: string> , a jeden z komentarzy mówi:

Przestań używać newtak dużo. Nigdzie nie widziałem powodu, dla którego używałeś nowego. Możesz tworzyć obiekty według wartości w C ++ i jest to jedna z ogromnych zalet korzystania z języka.
Nie musisz alokować wszystkiego na stercie.
Przestań myśleć jak programista Java .

Nie jestem do końca pewien, co przez to rozumie.

Dlaczego obiekty powinny być tworzone według wartości w C ++ tak często, jak to możliwe i jaką różnicę robi to wewnętrznie?
Czy źle zinterpretowałem odpowiedź?

Istnieją dwie powszechnie stosowane techniki alokacji pamięci: alokacja automatyczna i alokacja dynamiczna. Zwykle dla każdego istnieje odpowiedni region pamięci: stos i sterta.

Stos

Stos zawsze przydziela pamięć w sposób sekwencyjny. Może to zrobić, ponieważ wymaga zwolnienia pamięci w odwrotnej kolejności (pierwsze wejście, ostatnie wyjście: FILO). Jest to technika alokacji pamięci dla zmiennych lokalnych w wielu językach programowania. Jest bardzo, bardzo szybki, ponieważ wymaga minimalnej księgowości, a następny adres do przydzielenia jest domyślny.

W C ++ nazywa się to automatycznym magazynowaniem, ponieważ magazyn jest zgłaszany automatycznie na końcu zakresu. Po {}zakończeniu wykonywania bieżącego bloku kodu (ograniczonego za pomocą ), pamięć dla wszystkich zmiennych w tym bloku jest automatycznie gromadzona. Jest to także moment, w którym przywoływane są destruktory w celu oczyszczenia zasobów.

Sterta

Sterta pozwala na bardziej elastyczny tryb alokacji pamięci. Księgowość jest bardziej złożona, a alokacja wolniejsza. Ponieważ nie ma niejawnego punktu zwolnienia, musisz zwolnić pamięć ręcznie, używając deletelub delete[]( freew C). Jednak brak niejawnego punktu zwolnienia jest kluczem do elastyczności stosu.

Powody korzystania z alokacji dynamicznej

Nawet jeśli korzystanie ze sterty jest wolniejsze i potencjalnie prowadzi do wycieków pamięci lub fragmentacji pamięci, istnieją bardzo dobre przypadki użycia dla alokacji dynamicznej, ponieważ jest ona mniej ograniczona.

Dwa kluczowe powody korzystania z alokacji dynamicznej:

• Nie wiesz, ile pamięci potrzebujesz w czasie kompilacji. Na przykład podczas odczytywania pliku tekstowego do łańcucha zwykle nie wiesz, jaki rozmiar ma ten plik, więc nie możesz zdecydować, ile pamięci ma zostać przydzielone, dopóki nie uruchomisz programu.

• Chcesz przydzielić pamięć, która pozostanie po opuszczeniu bieżącego bloku. Na przykład możesz chcieć napisać funkcję, string readfile(string path)która zwraca zawartość pliku. W takim przypadku nawet jeśli stos może pomieścić całą zawartość pliku, nie można wrócić z funkcji i zachować przydzielonego bloku pamięci.

Dlaczego dynamiczna alokacja jest często niepotrzebna

W C ++ istnieje zgrabna konstrukcja zwana destruktorem . Ten mechanizm pozwala zarządzać zasobami, dopasowując czas życia zasobu do czasu życia zmiennej. Ta technika nazywa się RAII i jest wyróżnikiem C ++. „Zawija” zasoby w obiekty. std::stringjest doskonałym przykładem. Ten fragment kodu:

int main ( int argc, char* argv[] )
{
    std::string program(argv[0]);
}

faktycznie przydziela zmienną ilość pamięci. std::stringPrzydziela pamięć obiektów za pomocą sterty i uwalnia go w jego destruktora. W takim przypadku nie trzeba ręcznie zarządzać zasobami, a korzyści z dynamicznej alokacji pamięci są nadal możliwe.

W szczególności oznacza to, że w tym fragmencie:

int main ( int argc, char* argv[] )
{
    std::string * program = new std::string(argv[0]);  // Bad!
    delete program;
}

istnieje niepotrzebna dynamiczna alokacja pamięci. Program wymaga więcej pisania (!) I stwarza ryzyko zapomnienia o zwolnieniu pamięci. Robi to bez widocznych korzyści.

Dlaczego warto korzystać z automatycznego przechowywania tak często, jak to możliwe

Zasadniczo ostatni akapit podsumowuje. Używanie automatycznego przechowywania tak często, jak to możliwe, sprawia, że ​​twoje programy:

• szybciej pisać;
• szybciej po uruchomieniu;
• mniej podatne na wycieki pamięci / zasobów.

Punkty bonusowe

W cytowanym pytaniu pojawiają się dodatkowe obawy. W szczególności następująca klasa:

class Line {
public:
    Line();
    ~Line();
    std::string* mString;
};

Line::Line() {
    mString = new std::string("foo_bar");
}

Line::~Line() {
    delete mString;
}

Jest o wiele bardziej ryzykowny w użyciu niż następujący:

class Line {
public:
    Line();
    std::string mString;
};

Line::Line() {
    mString = "foo_bar";
    // note: there is a cleaner way to write this.
}

Powodem jest to, że std::stringpoprawnie definiuje konstruktor kopii. Rozważ następujący program:

int main ()
{
    Line l1;
    Line l2 = l1;
}

Korzystając z oryginalnej wersji, ten program najprawdopodobniej ulegnie awarii, ponieważ używa deletetego samego ciągu dwukrotnie. Korzystając ze zmodyfikowanej wersji, każda Lineinstancja będzie posiadać własną instancję łańcuchową , każda z własną pamięcią i obie zostaną zwolnione na końcu programu.

Inne notatki

Szerokie zastosowanie RAII jest uważane za najlepszą praktykę w C ++ ze wszystkich powyższych powodów. Istnieje jednak dodatkowa korzyść, która nie jest od razu oczywista. Zasadniczo jest lepszy niż suma jego części. Cały mechanizm się komponuje . Skaluje się.

Jeśli użyjesz Lineklasy jako elementu konstrukcyjnego:

 class Table
 {
      Line borders[4];
 };

Następnie

 int main ()
 {
     Table table;
 }

przydziela cztery std::stringinstancje, cztery Lineinstancje, jedną Tableinstancję i całą zawartość łańcucha, a wszystko jest automatycznie uwalniane automatycznie .

Ponieważ stos jest szybszy i szczelny

W C ++ potrzeba tylko jednej instrukcji, aby przydzielić miejsce - na stosie - dla każdego lokalnego obiektu zakresu w danej funkcji i nie można przeciekać żadnej z tych pamięci. Ten komentarz zamierzał (lub powinien był zamierzyć) powiedzieć coś w stylu „użyj stosu, a nie stosu”.

Powód jest skomplikowany.

Po pierwsze, C ++ nie jest śmieciami. Dlatego dla każdego nowego musi istnieć odpowiednie usunięcie. Jeśli nie umieścisz tego usuwania, oznacza to wyciek pamięci. Teraz w przypadku prostego przypadku takiego:

std::string *someString = new std::string(...);
//Do stuff
delete someString;

To jest proste. Ale co się stanie, jeśli „Do stuff” zgłosi wyjątek? Ups: wyciek pamięci. Co się stanie, jeśli problem „Zrób rzeczy” returnwcześnie? Ups: wyciek pamięci.

I to jest w najprostszym przypadku . Jeśli zdarzy ci się zwrócić komuś ten ciąg, teraz musi go usunąć. A jeśli przekażą to jako argument, to czy osoba otrzymująca go musi go usunąć? Kiedy powinni je usunąć?

Lub możesz po prostu to zrobić:

std::string someString(...);
//Do stuff

Nie delete. Obiekt został utworzony na „stosie” i zostanie zniszczony, gdy znajdzie się poza zasięgiem. Możesz nawet zwrócić obiekt, przenosząc jego zawartość do funkcji wywołującej. Możesz przekazać obiekt do funkcji (zwykle jako odwołanie lub stałe odwołanie: void SomeFunc(std::string &iCanModifyThis, const std::string &iCantModifyThis)itd.).

Wszystko bez newi delete. Nie ma wątpliwości, kto jest właścicielem pamięci lub kto jest odpowiedzialny za jej usunięcie. Jeśli zrobisz:

std::string someString(...);
std::string otherString;
otherString = someString;

Zrozumiałe jest, że otherStringposiada kopię danych z someString. To nie jest wskaźnik; jest to osobny obiekt. Może się zdarzyć, że mają tę samą zawartość, ale możesz zmienić jedną bez wpływu na drugą:

someString += "More text.";
if(otherString == someString) { /*Will never get here */ }

Widzisz pomysł?

Obiekty utworzone przez newmuszą w końcu deletenie przeciekać. Destruktor nie zostanie wywołany, pamięć nie zostanie uwolniona, cały czas. Ponieważ C ++ nie ma śmieci, jest to problem.

Obiekty tworzone przez wartość (tj. Na stosie) automatycznie umierają, gdy wykraczają poza zakres. Wywołanie destruktora jest wstawiane przez kompilator, a pamięć jest automatycznie zwalniana po powrocie funkcji.

Inteligentne wskaźniki, takie jak unique_ptr, shared_ptrrozwiązują wiszący problem odniesienia, ale wymagają dyscypliny kodowania i mają inne potencjalne problemy (kopiowanie, pętle odniesienia itp.).

Również w mocno wielowątkowych scenariuszach newistnieje spór między wątkami; nadużycie może mieć wpływ na wydajność new. Tworzenie obiektu stosu jest z definicji wątkiem lokalnym, ponieważ każdy wątek ma swój własny stos.

Wadą obiektów wartości jest to, że umierają one po powrocie funkcji hosta - nie można przekazać odwołania do tych z powrotem do obiektu wywołującego, tylko poprzez kopiowanie, zwracanie lub przenoszenie według wartości.

• C ++ nie używa własnego menedżera pamięci. Inne języki, takie jak C #, Java ma moduł czyszczenia pamięci do obsługi pamięci
• Implementacje w C ++ zwykle używają procedur systemu operacyjnego do przydzielania pamięci, a zbyt dużo nowych / usunięć może fragmentować dostępną pamięć
• W przypadku dowolnej aplikacji, jeśli pamięć jest często używana, zaleca się jej wstępne przydzielenie i zwolnienie, gdy nie jest wymagane.
• Nieprawidłowe zarządzanie pamięcią może prowadzić do wycieków pamięci i jest bardzo trudne do wyśledzenia. Zatem stosowanie obiektów stosu w zakresie funkcji jest sprawdzoną techniką
• Wadą używania obiektów stosu jest to, że tworzy wiele kopii obiektów po powrocie, przekazaniu do funkcji itp. Jednak inteligentne kompilatory są w pełni świadome tych sytuacji i zostały zoptymalizowane pod kątem wydajności
• To jest bardzo nudne w C ++, jeśli pamięć jest przydzielana i zwalniana w dwóch różnych miejscach. Odpowiedzialność za wydanie jest zawsze pytaniem i przeważnie polegamy na niektórych powszechnie dostępnych wskaźnikach, obiektach stosu (maksimum możliwe) i technikach takich jak auto_ptr (obiekty RAII)
• Najlepsze jest to, że masz kontrolę nad pamięcią, a najgorsze jest to, że nie będziesz mieć żadnej kontroli nad pamięcią, jeśli zastosujemy niewłaściwe zarządzanie pamięcią dla aplikacji. Awarie spowodowane uszkodzeniami pamięci są najgorsze i trudne do wyśledzenia.

Widzę, że pominięto kilka ważnych powodów, dla których należy robić jak najmniej nowości:

Operator newma niedeterministyczny czas wykonania

Wywołanie newmoże, ale nie musi, spowodować, że system operacyjny przydzieli nową fizyczną stronę procesowi. Może to być dość powolne, jeśli robisz to często. Lub może mieć już przygotowaną odpowiednią lokalizację pamięci, nie wiemy. Jeśli Twój program musi mieć spójny i przewidywalny czas wykonania (np. W systemie czasu rzeczywistego lub symulacji gry / fizyki), musisz unikać newkrytycznych pętli czasowych.

Operator newto niejawna synchronizacja wątków

Tak, słyszałeś mnie, twój system operacyjny musi się upewnić, że tabele stron są spójne i dlatego takie wywołanie newspowoduje, że Twój wątek uzyska ukrytą blokadę mutex. Jeśli konsekwentnie dzwonisz newz wielu wątków, w rzeczywistości szeregujesz swoje wątki (zrobiłem to z 32 procesorami, z których każdy uderzył o newkilkaset bajtów, ouch! To była królewska pita do debugowania)

Pozostałe odpowiedzi, takie jak powolność, fragmentacja, podatność na błędy itp. Zostały już wspomniane w innych odpowiedziach.

Pre-C ++ 17:

Ponieważ jest podatny na subtelne wycieki, nawet jeśli wynik zostanie zawinięty w inteligentny wskaźnik .

Rozważ „ostrożnego” użytkownika, który pamięta zawijanie obiektów w inteligentne wskaźniki:

foo(shared_ptr<T1>(new T1()), shared_ptr<T2>(new T2()));

Ten kod jest niebezpieczne, ponieważ nie ma żadnej gwarancji, że albo shared_ptrjest zbudowany przed albo T1albo T2. Stąd, jeśli jeden new T1()lub new T2()nie powiedzie się po drugiej powiedzie, to pierwszy obiekt będzie przeciekał ponieważ nie shared_ptristnieje, aby zniszczyć i zwalnianie go.

Rozwiązanie: użyj make_shared.

Post-C ++ 17:

Nie stanowi to już problemu: C ++ 17 nakłada ograniczenie na kolejność tych operacji, w tym przypadku zapewniając, że po każdym wywołaniu new()musi natychmiast nastąpić konstrukcja odpowiedniego inteligentnego wskaźnika, bez żadnych innych operacji pomiędzy. Oznacza to, że do czasu new()wywołania drugiego jest zagwarantowane, że pierwszy obiekt został już owinięty w inteligentny wskaźnik, zapobiegając w ten sposób wyciekom w przypadku zgłoszenia wyjątku.

Barry bardziej szczegółowe objaśnienie nowego porządku oceny wprowadzonego przez C ++ 17 zostało dostarczone przez Barry'ego w innej odpowiedzi .

Dzięki @Remy Lebeau za zwrócenie uwagi, że nadal jest to problem w C ++ 17 (choć mniej): shared_ptrkonstruktor może nie przydzielić bloku kontrolnego i wyrzucić, w którym to przypadku przekazany do niego wskaźnik nie jest usuwany.

Rozwiązanie: użyj make_shared.

W dużej mierze jest to ktoś, kto podnosi swoje słabości do ogólnej zasady. Nie ma nic złego per se z tworzenia obiektów za pomocą newoperatora. Argumentuje się za tym, że musisz to robić z pewną dyscypliną: jeśli tworzysz obiekt, musisz upewnić się, że zostanie zniszczony.

Najłatwiej to zrobić, tworząc obiekt w automatycznym magazynie, więc C ++ wie, jak go zniszczyć, gdy przekroczy zakres:

 {
    File foo = File("foo.dat");

    // do things

 }

Teraz zauważ, że kiedy spadniesz z tego bloku po nawiasie końcowym, foojest poza zasięgiem. C ++ wywoła dla ciebie swój dtor automatycznie. W przeciwieństwie do Javy, nie musisz czekać, aż GC go znajdzie.

Czy napisałeś?

 {
     File * foo = new File("foo.dat");

chciałbyś wyraźnie to dopasować

     delete foo;
  }

lub jeszcze lepiej, przydziel swój File *„inteligentny wskaźnik”. Jeśli nie będziesz ostrożny, może to prowadzić do wycieków.

Sama odpowiedź błędnie zakłada, że ​​jeśli nie użyjesz new, nie przydzielisz na stos; tak naprawdę w C ++ tego nie wiesz. Wiesz co najwyżej, że niewielka ilość pamięci, powiedzmy jeden wskaźnik, jest z pewnością przydzielona na stos. Zastanów się jednak, czy implementacja pliku jest podobna

  class File {
    private:
      FileImpl * fd;
    public:
      File(String fn){ fd = new FileImpl(fn);}

następnie FileImplbędzie nadal być alokowane na stosie.

I tak, lepiej upewnij się, że masz

     ~File(){ delete fd ; }

również w klasie; bez niego wycieknie pamięć ze sterty, nawet jeśli najwyraźniej w ogóle nie przydzielono jej na sterty.

new()nie powinien być używany tak mało, jak to możliwe. Należy go stosować tak ostrożnie, jak to możliwe. I należy go używać tak często, jak to konieczne, podyktowane pragmatyzmem.

Przydział obiektów na stosie, polegający na ich niejawnym zniszczeniu, jest prostym modelem. Jeśli wymagany zakres obiektu pasuje do tego modelu, nie ma potrzeby korzystania new()z powiązanego delete()i sprawdzania wskaźników NULL. W przypadku dużej ilości alokacji obiektów krótkotrwałych na stosie należy zmniejszyć problemy z fragmentacją sterty.

Jeśli jednak czas życia obiektu musi wykraczać poza obecny zakres, new()to właściwa odpowiedź. Upewnij się tylko, że zwracasz uwagę na to, kiedy i jak wywołujesz, delete()oraz na możliwości wskaźników NULL, używając usuniętych obiektów i wszystkich innych gotch, które pochodzą z użyciem wskaźników.

Gdy używasz nowego, obiekty są przydzielane do sterty. Zwykle jest używany, gdy spodziewasz się rozszerzenia. Kiedy deklarujesz obiekt taki jak:

Class var;

jest umieszczony na stosie.

Zawsze będziesz musiał wywołać kill na obiekcie, który umieściłeś na stosie z nowym. Otwiera to możliwość wycieków pamięci. Obiekty umieszczone na stosie nie są podatne na wycieki pamięci!

Jednym z godnych uwagi powodów, aby uniknąć nadużywania sterty, jest wydajność - szczególnie związana z wydajnością domyślnego mechanizmu zarządzania pamięcią używanego przez C ++. Podczas gdy alokacja może być dość szybka w trywialnym przypadku, robienie dużej ilości newi deletena obiektach o niejednorodnym rozmiarze bez ścisłego porządku prowadzi nie tylko do fragmentacji pamięci, ale także komplikuje algorytm alokacji i może całkowicie zniszczyć wydajność w niektórych przypadkach.

Jest to problem, który pule pamięci zostały stworzone do rozwiązania, co pozwala złagodzić nieodłączne wady tradycyjnych implementacji sterty, jednocześnie umożliwiając korzystanie ze sterty w razie potrzeby.

Jeszcze lepiej, aby całkowicie uniknąć problemu. Jeśli możesz umieścić go na stosie, zrób to.

Myślę, że plakat miał You do not have to allocate everything on theheapraczej na myśli niż stack.

Zasadniczo obiekty są alokowane na stosie (jeśli pozwala na to rozmiar obiektu, oczywiście) ze względu na niski koszt alokacji stosu, a nie alokację opartą na stercie, która wymaga dość pracy ze strony alokatora, i dodaje gadatliwości, ponieważ wtedy musisz zarządzać danymi przydzielonymi na stercie.

Zwykle nie zgadzam się z pomysłem użycia nowego „za dużo”. Chociaż użycie nowego plakatu w klasach systemowych przez pierwotnego plakatu jest nieco niedorzeczne. ( int *i; i = new int[9999];? naprawdę? int i[9999];jest znacznie jaśniejszy.) Myślę, że to właśnie dostało kozę komentatora.

Podczas pracy z obiektami systemowymi bardzo rzadko potrzeba więcej niż jednego odwołania do dokładnie tego samego obiektu. Dopóki wartość jest taka sama, tylko to się liczy. A obiekty systemowe zwykle nie zajmują dużo miejsca w pamięci. (jeden bajt na znak, w ciągu). A jeśli tak, biblioteki powinny być tak zaprojektowane, aby uwzględniały to zarządzanie pamięcią (jeśli są dobrze napisane). W takich przypadkach (wszystkie oprócz jednej lub dwóch wiadomości w jego kodzie) nowe są praktycznie bezcelowe i służą jedynie wprowadzeniu zamieszania i potencjalnym błędom.

Kiedy jednak pracujesz z własnymi klasami / obiektami (np. Klasą Line oryginalnego plakatu), musisz sam zacząć myśleć o takich kwestiach, jak pamięć, trwałość danych itp. W tym momencie dopuszczenie wielu odwołań do tej samej wartości jest nieocenione - pozwala na konstrukcje takie jak listy połączone, słowniki i wykresy, w których wiele zmiennych musi mieć nie tylko tę samą wartość, ale odwoływać się dokładnie do tego samego obiektu w pamięci. Jednak klasa Line nie ma żadnego z tych wymagań. Tak więc kod oryginalnego plakatu nie ma absolutnie żadnej potrzeby new.

Dwa powody:

1. W tym przypadku nie jest to konieczne. Sprawiasz, że kod staje się niepotrzebnie bardziej skomplikowany.
2. Przydziela miejsce na stercie i oznacza, że ​​musisz o tym pamiętać deletepóźniej, w przeciwnym razie spowoduje to wyciek pamięci.

newjest nowy goto.

Przypomnij sobie, dlaczego gotojest tak oczerniany: chociaż jest to potężne narzędzie niskiego poziomu do kontroli przepływu, ludzie często używali go w niepotrzebnie skomplikowanych sposobach, które utrudniały śledzenie kodu. Ponadto najbardziej przydatne i najłatwiejsze do odczytania wzorce zostały zakodowane w ustrukturyzowanych instrukcjach programowania (np. forLub while); ostatecznym efektem jest to, że kod, w którym gotojest odpowiedni sposób, jest raczej rzadki, jeśli masz ochotę pisać goto, prawdopodobnie robisz rzeczy źle (chyba że naprawdę wiesz, co robisz).

newjest podobny - jest często używany, aby uczynić rzeczy niepotrzebnie skomplikowanymi i trudniejszymi do odczytania, a najbardziej przydatne wzorce użytkowania, które można zakodować, zostały zakodowane w różnych klasach. Ponadto, jeśli chcesz użyć nowych wzorców użycia, dla których nie ma jeszcze klas standardowych, możesz napisać własne klasy, które je kodują!

Twierdziłbym nawet, że newjest gorzej niż gotoze względu na potrzebę parowania newi deleteoświadczeń.

Na przykład goto, jeśli kiedykolwiek uważasz, że musisz użyć new, prawdopodobnie robisz coś źle - zwłaszcza jeśli robisz to poza wdrożeniem klasy, której celem w życiu jest zawarcie wszelkich dynamicznych alokacji, które musisz zrobić.

Głównym powodem jest to, że obiekty na stercie są zawsze trudne w użyciu i zarządzaniu niż proste wartości. Pisanie łatwego do odczytania i utrzymania kodu jest zawsze priorytetem każdego poważnego programisty.

Innym scenariuszem jest używana przez nas biblioteka, która zapewnia semantykę wartości i sprawia, że ​​alokacja dynamiczna jest niepotrzebna. Std::stringjest dobrym przykładem

Jednak w przypadku kodu obiektowego konieczne jest użycie wskaźnika - co oznacza użycie newgo wcześniej. Aby uprościć złożoność zarządzania zasobami, mamy dziesiątki narzędzi, które sprawiają, że jest to tak proste, jak to możliwe, takie jak inteligentne wskaźniki. Paradygmat oparty na obiektach lub paradygmat ogólny zakłada semantykę wartości i wymaga mniej lub wcale new, tak jak napisano w innych plakatach.

Tradycyjne wzorce projektowe, zwłaszcza te wspomniane w książce GoF , newczęsto używają , ponieważ są typowym kodem OO.

Jeszcze jeden punkt do wszystkich powyższych poprawnych odpowiedzi, zależy to od rodzaju wykonywanego programowania. Jądro rozwijające się na przykład w systemie Windows -> Stos jest poważnie ograniczony i może nie być możliwe przyjmowanie błędów stron, tak jak w trybie użytkownika.

W takich środowiskach nowe lub podobne do C wywołania API są preferowane, a nawet wymagane.

Oczywiście jest to jedynie wyjątek od reguły.

newprzydziela obiekty na stercie. W przeciwnym razie obiekty są przydzielane na stosie. Sprawdź różnicę między nimi .