automatyczna konwersja bool do nullptr_t

Question

Mam następujący kod z klasy zwyczaj wariant i niestandardową SmartPtr Klasa:

using namespace std; 

class Object 
{ 
public: 
}; 

template<typename T> 
class SmartPtr 
{ 
public: 

    template<typename Y> 
    explicit SmartPtr(Y* p) { p_ = p; } 

    SmartPtr(std::nullptr_t) { p_ = nullptr; } 

private: 
    T* p_; 
}; 

class Variant 
{ 
public: 
    Variant(bool b) : _b(b) { } 

private: 
    bool _b; 
}; 

class Obj 
{ 
public: 
    void test(SmartPtr<Object> /*p*/) { cout << "smartptr version!" << endl; } 
    void test(Variant /*v*/) { cout << "variant version!" << endl; } 
}; 

int main(int argc, const char *argv[]) 
{ 
    Obj o; 
    o.test(nullptr); // calls SmartPtr version 
    o.test(true); // calls Variant version 
    o.test(false); // -> compiler error: ambiguous call to overloaded function 

    return 0; 
} 

Zakładam, że logiczna fałsz można przekształcić zarówno do wariantu i 0 następnie nullptr, a następnie SmartPtr, który powoduje ten błąd.

Jakieś szanse na uniknięcie tej konwersji?

Dla użytkownika biblioteki interfejs API współpracujący z "o.test (true);" ale wymaga czegoś takiego jak "o.test (Variant (false))" do kompilacji nie jest bardzo intuicyjny.

Answer 1

Uważam, że mam idealne rozwiązanie. Wymaga jedynie zmiany funkcji testu, więc pozostawia SmartPtr i Wariant sam, co jest idealne. Dodaje nieprzedefiniowane przeciążenie szablonowe w celu przetestowania, które ma zdefiniowane specjalizacje dla wartości bool i nullptr. Spowoduje to bezpośrednie wywołanie wartości bool i nullptr do wybranej specjalizacji, ale spowoduje błędy w łączach na innych nieobsługiwanych typach. Tak się cieszę, że to się udało, ponieważ sam z pewnością wpadłem na to w wielu postaciach. Szkoda, że ​​nie możesz użyć jawnych parametrów funkcji !!

mam pojęcia, stąd: C++ templates that accept only certain types

using namespace std; 

class Object 
{ 
public: 
}; 

class Variant 
{ 
public: 
    Variant(bool b) : _b(b) { } 

private: 
    bool _b; 
}; 

template<typename T> 
class SmartPtr 
{ 
public: 
    SmartPtr(std::nullptr_t null) { p_ = nullptr; } 

    template<typename Y> 
    SmartPtr(Y* p) { p_ = p; } 

private: 
    T* p_; 
}; 

class Obj 
{ 
public: 
    void test(SmartPtr<Object> here /*p*/) { 
     cout << "smartptr version!" << endl; 
    } 
    void test(Variant /*v*/) { cout << "variant version!" << endl; } 

    template<typename T> void test(T t); 

    template<> 
    void test<bool>(bool b) { 
     cout << "bool specialization" << endl; 
     test(Variant(b)); 
    } 

    template<> 
    void test<std::nullptr_t>(std::nullptr_t null) { 
     cout << "nullptr specialization" << endl; 
     test(SmartPtr<Object>(nullptr)); 
    } 
}; 

int main(int argc, const char *argv[]) 
{ 
    Obj o; 
    Obj c; 
    Object object; 

    //o.test(3); // Gives link error LNK2019 

    o.test(Variant(true)); // calls Variant version 
    o.test(SmartPtr<Object>(&object)); // calls SmartPtr version 
    o.test(nullptr); // dispatched to SmartPtr version by nullptr specialization 
    o.test(true); // dispatched to Variant version by bool specialization 
    o.test(false); // dispatched to Variant version by bool specialization 
    return 0; 
} 

ja już odpowiedział coś nie jest idealny, więc zostawiam tę odpowiedź w takt jak co następuje:

======= ======================================

Nie mam idealnego rozwiązania tutaj, i nie znam ograniczeń na twoim kodzie, więc może to nie być użyteczne dla ciebie, ale poniższe jest sensowne. Uniemożliwia to użycie kodu nullptr w czasie kompilacji i opiera się na globalnej stałej null_smart, która ma być używana we wszystkich przypadkach, gdy wywołujący po prostu nie wykazuje zainteresowania przekazywaniem obiektu.

#include <iostream> 

using namespace std; 

class Object 
{ 
public: 
}; 

class Variant 
{ 
public: 
    Variant(bool b) : _b(b) { } 
private: 
    Variant(std::nullptr_t) {}; 

private: 
    bool _b; 
}; 

template<typename T> 
class SmartPtr 
{ 
public: 
    SmartPtr() { p_ = nullptr; } 

    template<typename Y> 
    SmartPtr(Y* p) { p_ = p; } 

private: 
    T* p_; 
}; 

class Obj 
{ 
public: 
    void test(SmartPtr<Object> /*p*/) { cout << "smartptr version!" << endl; } 
    void test(Variant /*v*/) { cout << "variant version!" << endl; } 
}; 

const SmartPtr<Object> null_smart; 

int main(int argc, const char *argv[]) 
{ 
    Obj o; 
    o.test(null_smart); // calls SmartPtr version, without interest in passing object 
    o.test(true); // calls Variant version 
    o.test(false); // calls Variant version 
    return 0; 
} 

Jest czystszy niż prawdziwy/wariantowy (fałszywy), ale wciąż jest nieco bardziej wybredny.