Могу ли я перегрузить неявную инициализацию до 0?

Если вы не против Foo b = nullptr; поработать, это довольно легко взломать. Имейте явный конструктор из int и неявный из std::nullptr_t.

Если вы не против, чтобы это работало, я не уверен, что это возможно. Единственный способ отличить литерал 0 от других целочисленных литералов - это неявное преобразование первого в указатели и nullptr_t. Таким образом, nullptr предпочтет параметр nullptr_t параметру указателя, поэтому, имея оба конструктора, вы можете отфильтровать nullptr аргументов. Однако преобразования 0 в указатели и nullptr_t имеют одинаковый ранг, поэтому это приведет к уничтожению 0 аргументов из-за двусмысленности.

Хм ... может сработать что-то вроде этого:

class Foo {
  struct dummy;
public:
  explicit Foo(int); // the version that allows Foo x(1);
  Foo(dummy*); // the version that allows Foo x = 0;
  template <typename T,
            typename = typename std::enable_if<
                std::is_same<T, std::nullptr_t>::value>::type>
  Foo(T) = delete; // the version that prevents Foo x = nullptr;
};

На самом деле я этого не пробовал. Теоретически шаблон должен участвовать в разрешении перегрузки только тогда, когда аргумент равен nullptr, потому что в противном случае SFINAE убьет его. Однако в этом случае он должен быть лучше конструктора указателя.

Foo e(1); 

Вызов неявного конструктора Foo с аргументом int. По сути, эта строка будет делать то же самое, пытаясь преобразовать int в Foo с помощью этого конструктора int.

Foo b = 1;

Вы не можете предотвратить прямую обработку определенных значений этого int. Если у вас есть конструктор explicit, вы тоже не сможете написать следующую строку.

Foo b = 0;

gx_ правильно указал, что 0 можно преобразовать в std :: nullptr_t. Следующее будет работать в соответствии с вашим намерением.

Foo(std::nullptr_t x) : member(0) { }
explicit Foo(int c) : member(c) { }
// ...
Foo a = 0; // compiles
Foo b = 1; // doesn't compile

// Note:
int do_stuff (void) { return 0; }
Foo c = do_stuff(); // doesn't compile

У меня была одна идея:

Foo(const uint32_t c) : member(0) { static_assert(c == 0, "Nope"); }
explicit Foo(uint32_t c) : member(c) { }

Это ведет себя разумно?

Признаюсь, я еще не овладел семантикой rvalue в C ++ 11, но, похоже, это делает то, что вы хотите:

class Foo
{
    public:
    Foo(int&&) {}
};

int main()
{
    Foo a(123);
    int x = 123;
    Foo b(x); // error here, line 11
    return 0;
}

Результат:

prog.cpp: 11: error: невозможно привязать lvalue int к int &&

Комментарии приветствуются, если в этом коде есть какие-либо оговорки, которые я не заметил, или если вы можете меня заверить, что это не так.