Le registre facile (vc++ sans mfc)

Télécharger le projet
Commenter

Description

Voici une classe permattant une gestion quasi-totale du registre!
La plupart de celle deja presente sur le site présente des defaut, tel que la limite dans la saisie et la lecture des clés registres. Ce qui a pour effet de faire planter les prog utilisant ces classes.
Ainsi celle que je vous presente qui malgré tout n'est pas complete, ne presente plus ces limites, et en plus est en francais :p
Une gestion des erreurs a été incluse a la classe ! Pour ceux qui ne voudrait pas se servir de la gestion automatique des erreurs, une option permet de la désactiver pour une gestion personnalisée...

SheLL

Source / Exemple : 


/****


     
  •  Class : Registre

    •  
  •  Auteur: Shell

    •  
  •  Date : 24/08/2004

    •  
  •  Commentaires : Cette page de code contient la "class" permettant l'edition de la base de registre

       
      •  
      • /


#include "RegistreErreur.h"

class Registre
{
	int returnValue;
	DWORD dwLen;
	LPBYTE dwKeyEn;
	
	HKEY ChoisirBase(char *base);
	unsigned long ChoisirType(char *type);
	

public:
	Registre();
	~Registre();

	bool GestionErreur;
	
	bool OuvrirCle(char *base, char *chemin, HKEY *hCle);
	char *LireValeur(HKEY hCle, char *nom, bool *OpRes);
	bool EcrireValeur(HKEY hCle, char *nom, char *valeur, char *type);
	bool CreerCle(char *base, char *chemin, HKEY *hCle);
	bool SupprimerCle(char *base, char *chemin);
	bool SupprimerValeur(char *base, char *chemin, char *nom);
	bool FermerCle(HKEY hCle);
		
};

Registre::Registre()
{
	dwKeyEn = NULL;
	dwLen = 0;
}

Registre::~Registre()
{
	delete dwKeyEn;
}

HKEY Registre::ChoisirBase(char *base)
{
	HKEY tBase=0;
	
	if(strcmp(base,"HKEY_CURRENT_USER")==0)
		tBase = HKEY_CURRENT_USER;	
	else if(strcmp(base,"HKEY_USERS")==0)
		tBase = HKEY_USERS;
	else if(strcmp(base,"HKEY_LOCAL_MACHINE")==0)
		tBase = HKEY_LOCAL_MACHINE;
	else if(strcmp(base,"HKEY_CURRENT_CONFIG")==0)
		tBase = HKEY_CURRENT_CONFIG;
	else if(strcmp(base,"HKEY_CLASSES_ROOT")==0)
		tBase = HKEY_CLASSES_ROOT;

	return tBase;
}

unsigned long Registre::ChoisirType(char *type)
{
	unsigned long hResType=0;
	
	if(strcmp(type,"REG_NONE")==0)
		hResType = REG_NONE;	
	else if(strcmp(type,"REG_SZ")==0)
		hResType = REG_SZ;
	else if(strcmp(type,"REG_BINARY")==0)
		hResType = REG_BINARY;
	else if(strcmp(type,"REG_DWORD")==0)
		hResType = REG_DWORD;
	else if(strcmp(type,"REG_DWORD_BIG_ENDIAN")==0)
		hResType = REG_DWORD_BIG_ENDIAN;
	else if(strcmp(type,"REG_LINK")==0)
		hResType = REG_LINK;
	else if(strcmp(type,"REG_MULTI_SZ")==0)
		hResType = REG_MULTI_SZ;

	return hResType;
}

bool Registre::OuvrirCle(char *base, char *chemin, HKEY *hCle)
{
	HKEY hTempCle=0;

	//Ouvre la clef ou se trouve la valeur
	returnValue = RegOpenKey(ChoisirBase(base), chemin, &hTempCle);
    if (returnValue != ERROR_SUCCESS)
    {
		if(GestionErreur)
			OnRegError(ERR_CLECHEMIN);
		return false;
	}


    	
  • hCle = hTempCle;

	
	return 	true;
}

char *Registre::LireValeur(HKEY hCle, char *nom, bool *OpRes)
{
	
	//On recupere la taille de la clé dans un premier temps pour connaitre la taille du buffer que l'on va devoir spécifié
	returnValue = RegQueryValueEx(hCle, nom, NULL, NULL, NULL, &dwLen);
	//On alloue la taille nécéssaire pour éviter les dépassement de caaciter qui risqueraient décrassé d'aure varaible de la mémoire
    dwKeyEn = new BYTE[dwLen];
	//Maintenant on lit la valeur de la clé en spécifiant la taille du buffer
	returnValue = RegQueryValueEx(hCle, nom, NULL, NULL, dwKeyEn, &dwLen);

	if(returnValue != ERROR_SUCCESS)
    {


    		
  • OpRes = false;

		if(GestionErreur)
			OnRegError(ERR_NOM);
		return "Erreur!";
	}


    	
  • OpRes = true;

	return (char*)dwKeyEn; //on retourne le résultat a l'aide d'un CAST
}

bool Registre::EcrireValeur(HKEY hCle, char *nom, char *valeur, char *type)
{
	returnValue = RegSetValueEx(hCle,nom,NULL,ChoisirType(type),(PBYTE)valeur,strlen(valeur));
	if(returnValue != ERROR_SUCCESS)
    {
		if(GestionErreur)
			OnRegError(ERR_ECRIRE);
		return false;
	}

	return true;
}

bool Registre::CreerCle(char *base, char *chemin, HKEY *hCle)
{
	HKEY hTempCle=0;
	
	returnValue = RegCreateKey(ChoisirBase(base),chemin,&hTempCle);
	if(returnValue != ERROR_SUCCESS)
    {
		if(GestionErreur)
			OnRegError(ERR_CREERCLE);
		return false;
	}


    	
  • hCle = hTempCle;


	return true;
}

bool Registre::SupprimerCle(char *base, char *chemin)
{
	returnValue = RegDeleteKey(ChoisirBase(base),chemin);
	if(returnValue != ERROR_SUCCESS)
    {
		if(GestionErreur)
			OnRegError(ERR_SUPRCLE);
		return false;
	}
	return true;
}

bool Registre::SupprimerValeur(char *base, char *chemin, char *nom)
{
	HKEY hTempCle=0;		
	
	if(!OuvrirCle(base,chemin,&hTempCle))
		return false;

	returnValue = RegDeleteValue(hTempCle,nom);
	if(returnValue != ERROR_SUCCESS)
	{
		if(GestionErreur)
			OnRegError(ERR_SUPRVAL);
		return false;
	}

	return true;
}

bool Registre::FermerCle(HKEY hCle)
{
	returnValue = RegCloseKey(hCle);
	if(returnValue != ERROR_SUCCESS)
    {
		if(GestionErreur)
			OnRegError(ERR_FERMER);
		return false;
	}

	return true;
}

Conclusion :


Voili voilou pour ce qui est du code .... la gestion des erreurs est dans un header independant.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (DeAtHCrAsH)