防止整数0隐式转换为c ++中指针的最佳方法是什么

Question

我试图找出防止整数 0 被隐式转换为 nullptr_t 然后传递给采用指针的构造函数的最佳方法。显式不这样做，但我可以让 nullptr_t 导致模棱两可的重载错误：

#include <typeinfo.h>

struct A {
    explicit A(char*) { }
};

struct B {
    B(nullptr_t a) = delete;
    B(char*) { }
};

int main(int argc, char* argv[])
{
    A a(0);         // darnit I compiled...
    B b1(0);        // good, fails, but with only b/c ambiguous
    B b2((char*)0); // good, succeeds
    B b3(1);        // good, fails, with correct error
}

还有比这更好的方法吗？还有，delete到底是做什么的？

Answer 1

删除A(int) 不会阻止A(char *) 被调用 nullptr。所以你也需要删除A(nullptr_t)。

即使这样也无法保护您免受以下情况的影响 附近有一些流氓阶级 从 0 或 nullptr 隐式构造和 将相同的隐式转换为char *。

#include <iostream>

struct A {
    A(int) = delete;
    A(std::nullptr_t) = delete;
    explicit A(char * p) {
        std::cout << "Constructed with p = " << (void *)p << std::endl;
    }
};

struct X
{
    X(long i) : _i(i) {}
    operator char *() const { return (char *)_i; }
    long _i;
};

int main()
{
    X x(0);
    A a(x);
    return 0;
}

程序打印：

Constructed with p = 0

您可能认为这种可能性微乎其微，可以忽略不计； 或者您可能更喜欢删除 all 构造函数， 一下子，他的论点不完全是一种类型 你认可的。例如。假设认可的类型只是char *:

struct A {
    template<typename T>
    A(T) = delete;
    explicit A(char * p) {}
};

struct X
{
    X(long i) : _i(i) {}
    operator char *() const { return (char *)_i; }
    long _i;
};

int main()
{
    // A a0(0);
    //A a1(nullptr);
    X x(0);
    // A a2(x);
    char *p = x;
    A a3(p); // OK     
    return 0;
}

这里所有被注释掉的构造函数调用都无法编译。

Answer 2

如果您想阻止构造函数采用0，一种选择是删除B(int)：

B(int) = delete;

与采用 char * 的构造函数相比，B(0) 的匹配无疑更好。

请注意，在 C++11 之前，NULL 被指定为整数类型，即使在 C++11 及更高版本中，它仍然很可能实现为 #define NULL 0。如果您这样做，B(NULL) 将不起作用。 B(nullptr) 会起作用，但我还是会担心这是否值得做。