4. Bekomm RegQueryValueEx einfach nicht zum laufen

Bekomm RegQueryValueEx einfach nicht zum laufen

  • P

    Hi,
    ich hab (immernoch) Probleme mit der Registry Funktion "RegQueryValueEx" (http://msdn2.microsoft.com/en-us/library/ms724911.aspx) und zwar will ich nen REG_SZ-Wert auslesen aber bekomme das einfach nicht hin.
    Bei vielen Beispielen im Internet gebrauchen die Schreiber dort recht viele, für meinen Zweck unnötige viele (so denk ich das) Variablen da ich die Funktion nur einmal aufrufe und dort können die Werte alles statisch sein.
    so weit bin ich nun:

    //hKey wurde mit RegOpenKeyEx zugewiesen (das funktioniert korrekt, da ich ohne Probleme mit hKey schreiben kann)
RegQueryValueEx(hKey,"irgendwas",NULL,REG_SZ, //als nächstes muss nun eine Variable die den Wert speichert kommen, danach eine Variable die die Größe des Wertes beschreibt

    Ich hab schon alles Mögliche probiert aber bekomme immer eine Fehlermeldung nach der anderen, wenn ich die eine Fehlermeldung vermieden habe kommt die Nächste und wenn es dann mal läuft bekomm ich als ausgelesenen Wert nur murks raus.

    0
  • K

    Wahrscheinlich hast Du die Werte für den Typ und die Buffergröße direkt angegeben. Du mußt aber Zeiger auf diese einsetzen, dann funktionierts. Wenn r = 0, dann war die jeweilige Funktion erfolgreich.

    #include <windows.h>
#include <conio.h>
#include <stdio.h>

int main()
{
  HKEY k;
  unsigned long r, t, s;
  unsigned char b[160];

  r = RegOpenKeyEx(HKEY_CLASSES_ROOT, ".aom", 0, KEY_QUERY_VALUE, &k);
  printf("RegOpenKeyEx: r %i k %08lX\n\n", r, k);

  t = REG_SZ;
  s = sizeof(b);
  r = RegQueryValueEx(k, "Content Type", 0, &t, b, &s);
  printf("RegQueryValueEx: r %i s %u b \"%s\"\n\n", r, s, b);

  r = RegCloseKey(k);
  printf("RegCloseKey: r %i\n", r);

  getch();
  return 0;
}
    0
  • P

    Hi,
    sorry hat ein wenig gedauert aber hatte viel zu tun...
    Der Code funtzt nun, aber wie bekomme ich den REG_SZ-Wert in einen String?

    0
  • E

    ganz einfach:

    #define CHARLEN 259
HKEY CClass::Open(const std::string& strKey, HKEY hKey){
    HKEY ret=0;
    ::RegOpenKeyEx(hKey, strKey.c_str(), 0, KEY_ALL_ACCESS, &ret);
    return ret;
}
bool CClass::Close(HKEY key){
    return (::RegCloseKey(key)) ? false : true;
}
bool CClass::ReadValue(const std::string& strKey, const std::string& strTitle, std::string& strDest, HKEY hKey){
    HKEY key = Open(strKey, hKey);
    TCHAR *_tstr = new TCHAR[CHARLEN];
    DWORD lpType;
    DWORD lpcbData;
    bool ret = (::RegQueryValueEx(key, strTitle.c_str(), 0, &lpType, reinterpret_cast<LPBYTE>(_tstr), &lpcbData)) ? false : true;
    Close(key);
    strDest = _tstr;
    delete [] _tstr;
    _tstr = 0;
    return ret;
}

    der aufruf dann einfach

    CClass cclass;
std::string destination;
m_cclass.ReadValue(_T("SOFTWARE\\"), _T("subkey title"), destination, HKEY_LOCAL_MACHINE);
    0
  • P

    Mr Evil schrieb:

    ...ganz einfach:....

    Öhm ja.. Wenn ich sowas wie "ganz einfach" lese denk ich an ein paar Zeile Code und nicht an sowas 😮
    Ist das der Standardweg, um ein Keywert in einen String zu bekommen? Ist ja schön, dass du dir so viel mühe gegeben hast mit dem Code (oder war der nur kopiert?) aber, wenn das einfacher geht, dann bin ich ehr für einen kurzen und bündigen weg.
    Wenn das natürlich das Standardverfahren ist werd ich das wohl so nutzen müssen.

    Zumal was ist CClass? Haste den Code ausm Header kopiert oder wie?

    0
  • M

    Also wenn du mal die ganzen Klassen-Sachen weglässt ist der Code allgemein formuliert der Standardweg. Ja. Aber wenn du das einmal getippt hast gehts nun wirklich einfach wie nix.

    Greetz
    M.T.

    0
  • C

    @Mr Evil:

    TCHAR *_tstr = new TCHAR[CHARLEN];

    ist überflüssig. Sollte statisch allokiert werden.

    Und das mit dem 'Close' sollte sinnvollerweise über den Destruktor abgehandelt werden ➡ Preventing-Resource-Leaks.

    EDIT, PS: Man sollte seine (Variablen-)Namen nicht mit einem Unterstricht beginnen lassen, da es so schnell zu Namenkonflikten kommen kann, da diese auch intern vom Compiler verwendet werden ⚠ .

    0
  • E

    das war kopiert, darum ist auch CHARLEN angegeben da ich das in einer eigenen define header hab wo ich das dann immer schnell aendern kann

    kurzfassung:

    TCHAR *_tstr = new TCHAR[259];
DWORD lpType;
DWORD lpcbData;
HKEY key=0;
::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE"), 0, KEY_ALL_ACCESS, &key);
::RegQueryValueEx(key, strTitle.c_str(), 0, &lpType, reinterpret_cast<LPBYTE>(_tstr), &lpcbData);
::RegCloseKey(key)
std::string strDest;
strDest = _tstr;
delete [] _tstr;
_tstr = 0;

    ps das mit den unterstrichen mach ich immer wenn etwas fuer Unicode und Multibyte compiliert werden kann, dann sieht man schnell das es so ist
    _T("Text"); // string
    _tstr // string zb strd::string oder std::wstring, oder ein *TCHAR

    0
Anmelden zum Antworten