Falscher Konstruktor wird aufgerufen

Question

Ich habe eine Klasse, die verschiedene Arten von Variablen erstellt.

Und durch einige Makrodefinitionen wollen wir diese Variablen initialisieren.

Zahlen sind initialisiert, aber Strings rufen den Bool-Konstruktor aus unbekannten Gründen auf.

JsonVariable(string x) 
    : type(String), s(x) 
{ 
    cout << "String" << x << endl; 
    sleep 
} 
JsonVariable(bool x) 
    : type(Boolean), b(x) 
{ 
    cout << "Boolean" << x << endl; 
    sleep 
} 

Wenn ich den Bool-Konstruktor auskommentiere, dann wird die String-Eins aufgerufen.

Irgendwelche Vorschläge?

EDIT: Dies ist ein String-Konstruktor mit den definierten Makros. std :: string wird im Konstruktor verwendet.

JSON(test) = STRING("Hello") 

Typ ist eine definierte Enum. Auch Makros müssen als Teil dieser Zuweisung verwendet werden.

EDIT2: Zur Verdeutlichung. Hier ist der Enum-Typ.

std :: string wird mit Namespace std und somit single string verwendet. Auch ist String vom Typ ENUM so

String != string 

typedef enum { 
    Null, Integer, Double, Boolean, String, Object, Array 
} datatype; 

Answer 1

Als Faustregel gilt, wenn Ihre API überladenen Funktionen oder Konstrukteuren dieser Signatur (oder dessen CV qualifizierte und/oder Bezugsvarianten) aussetzt:

für const char*

void func(std::string){} 
void func(bool){} 

Sie sollten immer liefern die eine,

void func(std::string){} 
void func(bool){} 
void func(const char* c){ func(std::string(c)); } 

, was Sie und Ihre Benutzer (vor allem) in seinen für subtilen suprises weil:

String-l Iterale (z. B. "abc...") zerfällt schnell zu const char* und durch Überladung Auflösung hat die Umwandlung zu bool eine höhere Priorität als eine benutzerdefinierte Umwandlung was ist, was std::string tut.

Answer 2

Sie könnten die Wirkung von Konvertierungsregeln erfahren. Wenn Sie ein const char* übergeben, wird bool Überlastung über std::string& bevorzugt:

void f(std::string&) { std::cout << "string"; } 
void f(bool) { std::cout << "bool"; } 

int main() { 
    f("abc"); // prints 'bool' 
} 

Dies ist logisch: Zeiger werden in der Regel für seine Nicht-Null geprüft, so Umstellung auf int/bool Typen wünschenswert. Andererseits bedeutet das Binden an einen const std::string& einen std::string Erbauer und unter Bezugnahme. Eine Bindung an std::string& ist hier unmöglich, da Provisorien nicht an nicht-konstante Referenzen binden.

Workaround ist entweder manuell eine Zeichenfolge erstellen oder vorzugsweise einen Konstruktor für const char*.