C ++ işaretçileri için NULL veya 0 (sıfır) kullanıyor musunuz?

C ++ 'ın C üzerine cıvatalandığı ilk günlerinde NULL olarak tanımlandığı gibi kullanamazsınız (void*)0. Başka bir işaretçiye NULL atayamazsınız void*, bu da onu işe yaramaz hale getirir. O günlerde, 0boş göstericiler için (sıfır) kullandığınız kabul edildi .

Bugüne kadar sıfırı boş gösterici olarak kullanmaya devam ettim ama etrafımdakiler kullanmakta ısrar ediyorlar NULL. Ben şahsen NULLmevcut bir değere bir isim ( ) vermek için herhangi bir fayda görmüyorum - ve ben de işaretçileri doğruluk değerleri olarak test etmek istiyorum:

if (p && !q)
  do_something();

daha sonra sıfır kullanmak daha mantıklıdır (kullandığınız gibi NULL, mantıksal olarak kullanamazsınız p && !q- sıfır NULLolduğunu varsaymadıkça açıkça karşılaştırmanız gerekir NULL, bu durumda neden kullanılır NULL).

NULL yerine sıfırı tercih etmek için nesnel bir neden var mı (ya da tam tersi) mi, yoksa sadece kişisel tercih mi?

Düzenleme: RAII ve istisnalar ile nadiren sıfır / NULL işaretçileri kullandığımı eklemeliyim (ve aslında söylemek istedim), ancak bazen hala onlara ihtiyacınız var.

İşte Stroustrup'un bunu ele alacağı: C ++ Stil ve Teknik SSS

C ++ 'da, tanımı NULL0'dır, bu nedenle sadece estetik bir fark vardır. Makrolardan kaçınmayı tercih ederim, bu yüzden 0 kullanıyorum. Başka bir sorun NULL, insanların yanlışlıkla yanlışlıkla 0'dan farklı olduğuna ve / veya bir tamsayı olmadığına inanmasıdır. Standart öncesi kodda, NULLbazen uygun olmayan bir şeyle tanımlanır / tanımlanır ve bu nedenle kaçınılması gerekir. Bugünlerde bu daha az yaygın.

Boş göstericiyi adlandırmanız gerekiyorsa, onu çağırın nullptr; C ++ 11'de buna denir. Ardından, nullptrbir anahtar kelime olacaktır.

Bununla birlikte, küçük şeyleri terlemeyin.

Bjarne'nin bu konudaki tutumuyla çeliştiğine inandığım birkaç argüman var (bunlardan biri nispeten yenidir).

1. Niyetin belgelenmesi

Kullanımı NULL, kullanımında arama yapılmasına izin verir ve ayrıca , derleyici tarafından yorumlanıp yorumlanmamasına bakılmaksızın geliştiricinin bir işaretçi kullanmak istediğini vurgular .NULLNULL

2. İşaretçi ve 'int' aşırı yüklenmesi nispeten nadirdir

Herkesin alıntıladığı örnek:

void foo(int*);
void foo (int);

void bar() {
  foo (NULL);  // Calls 'foo(int)'
}

Ancak, en azından benim düşünceme göre, yukarıdaki sorun null işaretçi sabiti için NULL kullandığımız değil, çok farklı argümanlar alan 'foo' aşırı yüklemelerimiz var. intDiğer türler belirsiz bir çağrıya neden olacağından ve yararlı bir derleyici uyarısı oluşturacağından parametre de olmalıdır .

3. Analiz araçları BUGÜN yardımcı olabilir!

C ++ 0x yokluğunda bile, NULLişaretçiler 0için kullanıldığını ve integral türleri için kullanıldığını doğrulayan araçlar mevcuttur .

4. C ++ 11'in yeni bir std::nullptr_ttürü olacaktır.

Bu tablodaki en yeni argüman. C ++ 0x sorunu 0ve NULLaktif olarak ele alınmaktadır ve sağlayan her uygulama için NULLilk yapacakları şey olduğunu garanti edebilirsiniz :

#define NULL  nullptr

Kullananlar için NULLziyade 0, değişim çok az veya hiç çaba ile tip-güvenliğinde bir gelişme olacak - bu da onlar kullandım birkaç hata yakalayabilir şey olursa NULLiçin 0. 0Bugün kullanan herkes için .... erm ... umarım düzenli ifadeler hakkında iyi bir bilgiye sahiptirler ...

NULL kullanın. NULL niyetinizi gösterir. Bunun 0 olması, önemli olmaması gereken bir uygulama detayıdır.

Her zaman kullanıyorum:

• NULL işaretçiler için
• '\0' karakterler için
• 0.0 şamandıralar ve çiftler için

burada 0 iyi olur. Bu bir sinyal verme meselesidir. Dedi ki, ben bu konuda anal değilim.

NULL kullanmayı uzun süre önce (diğer makroların yanı sıra) lehine bıraktım. Bunu sadece makroları olabildiğince önlemek istemediğim için değil, aynı zamanda NULL'un C ve C ++ kodunda aşırı kullanılmış olduğu için yaptım. Sadece işaretçiler için değil, 0 değeri gerektiğinde kullanılıyor gibi görünüyor.

Yeni projelerde bunu bir proje başlığına koydum:

static const int nullptr = 0;

Şimdi, C ++ 0x uyumlu derleyiciler geldiğinde, tek yapmam gereken bu satırı kaldırmak. Bunun güzel bir yararı, Visual Studio'nun nullptr'i bir anahtar kelime olarak zaten tanıması ve uygun şekilde vurgulamasıdır.

    cerr << sizeof(0) << endl;
    cerr << sizeof(NULL) << endl;
    cerr << sizeof(void*) << endl;

    ============
    On a 64-bit gcc RHEL platform you get:
    4
    8
    8
    ================

Hikayenin ahlakı. İşaretçilerle uğraşırken NULL kullanmalısınız.

1) Niyetinizi beyan eder (bir değişkenin bir işaretçi veya sayısal bir tür olup olmadığını anlamaya çalışarak tüm kodlarınızda arama yapmayın).

2) Değişken argümanları bekleyen bazı API çağrılarında, argüman listesinin sonunu belirtmek için bir NULL-pointer kullanırlar. Bu durumda, NULL yerine '0' kullanmak sorunlara neden olabilir. 64 bit platformda va_arg çağrısı 64 bit işaretçi ister, ancak yalnızca 32 bit tam sayı iletilir. Sana sıfırlanmak için diğer 32 bite güveniyormuşsun gibi geliyor mu? Çok zarif olmayan bazı derleyiciler (örneğin Intel'in icpc) gördüm - ve bu çalışma zamanı hataları ile sonuçlandı.

Doğru hatırlıyorsam NULL kullandığım başlıklarda farklı tanımlanır. C için (void *) 0 olarak tanımlanır ve C ++ için sadece 0 olarak tanımlar. Kod şöyle görünüyordu:

#ifndef __cplusplus
#define NULL (void*)0
#else
#define NULL 0
#endif

Şahsen ben hala null işaretçileri temsil etmek için NULL değeri kullanın, bazı integral türü yerine bir işaretçi kullandığınız açıkça yapar. Evet dahili olarak NULL değeri hala 0'dır, ancak bu şekilde temsil edilmez.

Ayrıca, tamsayıların boole değerlerine otomatik dönüştürülmesine güvenmiyorum, ancak bunları açıkça karşılaştırıyorum.

Örneğin:

if (pointer_value != NULL || integer_value == 0)

ziyade:

if (pointer_value || !integer_value)

Bunların hepsinin nullptryerine basitçe kullanılabileceği C ++ 11'de düzeltildiğini NULLve aynı zamanda nullptr_ta tipi olduğunu söylemek yeterli nullptr.

Tarihin konuşulduğunu ve 0 (sıfır) kullanmayı savunanların yanlış olduğunu söylerdim (Bjarne Stroustrup dahil). 0 lehine olan argümanlar çoğunlukla estetik ve "kişisel tercih" idi.

C ++ 11 oluşturulduktan sonra, yeni nullptr türüyle, bazı derleyiciler 0'ı bir işaretçi olmadığı için 0'ı işaretçi bağımsız değişkenleri olan işlevlere geçirmekten şikayet ediyorlar (varsayılan parametrelerle).

Kod NULL kullanılarak yazılmış olsaydı, kod tabanından nullptr yapmak için basit bir arama ve değiştirme gerçekleştirilebilirdi. İşaretçi olarak 0 seçeneğini kullanarak yazılan bir kodla sıkışırsanız, onu güncellemek çok daha sıkıcıdır.

Ve şimdi C ++ 03 standardına yeni bir kod yazmak zorundaysanız (ve nullptr kullanamazsanız), gerçekten sadece NULL kullanmalısınız. Gelecekte güncellemenizi çok daha kolay hale getirecektir.

Genellikle 0 kullanırım. Makroları sevmiyorum ve kullandığınız bazı üçüncü taraf başlıklarının NULL değerini garip bir şey olarak tanımlamadığının garantisi yok.

C ++ bir nullptr anahtar kelimesi alana kadar Scott Meyers ve diğerleri tarafından önerilen şekilde bir nullptr nesnesi kullanabilirsiniz:

const // It is a const object...
class nullptr_t 
{
public:
    template<class T>
    operator T*() const // convertible to any type of null non-member pointer...
    { return 0; }

    template<class C, class T>
    operator T C::*() const   // or any type of null member pointer...
    { return 0; }

private:
    void operator&() const;  // Can't take address of nullptr

} nullptr = {};

Daha fazla bilgi için Google "nullptr".

Bir zamanlar 0'ın geçerli bir adres olduğu ve NULL'un özel bir sekizli değer olarak tanımlandığı bir makinede çalıştım. Bu makinede (0! = NULL), yani kod gibi

char *p;

...

if (p) { ... }

beklediğiniz gibi çalışmaz. Sen yazmak zorundasın

if (p != NULL) { ... }

Her ne kadar çoğu derleyicinin NULL'u 0 olarak tanımladığına inanmama rağmen, o yıllardan önceki dersi hala hatırlıyorum: NULL mutlaka 0 değildir.

Sanırım standart NULL == 0 garanti, bu yüzden ya da yapabilirsiniz. NULL'u tercih ediyorum çünkü niyetinizi belgeliyor.

0 veya NULL kullanılması aynı etkiye sahip olacaktır.

Ancak bu, her ikisinin de iyi programlama uygulamaları olduğu anlamına gelmez. Performansta bir fark olmadığı göz önüne alındığında, agnostik / soyut bir alternatife göre düşük seviyeli farkında bir seçenek seçmek kötü bir programlama uygulamasıdır. Kodunuzun okuyucularının düşünce sürecinizi anlamalarına yardımcı olun .

NULL, 0, 0.0, '\ 0', 0x00 ve whatelse aynı şeyi ifade eder, ancak programınızdaki farklı mantıksal varlıklardır. Bu şekilde kullanılmaları gerekir. NULL bir işaretçi, 0 miktar, 0x0, bitleri ilginç olan bir değerdir. Derleyici olsun olmasın bir işaretçiye '\ 0' atamazsınız.

Bazı toplulukların çevrenin sözleşmelerini kırarak bir çevre hakkında derinlemesine bilgi göstermeyi teşvik ettiğini biliyorum. Bununla birlikte, sorumlu programcılar sürdürülebilir kod hazırlar ve bu tür uygulamaları kodlarının dışında tutar.

Garip, Stroustroup dahil hiç kimse bundan bahsetmedi. O olduğunu fark standartlar ve estetik kimse hakkında çok şey konuşurken tehlikeli kullanmaya 0içinde NULLnerede mimarisine değişken argüman listesinde, örneğin, 'in yerine sizeof(int) != sizeof(void*). Stroustroup gibi, 0estetik nedenlerden dolayı tercih ederim , ancak biri türünün belirsiz olabileceği yerlerde kullanmamaya dikkat etmeliyim .

Mümkünse C ++ referanslarını kullanarak tüm soruyu önlemek için deneyin. Ziyade

void foo(const Bar* pBar) { ... }

sık sık yazabilirsiniz

void foo(const Bar& bar) { ... }

Tabii ki, bu her zaman işe yaramaz; ancak boş göstergeler aşırı kullanılabilir.

Ben bu konuda Stroustrup ile :-) :-) NULL dilin bir parçası olmadığından, 0 kullanmayı tercih ederim.

Çoğunlukla kişisel tercih, ancak NULL'un nesnenin şu anda hiçbir şeye işaret etmediği bir işaretçi olduğunu açıkça ortaya koyabileceği argümanı olabilir;

void *ptr = &something;
/* lots o' code */
ptr = NULL; // more obvious that it's a pointer and not being used

IIRC'de, standart NULL değerinin 0 olmasını gerektirmez, bu nedenle <stddef.h> dosyasında tanımlanan her şeyi kullanmak derleyiciniz için muhtemelen en iyisidir.

Argümanın bir başka yönü de mantıksal karşılaştırmalar (boole örtülü olarak döküm) veya NULL'a karşı açıklık kontrolü kullanmanız gerekip gerekmediğidir, ancak bu da okunabilirliğe iner.

NULL değerinin aritmetik bir değeri değil, bir işaretçi temsil olduğu açıktır gibi NULL kullanmayı tercih ederim. Bunun bir makro olması talihsiz, ama çok köklü bir şekilde yerleştiği için çok az tehlike var (birisi gerçekten baş dönmüş bir şey yapmadığı sürece). Keşke en başından beri bir anahtar kelime olsaydı, ama ne yapabilirsin?

Bununla birlikte, işaretçileri kendi içlerinde doğruluk değerleri olarak kullanma konusunda sorunum yok. Tıpkı NULL'da olduğu gibi, bu yerleşik bir deyimdir.

C ++ 09, gecikmiş olduğunu düşündüğüm nullptr yapısını ekleyecektir.

Ben her zaman 0 kullanıyorum. Sadece C ++ öğrenmeye başladığımda 0 ile tavsiye edilen bir şeyi okuduğumdan ve her zaman bu şekilde yaptığımdan dolayı, gerçek düşünülmüş bir sebep için değil. Teoride okunabilirlikte bir karışıklık sorunu olabilir, ancak pratikte bir zamanlar binlerce adam-saat ve milyonlarca kod satırında böyle bir konuyla hiç karşılaşmadım. Stroustrup'un dediği gibi, standart nullptr olana kadar gerçekten kişisel bir estetik sorun.

Birisi bana bir kez söyledi ... NULL değerini 69 olarak yeniden tanımlayacağım. O zamandan beri kullanmıyorum: P

Kodunuzu oldukça savunmasız hale getirir.

Düzenle:

Standarttaki her şey mükemmel değildir. NULL makro, C NULL makro ile tam olarak uyumlu olmayan, uygulama tanımlı bir C ++ null işaretçi sabiti olup, örtük türün gizlenmesinin yanı sıra işe yaramaz ve hatalara eğilimli bir araçta onu dönüştürür.

NULL, boş gösterici olarak değil, O / OL değişmezi olarak davranır.

Bir sonraki örneğin kafa karıştırıcı olmadığını söyle:

void foo(char *); 
void foo(int); 
foo(NULL); // calls int version instead of pointer version! 

Tüm bunlardan dolayı, yeni standartta std :: nullptr_t görünür

Yeni standardı beklemek istemiyorsanız ve bir nullptr kullanmak istiyorsanız, Meyers tarafından önerilen gibi en azından iyi bir standart kullanın (bkz. Jon.h yorumu).

Mümkün olduğunca 0 veya NULL işaretçileri kullanmadığımı iddia ediyorum.

Bunları er ya da geç kullanmak, kodunuzda segmentasyon hatalarına yol açacaktır. Benim tecrübelerime göre, bu ve gereral işaretçiler C ++ hataların en büyük kaynaklarından biridir

ayrıca, kodunuzun her yerinde "if-not-null" ifadelerine yol açar. Her zaman geçerli bir duruma güvenebilirseniz çok daha güzel.

Neredeyse her zaman daha iyi bir alternatif vardır.

İşaretçiyi 0 olarak ayarlamak o kadar açık değildir. Özellikle C ++ dışında bir dil gelirseniz. Buna C ve Javascript de dahildir.

Son zamanlarda böyle bazı kod ile delt:

virtual void DrawTo(BITMAP *buffer) =0;

ilk kez saf sanal işlev için. Bir hafta boyunca sihirli bir jiberjash olduğunu düşündüm. Ben sadece temel fonksiyon işaretçisi bir null(sanal fonksiyonlar C ++ için çoğu durumda sadece fonksiyon işaretçiler olduğu gibi) ayarlamak olduğunu fark kendimi tekmeledim.

virtual void DrawTo(BITMAP *buffer) =null;

yeni gözlerime uygun boşluk bırakmadan bu yıkımdan daha az kafa karıştırıcı olurdu. Aslında, neden C ++ küçük nullharf yanlış ve doğru kullanıyor gibi merak etmiyorum merak ediyorum .