[C++]RegQueryValueEx

[HVDSV]

Vorrei ottenere il valore corrispondente ad una chiave nel registro di windows.


Ho fatto:

wchar_t* RegOp::ReadKeyRegistry(LPCTSTR key, wchar_t* def)
{
     HKEY hKey;
     TCHAR result[512];
    
      if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Chiave") ,0,NULL,&hKey) == ERROR_SUCCESS)
      {
          DWORD dwType;
          DWORD dwSize;
          dwSize = sizeof(result);

          if (RegQueryValueEx(hKey, key, 0, &dwType, (LPBYTE)&result, &dwSize) == ERROR_SUCCESS && dwType == REG_SZ)
          {			
			  return  (wchar_t*)result;
          }
          RegCloseKey(hKey);
     }
	  return def;
}

wchar_t* prova1 = new wchar_t[256];
wchar_t* prova2 = new wchar_t[256];

prova1 = reg->ReadKeyRegistry(_T("prova1"),_T("ciao"));
prova2 = reg->ReadKeyRegistry(_T("prova2"),_T("pippo"));

Quello che mi aspetto è:
1-prova1= "test1";
2-prova2="test2";

Quello che succede è:

1- in prova1 viene messo il valore che mi aspetto (test1);
2- in prova2 viene messo il valore che mi aspetto (test2), ma prova1 viene modificato con lo stesso valore di prova2(test2)

Che pasticcio sto facendo?

[fero86]

hai commesso un errore concettuale per il quale Gesu Bambino sotto Natale piange: hai restituito il puntatore ad un buffer allocato sullo stack, é una cosa da non fare mai. il motivo é lasciato come esercizio per lo studente

PS: hai anche fatto un po' di macello tra wchar_t e TCHAR; a parte il fatto che in Win32 é preferibile usare WCHAR piuttosto che wchar_t, comunque deciditi: o usi WCHAR o usi TCHAR; nel tuo caso specifico sono la stessa cosa (probabilmente hai la macro UNICODE definita nelle impostazioni di Visual C++, come avviene di default) ma in generale non lo sono.

[HVDSV]

Originariamente inviato da fero86

hai commesso un errore concettuale per il quale Gesu Bambino sotto Natale piange: hai restituito il puntatore ad un buffer allocato sullo stack, é una cosa da non fare mai. il motivo é lasciato come esercizio per lo studente

PS: hai anche fatto un po' di macello tra wchar_t e TCHAR; a parte il fatto che in Win32 é preferibile usare WCHAR piuttosto che wchar_t, comunque deciditi: o usi WCHAR o usi TCHAR; nel tuo caso specifico sono la stessa cosa (probabilmente hai la macro UNICODE definita nelle impostazioni di Visual C++, come avviene di default) ma in generale non lo sono.

Purtroppo sui puntatori ho una gran confusione
Se ho capito giusto l'errore è nel restituire il puntatore a una variabile locale, allocata nello stack.
Potrei quindi allocarla nell'heap con una malloc o ho detto una str@@@ ?
E se passassi altri due parametri alla funzione, un buffer in cui mettere il risultato e un size_t per la dimensione GesuBambino si dispererebbe ancor di più?


Il TCHAR mi era scappato . Ma non ho capito che differenza c'è tra wchar_t e WCHAR

[HVDSV]

Invece di usare una malloc ho utilizzato new.
Così pare funzionante. Casualità?

wchar_t* ReadKeyRegistry2(wchar_t* key,wchar_t* def)
{
      HKEY hKey;
     wchar_t*  result = new wchar_t[256];

       if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("chiavel) ,0,NULL,&hKey) == ERROR_SUCCESS)
      {
          DWORD dwType;
          DWORD dwSize;
          dwSize = 255; /// sizeof(result);

          if (RegQueryValueEx(hKey, key, 0, &dwType, (LPBYTE)result, &dwSize) == ERROR_SUCCESS && dwType == REG_SZ)
          {	
	   return  result;
          }
          else 
         {
	  int y = GetLastError();

        }
          RegCloseKey(hKey);
     }
	  return def;
}

Quello che adesso non capisco è perché in dwSize se uso sizeof() restituisce 4 e la RegQueryValueEx fallisce

[Tommo]

Non vorrei dire una min****ta
Credo che succeda perchè new wchar_t[256] alloca 256*sizeof(wchar_t) bytes, ma poi te a RegQueryValueEx gli dici di operare su 255 bytes...
se quella funzione chiede una size in bytes dovresti usare 256*sizeof(wchar_t), come fai implicitamente quando usi new.

In più è ovvio che sizeof( result ) sia 4, perchè è come scrivere sizeof( puntatore ) che è 4!
non dimenticare che in C/C++ gli array sono semplicemente dei puntatori al primo elemento, e il modo giusto per ottenere la grandezza completa è quello che ho scritto sopra... cioè numero di elementi * sizeof( elemento )