İşaretçiler neden varsayılan olarak NULL ile başlatılmıyor?

Birisi lütfen işaretçilerin neden başlatılmadığını açıklayabilir NULLmi?
Misal:

  void test(){
     char *buf;
     if (!buf)
        // whatever
  }

Program if'in içine bufgirmez çünkü boş değildir.

Neden, hangi durumda, özellikle hafızadaki çöpleri ele alan işaretçilerle birlikte bir değişkene ihtiyacımız var?

Hepimiz işaretçinin (ve diğer POD türlerinin) başlatılması gerektiğinin farkındayız.
Soru daha sonra 'onları kimin başlatması gerektiği' olur.

Temelde iki yöntem var:

• Derleyici onları başlatır.
• Geliştirici bunları başlatır.

Derleyicinin, geliştirici tarafından açıkça başlatılmamış herhangi bir değişkeni başlattığını varsayalım. Sonra, değişkeni başlatmanın önemsiz olmadığı ve geliştiricinin bunu bildirim noktasında yapmamasının nedeni, bir işlem gerçekleştirmesi ve sonra atama yapması gerektiğiydi.

Şimdi, derleyicinin, değişkeni NULL olarak başlatan koda fazladan bir talimat eklediğini ve daha sonra doğru başlatmayı yapmak için geliştirici kodunun eklendiğini görüyoruz. Veya diğer koşullar altında değişken potansiyel olarak asla kullanılmaz. Pek çok C ++ geliştiricisi, her iki koşulda da bu ekstra talimatın bedeli olarak faul çığlık atabilir.

Bu sadece zamanla ilgili değil. Ama aynı zamanda boşluk. Her iki kaynağın da premium olduğu ve geliştiricilerin de pes etmek istemediği birçok ortam var.

AMA : Başlatmaya zorlamanın etkisini simüle edebilirsiniz. Çoğu derleyici, sizi başlatılmamış değişkenler hakkında uyaracaktır. Bu yüzden uyarı seviyemi her zaman mümkün olan en yüksek seviyeye çeviriyorum. Sonra derleyiciye tüm uyarıları hata olarak ele almasını söyleyin. Bu koşullar altında çoğu derleyici, başlatılmamış ancak kullanılan değişkenler için bir hata oluşturacak ve bu nedenle kodun oluşturulmasını engelleyecektir.

Bjarne Stroustrup'tan TC ++ PL'de alıntı yapmak (Özel Sürüm s.22):

Bir özelliğin uygulanması, onu gerektirmeyen programlara önemli genel giderler yüklememelidir.

Çünkü yeniden başlatma zaman alır. Ve C ++ 'da, herhangi bir değişkenle yapmanız gereken ilk şey, onu açıkça başlatmaktır:

int * p = & some_int;

veya:

int * p = 0;

veya:

class A {
   public:
     A() : p( 0 ) {}  // initialise via constructor
   private:
     int * p;
};

Çünkü C ++ 'ın sloganlarından biri:

Kullanmadığın şey için ödeme yapmazsın

Tam da bu nedenle, operator[]bir vectordizin örneğin sınırlar dışında ise sınıfta denetlemez.

Tarihsel nedenlerden ötürü, esas olarak C'de böyle yapıldığı için, C'de neden böyle yapıldığı başka bir sorudur, ancak bence bu tasarım kararına bir şekilde sıfır genel gider prensibi dahil edilmiştir.

Ayrıca, onu ne zaman uçurduğunuza dair bir uyarımız var: "muhtemelen bir değer atanmadan önce kullanılır" veya derleyicinize bağlı olarak benzer bir kelime.

Uyarılarla derlersiniz, değil mi?

Bir değişkenin başlatılmamış olmasının anlamlı olduğu ve varsayılan başlatmanın küçük bir maliyeti olduğu, kaybolan birkaç durum vardır, öyleyse neden yapalım?

C ++, C89 değildir. Cehennem, C bile C89 değil. Bildirimleri ve kodu karıştırabilirsiniz, böylece bildirimi başlatmak için uygun bir değere sahip oluncaya kadar ertelemelisiniz.

İşaretçi sadece başka bir türdür. Bir veya başka bir POD türü oluşturursanız int, charsıfıra başlatılmaz, öyleyse neden bir işaretçi yapsın? Bu, böyle bir program yazan biri için gereksiz ek yük olarak kabul edilebilir.

char* pBuf;
if (condition)
{
    pBuf = new char[50];
}
else
{
    pBuf = m_myMember->buf();
}

Eğer onu başlatacağınızı biliyorsanız pBuf, yöntemin en üstünde ilk oluşturduğunuzda program neden bir maliyet oluştursun ? Bu sıfır genel gider ilkesidir.

Her zaman NULL olarak başlatılan bir işaretçi istiyorsanız, bu işlevselliği taklit etmek için bir C ++ şablonu kullanabilirsiniz:

template<typename T> class InitializedPointer
{
public:
    typedef T       TObj;
    typedef TObj    *PObj;
protected:
    PObj        m_pPointer;

public:
    // Constructors / Destructor
    inline InitializedPointer() { m_pPointer=0; }
    inline InitializedPointer(PObj InPointer) { m_pPointer = InPointer; }
    inline InitializedPointer(const InitializedPointer& oCopy)
    { m_pPointer = oCopy.m_pPointer; }
    inline ~InitializedPointer() { m_pPointer=0; }

    inline PObj GetPointer() const  { return (m_pPointer); }
    inline void SetPointer(PObj InPtr)  { m_pPointer = InPtr; }

    // Operator Overloads
    inline InitializedPointer& operator = (PObj InPtr)
    { SetPointer(InPtr); return(*this); }
    inline InitializedPointer& operator = (const InitializedPointer& InPtr)
    { SetPointer(InPtr.m_pPointer); return(*this); }
    inline PObj operator ->() const { return (m_pPointer); }
    inline TObj &operator *() const { return (*m_pPointer); }

    inline bool operator!=(PObj pOther) const
    { return(m_pPointer!=pOther); }
    inline bool operator==(PObj pOther) const
    { return(m_pPointer==pOther); }
    inline bool operator!=(const InitializedPointer& InPtr) const
    { return(m_pPointer!=InPtr.m_pPointer); }
    inline bool operator==(const InitializedPointer& InPtr) const
    { return(m_pPointer==InPtr.m_pPointer); }

    inline bool operator<=(PObj pOther) const
    { return(m_pPointer<=pOther); }
    inline bool operator>=(PObj pOther) const
    { return(m_pPointer>=pOther); }
    inline bool operator<=(const InitializedPointer& InPtr) const
    { return(m_pPointer<=InPtr.m_pPointer); }
    inline bool operator>=(const InitializedPointer& InPtr) const
    { return(m_pPointer>=InPtr.m_pPointer); }

    inline bool operator<(PObj pOther) const
    { return(m_pPointer<pOther); }
    inline bool operator>(PObj pOther) const
    { return(m_pPointer>pOther); }
    inline bool operator<(const InitializedPointer& InPtr) const
    { return(m_pPointer<InPtr.m_pPointer); }
    inline bool operator>(const InitializedPointer& InPtr) const
    { return(m_pPointer>InPtr.m_pPointer); }
};

Statik verilerin 0 olarak başlatıldığını unutmayın (aksi belirtilmedikçe).

Ve evet, değişkenlerinizi her zaman olabildiğince geç ve bir başlangıç ​​değeri ile bildirmelisiniz. Kod gibi

int j;
char *foo;

okuduğunuzda alarm zillerini çalmalısınız. % 100 yasal olduğu için, herhangi bir tüy bırakmanın bu konuda sazan yapmaya ikna edilip edilemeyeceğini bilmiyorum .

Bunun bir başka olası nedeni, bağlantı zamanı işaretçilerine bir adres verilmesidir, ancak bir işaretçiye dolaylı adresleme / referansı kaldırma sorumluluğu programcının sorumluluğundadır. Genellikle, derleyici daha az umursamaz, ancak işaretçileri yönetmek ve bellek sızıntısı olmadığından emin olmak için yük programcıya aktarılır.

Gerçekte, kısaca, bağlantı anında işaretçi değişkenine bir adres verilmesi anlamında başlatılırlar. Yukarıdaki örnek kodunuzda, bunun bir SIGSEGV çökmesi veya oluşturması garantilidir.

Akıl sağlığı uğruna, işaretçileri her zaman NULL olarak başlatın, bu şekilde herhangi bir girişimde bulunmadan başvurmadan kaldırmaya çalışın mallocya newda programcıya programın neden yanlış davrandığına dair ipucu verir.

Umarım bu yardımcı olur ve mantıklıdır,

C ++ işaretçileri başlattıysa, "C ++ C'den daha yavaştır" diyen C milletinin asıl tutacağı gerçek bir şey olurdu;)

C ++, C arka planından gelir ve bundan geri dönen birkaç neden vardır:

C, C ++ 'dan daha fazlası, bir derleme dili değişimidir. Yapmasını söylemediğiniz hiçbir şeyi yapmaz. Bunun için: Eğer BOŞLUK istiyorsanız - yapın!

Ayrıca, C gibi çıplak metal bir dilde şeyleri sıfırlarsanız, tutarlılık soruları otomatik olarak ortaya çıkar: Eğer bir şey malloc ise - otomatik olarak sıfırlanmalı mı? Yığın üzerinde oluşturulan bir yapıya ne dersiniz? tüm baytlar sıfırlanmalı mı? Küresel değişkenler ne olacak? peki ya "(* 0x18);" gibi bir ifade bu, 0x18 bellek konumunun sıfırlanması gerektiği anlamına gelmez mi?

Bahsettiğiniz bu işaretçiler neler?

İstisna güvenliği için, her zaman kullanmak auto_ptr, shared_ptr, weak_ptrve onların diğer varyantları.
İyi kodun ayırt edici özelliği, tek bir çağrı içermeyen koddur delete.

Oh oğlum. Gerçek cevap, örneğin bir işaretçi için temel başlatma olan belleği sıfırlamanın kolay olmasıdır. Ayrıca nesnenin kendisini başlatmakla hiçbir ilgisi yoktur.

Çoğu derleyicinin en yüksek seviyelerde verdiği uyarıları göz önünde bulundurursak, en yüksek seviyede programlamayı ve bunları hata olarak ele almayı hayal edemiyorum. Bunları açmak beni asla büyük miktarda kodda bir hata bile kurtarmadığından bunu tavsiye edemem.