Template: const char[] als std::string fangen

DocShoe

Hallo,

ich habe ein Funktionstemplate, das als Aufrufparameter einen std::basic_string erwartet.

#include <string>

template<typename Ch>
static std::basic_string<Ch> quote_string( const std::basic_string<Ch>& Text )
{
   return Ch( '\"' ) + Text + Ch( '\"' );
}

int main()
{
   // Diese Zeile produziert einen Compiler-Fehler:
   // Kandidat-Template ignoriert: 
   // 'basic_string<type-parameter-0-0, char_traits<type-parameter-0-0>, allocator<type-parameter-0-0> >' und 
   // 'char const[12]' stimmen nicht überein  
   quote_string( "Hello World" );
}

Kann man dem Compiler iwie beibringen, dass er das String Literal für den string-Konstruktaufruf benutzen soll und damit das Funktionstemplate instanziiert?

Nein, da musst du halt nen Wrapper nehmen.

template<typename T>
std::basic_string<T> quote_string(const T* s){
    return quote_string(std::basic_string<T>(s));
}

ungetestet.

Seit C++14 hast du auch das 's'-Suffix, wenn ich mich nicht irre.

DocShoe

Hab´s jetzt über wrapper und ´nen detail namspace gelöst. Klappt zwar, ist aber trotzdem iwie unbefriedigend.

#include <string>

namespace detail
{
   template<typename Ch>
   static std::basic_string<Ch> quote_string( const std::basic_string<Ch>& Text, Ch QuoteChar )
   {
      return QuoteChar + Text + QuoteChar;
   }
}

std::string quote_string( const std::string& Text, char QuoteChar )
{
   return detail:quote_string( Text, QuoteChar );
}

std::wstring quote_string( const std::wstring& Text, wchar_t QuoteChar )
{
   return detail:quote_string( Text, QuoteChar );
}

Da stell ich mir bloß noch die Frage, warum überhaupt noch ein Template, wenn du das so löst.

DocShoe

Das ist halt nur eine Funktion von vielen, ist auch die einfachste. Andere sind da umfangreicher und länger als eine Zeile, den Code möchte ich nicht duplizieren.

DocShoe schrieb:

den Code möchte ich nicht duplizieren.

Das tust du aber wenn du für jeden Furz eine Überladung machst.

Stell dir vor jetzt kommt noch ein basic_string<uchar> bei. Schreibst du halt wieder ne Funktion mehr -> Duplikation.

Nimm die Variante mit dem Schablonenzeiger.

DocShoe

Ja, du hast leider recht, dass ich Code für zwei Fälle duplizieren muss. Es gibt allerdings Funktionen, die bis zu vier Parameter haben, und wenn ich da alle möglichen Kombinationen abdecken will habe ich 16 Varianten für eine Funktion. Mit den jeweiligen Überladungen habe ich zwar doppelten Code, aber nur zwei unterschiedlichen Funktionen.
Weitere string Typen kommen vermutlich nicht dazu, zumindest nicht in absehbarer Zeit.

Edit:
C++14 kann unser Compiler nicht

Meep Meep

warm schreibst du eigendlich nicht gleich

quote_string<char>("Hello World");

?

Oh man...

Meep Meep

sry ich versteh es grad nicht bzw. steh ich grad auf der leitung