Ich hoffe damit kennt sich einer von euch aus.
Danke im Voraus!

void Settings::FindStringW (int iID, std::wstring &strWide)
{
	wchar_t		*pwchMem	= NULL;
	wchar_t		*pwchCur	= NULL;
	HMODULE		hModule		= NULL;
	int			strIndex	= iID % 16;

	// Current module
	hModule = LS.hModule;

	HRSRC hRes = FindResourceW (hModule, MAKEINTRESOURCEW((iID / 16) +1), MAKEINTRESOURCEW(6));
	if (hRes != NULL)
	{
		pwchMem = reinterpret_cast<wchar_t*> (LoadResource (hModule, hRes));
		if (pwchMem != NULL)
		{
			pwchCur = pwchMem;
			for (int i = 0; i < 16; i++)
			{
				if (*pwchCur != NULL)
				{
					int cchString = *pwchCur;	// String length in characters
					pwchCur++;

					if (i == strIndex)
					{
						// String was found in string table
						strWide.~basic_string();
						strWide.insert (0, pwchCur, cchString);

						FreeResource (pwchMem);
						return;
					}
					pwchCur += cchString;
				}
				else
					pwchCur++;
			}
		}
	}
	else
	{
		err.NewError (EXCEPTION, L"FindResource failed, Settings::FindStringW", L"%x (hModule), %i (iID), RT_STRING", 
						hModule, iID);
	}
	return;
}

Musst es dir nur noch für dich umschreiben

Das habe ich hier bereits in fix und fertig:

UINT GetStringLength(HINSTANCE hInst, UINT uID)
{
    HGLOBAL hGlobal;
    LPWSTR  pwstr;
    HRSRC   hrsrc;
    UINT    uLen = 0, x;

    if(NULL == (hrsrc = FindResource(hInst, MAKEINTRESOURCE((uID / 16) + 1), RT_STRING)))
        return(0);

    if(NULL == (hGlobal = LoadResource(hInst, hrsrc)))
        return(0);

    if(NULL != (pwstr = (LPWSTR)LockResource(hGlobal)))
    {
        for(x = (uID % 16) + 1; x; --x)
        {
            uLen = *pwstr;
            pwstr += (uLen + 1);
        }
        UnlockResource(hGlobal);
    }

    FreeResource(hGlobal);
    return(uLen);
}

Ich bin vorher an FindResource gescheitert, habe nicht durch 16 dividiert und dann um 1 addiert, sondern einfach die ID 1 zu 1 übernommen.
Ach ja: ich habe die Division durch 16 um ein Bitshift ersetzt, ist performanter.

Sieht jetzt so aus:

String GTCORE_API LoadStringFromStringTable(HINSTANCE hModule,
											UINT uID)
{
	//Länge herausfinden	
	DWORD dwLength= SizeofResource(hModule, FindResource(hModule,MAKEINTRESOURCEW( (uID >> 4) + 1 ),RT_STRING) );
	if(!dwLength)
		throw(std::runtime_error("DWORD dwLength= SizeofResource(hModule, FindResource(hModule,MAKEINTRESOURCEW( (uID >> 4) + 1 ),RT_STRING) );"));
	WCHAR *pwcBuffer=new WCHAR[dwLength];

	//String laden
	::LoadStringW(hModule,uID,pwcBuffer,dwLength);
	String Str(pwcBuffer);
	delete[](pwcBuffer);

	return(Str);
}

Und funktioniert!

ich habe die Division durch 16 um ein Bitshift ersetzt, ist performanter.

Gemessen oder geraten? Das optimiert der Compiler doch automatisch.

Und funktioniert!

Schau Dir dwLength bitte einmal genauer an. Das ist never ever die Länge des Strings!

Belli schrieb:

Ich hab das noch nie benutzt ...
Was bitte hat das mit der Division der ResourceID durch 16 und anschließenden Addition von 1 für eine Bewandnis?

Diese Formel ergibt sich aus der Tatsache, dass die Zeichenketten in Resource-Dateien in 16er-Blöcken verwaltet werden, durch die Bitverschiebung wird ein Block angewählt, und weil die eigentlichen IDs pro Block mit 1 starten, muss das noch addiert werden.

Siehe dazu auch die Ausführungen hier:

http://blogs.msdn.com/oldnewthing/archive/2004/01/30/65013.aspx

MfG,

Probe-Nutzer