Nachdem ich nun seit gestern Abend alles abgesucht habe
und trotzdem nicht zu einer Lösung gekommen bin, wollte
ich es mal hier versuchen.

Arbeite mit Visual Studio 2005 und es handelt sich um ein
Spiel mit DirectX. Ich lese den Pfad eines Chipsets für eine
Map aus einem Textfile. Ich muss den Pfad als LPCTSTR übergeben.

Ich konvertiere den (C-)String in einen wchar_t*.
Diesen übergebe ich an den Map-Konstruktor.
Nun, beim Konvertieren klappt alles wunderbar.
Die Übergabe an den Konstruktor funktioniert ebenfalls.
Nur:
Sobald der Funktionsrumpf des Konstruktors betreten wird,
wird aus dem Pfad ("H:/Blah/Chipset.png") irgend ein Kauderwelsch.
Ohne dass ich etwas mache, es passiert einfach so im Konstruktor.

Weiss jemand, was das ist? Habe ich nicht gut genug gesucht?

wchar_t* str = Convert(tmpChipset.c_str());
LPCTSTR arrrr = str; // Zum Überprüfen noch in LPCTSTR

// GameMap erstellen
GameMap gm(tmpWidth, tmpHeight, renderDevice, arrrr);

Convert-Funktion:

wchar_t* Convert(const char* cp)
{
	// Convert to a wchar_t*
    size_t origsize = strlen(cp) + 1;
    const size_t newsize = 100;
    size_t convertedChars = 0;
    wchar_t wcstring[newsize];
    mbstowcs_s(&convertedChars, wcstring, origsize, cp, _TRUNCATE);
    return wcstring;
}

Der Wert von arrrr wird in ein Kauderwelsch verändert, sobald der Konstruktor aufgerufen wird.

GameMap::GameMap(int width, int height, LPDIRECT3DDEVICE9 renderDevice, LPCTSTR chipsetPath)
{
	this->width = width; // Hier. Einfach so. Plopp.
	this->height = height;
	this->renderDevice = renderDevice;
	this->chipsetPath = chipsetPath;

	this->tileWidth = 16;
	this->tileHeight = 16;

	this->Initialize();
	this->LoadContent();
}

================================

Das Problem gab es jetzt nochmal an einer anderen Stelle, mit einem normalen char*. Sobald ich ihn an eine Funktion übergebe -> selbes Veränderungs-Problem.

wchar_t* a = NULL;
char* b = a; // Gibt nur eine Warnung

Dass bei sowas nur Müll raus kommt, sollte klar sein.
LPCTSTR ist ja nur ein Makro (afaik), das von der Projekteinstellung abhängig ist.
Denn: "LPCTSTR = const char* oder const wchar_t* abhängig von _UNICODE"

Wenn dein LPCTSTR ein const char* ist, ist deine Konvertierung für die Katz'.

2. Warum machst du tmpChipset nicht zu einem std::wstring, wenn du eh mit wchar_t* arbeiten musst? Dann könntest du dir die Konvertierung sparen.

Falls du dein Programm ohne Unicode schreibst, sollte folgendes schon ausreichen und funktionieren.

LPCTSTR arrrr = tmpChipset.c_str();
GameMap gm(tmpWidth, tmpHeight, renderDevice, arrrr);

#include <iostream>
#include <string>
using namespace std;

void GameMap(LPCTSTR chipsetPath)
{
	// Wenn du jetzt den wstring doch wieder als normalen string brauchst,
	// beispielsweise um ihn auszugeben, kann man das so machen.
	// Falls du allerdings versuchen würdest chipsetPath direkt auszugeben,
	// ist das schon klar, dass da nur "Müll" rauskommt.
	std::string str;
	for(size_t i=0; i < wcslen(chipsetPath); ++i)
		str += static_cast<char>(chipsetPath[i]);
	cout << str << endl;
}

int main()
{    
	wstring tmpChipset = L"H:/Blah/Chipset.png";

	GameMap(tmpChipset.c_str());

    return 0;
}