Probleme mit Überladung Auflösung und Operator << für Vorlagenvorlagen

Question

Ich schreibe eine Bibliothek und es sollte Objekte zu string.

Ich habe gewählt, operator<<(ostream&... zu unterstützen.

Eine andere Sache ist, dass meine Bibliothek Standard-Stringifikation von Typen, die nicht operator<<(ostream&... in der {?} Form haben sollte.

Das Problem ist mit Templat-Typen wie vector<> - Ich will nicht der Benutzer 2 Überlastungen für vector<int> und vector<float> schreiben - aber ich kann es nicht zu arbeiten. Hier

ist der Code:

#include <string> 
#include <type_traits> 
#include <sstream> 
#include <vector> 
#include <iostream> 
using namespace std; 

namespace has_insertion_operator_impl { 
    typedef char no; 
    typedef char yes[2]; 

    struct any_t { 
     template <typename T> 
     any_t(T const&); 
    }; 

    no operator<<(ostream const&, any_t const&); 

    yes& test(ostream&); 
    no test(no); 

    template <typename T> 
    struct has_insertion_operator { 
     static ostream& s; 
     static T const&  t; 
     static bool const value = sizeof(test(s << t)) == sizeof(yes); 
    }; 
} 

template <typename T> 
struct has_insertion_operator : has_insertion_operator_impl::has_insertion_operator<T> {}; 

template <class T> 
typename enable_if<has_insertion_operator<T>::value, string>::type stringify(const T& in) { 
    stringstream stream; 
    stream << in; 
    return stream.str(); 
} 

template <class T> // note the negation here compared to the one above 
typename enable_if< ! has_insertion_operator<T>::value, string>::type stringify(const T&) { 
    return "{?}"; 
} 

// USER CODE: 

struct myType {}; 

ostream& operator<<(ostream& s, const myType&) { s << "myType"; return s; } 

template<typename T> 
ostream& operator<<(ostream& s, const vector<T>&) { s << "vector<T>"; return s; } 

int main() { 
    myType a;   cout << stringify(a) << endl; // prints "myType" 
         cout << stringify(6) << endl; // prints "6" 
    vector<int> v(5); cout << stringify(v) << endl; // prints "{?}" instead of "vector<T>" 

    return 0; 
} 

myType und die ganze Zahl sowohl Zeichenfolge erhalten, aber für die vector<int> erhalte ich den Standard {?}.

Ich brauche Hilfe dabei - es ist ein Showstopper für mich. Ich brauche von Benutzern bereitgestellte operator<<(ostream&... Überladungen, out-of-the-Box ohne Änderung zu arbeiten - und das alles in C++ 98.

Answer 1

stellte sich heraus, alles, was ich tun musste, war den Namensraum mit der Umsetzung des Einfügeoperator Merkmal entfernen so die Fallback operator<<(ostream&... endet im globalen Umfang - erklärt here.

Answer 2

Passend den Vektor Sie bessere Kandidaten für Ihre stringize Funktionen

Für C 11 ++ dies wäre zur Verfügung stellen müssen:

template <template <typename...> class V, typename... Args> 
typename enable_if< !has_insertion_operator<V<Args...>>::value, string>::type stringify(const V<Args...>&) { 
    return "template {?}"; 
} 
// also add enable_if for yes with code identical to the one in template<typename T> 

Da Sie ++ 98 brauchen C, ich fürchte, Sie müssen eine Anzahl von Template-Überladungen für 1 bis N (etwa 5 oder 10) Args bereitstellen. So was.

template <template <typename> class V, typename T0> 
... 
template <template <typename, typename> class V, typename T0, typename T1> 
... 
/// etc 

Zum Beispiel vector in Ihrem Fall hat 2 Vorlagenargumente, und das zweite Paar von yes/no Funktionen entsprechen