const char * replaceElements(const char * str) {
		std::string tmp (str);
		//tue irgendwas mit dem String, z.B.:
        tmp.replace(tmp.find("Element"), 7, "Tnemele");
		const char * result = tmp.c_str();
		return result;
	}

ich möchte die Funktion generisch umschreiben, sodass sie sowohl mit const char *, als auch mit const wchar_t * arbeitet. Der Funktionskopf wäre dann:

template <typename CharArray>
CharArray replaceElements(CharArray)

Das hört sich erstmal einfach an, aber ich zerbreche mir schon seit einer ganzen Weile den Kopf darüber. Es ist hierbei nicht wichtig, dass die Klasse String verwendet wird... wichtig ist nur, dass die übergebene Zeichenkette kopiert und an der Kopie etwas verändert werden kann. Hat jemand vielleicht eine Idee?

Es ist hierbei nicht wichtig, dass die Klasse String verwendet wird... wichtig ist nur, dass die übergebene Zeichenkette kopiert und an der Kopie etwas verändert werden kann. Hat jemand vielleicht eine Idee?

Wenn Du den String kopierst, dann mache es mit std:string und gebe auch einen eben solchen zurück - alles andere macht Arbeit und ist fehlerträchtig:

template< typename E, typename Traits >
std::basic_string< E, Traits > replaceElements( const std::basic_string< E, Traits >& str ) {
    std::basic_string< E, Traits > tmp (str);
    //tue irgendwas mit dem String, z.B.:
    const std::basic_string< E, Traits > tag = "Element";
    const std::basic_string< E, Traits >::size_type i = tmp.find(tag);
    if (i != std::basic_string< E, Traits >::npos)
        tmp.replace(i, tag.length(), "Tnemele");
    return tmp;
}

bzw.:

template< typename E >
std::basic_string< E, std::char_traits< E > > replaceElements( const E* str ) {
    typedef std::char_traits< E > Traits;
    std::basic_string< E, Traits > tmp (str);
    //tue irgendwas mit dem String, z.B.:
    const std::basic_string< E, Traits > tag = "Element";
    const std::basic_string< E, Traits >::size_type i = tmp.find(tag);
    if (i != std::basic_string< E, Traits >::npos)
        tmp.replace(i, tag.length(), "Tnemele");
    return tmp;
}

In Zeile 6:
Umwandlung von »const char [8]« in nicht-skalaren Typen »const std::basic_string<wchar_t>« angefordert

und in Zeile 8:
keine passende Funktion für Aufruf von »std::basic_string<wchar_t>::replace(size_t&, std::basic_string<wchar_t>::size_type, const char [8])«

Die Zeichenketten "Element" und "Tnemele" liegen als Char-Arrays vor und können nicht direckt in einen wstring umgewandelt werden.

std::pair<char const*, char const*> getReplacement(char*) {
  return std::make_pair("Element", "Tnemele");
}

std::pair<wchar_t const*, wchar_t const*> getReplacement(wchar_t*) {
  return std::make_pair(L"Element", L"Tnemele");
}

template< typename E, typename Traits >
std::basic_string< E, Traits > replaceElements( std::basic_string< E, Traits > str ) {
    typedef std::basic_string< E, Traits > string_t;
    auto replacement = getReplacement((E*)0);
    string_t tag(replacement.first);
    auto pos = str.find(tag);
    if (pos != string_t::npos)
        str.replace(pos, tag.length(), replacement.second);
    return str;
}

template <typename E>
auto replaceElements(E const* ptr) -> std::basic_string<E>
{ return replaceElements(std::basic_string<E>(ptr)); }

Edit: Zum casten kannst du dank den char_traits auf den zugrundeliegenden Zeichentyp zugreifen. Das ist dann ein komplett generischer Ansatz.

@Soahc:
Was sprichst dagegen nach basic_string<E, Traits> zu casten?
Pumuckls Idee wäre mein zweiter Vorschlag gewesen.

Edit: Zum casten kannst du dank den char_traits auf den zugrundeliegenden Zeichentyp zugreifen. Das ist dann ein komplett generischer Ansatz.

Wie sollen die beiden Vorschläge funktionieren? Bitte gib mal Beispiele für den Cast auf basic_string<E, T> und den ominösen "komplett generischen Ansatz". Du kannst nicht ohne Spezialbehandlung mit einem Literal beide Stringtypen abfackeln.

Aber von alledem mal ganz abgesehen: lass den ganzen Quatsch, lass wchar_t komplett weg, das ist eh keine gute Idee.

string literal = "Das Literal, immer vom Typ string.";
funktionDieLiteralBraucht(basic_string<E, Traits>(literal.begin(), literal.end()));

Klappt bei mir (gcc und C++11) wunderbar.

Es geht sogar viel einfach wie ich gerade feststellen konnte.

string literal = "Das Literal, immer vom Typ string.";
funktionDieLiteralBraucht(basic_string<E, Traits>(literal.begin(), literal.end()));

Klappt bei mir (gcc und C++11) wunderbar.

Gute Idee, danke

template <class E, class T = std::char_traits<E>, unsigned N = 0>
std::basic_string<E, T> convertLiteral(char const(& lit)[N])
{ return std::basic_string<E, T>(lit, lit+N); }

template< typename E, typename Traits >
std::basic_string< E, Traits > replaceElements( std::basic_string< E, Traits > str ) {
    auto tag = convertLiteral<E, Traits>("Element");
    auto pos = str.find(tag);
    if (pos != decltype(str)::npos)
        str.replace(pos, tag.length(), convertLiteral<E, Traits>("Tnemele"));
    return str;
}

template <typename E>
auto replaceElements(E const* ptr) -> std::basic_string<E>
{ return replaceElements(std::basic_string<E>(ptr)); }

Trotzdem kein wchar_t bitte

Die letzte Variante funktioniert bei mir leider nicht. Ich kann zwar kompilieren, aber die Elemente werden nicht getauscht.

Mal mit dem Debugger reingeschaut?

/edit: ich kanns nachstellen, dass das nicht funktioniert: http://ideone.com/kOLmiU

template<typename E>
E const* replaceElements(E const* ptr){
	return replaceElements(ptr).c_str();
}

mit der ich den ursprünglich übergebenen Zeiger umbiegen kann.:

const char *str= "Teste mit Element";
const wchar_t *wstr= L"Teste ebenfalls mit Element";

str= replacePointer(str);
wstr= replacePointer(wstr);

Es wird kompiliert, aber das verhalten ist unvorhersehbar. Rufe ich die Funktion nur einmal auf, dann funktioniert es wie gewünscht, rufe ich sie mehrmals hintereinander auf, dann kommt nur murks dabei raus. Ich vermute, der vom basic_string<E> angeforderte Speicher wird nach dem aufruf von replacePointer wieder freigegeben?! Stimmt das? Und gibt es eine Möglichkeit eine solche Funktion zu schreiben?

Und gibt es eine Möglichkeit eine solche Funktion zu schreiben?

Nicht so wirklich. Das Problem was du hast ist, dass der innere Aufruf von replaceElements einen temporären string erzeugt. Auf dem rufst du c_str auf, aber direkt danach wird er zerstört, du hast also einen ungültigen Pointer. Dass das mal "funktioniert" und mal nicht, ist typisch für undefiniertes Verhalten.

Und ja, das wäre eine Methode, wenn auch eine schlechte...
Wenn dann einen unique_ptr-Array zurückgeben, das wird im Zweifelsfall automatisch gelöscht.

Die Funktion sieht jetzt so aus:

template<typename E>
	E const* replacePointer(E const* ptr){
		std::basic_string<E> str = replaceElements(ptr);
		E* array = new E[str.length()];
		memcpy( array,str.c_str(),sizeof(E)*str.length());
		return array;
	}

und der Code verhält sich so, wie ich es möchte. Aus meiner Sicht dürfte, wenn ich später ein delete auf die pointer mache, auch kein memory-leak entstehen, oder? Trotzdem möchte ich Dich bitten, mir noch mal das mit dem unique_ptr-Array-Problem zu erklären.

http://msdn.microsoft.com/en-us/library/y471khhc%28v=vs.80%29.aspx

wobei strdup einen nullterminierten String annimmt und einen nullterminierten String zurückgibt
deine Funktion nimmt einen nullterminierten String an und gibt KEINEN nullterminierten String zurück