Bây giờ chúng ta có C ++ 11 với nhiều tính năng mới. Một điều thú vị và khó hiểu (ít nhất là đối với tôi) là cái mới nullptr.

Vâng, không cần nữa cho macro khó chịu NULL.

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

Tuy nhiên, tôi không nhận được làm thế nào nullptrhoạt động. Ví dụ, bài viết Wikipedia nói:

C ++ 11 sửa lỗi này bằng cách giới thiệu một từ khóa mới để phục vụ như một hằng con trỏ null phân biệt: nullptr. Nó thuộc loại nullptr_t , có thể chuyển đổi hoàn toàn và có thể so sánh với bất kỳ loại con trỏ hoặc loại con trỏ thành thành viên. Nó không hoàn toàn có thể chuyển đổi hoặc so sánh với các loại tích phân, ngoại trừ bool.

Làm thế nào nó là một từ khóa và một thể hiện của một loại?

Ngoài ra, bạn có một ví dụ khác (bên cạnh Wikipedia không) ở đâu nullptrtốt hơn cũ 0?

Làm thế nào nó là một từ khóa và một thể hiện của một loại?

Điều này không đáng ngạc nhiên. Cả hai truevà falselà từ khóa và dưới dạng chữ, chúng có một loại ( bool). nullptrlà một con trỏ nghĩa đen của loại std::nullptr_tvà nó là một giá trị (bạn không thể lấy địa chỉ của nó bằng cách sử dụng &).

• 4.10về chuyển đổi con trỏ nói rằng một giá trị loại std::nullptr_tlà hằng số con trỏ null và hằng số con trỏ null tích hợp có thể được chuyển đổi thành std::nullptr_t. Hướng ngược lại không được phép. Điều này cho phép nạp chồng một hàm cho cả con trỏ và số nguyên và chuyển qua nullptrđể chọn phiên bản con trỏ. Vượt qua NULLhoặc 0sẽ nhầm lẫn chọn intphiên bản.

• Việc truyền nullptr_tvào một kiểu tích phân cần a reinterpret_castvà có cùng ngữ nghĩa với một (void*)0kiểu kết hợp thành một kiểu tích phân (thực hiện ánh xạ được xác định). A reinterpret_castkhông thể chuyển đổi nullptr_tthành bất kỳ loại con trỏ. Dựa vào chuyển đổi ngầm nếu có thể hoặc sử dụng static_cast.

• Tiêu chuẩn yêu cầu đó sizeof(nullptr_t)là sizeof(void*).

Từ nullptr: Con trỏ Null loại an toàn và rõ ràng :

Từ khóa nullptr C ++ 09 mới chỉ định một hằng số giá trị đóng vai trò là một con trỏ null phổ quát theo nghĩa đen, thay thế cho lỗi 0 và gõ chữ yếu và macro NULL khét tiếng. nullptr do đó chấm dứt hơn 30 năm bối rối, mơ hồ và lỗi. Các phần sau đây trình bày cơ sở nullptr và chỉ ra cách nó có thể khắc phục các bệnh của NULL và 0.

Tài liệu tham khảo khác:

• WikiBooks , với mã mẫu.
• Ở đây tại Stack Overflow: Bạn có sử dụng NULL hoặc 0 (zero) cho con trỏ trong C ++ không?
• template
• Nhóm Google: comp.lang.c ++. Được kiểm duyệt - thảo luận về trình biên dịch

Tại sao nullptr trong C ++ 11? Nó là gì? Tại sao NULL không đủ?

Chuyên gia C ++ Alex Allain nói rằng nó hoàn hảo ở đây (nhấn mạnh của tôi được in đậm):

... hãy tưởng tượng bạn có hai khai báo hàm sau:

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

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

Mặc dù có vẻ như hàm thứ hai sẽ được gọi - sau tất cả, bạn chuyển qua cái dường như là một con trỏ - đó thực sự là hàm đầu tiên sẽ được gọi! Vấn đề là vì NULL bằng 0 và 0 là số nguyên, nên phiên bản đầu tiên của func sẽ được gọi thay thế. Đây là loại điều mà, vâng, không phải lúc nào cũng xảy ra, nhưng khi nó xảy ra, thì cực kỳ bực bội và khó hiểu. Nếu bạn không biết chi tiết về những gì đang xảy ra, nó có thể trông giống như một lỗi trình biên dịch. Một tính năng ngôn ngữ trông giống như một lỗi trình biên dịch, tốt, không phải là thứ bạn muốn.

Nhập nullptr. Trong C ++ 11, nullptr là một từ khóa mới có thể (và nên!) Được sử dụng để thể hiện các con trỏ NULL; nói cách khác, bất cứ nơi nào bạn viết NULL trước đây, bạn nên sử dụng nullptr thay thế. Điều đó không rõ ràng hơn đối với bạn, lập trình viên , (mọi người đều biết NULL nghĩa là gì), nhưng nó rõ ràng hơn với trình biên dịch , sẽ không còn thấy số 0 ở mọi nơi được sử dụng có ý nghĩa đặc biệt khi được sử dụng như một con trỏ.

Allain kết thúc bài viết của mình bằng:

Bất kể tất cả điều này - quy tắc của C ++ 11 chỉ đơn giản là bắt đầu sử dụng nullptrbất cứ khi nào bạn có thể sử dụng NULLtrong quá khứ.

(Lời của tôi):

Cuối cùng, đừng quên đó nullptrlà một đối tượng - một lớp. Nó có thể được sử dụng ở bất cứ đâu NULLđã được sử dụng trước đây, nhưng nếu bạn cần loại của nó vì một số lý do, loại này có thể được trích xuất với decltype(nullptr), hoặc được mô tả trực tiếp như std::nullptr_t, chỉ đơn giản là một typedeftrongdecltype(nullptr) .

Người giới thiệu:

1. Cprogramming.com: Các loại tốt hơn trong C ++ 11 - nullptr, các lớp enum (liệt kê được gõ mạnh) và cstdint
2. https://en.cppreference.com/w/cpp/lingu/decltype
3. https://en.cppreference.com/w/cpp/types/nullptr_t

Khi bạn có một chức năng có thể nhận con trỏ tới nhiều loại, việc gọi nó bằng NULLkhông rõ ràng. Cách thức này được thực hiện xung quanh bây giờ là rất khó khăn bằng cách chấp nhận một int và giả định nó 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); }
};

Trong C++11bạn sẽ có thể quá tải nullptr_tvì vậy đó ptr<T> p(42);sẽ là một lỗi thời gian biên dịch thay vì thời gian chạy assert.

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

nullptrkhông thể được gán cho một loại tích phân, chẳng hạn như intnhưng chỉ một loại con trỏ; hoặc một loại con trỏ tích hợp như int *ptrhoặc một con trỏ thông minh nhưstd::shared_ptr<T>

Tôi tin rằng đây là một sự khác biệt quan trọng vì NULLvẫn có thể được gán cho cả loại tích phân và con trỏ dưới dạng NULLmacro được mở rộng để 0có thể đóng vai trò là giá trị ban đầu cho intcả con trỏ cũng như con trỏ.

Ngoài ra, bạn có một ví dụ khác (bên cạnh Wikipedia) ở đâu nullptrtốt hơn 0 cũ không?

Đúng. Đó cũng là một ví dụ trong thế giới thực (đơn giản hóa) xảy ra trong mã sản xuất của chúng tôi. Nó chỉ nổi bật vì gcc có thể đưa ra cảnh báo khi biên dịch chéo sang nền tảng có độ rộng đăng ký khác nhau (vẫn không chắc chắn chính xác tại sao chỉ khi biên dịch chéo từ x86_64 đến x86, cảnh báowarning: converting to non-pointer type 'int' from NULL ):

Hãy xem xét mã này (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;
}

Nó mang lại sản lượng này:

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

Vâng, các ngôn ngữ khác có các từ dành riêng là trường hợp của các loại. Python, ví dụ:

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

Đây thực sự là một so sánh khá gần bởi vì Nonethường được sử dụng cho một cái gì đó chưa được xác định, nhưng đồng thời so sánh nhưNone == 0 là sai.

Mặt khác, ở đồng bằng C, NULL == 0sẽ trả về IIRC thực vì NULLchỉ là macro trả về 0, luôn là địa chỉ không hợp lệ (AFAIK).

Nó là một từ khóa vì tiêu chuẩn sẽ chỉ định nó như vậy. ;-) Theo dự thảo công khai mới nhất (n2914)

2.14.7 Con trỏ bằng chữ [lex.nullptr]

pointer-literal:
nullptr

Các con trỏ bằng chữ là từ khóa nullptr. Nó là một giá trị của loại std::nullptr_t.

Nó hữu ích vì nó không hoàn toàn chuyển đổi thành một giá trị tích phân.

Giả sử bạn có một hàm (f) bị quá tải để lấy cả int và char *. Trước C ++ 11, nếu bạn muốn gọi nó bằng một con trỏ null và bạn đã sử dụng NULL (tức là giá trị 0), thì bạn sẽ gọi một số bị quá tải cho int:

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

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

Đây có lẽ không phải là những gì bạn muốn. C ++ 11 giải quyết điều này với nullptr; Bây giờ bạn có thể viết như sau:

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

Hãy để tôi đầu tiên cung cấp cho bạn một thực hiện không tinh vi 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;

nullptrlà một ví dụ tinh tế của thành ngữ Resolver Kiểu trả về để tự động suy ra một con trỏ null của loại đúng tùy thuộc vào loại của thể hiện mà nó được gán.

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

• Như bạn có thể ở trên, khi nullptrđược gán cho một con trỏ nguyên, mộtint kiểu khởi tạo của hàm chuyển đổi templatized được tạo. Và con trỏ phương thức cũng vậy.
• Bằng cách này bằng cách tận dụng chức năng mẫu, chúng tôi thực sự đang tạo ra loại con trỏ null thích hợp mỗi khi chúng tôi thực hiện, một phép gán kiểu mới.
• Là nullptrmột số nguyên có giá trị bằng 0, bạn không thể sử dụng địa chỉ mà chúng tôi đã thực hiện bằng cách xóa & toán tử.

Tại sao chúng ta cần nullptrở nơi đầu tiên?

• Bạn thấy truyền thống NULLcó một số vấn đề với nó như dưới đây:

1️⃣ Chuyển đổi ngầm định

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

2️⃣ Chức năng gọi mơ hồ

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

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

• Quá trình biên dịch tạo ra các lỗi sau:

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️⃣ Quá tải xây dựng

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

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

• Trong những trường hợp như vậy, bạn cần diễn viên rõ ràng (nghĩa là  String s((char*)0)).

0 từng là giá trị số nguyên duy nhất có thể được sử dụng làm công cụ khởi tạo không có cast cho con trỏ: bạn không thể khởi tạo con trỏ với các giá trị nguyên khác mà không cần cast. Bạn có thể coi 0 là một đơn vị consexpr về mặt cú pháp tương tự như một số nguyên. Nó có thể khởi tạo bất kỳ con trỏ hoặc số nguyên. Nhưng đáng ngạc nhiên, bạn sẽ thấy rằng nó không có loại khác biệt: nó là một int. Vậy làm thế nào đến 0 có thể khởi tạo con trỏ và 1 không thể? Một câu trả lời thực tế là chúng ta cần một phương tiện xác định giá trị null của con trỏ và chuyển đổi ngầm định trực tiếp intthành một con trỏ dễ bị lỗi. Do đó, 0 trở thành một con quái vật kỳ dị thực sự ra khỏi thời kỳ tiền sử. nullptrđã được đề xuất để trở thành một đại diện constexpr singleton thực sự của giá trị null để khởi tạo con trỏ. Nó không thể được sử dụng để trực tiếp khởi tạo các số nguyên và loại bỏ sự mơ hồ liên quan đến việc xác định NULLtheo 0. nullptrcó thể được định nghĩa là một thư viện sử dụng cú pháp std nhưng về mặt ngữ nghĩa là một thành phần cốt lõi bị thiếu. NULLbây giờ không được ủng hộ nullptr, trừ khi một số thư viện quyết định định nghĩa nó là nullptr.

Đây là tiêu đề 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

(một thỏa thuận tuyệt vời có thể được phát hiện nhanh chóng grep -r /usr/include/*`)

Một điều nhảy ra là *quá tải toán tử (trả về 0 thân thiện hơn nhiều so với segfaulting ...). Một điều nữa là nó không giống phù hợp với lưu trữ một địa chỉ nào cả . Điều này, so với cách nó đi trượt khoảng trống * và chuyển kết quả NULL cho các con trỏ bình thường như các giá trị canh gác, rõ ràng sẽ làm giảm yếu tố "không bao giờ quên, nó có thể là một quả bom".

NULL không cần phải bằng 0. Miễn là bạn luôn sử dụng NULL và không bao giờ 0, NULL có thể là bất kỳ giá trị nào. Khi bạn lập trình một Vi điều khiển von Neuman với bộ nhớ phẳng, có vektor ngắt của nó ở mức 0. Nếu NULL bằng 0 và một cái gì đó ghi vào Con trỏ NULL thì Vi điều khiển gặp sự cố. Nếu NULL cho phép 1024 và tại 1024 có một biến dành riêng, thì ghi sẽ không bị lỗi và bạn có thể phát hiện các bài tập Con trỏ NULL từ bên trong chương trình. Điều này là vô nghĩa trên PC, nhưng đối với tàu thăm dò không gian, thiết bị quân sự hoặc y tế, điều quan trọng là không bị rơi.