Möglichst einfach und sicher.

Jetzt hab ich es fast geschafft:

wchar_t* CharToWide(char* source)
{
   size_t sourcesize = strlen(source) + 1;
   const size_t newsize = 100;
   size_t convertedChars = 0;
   wchar_t wcstring[newsize];
   mbstowcs_s(&convertedChars, wcstring, sourcesize, source, _TRUNCATE);
   return wcstring;
}

int main()
{
   char* orig = "Lol Lol Lol";
   Print(CharToWide(orig));
}

Ich erhalte aber immer nur "Lo". Die ersten zwei Zeichen.
Wenn ich aber nicht die Funktion benütze, sondern alles nacheinander
schreibe, dann gehts.
Kann mir das mal einer erklären?
Und was mach ich denn falsch?

mfg
vampir26

An einen C- String der std::string bzw. std::wstring Objekte kommst Du mit std::string::c_str() bzw. std::wstring::c_str().

Simon

Außerdem ist mbstowcs_s Windows-spezifisch, also gehört das ganze ins WinAPI-Forum. Ein C++-Weg, das zu machen, wäre beispielsweise

#include <string>

std::wstring widen(std::string const &s) {
  return std::wstring(s.begin(), s.end());
}

einen wchar_t const * kannst du dann mit c_str() nehmen. Wenn du einen variablen wchar_t-Buffer brauchst,

std::wstring ws = widen("foo");
wchar_t buf[LANG_GENUG];
std::copy(ws.begin(), ws.end(), buf);

Obwohl ich noch nicht alles 100% begreife ^^
Ist kompliziert mit den ganzen Typen und Zeiger und blabla

Etwa kann ich so:

char hello[] = "Hello, world!";
std::string s(hello, hello + 13);
std::string s2(s.begin(), s.end());

Strings erstellen, die "Hello, world!" enthalten. Auch kann ich so:

std::vector<int>(s.begin(), s.end());

einen Integer-Vektor erstellen, der die ASCII-Werte der Buchstaben in s enthält, weil char in int umwandelbar ist. Da char ebenfalls in wchar_t (den Werttyp eines std::wstring) umwandelbar ist, kann ich auf die gleiche Weise

std::wstring ws(s.begin(), s.end());

schreiben und einen wstring erstellen, dessen Inhalt dem von s entspricht. Das Ergebnis ist das selbe, als hätte ich

std::wstring(s.size());

for(std::size_t i = 0; i < s.size(); ++i) {
  ws[i] = s[i];
}

geschrieben.

Bei komplexen Datentypen gibt es Feinheiten mit Konstruktoren und Zuweisungsoperatoren zu beachten, aber ich hoffe, dass die grundlegende Idee damit klar geworden ist.

Ich verwende die Irrlicht Engine mit der RakNet Engine, sende Pakete mache ein
ganzes Login System - alles kein Problem, aber ein paar Variablen zu konvertieren
Ich bekomme dauernd Warnungen, dass die Variable unsicher ist und blabla

Ich werd die Funktion sehr oft nutzen und deshalb ist es wichtig, dass die
wirklich klappt.

wchar_t* ConvertCharToWidechar(std::string const &s)
{
   std::wstring temp = std::wstring(s.begin(), s.end());
   wchar_t* dest = new wchar_t[strlen(s.c_str())];
   std::copy(temp.begin(), temp.end(), dest);
   return dest;
}

Muss ich jetzt den Speicher der Variable dest wieder freigeben? Ich bekomm nähmlich die Warnung:

warning C4996: 'std::copy': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS.

Funktionieren tuts im moment gut, aber wird dann später schwierig den Fehler zu finden, wenn plötzlich was nicht mehr funzt.

Thx für hilfe

MS hat sich aber damals verpflichtet, gegen solche unsicheren Funktionen vorzugehen. Auch für ihre eigenen Inhouse-Entwickler! Genau deshalb kommen solche Meldungen von MS-Compiler, weil man unsichere C-Funktionen verwendet! Andere Compiler melden so was nicht.

Entweder du benutzt eine sichere Funktion, oder du schaltest die Warnung ab, weil du der Meinung bist, das du es besser weißt. Und wie das geht, steht sogar am Ende der Warning-Meldung. Machen mußt du es aber selber.

Übrigens hilft die MSDN bei Warning und Error Meldungen immer weiter, in dem man Fehlercode (in disem Fall C4996) eingibt:
http://msdn.microsoft.com/en-us/library/ttcz0bys.aspx

Was die Warnung angeht, die kannst du getrost ignorieren (bzw. das angegebene Makro in die Projekteigenschaften aufnehmen). Microsoft hat seit MSVC 2005 eine Reihe von nicht standardisierten Funktionen, die im Grunde das gleiche wie Standardfunktionen machen, aber anderes Fehlerbehandlungsverhalten haben. In einigen Fällen ist das sinnvoll, beispielsweise gets und strcpy, allerdings gibt es dafür in nahezu allen Fällen standardisierte Funktionen, die deren Probleme behandeln (gets -> fgets, strcpy -> strncpy).

Das Problem damit ist, dass MSVC mit ziemlich bei den Haaren herbeigezogenen Begründungen über nicht weiter gefährliche Funktionen warnt. Es ist ohne die *_SECURE_NO_WARNINGS-Makros nahezu unmöglich, standardkonformen C++-Code (oder auch C-Code) zu schreiben, über den MSVC sich nicht beschwert. Im Falle von std::copy kannst etwa du Probleme kriegen, wenn du dich sehr dämlich anstellst, beispielsweise

std::string s = "foo", s2 = "bar", s3;

// Iteratoren von zwei verschiedenen Containern als Bereichsbegrenzungen,
// d.h. KAWUMM!
std::copy(s.begin(), s2.end(), std::back_inserter(s3));

Natürlich kann man die _s-Funktionen auf ähnliche Weisen auch zu Blödsinn überreden, ein Gewinn ist damit also an dieser Stelle nicht wirklich zu haben.

Ich habe den Verdacht, dass dahinter vor allem das Bestreben steht, Programmierer dazu zu erziehen, nur unter Windows lauffähigen Code zu schreiben.