Làm thế nào để thực hiện c ++ nullptr hoạt động?

Tôi tò mò muốn biết làm thế nào nullptrhoạt động. Tiêu chuẩn N4659 và N4849 nói:

1. nó phải có loại std::nullptr_t;
2. bạn không thể lấy địa chỉ của nó;
3. nó có thể được chuyển đổi trực tiếp thành một con trỏ và con trỏ thành thành viên;
4. sizeof(std::nullptr_t) == sizeof(void*);
5. chuyển đổi sang boollà false;
6. giá trị của nó có thể được chuyển đổi thành loại tích phân giống hệt (void*)0, nhưng không ngược lại;

Vì vậy, về cơ bản nó là một hằng số có cùng ý nghĩa (void*)0, nhưng nó có một loại khác. Tôi đã tìm thấy việc thực hiện std::nullptr_ttrên thiết bị của mình và nó như sau.

#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

Tôi quan tâm nhiều hơn trong phần đầu tiên mặc dù. Nó dường như thỏa mãn các điểm 1-5, nhưng tôi không biết tại sao nó lại có một lớp con __nat và mọi thứ liên quan đến nó. Tôi cũng muốn biết lý do tại sao nó thất bại trên các chuyển đổi tích hợp.

struct nullptr_t2{
    void* __lx;
    struct __nat {int __for_bool_;};
     constexpr nullptr_t2() : __lx(0) {}
     constexpr nullptr_t2(int __nat::*) : __lx(0) {}
     constexpr operator int __nat::*() const {return 0;}
    template <class _Tp>
         constexpr
        operator _Tp* () const {return 0;}
    template <class _Tp, class _Up>
        operator _Tp _Up::* () const {return 0;}
    friend  constexpr bool operator==(nullptr_t2, nullptr_t2) {return true;}
    friend  constexpr bool operator!=(nullptr_t2, nullptr_t2) {return false;}
};
inline constexpr nullptr_t2 __get_nullptr_t2() {return nullptr_t2(0);}
#define nullptr2 __get_nullptr_t2()

int main(){
    long l  = reinterpret_cast<long>(nullptr);
    long l2 = reinterpret_cast<long>(nullptr2); // error: invalid type conversion
    bool b  = nullptr; // warning: implicit conversion
                       // edditor error: a value of type "std::nullptr_t" cannot be used to initialize an entity of type "bool"
    bool b2 = nullptr2;
    if (nullptr){}; // warning: implicit conversion
    if (nullptr2){};
};

Tôi tò mò muốn biết nullptr hoạt động như thế nào.

Nó hoạt động theo cách đơn giản nhất có thể: bởi fiat . Nó hoạt động vì tiêu chuẩn C ++ nói rằng nó hoạt động và nó hoạt động theo cách đó bởi vì tiêu chuẩn C ++ nói rằng việc triển khai phải làm cho nó hoạt động theo kiểu đó.

Điều quan trọng là phải nhận ra rằng không thể thực hiện std::nullptr_tbằng cách sử dụng các quy tắc của ngôn ngữ C ++. Chuyển đổi từ hằng số con trỏ null thành loại std::nullptr_tcon trỏ không phải là chuyển đổi do người dùng xác định. Điều đó có nghĩa là bạn có thể chuyển từ hằng số con trỏ null sang con trỏ, sau đó thông qua chuyển đổi do người dùng xác định sang một loại khác, tất cả trong một chuỗi chuyển đổi ngầm định.

Điều đó là không thể nếu bạn thực hiện nullptr_tnhư một lớp học. Toán tử chuyển đổi biểu thị các chuyển đổi do người dùng xác định và các quy tắc trình tự chuyển đổi ngầm định của C ++ không cho phép nhiều hơn một chuyển đổi do người dùng xác định trong chuỗi đó.

Vì vậy, mã bạn đã đăng là một xấp xỉ tốt đẹp std::nullptr_t, nhưng nó không có gì hơn thế. Nó không phải là một thực hiện hợp pháp của các loại. Đây có lẽ là từ một phiên bản cũ hơn của trình biên dịch (còn lại vì lý do tương thích ngược) trước khi trình biên dịch cung cấp hỗ trợ thích hợp cho std::nullptr_t. Bạn có thể thấy điều này bởi thực tế là nó #defines nullptr, trong khi C ++ 11 nói rằng nullptrlà một từ khóa , không phải là một vĩ mô.

C ++ không thể thực hiện std::nullptr_t, giống như C ++ không thể thực hiện inthoặc void*. Chỉ có việc thực hiện có thể thực hiện những điều đó. Đây là những gì làm cho nó một "loại cơ bản"; đó là một phần của ngôn ngữ .

giá trị của nó có thể được chuyển đổi thành loại tích phân giống hệt (void *) 0, nhưng không ngược lại;

Không có chuyển đổi ngầm định từ hằng con trỏ null sang các kiểu tích phân. Có một chuyển đổi từ 0một loại tích phân, nhưng đó là bởi vì đó là số nguyên bằng không, đó là ... một số nguyên.

nullptr_tcó thể được đúc để một kiểu số nguyên (thông qua reinterpret_cast), nhưng nó chỉ có thể được ngầm chuyển đổi sang con trỏ và bool.