FAQ C++ BuilderConsultez toutes les FAQ

La base de registre stocke ses données dans un arbre hiérarchiquement structuré. La partie du registre qui apparaît en tant que fichier sur votre disque dur s'appelle une ruche. Le sous-arbre du registre est divisé en ruches (en raison de leur ressemblance avec la structure cellulaire d'une ruche d'abeilles). Une ruche correspond à un ensemble discret de clés, de sous-clés et de valeurs, qui figure en haut de la hiérarchie du Registre.

Chaque noeud dans l'arbre s'appelle une clé.
Chaque clé peut contenir des sous-clés et des rubriques valuées appelées valeurs. Une clé peut avoir n'importe quel nombre de valeurs, et les valeurs peuvent être de n'importe quel type prédéfini.
Chaque clé possède un nom se composant d'un ou plusieurs caractères imprimables c'est-à-dire, s'étendant des valeurs ASCII 32 à 127.
Les noms principaux ne peuvent pas inclure d'espace, d'antislash (\), ou de caractère de remplacement (* ou ?).
Les noms principaux commençant par un point (.) sont réservés.
Le nom de chaque sous-clé est unique dans le contexte de sa clé parente.
Les noms de clé n'utilisent pas d'autres langues que l'US ; les valeurs peuvent par contre utiliser d'autres langues.

Notes:

• Une clé absolue commence par une barre oblique inverse (\) et est sous-clé de la clé racine.
• Une clé relative est sous-clé de la clé en cours.
• Une clé non-volatile est stockée dans un fichier et est préservée lorsque le système redémarre ( NT ).
• Une clé volatile est stockée en mémoire et n'est pas préservée lorsque le système redémarre ( NT ).
  

Tous les accès à la base de registre sont encapsulés dans une classe : TRegistry. Cette classe est définie dans l'unité Registry, c'est pourquoi il est indispensable d'inclure registry.hpp avant toute manipulation du registre.

#include <registry.hpp>

TRegistry *registre = new TRegistry();

registre->RootKey = HKEY_CLASSES_ROOT;

registre->CloseKey();

delete registre;

1
2
registre->CloseKey(); 
delete regisre;

1
2
3
4
5
6
7
8
9
10
TRegistry *registre = new TRegistry(); 
try 
{ 
   registre->RootKey = HKEY_CLASSES_ROOT; 
   // Traitement... 
} 
__finally 
{ 
   delete registre; 
}

Quelques méthodes de TRegistry n'opèrent que sur des clés existantes, dans ces cas-là on testera préalablement l'existence de la clé en utilisant la méthode KeyExists.

1
2
3
if registre->KeyExists("nom_de_la_clé") 
{ 
  // ...

Quelques méthodes de TRegistry n'opèrent que sur des valeurs de clé existante, dans ces cas-là on testera préalablement leur existence en utilisant la méthode ValueExists.

1
2
3
if registre->ValueExists("nom_de_la_valeur") 
{ 
  // ...

Lorsqu'on exécute un traitement itératif sur un sous-ensemble de clés il est parfois nécessaire de savoir si la clé en cours possède des sous-clés. Dans ces cas-là on utilisera la méthode HasSubKeys.

1
2
3
if registre->HasSubKeys() 
{ 
  // ...

Pour créer une nouvelle clé on utilise la méthode CreateKey. Le nom de la clé à créer peut être absolu ou relatif.

1
2
3
4
5
TRegistry *registre = new TRegistry(); 
registre->RootKey = HKEY_CURRENT_USER; 
if(registre->CreateKey("\\Software\\Essai")) // Nom absolu 
{ 
  ...

1
2
3
4
5
6
7
TRegistry *registre = new TRegistry(); 
registre->RootKey = HKEY_CURRENT_USER; 
if(registre->OpenKeyReadOnly("Software")) 
{ 
   if(registre->CreateKey("Test")) // Nom relatif 
   { 
    ...

Pour accéder à la valeur d'un nom de clé, il faut ouvrir la clé qui la contient. On utilise pour cela la méthode OpenKey de TRegistry :

bool __fastcall OpenKey(const AnsiString Key, bool CanCreate);

registre->OpenKey("nom_de_la_clé", true);

maChaine = registre->ReadString("nom_de_la_valeur");

registre->WriteString("nom_de_la_valeur", "valeur");

1
2
3
if(registre->DeleteValue("nom_de_la_valeur"); 
{ 
  ...

Lorsqu'on envisage d'effectuer un traitement itératif sur un ensemble de clés, on utilise la méthode GetKeyNames. Elle permet de récupérer une liste de l'ensemble des noms des sous-clés de la clé en cours en initialisant un objet d'un type descendant de TStrings.

1
2
3
4
5
6
7
8
9
10
TRegistry *registre = new TRegistry(); 
TStringList *mesCles = new TStringList(); 
  
// la clé racine par défaut est HKEY_CURRENT_USER 
registre->OpenKeyReadOnly("Software"); // clé courante 
registre->GetKeyNames(mesCles); 
ShowMessage(mesCles->Count); // affiche le nombre de sous-clés 
  
delete registre; 
delete mesCles;

Lorsqu'on envisage d'effectuer un traitement itératif sur l'ensemble des valeurs d'une clé, on utilise la méthode GetValueNames. Elle permet de récupérer une liste de l'ensemble des valeurs de la clé en cours en initialisant un objet d'un type descendant de TStrings.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
TRegistry *registre = new TRegistry(); 
TStringList *mesCles = new TStringList(); 
  
registre->OpenKeyReadOnly("Software\\Borland\\C++Builder\\6.0"); // clé courante 
registre->GetValueNames(mesCles); // lecture des noms 
  
// affichage d'une des valeurs 
AnsiString val, res; 
val = mesCles->Strings[6]; 
res = val + "=" + registre->ReadString(val); 
ShowMessage(res); // affiche "Version=PRO" 
  
delete registre; 
delete mesCles;

On peut supprimer une clé devenue inutile : cette opération supprimera également toutes les valeurs qu'elle contient.
Ceci est le rôle de la méthode DeleteKey de TRegistry.

1
2
3
4
if(registre->DeleteKey("nom_de_la_clé")) 
{ 
   // la clé a bien été supprimée 
}

Il est parfois nécessaire de modifier des clés de registre d'une machine distante. Dans ce cas on utilise la méthode RegistryConnect.

bool __fastcall RegistryConnect(const AnsiString UNCName);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void __fastcall LitClesDistantes(AnsiString serverName, TStringList* listeSousCles) 
{ 
   AnsiString CleMachineDistante = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion"; 
   AnsiString CleRecherchee = "App Paths"; 
  
   TRegistry *registreMachineDistante = new TRegistry(); 
   listeSousCles->Clear(); 
  
   try 
   { 
      /* pour les accès distant la propriété RootKey est égale soit 
         à HKEY_USERS soit à HKEY_LOCAL_MACHINE                  */ 
      registreMachineDistante->RootKey = HKEY_LOCAL_MACHINE; 
      if(!registreMachineDistante->RegistryConnect("\\\\"+serverName)) 
      { 
         // vérifier la configuration réseau ou les permissions d'accès 
         ShowMessage("Impossible de se connecter."); 
         return; 
      } 
      if(registreMachineDistante->OpenKeyReadOnly("\\"+CleMachineDistante+"\\"+CleRecherchee)) 
      { 
         registreMachineDistante->GetKeyNames(listeSousCles); // liste des sous-clés 
      } 
      else 
      { 
         ShowMessage("Erreur, clé absente."); 
      } 
    } 
    __finally 
    { 
       delete registreMachineDistante; 
    } 
}

La propriété ACCESS spécifie le niveau d'accès à utiliser lors de l'ouverture d'une clé. Le niveau d'accès autorisé dépend des permissions associées à votre compte NT.

L'accès à la base de registre d'une machine peut être limité par l'administrateur. Si vous définissez la propriété Access=KEY_ALL_ACCESS vous devez avoir le droit d'accès NT 'contrôle total' sur la clé que vous souhaitez modifier.

Sous NT/W2K et XP, vous pouvez visualiser les droits en utilisant l'outil RegEdt32.
Voir l'aide en ligne pour plus de détails.