Posso sovraccaricare un'inizializzazione implicita su 0?

Question

E 'possibile scrivere una classe tale che questi sono validi:

Foo a; 
Foo b = 0; 
Foo c = b; 
Foo d(0); 
Foo e(1); 
Foo f = Foo(1); 

Ma questi non sono:

int x; 
Foo a = x; 
Foo b = 1; 
Foo c = 2; 
//etc 

In sostanza, la mia regola è "Una costante 0 è implicitamente convertibile in un Foo , ma nessun altro valore è "

Answer 1

Se non ti dispiace lavorare su Foo b = nullptr;, è piuttosto semplice effettuare l'hacking. Avere un costruttore esplicito da int e un implicito da std::nullptr_t.

Se pensi che funzioni, non sono sicuro che sia possibile. L'unico modo per distinguere tra un valore letterale di 0 e altri valori letterali interi è la conversione implicita del primo in puntatori e nullptr_t. Pertanto, nullptr preferirà un parametro nullptr_t a un parametro puntatore, pertanto, avendo entrambi i costruttori, è possibile filtrare gli argomenti nullptr. Tuttavia, le conversioni di 0 per i puntatori e nullptr_t sono dello stesso valore, quindi questo ucciderebbe gli argomenti 0 con un'ambiguità.

Hmm ... qualcosa come questo può funzionare:

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; 
}; 

Non ho effettivamente provato questo. In teoria, il modello dovrebbe partecipare solo alla risoluzione di sovraccarico quando l'argomento è nullptr, perché altrimenti FINEE lo uccide. In tal caso, tuttavia, dovrebbe essere migliore del costruttore di puntatori.

Answer 2

Ca ca Un costruttore non esplicito di Foo che prende un int come argomento. Essenzialmente questa linea farà lo stesso cercando di convertire int a Foo usando questo costruttore int.

Foo b = 1; 

Non è possibile impedire che determinati valori di tale int vengano elaborati direttamente. Se si dispone del costruttore explicit, non sarà possibile scrivere anche la riga successiva.

Foo b = 0; 

gx_ ha dichiarato correttamente che 0 può essere convertito in std :: nullptr_t. Quanto segue funzionerà rispetto al tuo intento.

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 

Answer 3

Un'idea che avevo era:

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

Questo comportarsi sensibilmente?

Answer 4

ammetto che non ho raggiunto la completa padronanza della semantica rvalue di C++ ancora 11, ma questo sembra fare quello che vuoi:

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

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

risultati:

prog.cpp:11: error: cannot bind ‘int’ lvalue to ‘int&&’

Commenti benvenuto, se questo codice ha qualche avvertenza che non ho notato, o se puoi rassicurarmi che non è così.