char buffer1[50];
char buffer2[50];
.
.
.
.
char buffer10[50];

alle enthalten mehr oder weniger lange \0 terminierte strings
ich muss diese zusammensetzten, und am Ende

static TCHAR myTchar[] = DerGesamteString;

herausbekommen
Hat jemand eine Idee dazu?

static TCHAR myTchar[] = _T("Ein Beispielstring");

klappt prima, aber wie bringe ich den string da rein?

static TCHAR myTchar[] = _T(myString.c_str());

ergibt:
initializer fails to determine size of `myTchar'
logisch, kann nicht gehen, aber wie sonst?

typedef std::basic_string<TCHAR> tstring

static TCHAR myTchar[] = _T(myString.c_str());

ohohoh... Du kannst nicht einfach so ein array da draus machen. Nur einen Pointer auf ein array. Und static wird das dann auch niemals!

//Das sollte funktionieren
TCHAR *myTchar = myString.c_str();

invalid conversion from `const char*' to `TCHAR*'

Thomasio schrieb:

static TCHAR myTchar[] = DerGesamteString;

das kann niemals funktionieren, denn eine arraydefinition ohne dimensionsangabe benötigt eine geeignete initilisierungsliste oder ein stringliteral.

der vorschlag mit c_str ist genauso unsinnig, denn das ergebnis von c_str wird relativ schnell ungültig - spätestens, wenn der string zerstört wird.

wenn wir schon dabei sind...

char buffer1[50];
char buffer2[50];
.
.
.
.
char buffer10[50];

std::string my_string = std::string(buffer1)+buffer2+buffer3+ ... + buffer10;
std::basic_string<TCHAR> my_tstring;
std::transform(my_string.begin(),my_string.end(),std::back_inserter(my_tstring),std::bind1st(
    std::mem_fun(static_cast<TCHAR (std::ctype<TCHAR>::*)(char) const>(&std::ctype<TCHAR>::widen)),&std::use_facet<std::ctype<TCHAR> >(std::locale())));

ist auch ein bisschen masochistisch...

soviel unfug auf einen haufen...

Thomasio schrieb:

static TCHAR myTchar[] = DerGesamteString;

das kann niemals funktionieren, denn eine arraydefinition ohne dimensionsangabe benötigt eine geeignete initilisierungsliste oder ein stringliteral.

der vorschlag mit c_str ist genauso unsinnig, denn das ergebnis von c_str wird relativ schnell ungültig - spätestens, wenn der string zerstört wird.

wenn wir schon dabei sind...

char buffer1[50];
char buffer2[50];
.
.
.
.
char buffer10[50];

std::string my_string = std::string(buffer1)+buffer2+buffer3+ ... + buffer10;
std::basic_string<TCHAR> my_tstring;
std::transform(my_string.begin(),my_string.end(),std::back_inserter(my_tstring),std::bind1st(
    std::mem_fun(static_cast<TCHAR (std::ctype<TCHAR>::*)(char) const>(&std::ctype<TCHAR>::widen)),&std::use_facet<std::ctype<TCHAR> >(std::locale())));

ist auch ein bisschen masochistisch...

ein bisschen?!?!

TCHAR buffer1[50];
TCHAR buffer2[50];
.
.
.
.
TCHAR buffer10[50];

typedef std::basic_string<TCHAR> tstring;
tstring my_tstring = tstring(buffer1)+buffer2+buffer3+ ... + buffer10;
// Dann kannste wenigstens das gecaste wech lassen

Habe aber nochmal einen Link gefunden, wo einer eine Klasse für die Umwandlung erstellt hat (eigentlich das was camper da schrieb):
http://www.codecomments.com/archive373-2005-4-477778.html

static TCHAR myTchar[]

einen const TCHAR draus zu machen führt eine Zeile weiter nur zu
invalid conversion from const TCHAR* to TCHAR*

std::string my_string = std::string(buffer1)+buffer2+buffer3+ ... + buffer10;
std::basic_string<TCHAR> my_tstring;
std::transform(my_string.begin(),my_string.end(),std::back_inserter(my_tstring),std::bind1st(
    std::mem_fun(static_cast<TCHAR (std::ctype<TCHAR>::*)(char) const>(&std::ctype<TCHAR>::widen)),&std::use_facet<std::ctype<TCHAR> >(std::locale())));

bringt mehr Errors als ich zählen kann
und beim typedef funktioniert die konvertierung zu TCHAR* auch nicht

das ist ja alles ganz nett, das meiste davon hatte ich selber auch schon raus, hilft mir nur nicht, denn am Ende brauche ich

static TCHAR myTchar[]

einen const TCHAR draus zu machen führt eine Zeile weiter nur zu
invalid conversion from const TCHAR* to TCHAR*

std::string my_string = std::string(buffer1)+buffer2+buffer3+ ... + buffer10;
std::basic_string<TCHAR> my_tstring;
std::transform(my_string.begin(),my_string.end(),std::back_inserter(my_tstring),std::bind1st(
    std::mem_fun(static_cast<TCHAR (std::ctype<TCHAR>::*)(char) const>(&std::ctype<TCHAR>::widen)),&std::use_facet<std::ctype<TCHAR> >(std::locale())));

bringt mehr Errors als ich zählen kann
und beim typedef funktioniert die konvertierung zu TCHAR* auch nicht

du benötigst dafür diese header:

#include <string>
#include <algorithm>
#include <locale>
#include <utility>
#include <functional>

falls du wirklich ein statisches array benötigst, wäre noch etwas der art:

static TCHAR myTchar[sizeof buffer1+sizeof buffer2+...+sizeof buffer10]

möglich. es ist aber eben nicht möglich, dieses array direkt so zu initialisieren, wie du es wünschst.

selbst wenn ich die exakte Länge von myString kenne und
static TCHAR myTchar[47]
schreibe, bekomme ich
invalid initializer

Ich hätte gern den Inhalt der buffer in static TCHAR myTchar[]
was ich dabei wie konvertieren muss, ob über std:string oder sonstwas ist mir völlig wurscht
mit Deinen headern sind zwar die Fehler weg, bin ich aber auch wieder bei
cannot convert const TCHAR* to TCHAR*

selbst wenn ich die exakte Länge von myString kenne und
static TCHAR myTchar[47]
schreibe, bekomme ich
invalid initializer

wie sieht denn dein code aus? ich bin davon ausgegangen, dass my_tstring als ersatz für myTchar dient. die benutzung eines arrays ist trivial genug:

std::string my_string = std::string(buffer1)+buffer2+buffer3+ ... + buffer10;
static TCHAR myTchar[...];
std::transform(my_string.begin(),my_string.end(),myTchar,std::bind1st(
    std::mem_fun(static_cast<TCHAR (std::ctype<TCHAR>::*)(char) const>(&std::ctype<TCHAR>::widen)),&std::use_facet<std::ctype<TCHAR> >(std::locale())));

fundamentale vorteile hat das nicht. wenn du auf exakte konvertierung keinen wert legst, würde ein simples copy auch reichen:

std::copy(my_string.begin(),my_string.end(),myTchar);

static TCHAR myTchar[sizeof buffer1+sizeof buffer2+...+sizeof buffer10];
std::copy(my_string.begin(),my_string.end(),myTchar);

und schon funktioniert das
danke auch