C / C ++ 'da NULL işaretçisi kontrol ediliyor [kapalı]

Son zamanlarda yapılan bir kod incelemesinde, bir katılımcı NULLişaretçiler üzerindeki tüm kontrollerin aşağıdaki şekilde yapılmasını zorunlu kılmaya çalışmaktadır :

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

onun yerine

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

Açıkça "Bu işaretçinin NULL olmadığından emin olun" derken yolunun biraz daha açık olduğunu kabul ediyorum, ancak bu kod üzerinde çalışan herkesin bir işaretçi değişkenini kullanarak bir ififadesi dolaylı olarak kontrol ediyor NULL. Ayrıca ikinci yöntemin ilk bir hata tanıtmak için daha küçük bir şans olduğunu hissediyorum:

if (some_ptr = NULL)

bu sadece bulmak ve hata ayıklamak için mutlak bir acıdır.

Hangi yolu tercih edersiniz ve neden?

Deneyimlerime göre, form if (ptr)veya test testleri if (!ptr)tercih edilir. Sembolün tanımına bağlı değildirler NULL. Kazara görevlendirme fırsatını ortaya çıkarmazlar. Ve onlar açık ve özlü.

Düzenleme: SoapBox bir açıklamada işaret ettiği gibi, bunlar auto_ptrgibi işaretçiler olarak hareket eden ve booltam olarak bu deyimi etkinleştirmek için bir dönüşüm sağlayan nesneler gibi C ++ sınıfları ile uyumludur . Bu nesneler için, açık bir karşılaştırma NULL, diğer semantik yan etkilere sahip olabilen veya booldönüşümün ima ettiği basit varoluş kontrolünden daha pahalı olabilen işaretçiye bir dönüşüm çağırmak zorunda kalacaktır .

Gereksiz metin olmadan ne anlama geldiğini söyleyen kod için bir tercih var. if (ptr != NULL)aynı if (ptr)özgüllük pahasına aynı anlama sahiptir . Bir sonraki mantıklı şey yazmaktır if ((ptr != NULL) == TRUE)ve bu şekilde delilik yatar. C dili, bir Boole ile test açıktır if, whileveya sıfır değerinin anlamı, belirli bir yer alır gibi gerçek ve sıfır yanlıştır. Artıklık bunu netleştirmez.

if (foo)yeterince açıktır. Kullanın.

Bununla başlayacağım: tutarlılık kraldır, karar kod tabanınızdaki tutarlılıktan daha az önemlidir.

C ++ dilinde

NULL, C ++ 'da 0 veya 0L olarak tanımlanır.

C ++ Programlama Dili'ni okuduysanız Bjarne Stroustrup, atama yaparken makrodan 0kaçınmak için açıkça kullanmanızı önerirNULL , karşılaştırmalarıyla aynı şeyi yapıp yapmadığından emin değilim, kitabı okuduğumdan beri bir süre geçti, sanırım sadece yaptı if(some_ptr)açık bir karşılaştırma olmadan ama ben bu konuda bulanık.

Bunun nedeni, NULLmakronun aldatıcı olması (neredeyse tüm makrolar gibi) aslında 0gerçek anlamlıdır, adından da anlaşılacağı gibi benzersiz bir tür değildir. Makrolardan kaçınmak, C ++ 'daki genel yönergelerden biridir. Öte yandan, 0bir tamsayı gibi görünür ve işaretçilerle karşılaştırıldığında ya da atanmış değildir. Şahsen ben her iki şekilde de gidebilirim, ama tipik olarak açık karşılaştırmayı atlıyorum (bazı insanlar bunu sevmiyor olsa da, muhtemelen neden bir değişiklik öneren bir katkıda bulunuyorsunuz).

Kişisel duygular ne olursa olsun, doğru bir yöntem olmadığı için bu büyük ölçüde en az kötülük seçeneğidir.

Bu açık ve ortak bir deyim ve bunu tercih ediyorum, karşılaştırma sırasında yanlışlıkla bir değer atama şansı yok ve açıkça okuyor:

if(some_ptr){;}

Bu some_ptrbir işaretçi türü olduğunu biliyorsanız açıktır , ancak tamsayı karşılaştırması gibi de görünebilir:

if(some_ptr != 0){;}

Bu açıktır, yaygın durumlarda mantıklıdır ... Ama sızdıran bir soyutlama, NULLaslında 0gerçek anlamlıdır ve kolayca kötüye kullanılabilir:

if(some_ptr != NULL){;}

C ++ 0x şimdi açık ve doğru olduğu için tercih edilen yöntem olan nullptr'e sahiptir, sadece yanlışlıkla atama konusunda dikkatli olun:

if(some_ptr != nullptr){;}

C ++ 0x'e geçiş yapabilene kadar, bu yöntemlerden hangisini kullandığınız konusunda endişelenmenin zaman kaybı olduğunu iddia edeceğim, hepsi yetersizdir, bu yüzden nullptr icat edilmiştir (mükemmel yönlendirme ile ortaya çıkan genel programlama sorunları ile birlikte) .) En önemli şey tutarlılığı sağlamaktır.

C cinsinden

C farklı bir yaratıktır.

C NULL değerinde 0 veya ((void *) 0) olarak tanımlanabilir, C99, tanımlanmış null işaretçi sabitlerinin uygulanmasına izin verir. Yani aslında uygulamanın NULL tanımına gelir ve bunu standart kütüphanenizde incelemeniz gerekir.

Makrolar çok yaygındır ve genel olarak, dilde ve diğer şeylerde genel programlama desteğindeki eksiklikleri telafi etmek için çok kullanılırlar. Dil çok daha basittir ve ön işlemciye güvenmek daha yaygındır.

Bu açıdan muhtemelen NULLC'deki makro tanımını kullanmanızı tavsiye ederim .

Kullanıyorum if (ptr), ama bu tartışmaya değmez.

Yolumu seviyorum çünkü kısa ve öz olsa da, diğerleri == NULLokumayı daha kolay ve daha açık hale getiriyor. Nereden geldiklerini görüyorum, sadece ekstra şeylerin bunu kolaylaştırdığını kabul etmiyorum. (Makrodan nefret ediyorum, bu yüzden önyargılıyım.) Size kalmış.

Tartışmanıza katılmıyorum. Koşullu ödevler için uyarı almıyorsanız, uyarı seviyelerinizi artırmanız gerekir. Bu kadar basit. (Ve iyi olan her şeyin aşkı için onları değiştirmeyin.)

C ++ 0x ile Not, yapabileceğimiz if (ptr == nullptr)bana hangi yapar okuma daha güzel. (Yine, makrodan nefret ediyorum. Ama nullptrgüzel.) Yine de hala if (ptr)alışkın olduğum için yapıyorum.

Açıkçası, neden önemli olduğunu anlamıyorum. Her ikisi de oldukça açıktır ve C veya C ++ ile orta derecede deneyimli herkes ikisini de anlamalıdır. Bir yorum olsa da:

Hatayı tanımayı planlıyorsanız ve işlevi yürütmeye devam etmemeyi planlıyorsanız (yani, bir istisna atayacak veya hemen bir hata kodu döndüreceksiniz), bir koruma yan tümcesi yapmalısınız:

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

    // p is not null
    return 0;
}

Bu şekilde "ok kodundan" kaçınmış olursunuz.

Şahsen her zaman kullandım if (ptr == NULL)çünkü niyetimi açıkça ortaya koyuyor, ama bu noktada sadece bir alışkanlık.

=Yerinde kullanmak ==, doğru uyarı ayarlarına sahip herhangi bir yetkili derleyici tarafından yakalanacaktır.

Önemli olan, grubunuz için tutarlı bir stil seçmek ve ona bağlı kalmaktır. Hangi yöne giderseniz gidin, sonunda buna alışacaksınız ve diğer insanların kodlarında çalışırken sürtünme kaybı kabul edilecektir.

foo == NULLUygulama lehine sadece bir nokta daha : foodiyelim ki, bir int *ya da bir bool *, o zaman if (foo)çek, bir okuyucu tarafından yanlışlıkla sivri kıymetin değerini test etmek olarak yorumlanabilir if (*foo). NULL karşılaştırma, bir işaretçi hakkında konuştuğumuzu hatırlatıyor.

Ama iyi bir isimlendirme sözleşmesinin bu argümanı tartıştığını düşünüyorum.

Aslında her iki varyantı da kullanıyorum.

İlk önce bir işaretçinin geçerliliğini kontrol ettiğiniz durumlar vardır ve NULL ise, bir işlevden geri dönersiniz / çıkarsınız. (Bunun "bir işlevin yalnızca bir çıkış noktası olması durumunda" tartışmasına yol açabileceğini biliyorum)

Çoğu zaman, işaretçiyi kontrol edin, sonra istediğinizi yapın ve ardından hata durumunu çözün. Sonuç, birden çok if ile çirkin x-kez girintili kod olabilir.

C Programlama Dili (K&R), yanlışlıkla atamayı önlemek için null == ptr öğesini kontrol etmenizi sağlar.

Stil ve biçim incelemelerinizin bir parçası olacaksa, ölçmek için üzerinde anlaşmaya varılmış bir stil kılavuzu olmalıdır. Eğer varsa, stil rehberinin söylediklerini yapın. Bir tane yoksa, bunun gibi detaylar yazıldığı gibi bırakılmalıdır. Bu, zaman ve enerji kaybıdır ve kod incelemelerinin gerçekten ortaya çıkarması gereken şeylerden dikkati çeker. Cidden, bir stil rehberi olmadan, tercih ettiğim konvansiyonu kullanmasa bile, prensip olarak böyle bir kodu DEĞİŞTİRMEYE zorlayacağım.

Ve bu önemli değil, ama kişisel tercihim if (ptr). Anlam benim için her zamankinden daha açık if (ptr == NULL).

Belki de hata yolunu mutlu yoldan önce halletmenin daha iyi olduğunu söylemeye çalışıyor? Bu durumda hala gözden geçiren ile aynı fikirde değilim. Bunun için kabul edilmiş bir sözleşme olduğunu bilmiyorum, ama bence en "normal" koşul herhangi bir if ifadesinde ilk sırada yer almalıdır. Bu şekilde, işlevin ne hakkında olduğunu ve nasıl çalıştığını anlamak için daha az kazma yaptım.

Bunun istisnası, hata işlevden kefalet etmeme neden oluyorsa veya devam etmeden önce ondan kurtulabilirsem. Bu durumlarda, önce hatayı ele alıyorum:

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

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

Önde olağandışı durumla başa çıkarak, onunla ilgilenebilir ve sonra unutabilirim. Ben ön onu ele alarak mutlu yolda geri alamayan Ama eğer, o zaman işleneceğini sonra ana durumdan , çünkü kodu daha anlaşılır hale getirir. Bence.

Ama bir stil rehberinde değilse o zaman sadece benim görüşüm ve senin fikrin de geçerli. Ya standardize edin ya da etmeyin. Bir yorumcunun sadece bir fikri olduğu için sözde standardize olmasına izin vermeyin.

Bu, işaretçilerin boolC ++ ve C'de kontrol ifadesi olarak kullanılabilecek bir tür ve değere göre değerlendirdiği her iki dilin temellerinden biridir int.

• İşaretçiler boolean değil
• Modern C / C ++ derleyicileri if (foo = bar)yanlışlıkla yazdığınızda uyarı verir .

Bu yüzden tercih ederim

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

veya

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

Ancak, bir dizi stil kılavuzu yazıyor olsaydım buna böyle şeyler koymazdım, şöyle şeyler koyardım:

İmleci boş olarak kontrol ettiğinizden emin olun.

C / C ++ boolean içinde koşullarda türlerini kontrol etmez gerçeğinin büyük bir hayranıyım if, forve whiletabloların. Her zaman aşağıdakileri kullanıyorum:

if (ptr)

if (!ptr)

tamsayılarda veya boole dönüştürülen diğer türlerde bile:

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

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

Bu tarzda kodlama benim için daha okunaklı ve daha net. Sadece benim kişisel fikrim.

Son zamanlarda, OKI 431 mikrodenetleyici üzerinde çalışırken, aşağıdakileri fark ettim:

unsigned char chx;

if (chx) // ...

daha verimli

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

çünkü daha sonraki bir durumda derleyici chx değerini 1 ile karşılaştırmak zorundadır. Burada chx sadece doğru / yanlış bayraktır.

Kullandığım çoğu derleyici en azından ifsözdizimi şekeri olmadan ödev konusunda uyarır , bu yüzden bu argümanı satın almam. Bununla birlikte, hem profesyonel olarak kullandım hem de hiçbir tercihim yok. == NULLBence olsa kesinlikle nettir.