Mengapa pointer tidak diinisialisasi dengan NULL secara default?

Bisakah seseorang menjelaskan mengapa pointer tidak diinisialisasi NULL?
Contoh:

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

Program tidak akan masuk ke dalam jika karena buf bukan null.

Saya ingin tahu mengapa, dalam hal apa kita memerlukan variabel dengan tempat sampah aktif, khususnya penunjuk yang menangani sampah di memori?

Kita semua menyadari bahwa pointer (dan jenis POD lainnya) harus diinisialisasi.
Pertanyaannya kemudian menjadi 'siapa yang harus menginisialisasi mereka'.

Pada dasarnya ada dua metode:

• Kompilator menginisialisasi mereka.
• Pengembang menginisialisasi mereka.

Mari kita asumsikan bahwa kompilator menginisialisasi variabel apa pun yang tidak diinisialisasi secara eksplisit oleh pengembang. Kemudian kami mengalami situasi di mana menginisialisasi variabel tidak sepele dan alasan pengembang tidak melakukannya pada titik deklarasi adalah dia perlu melakukan beberapa operasi dan kemudian menetapkan.

Jadi sekarang kita memiliki situasi dimana kompilator telah menambahkan instruksi tambahan ke kode yang menginisialisasi variabel ke NULL kemudian kode pengembang ditambahkan untuk melakukan inisialisasi yang benar. Atau dalam kondisi lain variabel tersebut berpotensi tidak pernah digunakan. Banyak pengembang C ++ akan menjerit di bawah kedua kondisi dengan mengorbankan instruksi tambahan itu.

Ini bukan hanya tentang waktu. Tapi juga ruang. Ada banyak lingkungan di mana kedua sumber daya memiliki harga premium dan pengembang juga tidak ingin menyerah.

TAPI : Anda dapat mensimulasikan efek dari memaksa inisialisasi. Sebagian besar kompiler akan memperingatkan Anda tentang variabel yang tidak diinisialisasi. Jadi saya selalu mengubah level peringatan saya ke level tertinggi. Kemudian beri tahu kompilator untuk memperlakukan semua peringatan sebagai kesalahan. Dalam kondisi ini, sebagian besar kompiler akan menghasilkan kesalahan untuk variabel yang tidak diinisialisasi tetapi digunakan dan dengan demikian akan mencegah pembuatan kode.

Mengutip Bjarne Stroustrup di TC ++ PL (Edisi Khusus p. 22):

Implementasi fitur tidak boleh membebankan biaya tambahan yang signifikan pada program yang tidak membutuhkannya.

Karena inisialisasi membutuhkan waktu. Dan di C ++, hal pertama yang harus Anda lakukan dengan variabel apa pun adalah menginisialisasinya secara eksplisit:

int * p = & some_int;

atau:

int * p = 0;

atau:

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

Karena salah satu semboyan dari C ++ adalah:

Anda tidak membayar untuk apa yang tidak Anda gunakan

Untuk alasan ini, operator[]dari vectorkelas tidak memeriksa apakah indeks di luar batas, misalnya.

Untuk alasan sejarah, terutama karena ini adalah bagaimana hal itu dilakukan di C. Mengapa dilakukan seperti itu di C, adalah pertanyaan lain, tapi saya pikir prinsip overhead nol terlibat entah bagaimana dalam keputusan desain ini.

Selain itu, kami memiliki peringatan ketika Anda meledakkannya: "mungkin digunakan sebelum diberi nilai" atau verbage serupa tergantung pada kompiler Anda.

Anda melakukan kompilasi dengan peringatan, bukan?

Hanya ada sedikit situasi di mana masuk akal untuk variabel tidak diinisialisasi, dan inisialisasi default memiliki biaya yang kecil, jadi mengapa melakukannya?

C ++ bukan C89. Sial, bahkan C bukanlah C89. Anda dapat mencampur deklarasi dan kode, jadi Anda harus menunda deklarasi sampai Anda memiliki nilai yang sesuai untuk diinisialisasi.

Pointer hanyalah tipe lain. Jika Anda membuat int, charatau jenis POD lainnya, itu tidak diinisialisasi ke nol, jadi mengapa harus ada pointer? Ini bisa dianggap overhead yang tidak perlu bagi seseorang yang menulis program seperti ini.

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

Jika Anda tahu Anda akan memulainya, mengapa program harus mengeluarkan biaya saat Anda pertama kali membuat pBufdi bagian atas metode? Ini adalah prinsip overhead nol.

Jika Anda menginginkan pointer yang selalu diinisialisasi ke NULL, Anda dapat menggunakan template C ++ untuk meniru fungsionalitas itu:

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); }
};

Perhatikan bahwa data statis diinisialisasi ke 0 (kecuali Anda mengatakan sebaliknya).

Dan ya, Anda harus selalu mendeklarasikan variabel Anda selambat mungkin dan dengan nilai awal. Kode seperti

int j;
char *foo;

harus membunyikan bel alarm saat Anda membacanya. Saya tidak tahu apakah ada serat yang dapat dibujuk untuk mempermasalahkannya karena 100% legal.

Alasan lain yang mungkin mengapa, adalah bahwa pada penunjuk waktu tautan diberi alamat, tetapi pengalamatan tidak langsung / de-referensi penunjuk adalah tanggung jawab programmer. Biasanya, compiler tidak peduli, tetapi beban diteruskan ke programmer untuk mengelola pointer dan untuk memastikan tidak ada kebocoran memori yang terjadi.

Sungguh, singkatnya, mereka diinisialisasi dalam arti bahwa pada saat link, variabel pointer diberi alamat. Dalam kode contoh Anda di atas, yang dijamin akan crash atau menghasilkan SIGSEGV.

Demi kewarasan, selalu inisialisasi pointer ke NULL, dengan cara itu jika ada upaya untuk dereferensi tanpa mallocatau new akan memberi petunjuk kepada programmer tentang alasan mengapa program berperilaku salah.

Semoga ini membantu dan masuk akal,

Nah, jika C ++ melakukan inisialisasi pointer, maka orang-orang C yang mengeluh "C ++ lebih lambat dari C" akan memiliki sesuatu yang nyata untuk dipegang;)

C ++ berasal dari latar belakang C - dan ada beberapa alasan yang muncul kembali dari ini:

C, bahkan lebih dari C ++ adalah pengganti bahasa assembly. Ia tidak melakukan apa pun yang tidak Anda perintahkan. Oleh karena itu: Jika Anda ingin membatalkannya - lakukanlah!

Juga, jika Anda membatalkan sesuatu dalam bahasa bare-metal seperti C secara otomatis pertanyaan konsistensi muncul: Jika Anda malloc sesuatu - haruskah itu secara otomatis menjadi nol? Bagaimana dengan struct yang dibuat di stack? haruskah semua byte menjadi nol? Bagaimana dengan variabel global? bagaimana dengan pernyataan seperti "(* 0x18);" bukankah itu berarti bahwa posisi memori 0x18 harus menjadi nol?

Apa petunjuk yang Anda bicarakan ini?

Untuk keamanan pengecualian, selalu menggunakan auto_ptr, shared_ptr, weak_ptrdan varian mereka yang lain.
Ciri khas kode yang baik adalah yang tidak menyertakan satu panggilan pun delete.

Oh Boy. Jawaban sebenarnya adalah mudah untuk menghilangkan memori, yang merupakan inisialisasi dasar untuk, katakanlah sebuah pointer. Yang juga tidak ada hubungannya dengan menginisialisasi objek itu sendiri.

Mempertimbangkan peringatan yang diberikan sebagian besar kompiler pada level tertinggi, saya tidak dapat membayangkan pemrograman pada level tertinggi dan memperlakukannya sebagai kesalahan. Sejak menyalakannya tidak pernah menyelamatkan saya bahkan satu bug dalam jumlah besar kode yang dihasilkan, saya tidak dapat merekomendasikan ini.