Sprawdzanie wskaźnika NULL w C / C ++ [zamknięte]

W ostatnim przeglądzie kodu współtwórca próbuje wymusić, aby wszystkie NULLsprawdzenia wskaźników były wykonywane w następujący sposób:

int * some_ptr;
// ...
if (some_ptr == NULL)
{
    // Handle null-pointer error
}
else
{
    // Proceed
}

zamiast

int * some_ptr;
// ...
if (some_ptr)
{
    // Proceed
}
else
{
    // Handle null-pointer error
}

Zgadzam się, że jego sposób jest nieco bardziej przejrzysty w tym sensie, że wyraźnie mówi „Upewnij się, że ten wskaźnik nie ma wartości NULL”, ale chciałbym temu przeciwdziałać, mówiąc, że każdy, kto pracuje nad tym kodem, zrozumiałby, że użycie zmiennej wskaźnika w ifinstrukcja niejawnie sprawdzaNULL . Uważam również, że druga metoda ma mniejsze szanse na wprowadzenie błędu podobnego:

if (some_ptr = NULL)

co jest absolutnym trudem do znalezienia i debugowania.

Który sposób wolisz i dlaczego?

Z mojego doświadczenia wynika, że preferowane są testy formy if (ptr)lub if (!ptr). Nie zależą od definicji symbolu NULL. Nie stwarzają okazji do przypadkowego zadania. Są jasne i zwięzłe.

Edycja: jak SoapBox wskazuje w komentarzu, są one kompatybilne z klasami C ++, takimi jak auto_ptrobiekty, które działają jako wskaźniki i które zapewniają konwersję, boolaby włączyć dokładnie ten idiom. W przypadku tych obiektów jawne porównanie NULLmusiałoby wywołać konwersję do wskaźnika, co może mieć inne semantyczne skutki uboczne lub być droższe niż proste sprawdzenie istnienia, które boolimplikuje konwersja.

Preferuję kod, który mówi, co to znaczy, bez zbędnego tekstu. if (ptr != NULL)ma to samo znaczenie, if (ptr)ale kosztem zbędnej specyfiki. Następną logiczną rzeczą jest pisanie if ((ptr != NULL) == TRUE)i na tym polega szaleństwo. Język C jest jasne, że logiczna przetestowany przez if, whilelub jak ma szczególne znaczenie z niezerową wartością jest prawda i zero jest fałszywe. Nadmiarowość nie czyni tego jaśniejszym.

if (foo)jest wystarczająco jasne. Użyj tego.

Zacznę od tego: spójność jest królem, decyzja jest mniej ważna niż spójność w bazie kodu.

W C ++

NULL jest definiowane jako 0 lub 0L w C ++.

Jeśli przeczytałeś Język programowania C ++ Bjarne Stroustrup sugeruje użycie 0jawnego unikania NULLmakra podczas wykonywania przypisań , nie jestem pewien, czy zrobił to samo z porównaniami, minęło trochę czasu, odkąd przeczytałem książkę, myślę, że właśnie to zrobiłif(some_ptr) bez wyraźnego porównania, ale jestem niejasny.

Powodem tego jest to, że NULLmakro jest zwodnicze (jak prawie wszystkie makra), w rzeczywistości jest 0dosłowne, a nie jest unikalnym typem, jak sugeruje nazwa. Unikanie makr to jedna z ogólnych wskazówek w C ++. Z drugiej strony 0wygląda jak liczba całkowita i nie jest porównywana lub przypisywana do wskaźników. Osobiście mógłbym pójść w obie strony, ale zazwyczaj pomijam wyraźne porównanie (chociaż niektórym to się nie podoba, dlatego prawdopodobnie masz współpracownika sugerującego zmianę).

Niezależnie od osobistych odczuć jest to w dużej mierze wybór najmniejszego zła, ponieważ nie ma jednej właściwej metody.

To jest klarowny i powszechny idiom i wolę taki, nie ma szans przypadkowego przypisania wartości podczas porównania i czyta się wyraźnie:

if(some_ptr){;}

Jest to jasne, jeśli wiesz, że some_ptrjest to typ wskaźnika, ale może również wyglądać jak porównanie liczb całkowitych:

if(some_ptr != 0){;}

Jest to jasne, w typowych przypadkach ma to sens ... Ale jest to nieszczelna abstrakcja, w NULLrzeczywistości jest 0dosłowna i może łatwo zostać niewłaściwie wykorzystana:

if(some_ptr != NULL){;}

C ++ 0x ma nullptr, który jest teraz preferowaną metodą, ponieważ jest wyraźny i dokładny, po prostu uważaj na przypadkowe przypisanie:

if(some_ptr != nullptr){;}

Dopóki nie będziesz w stanie przejść na C ++ 0x, uważałbym, że to strata czasu na martwienie się o to, której z tych metod używasz, wszystkie są niewystarczające, dlatego wynaleziono nullptr (razem z ogólnymi problemami programistycznymi, które doprowadziły do ​​idealnego przekazywania .) Najważniejsze jest zachowanie spójności.

W C

C to inna bestia.

W C NULL można zdefiniować jako 0 lub jako ((void *) 0), C99 pozwala na implementację zdefiniowanych zerowych stałych wskaźnika. Tak więc sprowadza się to do definicji NULL zdefiniowanej przez implementację i będziesz musiał sprawdzić to w swojej standardowej bibliotece.

Makra są bardzo powszechne i na ogół są często używane, aby nadrobić braki w ogólnej obsłudze programowania w języku i nie tylko. Język jest znacznie prostszy i bardziej powszechne jest poleganie na preprocesorze.

Z tego punktu widzenia prawdopodobnie zalecałbym użycie NULLdefinicji makra w C.

Używam if (ptr), ale zupełnie nie warto się o to spierać.

Podoba mi się mój sposób, ponieważ jest zwięzły, chociaż inni mówią, == NULLże jest łatwiejszy do odczytania i bardziej wyraźny. Widzę, skąd pochodzą, po prostu nie zgadzam się, że dodatkowe rzeczy sprawiają, że jest to łatwiejsze. (Nienawidzę makra, więc jestem stronniczy.) Do ciebie.

Nie zgadzam się z twoim argumentem. Jeśli nie otrzymujesz ostrzeżeń dla przydziałów warunkowych, musisz zwiększyć poziomy ostrzeżeń. Proste. (I z miłości do wszystkiego, co dobre, nie zmieniaj ich).

Zauważ, że w C ++ 0x możemy zrobić if (ptr == nullptr), co dla mnie jest przyjemniejsze. (Ponownie, nienawidzę makra. Ale nullptrjest fajne.) Jednak nadal to robię if (ptr), tylko dlatego, że jestem do tego przyzwyczajony.

Szczerze mówiąc, nie rozumiem, dlaczego to ma znaczenie. Każdy z nich jest całkiem jasny i każdy średnio doświadczony w C lub C ++ powinien rozumieć oba. Jednak jeden komentarz:

Jeśli planujesz rozpoznać błąd i nie kontynuować wykonywania funkcji (tj. Zamierzasz natychmiast zgłosić wyjątek lub zwrócić kod błędu), powinieneś uczynić z tego klauzulę ochronną:

int f(void* p)
{
    if (!p) { return -1; }

    // p is not null
    return 0;
}

W ten sposób unikniesz „kodu strzałki”.

Osobiście zawsze używałem, if (ptr == NULL)ponieważ jasno określa to mój zamiar, ale w tym momencie to tylko nawyk.

Użycie =zamiast ==will zostanie przechwycone przez dowolny kompetentny kompilator z poprawnymi ustawieniami ostrzeżeń.

Ważne jest, aby wybrać spójny styl dla swojej grupy i trzymać się go. Bez względu na to, którą drogą pójdziesz, w końcu przyzwyczaisz się do tego, a utrata tarcia podczas pracy z kodem innych osób będzie mile widziana.

Jeszcze jeden punkt na korzyść foo == NULLpraktyki: jeśli foojest, powiedzmy, a int *lub a bool *, to if (foo)czek może zostać przypadkowo zinterpretowany przez czytelnika jako testowanie wartości pointee, tj if (*foo). Jako . NULLPorównanie tutaj jest przypomnieniem, że mówimy o wskaźnik.

Ale przypuszczam, że dobra konwencja nazewnictwa sprawia, że ​​ten argument jest dyskusyjny.

Właściwie używam obu wariantów.

Są sytuacje, w których najpierw sprawdzasz poprawność wskaźnika, a jeśli ma on wartość NULL, po prostu wracasz / wychodzisz z funkcji. (Wiem, że może to prowadzić do dyskusji „jeśli funkcja ma tylko jeden punkt wyjścia”)

W większości przypadków sprawdzasz wskaźnik, robisz, co chcesz, a następnie rozwiązujesz przypadek błędu. Rezultatem może być brzydki kod z wcięciem x razy z wieloma ifami.

Język programowania C (K&R) wymagałby sprawdzenia null == ptr, aby uniknąć przypadkowego przypisania.

Jeśli styl i format będą częścią twoich recenzji, powinien istnieć uzgodniony przewodnik po stylu, z którym można się zmierzyć. Jeśli istnieje, zrób to, co mówi przewodnik stylu. Jeśli go nie ma, takie szczegóły należy pozostawić tak, jak są zapisane. To strata czasu i energii i odwraca uwagę od tego, co naprawdę powinny być odkrywane recenzje kodu. Poważnie, bez przewodnika po stylu nalegałbym z zasady, aby NIE zmieniać takiego kodu, nawet jeśli nie używa on preferowanej przeze mnie konwencji.

Nie żeby to miało znaczenie, ale moje osobiste preferencje są takie if (ptr). Znaczenie jest dla mnie bardziej oczywiste niż nawet if (ptr == NULL).

Może próbuje powiedzieć, że lepiej poradzić sobie z warunkami błędu, niż szczęśliwą ścieżką? W takim razie nadal nie zgadzam się z recenzentem. Nie wiem, czy istnieje na to przyjęta konwencja, ale moim zdaniem najbardziej „normalny” stan powinien mieć pierwszeństwo w każdym stwierdzeniu if. W ten sposób mam mniej do zrobienia, aby dowiedzieć się, o co chodzi w tej funkcji i jak działa.

Wyjątkiem jest sytuacja, gdy błąd powoduje wycofanie się z funkcji lub przywrócenie jej przed przejściem dalej. W takich przypadkach najpierw zajmuję się błędem:

if (error_condition)
  bail_or_fix();
  return if not fixed;

// If I'm still here, I'm on the happy path

Zajmując się z góry nietypowym stanem, mogę się tym zająć, a potem o nim zapomnieć. Ale jeśli nie mogę wrócić na szczęśliwą ścieżkę, zajmując się tym z przodu, należy to załatwić później głównej sprawie, ponieważ czyni to kod bardziej zrozumiałym. W mojej opinii.

Ale jeśli nie jest to przewodnik po stylu, to tylko moja opinia, a Twoja opinia jest równie ważna. Albo standaryzuj, albo nie. Nie pozwól recenzentowi pseudo-standaryzacji tylko dlatego, że ma opinię.

Jest to jedna z podstaw obu języków, w której wskaźniki oceniają typ i wartość, które mogą być używane jako wyrażenie sterujące, boolw C ++ i intC. Po prostu użyj tego.

• Wskaźniki nie są wartościami logicznymi
• Nowoczesne kompilatory C / C ++ emitują ostrzeżenie, gdy piszesz if (foo = bar)przez przypadek.

Dlatego wolę

if (foo == NULL)
{
    // null case
}
else
{
    // non null case
}

lub

if (foo != NULL)
{
    // non null case
}
else
{
    // null case
}

Jednak gdybym pisał zestaw wskazówek dotyczących stylu, nie umieszczałbym w nim takich rzeczy, jak:

Upewnij się, że wykonałeś zerową kontrolę wskaźnika.

Jestem wielkim fanem tego, że C / C ++ nie sprawdza typy w logicznych warunków if, fororaz whilesprawozdania. Zawsze używam:

if (ptr)

if (!ptr)

nawet na liczbach całkowitych lub innych typach, które konwertują na bool:

while(i--)
{
    // Something to do i times
}

while(cin >> a >> b)
{
    // Do something while you've input
}

Kodowanie w tym stylu jest dla mnie bardziej czytelne i jaśniejsze. Tylko moja osobista opinia.

Ostatnio pracując nad mikrokontrolerem OKI 431 zauważyłem, że:

unsigned char chx;

if (chx) // ...

jest bardziej wydajny niż

if (chx == 1) // ...

ponieważ w późniejszym przypadku kompilator musi porównać wartość chx do 1. Gdzie chx jest po prostu flagą true / false.

Większość kompilatorów, z których korzystałem, przynajmniej ostrzega przed ifprzypisaniem bez dalszego poprawiania składni, więc nie kupuję tego argumentu. To powiedziawszy, użyłem obu profesjonalnie i nie preferuję żadnego. Jest == NULLto zdecydowanie jaśniejsze moim zdaniem.