Das Zeichenfolgenliteral stimmt mit der bool-Überladung anstelle von std::string überein

Ich versuche, eine C++-Klasse zu schreiben, die einige überladene Methoden hat:

class Output
{
public:
    static void Print(bool value)
    {
        std::cout << value ? "True" : "False";
    }

    static void Print(std::string value)
    {
        std::cout << value;
    }
};

Nehmen wir nun an, ich rufe die Methode wie folgt auf:

Output::Print("Hello World");

das ist das Ergebnis

Wahr

Warum also, wenn ich definiert habe, dass die Methode boolesche und Zeichenfolgen akzeptieren kann, verwendet sie die boolesche Überladung, wenn ich einen nicht booleschen Wert übergebe?

EDIT: Ich komme aus einer C#/Java-Umgebung, also ziemlich neu in C++!

"Hello World" ist ein String-Literal vom Typ “Array of 12 const char” die in einen “Zeiger auf umgewandelt werden kann const char” was sich wiederum in a umwandeln lässt bool. Genau das passiert. Der Compiler zieht dies der Verwendung vor std::stringDer Konvertierungskonstruktor von .

Eine Konvertierungssequenz, die einen Konvertierungskonstruktor beinhaltet, wird als a bezeichnet benutzerdefinierte Konvertierungssequenz. Die Umstellung von "Hello World" zu einem bool ist ein Standard-Konvertierungssequenz. Der Standard besagt, dass eine Standard-Konvertierungssequenz immer besser ist als eine benutzerdefinierte Konvertierungssequenz (§13.3.3.2/2):

eine standardmäßige Konvertierungssequenz (13.3.3.1.1) ist eine bessere Konvertierungssequenz als eine benutzerdefinierte Konvertierungssequenz oder eine Auslassungs-Konvertierungssequenz

Diese Analyse der “besseren Konvertierungssequenz” wird für jedes Argument jeder brauchbaren Funktion durchgeführt (und Sie haben nur ein Argument) und die bessere Funktion wird durch Überladungsauflösung ausgewählt.

Wenn Sie sichergehen wollen, dass std::string Version aufgerufen wird, müssen Sie ihr eine geben std::string:

Output::Print(std::string("Hello World"));

Ich bin mir nicht sicher, warum niemand das gepostet hat, aber Sie können eine weitere Überladung hinzufügen, die für Sie von const char* in std::string konvertiert. Dies erspart dem Anrufer diese Sorge.

class Output
{
public:
    static void Print(bool value)
    {
        std::cout << value ? "True" : "False";
    }

    static void Print(std::string value)
    {
        std::cout << value;
    }

    // Just add the override that cast to std::string
    static void Print(const char* value)
    {
        Output::Print(std::string(value));
    }
};

FWIW, es kann auf diese Weise angesprochen werden (wenn Vorlagen verwendet werden können), wenn Sie keine Überladungen für hinzufügen möchten const char*.

#include <iostream>
#include <string>
#include <type_traits>

template <typename Bool,
          typename T = std::enable_if_t<std::is_same<Bool, bool>{}>>
void foo(Bool)
{
  std::cerr << "bool\n";
}

void foo(const std::string&)
{
  std::cerr << "string\n";  
}

int main()
{
  foo("bar");
  foo(false);
}

Seit C++14 haben wir die operator""s von dem std::string_literals Namespace, der verwendet werden kann, um dem Compiler mitzuteilen, dass er an die binden soll string (oder string_view in C++17) überladen:

using namespace std::string_literals;
Output::Print("Hello World"s);

Drucke: Hello World