Jakich pułapek w C++ powinienem unikać? [zamknięte]

Pułapki w kolejności malejącej ich znaczenia

Po pierwsze, powinieneś odwiedzić nagradzane C++ FAQ . Ma wiele dobrych odpowiedzi na pułapki. Jeśli masz dodatkowe pytania, odwiedź ##c++ na irc.freenode.org W IRC . Cieszymy się, że możemy Ci pomóc, jeśli możemy. Uwaga wszystkie poniższe pułapki zostały pierwotnie napisane. Nie są one kopiowane tylko z przypadkowych źródeł.

delete[] on new, delete on new[]

Rozwiązanie : Doing powyższe prowadzi do nieokreślonego zachowania: wszystko może się zdarzyć. Zrozum swój kod i co on robi, i zawsze delete[] co Ty new[] i delete co Ty new, wtedy to się nie stanie.

Wyjątek :

typedef T type[N]; T * pT = new type; delete[] pT;

Musisz delete[] mimo, że new, skoro masz nową tablicę. Jeśli więc pracujesz z typedef, należy zachować szczególną ostrożność.

[[62]}wywołanie funkcji wirtualnej w konstruktorze lub destruktorze

Rozwiązanie : Wywołanie funkcji wirtualnej nie wywoła funkcji nadrzędnych w klasach pochodnych. Wywołanie czystej funkcji wirtualnej w konstruktorze lub desstructorze jest niezdefiniowanym zachowaniem.

Wywołanie delete lub delete[] na już usuniętym wskaźniku

Rozwiązanie : Przypisz 0 do każdego usuniętego wskaźnika. Wywołanie delete lub delete[] na wskaźniku null nic nie robi.

Biorąc wielkość wskaźnika, gdy liczba elementów należy obliczyć "tablicę".

Rozwiązanie: przekazuje liczbę elementów obok wskaźnika, gdy trzeba przekazać tablicę jako wskaźnik do funkcji. Użyj funkcji tutaj jeśli weźmiesz rozmiar tablicy, która ma być naprawdę tablicą.

Używanie tablicy tak, jakby była wskaźnikiem. Tak więc, używając T ** dla macierzy dwuwymiarowej.

Rozwiązanie : Zobacz tutaj {[64] } dlaczego oni są różne i jak sobie z nimi radzisz.

Zapis do łańcucha literalnego: char * c = "hello"; *c = 'B';

Rozwiązanie : Przydziel tablicę, która jest zainicjalizowana z danych literalnego łańcucha znaków, wtedy możesz do niej napisać:

char c[] = "hello"; *c = 'B';

Zapis do literału łańcuchowego jest niezdefiniowanym zachowaniem. W każdym razie, powyższa konwersja z literału łańcuchowego na char * jest przestarzała. Więc Kompilatory prawdopodobnie ostrzegają, jeśli zwiększysz poziom ostrzeżenia.

Tworzenie zasoby, a następnie zapominając o ich uwolnieniu, gdy coś rzuca.

Rozwiązanie : użyj inteligentnych wskaźników, takich jak std::unique_ptr lub std::shared_ptr Jak wskazują inne odpowiedzi.

Modyfikowanie obiektu dwa razy, jak w tym przykładzie: i = ++i;

Rozwiązanie : powyższe miało przypisać i wartość i+1. Ale to, co robi, nie jest zdefiniowane. Zamiast zwiększać i i przypisywać wynik, zmienia się i po prawej stronie również. Zmiana obiektu między dwoma punktami sekwencji jest niezdefiniowanym zachowaniem. Punkty sekwencji obejmują ||, &&, comma-operator, semicolon i entering a function (lista niewyczerpująca!). Zmień kod na następujący, aby zachowywał się poprawnie: i = i + 1;

Różne Problemy

Zapominanie o spłukiwaniu strumieni przed wywołaniem funkcji blokującej, takiej jak sleep.

Rozwiązanie : przepłukać strumień przez strumieniowanie std::endl zamiast \n lub dzwoniąc stream.flush();.

Deklarowanie funkcji zamiast zmiennej.

Rozwiązanie : problem pojawia się, ponieważ kompilator interpretuje na przykład

Type t(other_type(value));

Jako deklaracja funkcji t zwracającej Type i posiadającej parametr typu other_type, który nazywa się value. Rozwiązujesz to, umieszczając nawiasy wokół pierwszego argumentu. Teraz otrzymujesz zmienną t typu Type:

Type t((other_type(value)));

Wywołanie funkcja wolnego obiektu, która jest zadeklarowana tylko w bieżącej jednostce translacji (plik.cpp).

Rozwiązanie : standard nie definiuje kolejności tworzenia wolnych obiektów (w zakresie przestrzeni nazw) zdefiniowanych w różnych jednostkach translacji. Wywołanie funkcji członka na obiekcie jeszcze nie zbudowanym jest niezdefiniowanym zachowaniem. Można zdefiniować następującą funkcję w jednostce translacji obiektu i wywołać ją z innych:

House & getTheHouse() { static House h; return h; }

To by Utwórz obiekt na żądanie i pozostaw w pełni skonstruowany obiekt w momencie wywołania funkcji na nim.

Definiowanie szablonu w pliku .cpp, podczas gdy jest on używany w innym pliku .cpp.

Rozwiązanie : prawie zawsze pojawią się błędy typu undefined reference to .... Umieść wszystkie definicje szablonów w nagłówku, tak aby gdy kompilator ich używa, mógł już wyprodukować potrzebny kod.

static_cast<Derived*>(base); jeśli baza jest wskaźnikiem do wirtualna klasa bazowa Derived.

Rozwiązanie : wirtualna klasa bazowa jest bazą, która występuje tylko raz, nawet jeśli jest dziedziczona więcej niż raz przez różne klasy pośrednio w drzewie dziedziczenia. Powyższe czynności nie są dozwolone przez normę. Aby to zrobić, użyj dynamic_cast i upewnij się, że twoja klasa bazowa jest polimorficzna.

dynamic_cast<Derived*>(ptr_to_base); jeśli baza nie jest polimorficzna

Rozwiązanie : standard nie pozwala na wskaźnik lub odniesienie po przekazaniu obiektu nie jest polimorficzne. On lub jedna z jego klas bazowych musi mieć funkcję wirtualną.

Sprawienie, by Twoja funkcja zaakceptowała T const **

Rozwiązanie: możesz pomyśleć, że jest to bezpieczniejsze niż używanie T **, ale w rzeczywistości spowoduje to ból głowy dla osób, które chcą przejść T**: standard na to nie pozwala. To daje schludny przykład, dlaczego nie jest dozwolone:

int main() {
    char const c = ’c’;
    char* pc;
    char const** pcc = &pc; //1: not allowed
    *pcc = &c;
    *pc = ’C’; //2: modifies a const object
}

Zawsze Akceptuj T const* const*; zamiast tego.

Kolejny (zamknięty) wątek o C++, więc ludzie szukający ich znajdą, to pytanie o przepełnienie stosu pułapki C++ .

Niektóre muszą mieć książki C++, które pomogą Ci uniknąć typowych pułapek w C++:

Skuteczne C++
skuteczniejsze C++
skuteczne STL

Efektywna książka STL wyjaśnia wektor zagadnienia bools:)

Brian ma świetną listę: dodałbym " zawsze oznaczaj konstruktory pojedynczych argumentów jawnie(z wyjątkiem tych rzadkich przypadków, w których chcesz automatycznego odlewania)."

Nie do końca konkretna wskazówka, ale ogólna wskazówka: Sprawdź swoje źródła. C++ to stary język, który na przestrzeni lat bardzo się zmienił. Najlepsze praktyki zmieniły się wraz z nim, ale niestety nadal istnieje wiele starych informacji. Było tu kilka bardzo dobrych rekomendacji książkowych - mogę po drugie kupić każdą książkę Scotta Meyersa C++. Zapoznaj się z Boost i ze stylami kodowania używanymi w Boost - ludzie zaangażowani w ten projekt są w trakcie cięcia edge of C++ design.

Nie odkrywaj koła na nowo. Zapoznaj się z STL i Boost, i korzystać z ich urządzeń, gdy tylko to możliwe toczenia własne. W szczególności używaj ciągów i kolekcji STL, chyba że masz bardzo, bardzo dobry powód, aby tego nie robić. Zapoznaj się z auto_ptr i biblioteką inteligentnych wskaźników Boost, zrozum, w jakich okolicznościach każdy typ inteligentnego wskaźnika ma być używany, a następnie użyj inteligentnych wskaźników wszędzie tam, gdzie mógłbyś użyć wskaźników surowych. Twój kod będzie równie wydajny i znacznie mniej podatny na wycieki pamięci.

Użyj static_cast, dynamic_cast, const_cast i reinterpret_cast zamiast odlewów w stylu C. W przeciwieństwie do odlewów w stylu C, dadzą Ci znać, jeśli naprawdę prosisz o inny rodzaj odlewu, niż myślisz, że o niego prosisz. I wyróżniają się viisually, alarmując czytelnika, że obsada odbywa się.

Strona WWW Pułapki C++ Scott Wheeler obejmuje niektóre z głównych pułapek C++.

Dwa gotchy, których żałuję, że nie nauczyłem się na trudnym poziomie:

(1) wiele danych wyjściowych (takich jak printf) jest domyślnie buforowanych. Jeśli debugujesz kod awarii i używasz buforowanych instrukcji debugowania, ostatnie wyjście, które widzisz, może , a nie być ostatnią instrukcją print napotkaną w kodzie. Rozwiązaniem jest przepłukanie bufora po każdym wydruku debugowania (lub całkowite wyłączenie buforowania).

(2) uważaj na inicjalizacje - (a) unikaj instancji klasy jako (B) spróbuj zainicjować wszystkie zmienne członkowskie do pewnej bezpiecznej wartości w ctor, nawet jeśli jest to trywialna wartość, taka jak NULL dla wskaźników.

Rozumowanie: kolejność inicjalizacji globalnego obiektu nie jest gwarantowana (globals zawiera zmienne statyczne), więc możesz skończyć z kodem, który wydaje się nie być nieokreślony, ponieważ zależy to od obiektu X zainicjalizowanego przed obiektem Y. Jeśli nie zainicjalizujesz jawnie zmiennej typu prymitywnego, takiej jak member bool lub member bool. enum klasy, będziesz miał różne wartości w zaskakujących sytuacjach. znowu zachowanie może wydawać się bardzo nieeterministyczne.

Wspominałem już o tym kilka razy, ale książki Scotta Meyersa Effective C++ i Effective STL są naprawdę warte swojej wagi za pomoc w C++.

Jeśli o tym pomyśleć, C++ Gotchas Stevena Dewhursta jest również doskonałym zasobem "z okopów". Jego pozycja na temat zwijania własnych wyjątków i sposobu ich konstruowania naprawdę pomogła mi w jednym projekcie.

Używanie C++ jak C. posiadanie cyklu tworzenia i uwalniania w kodzie.

W C++ nie jest to bezpieczne dla wyjątków i dlatego wydanie może nie zostać wykonane. W C++ używamy RAII do rozwiązania tego problemu.

Wszystkie zasoby, które mają ręczne tworzenie i zwalnianie, powinny być zawinięte w obiekt, aby te działania były wykonywane w konstruktorze / destruktorze.

// C Code
void myFunc()
{
    Plop*   plop = createMyPlopResource();

    // Use the plop

    releaseMyPlopResource(plop);
}

W C++ powinno to być zawinięte w obiekt:

// C++
class PlopResource
{
    public:
        PlopResource()
        {
            mPlop=createMyPlopResource();
            // handle exceptions and errors.
        }
        ~PlopResource()
        {
             releaseMyPlopResource(mPlop);
        }
    private:
        Plop*  mPlop;
 };

void myFunc()
{
    PlopResource  plop;

    // Use the plop
    // Exception safe release on exit.
}

Książka C++ Gotchas może się przydać.

Oto kilka dołów, w które miałem pecha wpaść. Wszystko to ma dobre powody, które zrozumiaĺ 'em dopiero po tym, jak zostaĹ' em ugryziony przez zachowanie ktĂłre mnie zaskoczyĹ ' o.

• virtual funkcje w konstruktorach nie są .

• Nie naruszaj ODR (One Definition Rule) , do tego służą anonimowe przestrzenie nazw (między innymi).

• Kolejność inicjalizacji członków zależy od kolejności, w jakiej są zadeklarowane.

  class bar {
      vector<int> vec_;
      unsigned size_; // Note size_ declared *after* vec_
  public:
      bar(unsigned size)
          : size_(size)
          , vec_(size_) // size_ is uninitialized
          {}
  };
  

• Wartości domyślne i virtual mają inną semantykę.

  class base {
  public:
      virtual foo(int i = 42) { cout << "base " << i; }
  };
  
  class derived : public base {
  public:
      virtual foo(int i = 12) { cout << "derived "<< i; }
  };
  
  derived d;
  base& b = d;
  b.foo(); // Outputs `derived 42`
  

Najważniejszą pułapką dla początkujących programistów jest unikanie pomyłek między C i C++. C++ nigdy nie powinien być traktowany jako zwykłe lepsze C lub C z klasami, ponieważ zmniejsza to jego moc i może uczynić go nawet niebezpiecznym(zwłaszcza przy użyciu pamięci jak w C).

Sprawdź boost.org . zapewnia wiele dodatkowych funkcjonalności, zwłaszcza ich inteligentne implementacje wskaźników.

Prqa mają doskonały i darmowy standard kodowania C++ oparty na książkach Scotta Meyersa, Bjarne Stroustropa i Herba Suttera. Łączy wszystkie te informacje w jednym dokumencie.

1. nie czytam C++ FAQ Lite . Wyjaśnia wiele złych (i dobrych!).
2. nie używając Boost . Oszczędzisz sobie wielu frustracji, korzystając z Boost tam, gdzie to możliwe.

Należy zachować ostrożność podczas używania inteligentnych wskaźników i klas kontenerów.

Unikaj pseudo klas i quasi klas ... Zasadniczo Overdesign.

Zapominanie o zdefiniowaniu Wirtualnego destruktora klasy bazowej. Oznacza to, że wywołanie delete Na Bazie* nie zakończy się zniszczeniem pochodnej części.

Utrzymuj przestrzenie nazw prosto (w tym struct, class, namespace i using). To moja frustracja numer jeden, gdy program po prostu nie kompiluje się.

Aby zepsuć, używaj często prostych wskaźników. Zamiast tego używaj RAII do prawie wszystkiego, upewniając się oczywiście, że używasz właściwych inteligentnych wskaźników. Jeśli napiszesz "Usuń" w dowolnym miejscu poza klasą typu handle lub pointer, najprawdopodobniej zrobisz to źle.

Przeczytaj książkę C++ Gotchas: unikanie typowych problemów w kodowaniu i projektowaniu.

• Blizpasta. To jest ogromny jeden widzę dużo...

• Niezainicjowane zmienne są ogromnym błędem, który popełniają moi uczniowie. Wielu ludzi z Javy zapomina, że samo powiedzenie "int counter" nie ustawia licznika na 0. Ponieważ musisz zdefiniować zmienne w pliku h (i zainicjalizować je w konstruktorze / konfiguracji obiektu), łatwo o tym zapomnieć.

• Błędy Off-by - one przy dostępie do pętli / tablicy for.

• Nieprawidłowe czyszczenie kodu obiektu, gdy zaczyna się voodoo.

• static_cast downcast na wirtualnej klasie bazowej

struct B { virtual ~B() {} };

struct D : B { };

Zawsze sprawdzaj wskaźnik, zanim go odwołasz. W C, zazwyczaj można liczyć na awarię w punkcie, w którym dereference zły wskaźnik; w C++, można utworzyć nieprawidłowe odniesienie, które będzie awarię w miejscu daleko od źródła problemu.

class SomeClass
{
    ...
    void DoSomething()
    {
        ++counter;    // crash here!
    }
    int counter;
};

void Foo(SomeClass & ref)
{
    ...
    ref.DoSomething();    // if DoSomething is virtual, you might crash here
    ...
}

void Bar(SomeClass * ptr)
{
    Foo(*ptr);    // if ptr is NULL, you have created an invalid reference
                  // which probably WILL NOT crash here
}

Zapominając o {[0] } i tym samym tworząc kopię zamiast odniesienia.

Zdarzyło mi się to dwa razy na różne sposoby:

• Jedna instancja znajdowała się na liście argumentów, co spowodowało Umieszczenie Dużego obiektu na stosie w wyniku przepełnienia stosu i awarii systemu wbudowanego.

• Zapomniałem & Na zmiennej instancji, z efektem, że obiekt został skopiowany. Po zarejestrowaniu się jako słuchacz do kopii zastanawiałem się, dlaczego nigdy nie dostałem wywołania z oryginalnego obiektu.

Oba miejsca są raczej trudne do zauważenia, ponieważ różnica jest niewielka i trudna do zauważenia, a w przeciwnym razie obiekty i odniesienia są używane składniowo w ten sam sposób.

Intencja jest (x == 10):

if (x = 10) {
    //Do something
}

Esej/Artykuł Wskaźniki, referencje i wartości jest bardzo przydatna. Mówi unikać unikania pułapek i dobrych praktyk. Możesz też przeglądać całą stronę, która zawiera porady programistyczne, głównie dla C++.

Przez wiele lat zajmowałem się tworzeniem C++. Napisałem krótkie podsumowanie problemów, które miałem z nim lata temu. Kompilatory zgodne ze standardami nie są już tak naprawdę problemem, ale podejrzewam, że inne opisane pułapki są nadal aktualne.

#include <boost/shared_ptr.hpp>
class A {
public:
  void nuke() {
     boost::shared_ptr<A> (this);
  }
};

int main(int argc, char** argv) {
  A a;
  a.nuke();
  return(0);
}