Newsgroup: it.comp.programmare.win32
Titolo: RegCreateKey() e RegSetValue()

Qualcuno potrebbe farmi un semplice esempio di come funzionano? Mi
basterebbe sapere come aggiungere una chive in una posizione con scritto
dentro qualsiasi cosa.
Grazie.
Luca Carlon

http://msdn.microsoft.com

 
http://msdn.microsoft.com
Ho già guardato, ma non ci sarebbe qualche esempio? Non sono riuscito a
farle funzionare.
Grazie.
Luca Carlon

a parte un problema di cui tempo fa avevo cercato spiegazioni qua (ovvero
del fatto che la createkey non capisce "\" come separatore delle
sottochiavi), e di cui non erano stati in grado di darmi una spiegazione, le
funzioni funzionano bene, a me... non so, che problemi hai?
anche a te succede che creando una chiave di nome "key1\key2" venga creata
una chiave chiamata "key1\key2" e non una "key2" come sottochiave di "key1"?
oltretutto a me dice che la sequenza di escape e' scorretta, cmq non sono
deficente (come mi aveva suggerito qualcuno al tempo della esposizione del
mio problema), ho provato anche con "\\" ma niente da fare, inutili anche
"/" e "//" e tutti le cose di questo tipo...

Qualcuno potrebbe farmi un semplice esempio di come funzionano? 
The RegQueryValueEx function retrieves the type and data for a
specified value name associated with an open registry key. 
LONG RegQueryValueEx(
    HKEY hKey,	// handle of key to query 
    LPTSTR lpValueName,	// address of name of value to query 
    LPDWORD lpReserved,	// reserved 
    LPDWORD lpType,	// address of buffer for value type 
    LPBYTE lpData,	// address of data buffer 
    LPDWORD lpcbData 	// address of data buffer size 
   );	
 
Parameters
hKey
Identifies a currently open key or any of the following predefined
reserved handle values: 
HKEY_CLASSES_ROOT
HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE
HKEY_USERS
lpValueName
Points to a null-terminated string containing the name of the value to
be queried. 
lpReserved
Reserved; must be NULL. 
lpType
Points to a variable that receives the key's value type. The value
returned through this parameter will be one of the following: 
Value	Meaning
REG_BINARY	Binary data in any form.
REG_DWORD	A 32-bit number.
REG_DWORD_LITTLE_ENDIAN	A 32-bit number in little-endian format (same
as REG_DWORD). In little-endian format, the most significant byte of a
word is the high-order byte. This is the most common format for
computers running Windows NT and Windows 95.
REG_DWORD_BIG_ENDIAN	A 32-bit number in big-endian format. In
big-endian format, the most significant byte of a word is the
low-order byte.
REG_EXPAND_SZ	A null-terminated string that contains unexpanded
references to environment variables (for example, "%PATH%"). It will
be a Unicode or ANSI string depending on whether you use the Unicode
or ANSI functions.
REG_LINK	A Unicode symbolic link.
REG_MULTI_SZ	An array of null-terminated strings, terminated by two
null characters.
REG_NONE	No defined value type.
REG_RESOURCE_LIST	A device-driver resource list.
REG_SZ	A null-terminated string. It will be a Unicode or ANSI string
depending on whether you use the Unicode or ANSI functions.
 
The lpType parameter can be NULL if the type is not required. 
lpData
Points to a buffer that receives the value's data. This parameter can
be NULL if the data is not required. 
lpcbData
Points to a variable that specifies the size, in bytes, of the buffer
pointed to by the lpData parameter. When the function returns, this
variable contains the size of the data copied to lpData. 
If the buffer specified by lpData parameter is not large enough to
hold the data, the function returns the value ERROR_MORE_DATA, and
stores the required buffer size, in bytes, into the variable pointed
to by lpcbData. 
If lpData is NULL, and lpcbData is non-NULL, the function returns
ERROR_SUCCESS, and stores the size of the data, in bytes, in the
variable pointed to by lpcbData. This lets an application determine
the best way to allocate a buffer for the value key's data. 
If the data has the REG_SZ, REG_MULTI_SZ or REG_EXPAND_SZ type, then
lpData will also include the size of the terminating null character. 
The lpcbData parameter can be NULL only if lpData is NULL. 
 
Return Values
If the function succeeds, the return value is ERROR_SUCCESS.
If the function fails, the return value is a nonzero error code
defined in WINERROR.H. You can use the FormatMessage function with the
FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic description of the
error.
Remarks
The key identified by hKey must have been opened with KEY_QUERY_VALUE
access. To open the key, use the RegCreateKeyEx or RegOpenKeyEx
function. 
This function does not expand the environment-variable names in the
value data when the value type is REG_EXPAND_SZ. The
ExpandEnvironmentStrings function can be used to expand the
environment-variable names. 
If the value data has the REG_SZ, REG_MULTI_SZ or REG_EXPAND_SZ type,
and the ANSI version of this function is used (either by explicitly
calling RegQueryValueEx or by not defining Unicode before including
the WINDOWS.H file), this function converts the stored Unicode string
to an ANSI string before copying it to the buffer pointed to by
lpData. 
When calling the RegQueryValueEx function with hKey set to the
HKEY_PERFORMANCE_DATA handle and a value string of a specified object,
the returned data structure sometimes has unrequested objects. Don't
be surprised; this is normal behavior. When calling the
RegQueryValueEx function, you should always expect to walk the
returned data structure to look for the requested object. 
See Also
ExpandEnvironmentStrings, RegCreateKeyEx, RegEnumKey, RegEnumKeyEx,
RegEnumValue
, RegOpenKeyEx, RegQueryInfoKey, RegQueryValue 
Esempio:
/* apro la chiave */
      value =
RegOpenKeyEx(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Run",0,KEY_ALL_ACCESS,&key);
/* controllo se un determinato valore (NomeValue) esiste nella chiave
aperta */
           if ( RegQueryValueEx(key,NomeValue,NULL,NULL,NULL,NULL) ==
ERROR_SUCCESS ) ;
           else 
/*se esiste  metto un nuovo valore */
RegSetValueEx(key,NomeValue,0,REG_SZ,Nomefile,sizeof(Nomefile)+1) ;
/* chiudo la chiave */
           RegCloseKey(key);

            RegCloseKey(key);
Grazie, mi bastavano gli esempi, il resto lo avevo trovato.
Luca Carlon

 scritto dentro qualsiasi cosa.
Le chiavi si creano e si aprono sempre relativamente ad un'altra 
chiave. Fin qui ci sei? ok... le chiavi aperte sono identificate da un 
valore, chiamato handle, tutto ok fin qui? Gli handle si ottengono 
quindi aprendo una chiave relativamente ad un handle di riferimento, e 
per risolvere questo problema uovo-gallina (come faccio ad aprire una 
chiave per ottenere un handle se non ho nessun handle di riferimento? 
come ottengo l'handle di riferimento se non posso aprire una chiave?), 
i tecnici Microsoft hanno fatto questa (discutibilissima) scelta di 
stabilire una serie di handle speciali, sempre aperti e disponibili 
(prego astenersi da battute di cattivo gusto), che rappresentano le 
chiavi di cui tutte le altre chiavi sono discendenti. Tali handle sono:
HKEY_CLASSES_ROOT
HKEY_CURRENT_USERS
HKEY_LOCAL_MACHINE
...
aspetta, ma questo lo sai già, vero? Inutile ripetere quello che sai 
già o che comunque trovi scritto ovunque. Allora, detto questo ti serve 
solo sapere che la sequenza di chiamate che ti serve è qualcosa del 
genere:
 - apri/crei la tua bella chiave con RegCreateKey, stabilendo uno degli
   handle speciali di cui sopra come handle di riferimento, e il
   percorso alla tua chiave (attenzione, il registro accetta solo lo
   slash inverso come separatore). In questo modo otterrai un handle
   alla chiave appena aperta/creata
 - passi quest'ultimo handle a RegSetValue, che appunto vuole un handle
   alla chiave da manipolare
-- 
 < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
     Don't stand, REACT!      version 0.0.18. C, C++ and ASM developers
                              and beta testers are welcome!