Machen Sie eine Benutzer-definierte Klasse std::to_string(Lage)

Was ist die 'beste' Weg ist eine offene Frage.

Gibt es ein paar Möglichkeiten.

Das erste, was zu sagen ist, dass eine überlastung std::to_string für einen benutzerdefinierten Typ ist nicht erlaubt. Wir können nur spezialisieren template-Funktionen und Klassen in der std Namensraum für benutzerdefinierte Typen und std::to_string ist nicht eine template-Funktion.

Gesagt, ein guter Weg, um zu behandeln to_string ist viel wie ein operator oder eine Implementierung von swap. also erlauben argument-dependent lookup um die Arbeit zu tun.

so, wenn wir möchten, zu konvertieren, was zu einem string wir könnten schreiben:

using std::to_string;
auto s = to_string(x) + " : " + to_string(i);

vorausgesetzt, dass x ein Objekt vom Typ X in namespace Y und ich war ein int, dann könnten wir definieren:

namespace Y {

  std::string to_string(const X& x);

}

das würde jetzt bedeuten, dass:

aufrufen to_string(x) tatsächlich wählt Y::to_string(const Y::X&), und

aufrufen to_string(i) wählt std::to_string(int)

Weiter zu gehen, kann es sein, dass Sie wollen to_string viel zu tun das gleiche wie operator<<, also man kann dann geschrieben werden in Bezug auf die anderen:

namespace Y {

  inline std::ostream& operator<<(std::ostream& os, const X& x) { /* implement here */; return os; }

  inline std::string to_string(const X& x) {
    std::ostringstream ss;
    ss << x;
    return ss.str();
  }
}

Hier eine Alternative Lösung. Nichts unbedingt mehr elegant oder auch Lust, aber es ist eine Alternative Methode. Es wird davon ausgegangen, dass alle Klassen, die Sie beabsichtigen, zu nennen to_string auf eine ToString () - Funktion.

Hier ist ein Funktions-template, das funktioniert nur mit Objekten der Klasse Typ, und rufen Sie eine ToString () - Funktion.

    template<typename T, typename = std::enable_if_t<std::is_class<T>::value>>
    std::string to_string(const T& t) {
      return t.ToString();
    }

Vielleicht sollten wir es mit std::string als gut.

    template<>
    std::string to_string(const std::string& t) {
      return t;
    }

Hier ist ein Beispiel des Codes im Einsatz. Hinweis: die dummy-namespace to_s. Ich denke, wenn man mit std::to_string in der main-Funktion, es Schritte auf unserem template Funktion name, so haben wir die Einführung der Namen indirekt wie diese. Wenn jemand weiß, der richtige Weg, dies zu tun, würde ich mich über ein Kommentar.

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


    union U {
      double d;
      const char* cp;
    };

    struct A {
      enum State { kString, kDouble };
      State state;
      U u;

      void Set(const char* cp) {
        u.cp = cp;
        state = kString;
      }

      std::string ToString() const {
        switch (state) {
          case A::kString : return std::string(u.cp); break;
          case A::kDouble : return std::to_string(u.d); break;
          default : return "Invalid State";
        }
      }
    };

    namespace to_s { using std::to_string; };

    int main() {
      using namespace to_s;
      std::string str = "a nice string";
      double d = 1.1;
      A a { A::kDouble, {1.2} };

      std::cout << "str: " << to_string(str) << ", d: " << to_string(d) << std::endl;
      std::cout << "a: " << to_string(a) << std::endl;
      a.Set(str.c_str());
      std::cout << "a: " << to_string(a) << std::endl;
      std::memset(&a, 'i', sizeof(a));
      std::cout << "a: " << to_string(a) << std::endl;
    }

Hier ist was ich habe:

str: ein schöner string, d: 1.100000

a: 1.200000

einem: ein schöner string

a: Ungültiger Status

Werden Sie wahrscheinlich wollen einfach nur, um eine überlastung operator<<() etwas wie:

std::ostream& operator << ( std::ostream& os, const my_class& rhs ) {
    os << "I am " << rhs.i;
    return os;
}

Alternativ:

std::ostream& operator << ( std::ostream& os, const my_class& rhs ) {
    os << rhs.print_a_string();
    return os;
}

Dann können Sie einfach tun:

int main() {
    my_class my_object;
    std::cout << my_object;

    return 0;
}