Kami sekarang memiliki C ++ 11 dengan banyak fitur baru. Yang menarik dan membingungkan (setidaknya bagi saya) adalah yang baru nullptr.

Yah, tidak perlu lagi untuk makro jahat NULL.

int* x = nullptr;
myclass* obj = nullptr;

Tetap saja, saya tidak mengerti cara nullptrkerjanya. Sebagai contoh, artikel Wikipedia mengatakan:

C ++ 11 memperbaiki ini dengan memperkenalkan kata kunci baru untuk dijadikan sebagai konstanta penunjuk nol yang dibedakan: nullptr. Ini adalah tipe nullptr_t , yang secara implisit dapat dikonversi dan sebanding dengan tipe penunjuk atau tipe penunjuk-ke-anggota. Ini tidak secara implisit dapat dikonversi atau sebanding dengan tipe integral, kecuali untuk bool.

Bagaimana kata kunci dan turunan tipe?

Juga, apakah Anda memiliki contoh lain (di samping Wikipedia) di mana nullptrlebih baik dari yang lama 0?

Bagaimana kata kunci dan turunan tipe?

Ini tidak mengejutkan. Kedua truedan falseadalah kata kunci dan sebagai literal mereka memiliki tipe ( bool). nullptradalah pointer tipe literalstd::nullptr_t , dan ini merupakan nilai awal (Anda tidak dapat menggunakan alamatnya &).

• 4.10tentang konversi penunjuk mengatakan bahwa nilai jenis std::nullptr_tadalah konstanta penunjuk nol, dan konstanta penunjuk nol integral dapat dikonversi menjadi std::nullptr_t. Arah sebaliknya tidak diizinkan. Ini memungkinkan overloading fungsi untuk pointer dan integer, dan meneruskan nullptruntuk memilih versi pointer. Lulus NULLatau 0akan bingung memilih intversi.

• Sebuah gips nullptr_tuntuk tipe integral membutuhkan a reinterpret_cast, dan memiliki semantik yang sama dengan gips (void*)0untuk tipe integral (implementasi pemetaan didefinisikan). A reinterpret_casttidak dapat dikonversi nullptr_tke tipe pointer apa pun. Andalkan konversi implisit jika memungkinkan atau gunakan static_cast.

• Standar mengharuskan sizeof(nullptr_t)be sizeof(void*).

Dari nullptr: Tipe-aman dan Clear-Cut Null Pointer :

Kata kunci nullptr C ++ 09 nullptr yang baru menetapkan konstanta nilai ulang yang berfungsi sebagai universal null pointer literal, menggantikan buggy dan literal 0 yang diketik dengan lemah dan makro NULL yang terkenal. nullptr dengan demikian mengakhiri lebih dari 30 tahun rasa malu, ambiguitas, dan bug. Bagian berikut ini menyajikan fasilitas nullptr dan menunjukkan bagaimana ia dapat memperbaiki penyakit NULL dan 0.

Referensi lain:

• WikiBooks , dengan kode sampel.
• Di sini, di Stack Overflow: Apakah Anda menggunakan NULL atau 0 (nol) untuk pointer di C ++?
• template
• Grup Google: comp.lang.c ++. Dimoderatori - diskusi kompiler

Mengapa nullptr di C ++ 11? Apa itu? Mengapa NULL tidak cukup?

Pakar C ++ Alex Allain mengatakannya dengan sempurna di sini (penekanan saya ditambahkan dengan huruf tebal):

... bayangkan Anda memiliki dua deklarasi fungsi berikut:

void func(int n); 
void func(char *s);

func( NULL ); // guess which function gets called?

Meskipun sepertinya fungsi kedua akan dipanggil - Anda, setelah semua, melewati apa yang tampaknya menjadi pointer - itu benar-benar fungsi pertama yang akan dipanggil! Masalahnya adalah bahwa karena NULL adalah 0, dan 0 adalah bilangan bulat, versi pertama dari func akan dipanggil sebagai gantinya. Ini adalah jenis hal yang, ya, tidak terjadi setiap saat, tetapi ketika itu terjadi, sangat membuat frustrasi dan membingungkan. Jika Anda tidak tahu detail apa yang sedang terjadi, itu mungkin terlihat seperti bug kompiler. Fitur bahasa yang kelihatannya seperti bug penyusun, bukan sesuatu yang Anda inginkan.

Masukkan nullptr. Dalam C ++ 11, nullptr adalah kata kunci baru yang dapat (dan seharusnya!) Digunakan untuk mewakili pointer NULL; dengan kata lain, di mana pun Anda menulis NULL sebelumnya, Anda harus menggunakan nullptr. Tidak lagi jelas bagi Anda, programmer , (semua orang tahu apa arti NULL), tetapi lebih eksplisit untuk kompiler , yang tidak akan lagi melihat 0s di mana-mana digunakan untuk memiliki makna khusus ketika digunakan sebagai pointer.

Allain mengakhiri artikelnya dengan:

Terlepas dari semua ini - aturan praktis untuk C ++ 11 adalah untuk mulai menggunakan nullptrkapan saja Anda akan menggunakan NULLsebelumnya.

(Kata-kataku):

Terakhir, jangan lupa bahwa itu nullptradalah objek - kelas. Itu dapat digunakan di mana saja NULLdigunakan sebelumnya, tetapi jika Anda memerlukan jenisnya untuk beberapa alasan, jenisnya dapat diekstraksi dengan decltype(nullptr), atau langsung digambarkan sebagai std::nullptr_t, yang hanya merupakan typedefdari decltype(nullptr).

Referensi:

1. Cprogramming.com: Jenis yang lebih baik di C ++ 11 - nullptr, kelas enum (enumerasi yang sangat diketik) dan cstdint
2. https://en.cppreference.com/w/cpp/language/decltype
3. https://en.cppreference.com/w/cpp/types/nullptr_t

Ketika Anda memiliki fungsi yang dapat menerima pointer ke lebih dari satu jenis, memanggilnya dengan NULLambigu. Cara ini dikerjakan sekarang sangat berantakan dengan menerima int dan menganggapnya NULL.

template <class T>
class ptr {
    T* p_;
    public:
        ptr(T* p) : p_(p) {}

        template <class U>
        ptr(U* u) : p_(dynamic_cast<T*>(u)) { }

        // Without this ptr<T> p(NULL) would be ambiguous
        ptr(int null) : p_(NULL)  { assert(null == NULL); }
};

Di dalam C++11Anda akan dapat kelebihan pada nullptr_tsehingga ptr<T> p(42);akan menjadi kesalahan waktu kompilasi daripada run-time assert.

ptr(std::nullptr_t) : p_(nullptr)  {  }

nullptrtidak dapat ditugaskan ke tipe integral seperti inttetapi hanya tipe pointer; baik tipe built-in pointer seperti int *ptratau smart pointer sepertistd::shared_ptr<T>

Saya percaya ini adalah perbedaan penting karena NULLmasih dapat ditugaskan untuk kedua tipe integral dan pointer sebagaimana NULLmakro diperluas 0yang dapat berfungsi sebagai nilai awal untuk intserta pointer.

Juga, apakah Anda memiliki contoh lain (di samping Wikipedia) di mana nullptrlebih baik dari 0 tua?

Iya. Ini juga contoh dunia nyata (disederhanakan) yang terjadi dalam kode produksi kami. Itu hanya menonjol karena gcc mampu mengeluarkan peringatan ketika crosscompiling ke platform dengan lebar register yang berbeda (masih tidak yakin persis mengapa hanya ketika crosscompiling dari x86_64 ke x86, ingatkan warning: converting to non-pointer type 'int' from NULL):

Pertimbangkan kode ini (C ++ 03):

#include <iostream>

struct B {};

struct A
{
    operator B*() {return 0;}
    operator bool() {return true;}
};

int main()
{
    A a;
    B* pb = 0;
    typedef void* null_ptr_t;
    null_ptr_t null = 0;

    std::cout << "(a == pb): " << (a == pb) << std::endl;
    std::cout << "(a == 0): " << (a == 0) << std::endl; // no warning
    std::cout << "(a == NULL): " << (a == NULL) << std::endl; // warns sometimes
    std::cout << "(a == null): " << (a == null) << std::endl;
}

Ini menghasilkan output ini:

(a == pb): 1
(a == 0): 0
(a == NULL): 0
(a == null): 1

Nah, bahasa lain telah memesan kata-kata yang merupakan contoh jenis. Python, misalnya:

>>> None = 5
  File "<stdin>", line 1
SyntaxError: assignment to None
>>> type(None)
<type 'NoneType'>

Ini sebenarnya perbandingan yang cukup dekat karena Nonebiasanya digunakan untuk sesuatu yang belum diinternisasi, tetapi pada saat yang sama perbandingan seperti None == 0itu salah.

Di sisi lain, di dataran C, NULL == 0akan mengembalikan true IIRC karena NULLhanya makro mengembalikan 0, yang selalu merupakan alamat tidak valid (AFAIK).

Itu adalah kata kunci karena standar akan menentukannya seperti itu. ;-) Menurut konsep publik terbaru (n2914)

2.14.7 Pointer literals [lex.nullptr]

pointer-literal:
nullptr

Pointer literal adalah kata kunci nullptr. Ini adalah nilai jenis std::nullptr_t.

Ini berguna karena tidak secara implisit dikonversi ke nilai integral.

Katakanlah Anda memiliki fungsi (f) yang kelebihan beban untuk mengambil int dan char *. Sebelum C ++ 11, Jika Anda ingin menyebutnya dengan pointer nol, dan Anda menggunakan NULL (yaitu nilai 0), maka Anda akan memanggil yang kelebihan beban untuk int:

void f(int);
void f(char*);

void g() 
{
  f(0); // Calls f(int).
  f(NULL); // Equals to f(0). Calls f(int).
}

Ini mungkin bukan yang Anda inginkan. C ++ 11 memecahkan ini dengan nullptr; Sekarang Anda dapat menulis yang berikut ini:

void g()
{
  f(nullptr); //calls f(char*)
}

Biarkan saya memberi Anda implementasi tidak canggih nullptr_t

struct nullptr_t 
{
    void operator&() const = delete;  // Can't take address of nullptr

    template<class T>
    inline operator T*() const { return 0; }

    template<class C, class T>
    inline operator T C::*() const { return 0; }
};

nullptr_t nullptr;

nullptradalah contoh halus dari idiom Return Type Resolver untuk secara otomatis menyimpulkan pointer nol dari tipe yang benar tergantung pada jenis instance yang ditugaskan kepadanya.

int *ptr = nullptr;                // OK
void (C::*method_ptr)() = nullptr; // OK

• Seperti yang Anda bisa di atas, ketika nullptrsedang ditugaskan ke pointer integer, intjenis instantiation dari fungsi konversi templatized dibuat. Dan hal yang sama juga berlaku untuk pointer metode.
• Dengan cara ini dengan memanfaatkan fungsionalitas templat, kami sebenarnya membuat jenis pointer nol yang tepat setiap kali kami melakukannya, penetapan jenis baru.
• Seperti nullptrbilangan bulat integer dengan nilai nol, Anda tidak dapat menggunakan alamatnya yang kami capai dengan menghapus & operator.

Mengapa kita perlu nullptrdi tempat pertama?

• Anda melihat tradisional NULLmemiliki beberapa masalah dengan itu seperti di bawah ini:

1️⃣ Konversi tersirat

char *str = NULL; // Implicit conversion from void * to char *
int i = NULL;     // OK, but `i` is not pointer type

2️⃣ Fungsi memanggil ambiguitas

void func(int) {}
void func(int*){}
void func(bool){}

func(NULL);     // Which one to call?

• Kompilasi menghasilkan kesalahan berikut:

error: call to 'func' is ambiguous
    func(NULL);
    ^~~~
note: candidate function void func(bool){}
                              ^
note: candidate function void func(int*){}
                              ^
note: candidate function void func(int){}
                              ^
1 error generated.
compiler exit status 1

3️⃣ Konstruktor kelebihan beban

struct String
{
    String(uint32_t)    {   /* size of string */    }
    String(const char*) {       /* string */        }
};

String s1( NULL );
String s2( 5 );

• Dalam kasus seperti itu, Anda perlu pemeran eksplisit (mis  String s((char*)0)).

0 digunakan sebagai satu-satunya nilai integer yang dapat digunakan sebagai inisialisasi bebas-cor untuk pointer: Anda tidak dapat menginisialisasi pointer dengan nilai integer lain tanpa gips. Anda dapat menganggap 0 sebagai singleton consexpr secara sintaksis mirip dengan integer literal. Itu dapat memulai setiap pointer atau integer. Tetapi yang mengejutkan, Anda akan menemukan bahwa itu tidak memiliki tipe yang berbeda: itu adalah int. Jadi, mengapa 0 dapat menginisialisasi pointer dan 1 tidak bisa? Jawaban praktisnya adalah kita perlu sarana untuk mendefinisikan nilai null pointer dan konversi implisit langsung intke pointer rentan kesalahan. Jadi 0 menjadi makhluk aneh aneh yang aneh dari era prasejarah. nullptrdiusulkan menjadi representasi constexpr tunggal nyata dari nilai nol untuk menginisialisasi pointer. Itu tidak dapat digunakan untuk secara langsung menginisialisasi bilangan bulat dan menghilangkan ambiguitas yang terlibat dengan mendefinisikan NULLdalam hal 0. nullptrdapat didefinisikan sebagai perpustakaan menggunakan sintaks std tetapi secara semantik tampak menjadi komponen inti yang hilang. NULLsekarang tidak digunakan lagi nullptr, kecuali beberapa perpustakaan memutuskan untuk mendefinisikannya sebagai nullptr.

Inilah tajuk LLVM.

// -*- C++ -*-
//===--------------------------- __nullptr --------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_NULLPTR
#define _LIBCPP_NULLPTR

#include <__config>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

#ifdef _LIBCPP_HAS_NO_NULLPTR

_LIBCPP_BEGIN_NAMESPACE_STD

struct _LIBCPP_TEMPLATE_VIS nullptr_t
{
    void* __lx;

    struct __nat {int __for_bool_;};

    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t() : __lx(0) {}
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t(int __nat::*) : __lx(0) {}

    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator int __nat::*() const {return 0;}

    template <class _Tp>
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
        operator _Tp* () const {return 0;}

    template <class _Tp, class _Up>
        _LIBCPP_INLINE_VISIBILITY
        operator _Tp _Up::* () const {return 0;}

    friend _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool operator==(nullptr_t, nullptr_t) {return true;}
    friend _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool operator!=(nullptr_t, nullptr_t) {return false;}
};

inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t __get_nullptr_t() {return nullptr_t(0);}

#define nullptr _VSTD::__get_nullptr_t()

_LIBCPP_END_NAMESPACE_STD

#else  // _LIBCPP_HAS_NO_NULLPTR

namespace std
{
    typedef decltype(nullptr) nullptr_t;
}

#endif  // _LIBCPP_HAS_NO_NULLPTR

#endif  // _LIBCPP_NULLPTR

(Banyak yang bisa diungkap dengan cepat grep -r /usr/include/*`)

Satu hal yang melompat keluar adalah *kelebihan operator (mengembalikan 0 jauh lebih ramah daripada segfaulting ...). Hal lain adalah tidak terlihat kompatibel dengan menyimpan alamat sama sekali . Yang, dibandingkan dengan bagaimana cara slinging void * dan memberikan hasil NULL ke pointer normal sebagai nilai sentinel, jelas akan mengurangi faktor "jangan lupa, itu mungkin bom".

NULL tidak perlu 0. Selama Anda menggunakan selalu NULL dan tidak pernah 0, NULL dapat berupa nilai apa pun. Dengan asumsi Anda memprogram Mikrokontroler von Neuman dengan memori datar, yang memiliki vektor interruptnya pada 0. Jika NULL adalah 0 dan sesuatu menulis pada NULL Pointer maka Mikrokontroler mogok. Jika NULL misalkan 1024 dan pada 1024 ada variabel yang dilindungi undang-undang, maka penulisan tidak akan merusaknya, dan Anda dapat mendeteksi penetapan NULL Pointer dari dalam program. Ini tidak ada gunanya pada PC, tetapi untuk pesawat ruang angkasa, peralatan militer atau medis, penting untuk tidak menabrak.