为什么我可以将 0 转换为 std::shared_ptr<T> 但不是1？

Question

#include <memory>

void f1(std::shared_ptr<bool> ptr) {}

int main() {
    f1(0); // OK
    f1(1); // compilation error: could not convert ‘1’ from ‘int’ to ‘std::shared_ptr<bool>’
}

Both as int , why 0 but 1 can be converted to std::shared_ptr<T> ?

How the disability of conversion from 1 to std::shared_ptr<T> be checked when compiling?

How the disability of conversion from 1 to std::nullptr_t be checked when compiling?

Answer 1

0 is a special value in C/C++. Many things work with 0 but not with 1 . The reason(s) for that are the conversion rules of the language.

f1(0); // OK

That's ok because of the following conversions.

0  -> nullptr
nullptr -> std::shared_ptr<bool> // Through a constructor

However,

f1(1);

is not ok since there is no conversion available to convert 1 to a shared_ptr<bool> .

Answer 2

std::shared_ptr<T> has a constructor taking a std::nullptr_t , for which there exist an implicit conversion from any valid null pointer constant, which includes a plain 0 literal. On the other hand, 1 is not a valid argument for any shared_ptr constructor.

Answer 3

In addition to other answers, one workaround would be to use thestd::make_shared macro instead:

f1(std::make_shared<bool>(0)); // OK
f1(std::make_shared<bool>(1)); // OK

This way you will be able to supply any integer literal to the function. Simple working example:

#include <iostream>
#include <memory>

void f1(std::shared_ptr<bool> ptr) {
    std::cout << std::boolalpha << *ptr << '\n';    
}

int main() {
    f1(std::make_shared<bool>(0)); // OK
    f1(std::make_shared<bool>(1)); // OK
    f1(std::make_shared<bool>(2)); // OK
}

Answer 4

Some notes:

• Integral literals of zero value, such as 0 , 0LL , 0x0 etc, are null pointer constants .

• nullptr is also a null pointer constant .

• Non-literals, such as +0 , -0 , int{0} , (void*)0 , etc, are NOT null pointer constants .

• Null pointer constants are implicit convertible to any pointer type and nullptr_t .

Integral null pointer constants have been introducing problems since they are defined.

For example,

void foo(const string&);
foo(0);

compiles and calls the constructor string(const char*) with a null pointer value, which is undefined behavior. (C++23 adds an overload string(nullptr_t) = delete , which also disables constructing from 0 due to ambiguous matches.)