Vorlagen und String-Literale und UNICODE

Question

NEU: Vielen Dank an alle, die mir dabei geholfen haben! Die Antwort ist unten markiert, und ich habe mit einer funktionierenden Version in meiner Frage auf der Antwort erweitert, unter (siehe dort):

---

Ich scheine viel in diese Situation zu laufen (während unseres String-Dienstprogramme Aktualisierung Bibliothek):

Ich brauche eine Möglichkeit, eine Vorlage, die für beide char und wchar_t, die verschiedene String-Literale verwendet funktioniert. Momentan finde ich das herausfordernd, weil ich nicht weiß, wie ich eine Kompilierzeit haben kann, um String-Literale als schmale oder breite Zeichen zu ändern.

Zur Erörterung, nehmen Sie die folgende TCHAR basierte Funktion:

// quote the given string in-place using the given quote character 
inline void MakeQuoted(CString & str, TCHAR chQuote = _T('"')) 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format(_T("%c%s%c"), chQuote, str, chQuote); 
} 

ich möchte es als Templat statt:

// quote the given string in-place using the given quote character 
template <typename CSTRING_T, typename CHAR_T> 
inline void MakeQuoted(CSTRING_T & str, CHAR_T chQuote = '"') 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format("%c%s%c", chQuote, str, chQuote); 
} 

Ab sofort haben wir ein Problem mit den beiden Zeichenketten (" ', und "% c% s% c").

Wenn das obige für CSTRING_T = CStringA, CHAR_T = char aufgerufen wird, dann sind die obigen Literale in Ordnung. Wenn es für CStringW und wchar_t aufgerufen wird, dann reall y brauchen (L '"' und L"% c% c% c ").

Also muss ich einen Weg, etwas zu tun wie:

template <typename CSTRING_T, typename CHAR_T> 
inline void MakeQuoted(CSTRING_T & str, CHAR_T chQuote = Literal<CHAR_T>('"')) 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format(Literal<CHAR_T>("%c%s%c"), chQuote, str, chQuote); 
} 

Und das ist, wo ich bin verloren: Was in der Welt kann ich Wörtliche tun, um (String-oder-Zeichen-Literal), die tatsächlich Ergebnisse in L "string" oder "string" abhängig von CHAR_T?

Edit: Es gibt über hundert Funktionen, viele von ihnen komplexer mit mehr String-Literalen in ihnen, die für schmale und breite Strings verfügbar sein müssen. Kurz vor dem Kopieren jeder dieser Funktionen und dann jeder Bearbeitung entweder breit oder schmal, sicherlich gibt es eine Technik, die eine einzige Definition erlauben würde, die sich nach CHAR_T unterscheidet?

---

Ich gebe die Antwort auf den Hybrid-Makro + Vorlage, dass Mark Ransom geliefert, aber ich wollte eine vollständigere Lösung (für alle, die gepflegt) aufzunehmen, so ist es hier:

// we supply a few helper constructs to make templates easier to write 
// this is sort of the dark underbelly of template writing 
// to help make the c++ compiler slightly less obnoxious 

// generates the narrow or wide character literal depending on T 
// usage: LITERAL(charT, "literal text") or LITERAL(charT, 'c') 
#define LITERAL(T,x) template_details::literal_traits<typename T>::choose(x, L##x) 

namespace template_details { 

    // Literal Traits uses template specialization to achieve templated narrow or wide character literals for templates 
    // the idea came from me (Steven S. Wolf), and the implementation from Mark Ransom on stackoverflow (http://stackoverflow.com/questions/4261673/templates-and-string-literals-and-unicode) 
    template<typename T> 
    struct literal_traits 
    { 
     typedef char char_type; 
     static const char * choose(const char * narrow, const wchar_t * wide) { return narrow; } 
     static char choose(const char narrow, const wchar_t wide) { return narrow; } 
    }; 

    template<> 
    struct literal_traits<wchar_t> 
    { 
     typedef wchar_t char_type; 
     static const wchar_t * choose(const char * narrow, const wchar_t * wide) { return wide; } 
     static wchar_t choose(const char narrow, const wchar_t wide) { return wide; } 
    }; 

} // template_details 

Darüber hinaus habe ich einige Helfer schreiben Vorlagen zu machen, die dieses Konzept in Verbindung mit CStringT verwendet <> ein bisschen leichter/schöner & comprehend zu lesen:

// generates the correct CString type based on char_T 
template <typename charT> 
struct cstring_type 
{ 
    // typedef CStringT< charT, ATL::StrTraitATL< charT, ATL::ChTraitsCRT<charT> > > type; 
    // generate a compile time error if we're invoked on a charT that doesn't make sense 
}; 

template <> 
struct cstring_type<char> 
{ 
    typedef CStringA type; 
}; 

template <> 
struct cstring_type<wchar_t> 
{ 
    typedef CStringW type; 
}; 

#define CSTRINGTYPE(T) typename cstring_type<T>::type 

// returns an instance of a CStringA or CStringW based on the given char_T 
template <typename charT> 
inline CSTRINGTYPE(charT) make_cstring(const charT * psz) 
{ 
    return psz; 
} 

// generates the character type of a given CStringT<> 
#define CSTRINGCHAR(T) typename T::XCHAR 

Mit dem oben genannten ist es möglich, Vorlagen zu schreiben, die die richtige CString-Varietät basierend auf CStringT <> oder char/wchar_t-Argumenten generieren. Zum Beispiel:

// quote the given string in-place using the given quote character 
template <typename cstringT> 
inline void MakeQuoted(cstringT & str, CSTRINGCHAR(cstringT) chQuote = LITERAL(CSTRINGCHAR(cstringT), '"')) 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format(LITERAL(cstringT::XCHAR, "%c%s%c"), chQuote, str, chQuote); 
} 

// return a quoted version of the given string 
template <typename cstringT> 
inline cstringT GetQuoted(cstringT str, CSTRINGCHAR(cstringT) chQuote = LITERAL(CSTRINGCHAR(cstringT), '"')) 
{ 
    MakeQuoted(str, chQuote); 
    return str; 
} 

Answer 1

Das Konzept ist ein Makro zu verwenden, um beide Formen der wörtlichen, char und wchar_t zu erzeugen, dann lassen Sie eine Template-Funktion wählen, welche für den Kontext geeignet ist.

Denken Sie daran, dass Vorlagenfunktionen keinen Code generieren, bis Sie anderen Code haben, der sie aufruft. Die meiste Zeit ist das egal, aber es wäre für eine Bibliothek.

Dieser Code ist nicht getestet, aber ich glaube, es wird funktionieren.

#define LITERAL(T,x) CString_traits<T>::choose(x, L##x) 

template<typename T> 
struct CString_traits 
{ 
    typedef char char_type; 
    static const char * choose(const char * narrow, const wchar_t * wide) { return narrow; } 
    static char choose(char narrow, wchar_t wide) { return narrow; } 
}; 

template<> 
struct CString_traits<CStringW> 
{ 
    typedef wchar_t char_type; 
    static const wchar_t * choose(const char * narrow, const wchar_t * wide) { return wide; } 
    static wchar_t choose(char narrow, wchar_t wide) { return wide; } 
}; 

template <typename T> 
inline void MakeQuoted(T & str, CString_traits<T>::char_type chQuote = LITERAL(T,'"')) 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format(LITERAL(T,"%c%s%c"), chQuote, str, chQuote); 
} 

Answer 2

Ich glaube, Sie TEXT MFC Makro wollen:

TCHAR* psz = TEXT("Hello, generic string"); 

Answer 3

Sie brauchen keine Vorlagen zu verwenden für so etwas, wenn man bedenkt, es gibt nur zwei Möglichkeiten, MakeQuoted() zu verwenden.Sie können Überladen von Funktionen für den gleichen Zweck verwendet werden:

inline void MakeQuoted(CStringA& str, char chQuote = '"') 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format("%c%s%c", chQuote, str, chQuote); 
} 


inline void MakeQuoted(CStringW& str, wchar_t chQuote = L'"') 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format(L"%c%s%c", chQuote, str, chQuote); 
} 

Sicherlich ist dies der einfachste Weg, es zu tun, ohne Makros zu verwenden, vorausgesetzt, dass Ihr Grund ist Bibliothek eine Template-basierte Lösung mit String-Dienstprogramme für den Versuch.

Sie können gemeinsame Funktionalität für lange und komplizierte Funktionen ausklammern:

template<typename CStrT, typename CharT> 
inline void MakeQuotedImpl(CStrT& str, CharT chQuote, 
    const CharT* literal) 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
     str.Format(literal, chQuote, str, chQuote); 

} 

inline void MakeQuoted(CStringA& str, char chQuote = '"') 
{ 
    MakeQuotedImpl(str, chQuote, "%c%s%c"); 
} 


inline void MakeQuoted(CStringW& str, wchar_t chQuote = L'"') 
{ 
    MakeQuotedImpl(str, chQuote, L"%c%s%c"); 
} 

Answer 4

OK, also, wenn Sie wirklich diese Vorlage zu verwenden wollen, glaube ich, das Beste, was ich in der Lage gewesen, mit zu kommen eine Vorlagenklasse, die Ihre Literale basierend auf this discussion speichert. Etwas wie folgt aus:

template <typename T> class Literal; 
template <> class Literal<char> 
{ 
public: 
    static const char Quote = '"'; 
}; 
template <> class Literal<wchar_t> 
{ 
public: 
    static const wchar_t Quote = L'"'; 
}; 

Dann Sie Literal<CHAR_T>::Quote in Ihre nicht-spezialisierten aber Templat-Funktionen verwenden würde. Irgendwie chaotisch, schätze ich, aber es hat den Vorteil, dass Sie Ihre Funktionslogik unduplicated belassen und Ihnen templated String-Literale gibt.

Answer 5

Sie können die Teilspezialisierung der Vorlage für MarkQuoted verwenden und das Angebot basierend auf dem Typ angeben.

Answer 6

Dieses Stück ist mein persönliches winziges kleines Genie.

#include <malloc.h> 
template<typename to, int size> to* make_stack_temporary(const char(&lit)[size], to* memory = (to*)_alloca(sizeof(to)*size)) { 
    for(int i = 0; i < size; i++) 
     memory[i] = lit[i]; 
    return memory; 
} 

Wenn Sie alloca in einem Standardargument verwenden, es ist eigentlich die Anrufer ‚s Stack, so dass Sie Arrays auf den Heap, ohne auf das Rück zugewiesen wird. Keine dynamische Zuweisung, keine Speicherbefreiung. _alloca ist eine CRT-Funktion von MSVC, daher gebe ich keine Portabilitätsgarantien - aber wenn Sie ATL verwenden, ist das wahrscheinlich kein Problem. Natürlich bedeutet dies auch, dass der Zeiger nicht über die aufrufende Funktion hinaus gehalten werden kann, aber für temporäre Verwendungen wie Formatzeichenfolgen sollte er ausreichen. Es gibt auch einige Vorbehalte, die mit der Ausnahmebehandlung zu tun haben, auf die Sie wahrscheinlich nicht stoßen werden (überprüfen Sie MSDN für Details), und natürlich wird es nur für Charaktere funktionieren, die die gleiche binäre Darstellung haben, die meines Wissens jedes Zeichen ist in ein schmales String-Literal eingeben. Ich schätze, dass dies nur eine Teilmenge der tatsächlich aufgetretenen Probleme löst, aber es ist eine weit überlegene Lösung für diese spezifische Teilmenge als das Makro, oder jedes Literal zweimal angeben, etc.

Sie können auch die definitiv hässlichere verwenden aber mehr verhaltenskonsistente Aggregatinitialisierung.

template<typename T> some_type some_func() { 
    static const T array[] = { 'a', ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', 'l', 'i', 't', 'e', 'r', 'a', 'l', '\0' }; 
} 

In C++ 0x mit variadische Vorlagen kann es möglich sein, diese Lösung nicht zu saugen. Ich bin nah an einer besseren Lösung, die C++ 03 ist, aber halte nicht den Atem an.

Edit: Sie können dies tun, welche IMO die beste Lösung ist, beinhaltet immer noch einige Unordnung.

#include <iostream> 
#include <array> 
#include <string> 

struct something { 
    static const char ref[]; 
}; 

const char something::ref[] = ""; 

template<int N, const char(*t_ref)[N], typename to> struct to_literal { 
private: 
    static to hidden[N]; 
public: 
    to_literal() 
    : ref(hidden) { 
     for(int i = 0; i < N; i++) 
      hidden[i] = (*t_ref)[i]; 
    } 
    const to(&ref)[N]; 
}; 
template<int N, const char(*t_ref)[N], typename to> to to_literal<N, t_ref, to>::hidden[]; 

template<int N, const char(&ref)[N], typename to> const to* make_literal() { 
    return to_literal<N, &ref, to>().ref; 
} 

int main() { 
    std::wcout << make_literal<sizeof(something::ref), something::ref, wchar_t>(); 
    std::wcin.get(); 
} 

Sie haben durch alle wörtlichen gehen und es ein statisches Element einer Struktur zu machen, dann verweisen sie, aber es funktioniert viel besser.

Answer 7

Ich habe eine ähnliche Situation. Ich habe 1 Quellcode-Datei und eine Header-Datei (natürlich) gemacht, die ich vom Aufbau ausschließe. Dann erstellt 2 andere Quelldateien, die die ursprüngliche Quelle enthalten, über eine Direktive #include. In einer Datei definiere ich UNICODE (wenn nicht bereits definiert) vor dem Include. In der anderen Datei habe ich #undef UNICODE (falls definiert). Die Quelldatei enthält einige statische Strukturen und eine Reihe von Funktionen, die für beide char-Sätze identisch sind (im Text) (nicht beim Kompilieren). Wenn jede Funktion entweder wchar_t oder char als Parameter hat, ergibt sich diese Methode in 2 Mengen überladener Funktionen oder 2 Mengen unterschiedlich benannter Funktionen (hängt davon ab, wie die Header-Datei geschrieben wird, nehmen Sie tchar.h als Beispiel). Jetzt sind sowohl UNICODE- als auch ANSI-Versionen der Funktionen für eine Anwendung verfügbar und wenn die Header-Datei korrekt geschrieben ist, ist auch die Standardversion für TCHAR. Wenn Sie möchten, dass ich darauf eingehen kann, sagen Sie es einfach.