Discussion :

[manticore]

Bonjour,

j'ai une question sur la bonne façon de déclarer des "dictionnaires" en c++.

Un petit exemple sur ce que je fais.

Voici mon .h qui contient une énumération

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
typedef enum LOG_LEVEL
{
	DEBUG = 0,
	INFO = 1,
	NOTICE = 2,
	WARNING = 3,
	ERROR = 4,
	CRITICAL = 5,
	ALERT = 6,
	EMERGENCY = 7
}LOG_LEVEL;

Et maintenant j'ai une méthode qui prend l'enum en parmètre et ou j'utilise la clé (donc le string) à un autre emplacement.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
// Passage de l'enum en paramètre
void Log::log(LOG_LEVEL _level, const std::string& _message)
{
        // Récupération de la clé.
        m_type = typeToString(_type);
	// Syslog display().
	openlog(m_type.c_str(), OPTION, LOCATION);
        // 
	syslog(_level, _message.c_str());
	closelog();
}

Et finalement la méthode qui fait la conversion.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
std::string Log::levelToString(LOG_LEVEL level)
{
	std::string result;
 
	switch(level)
	{
		case 0 : result = "DEBUG";
				 break;
		case 1 : result = "INFO";
				 break;
		case 2 : result = "NOTICE";
				 break;
		case 3 : result = "WARNING";
				 break;
		case 4 : result = "ERROR";
				 break;
		case 5 : result = "CRITICAL";
				 break;
		case 6 : result = "ALERT";
				 break;
		case 7 : result = "EMERGENCY";
				 break;
	}
 
	return result;
}

Donc c'est très peu pratique, lorsque l'on fait une modification, il faut donc le faire dans l’énumération et dans la méthode de conversion.

Quelle est la meilleurs façon de le faire en c++ ? En python j'aurai déclarer un dictionnaire dans un fichier externe.

Avec quelques recherches j'ai trouvé une méthode avec la lib de boost :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
enum X
{
   A,
   B,
   C
};
 
std::map<std::string, X> xmap = boost::map_list_of("A", A)("B", B)("C",C);

Mais finalement elle change pas grand chose par rapport à la méthode précédente.

Merci de vos conseils.

[PilloBuenaGente]

Je ne suis pas sûr à 100% mais peut être devrais-tu l'utiliser ainsi :
header Enum.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef ENUM_H_INCLUDED
#define ENUM_H_INCLUDED
 
enum LOG_LEVEL
{
	DEBUG,//0
	INFO,//1
	NOTICE,//2
	WARNING,//3
	ERROR,
	CRITICAL,
	ALERT,
	EMERGENCY
};
 
#endif // ENUM_H_INCLUDED

Dans ton main tu peux, si tu inclus le header, utiliser les noms à la place des chiffres. (Ils seront considérés comme des const int me semble-il)

[manticore]

Je me suis peut-être mal exprimé, je ne cherche pas uniquement à utiliser des nom pour les valeurs, mais aussi à pouvoir récupérer le nom depuis la valeur.

Sinon c'est un collègue qui a fait cette classe, j'ai pas vu qu'il réaffectait les valeur par défaut sur les clés.

[koala01]

Salut,

D'abord, il faut savoir que, contrairement à C, la définition d'un type personnalisé (structure, classe, enum ou union) équivaut à sa déclaration.

Il n'est donc plus nécessaire de créer un typedef de ces types.
Ensuite, il faut savoir que les valeurs énumérées sont, de toutes manière auto-incrémentée et commencent à 0, ce qui fait que tu n'as aucun besoin de spécifier une valeur si celle qui sera fournie correspond à tes besoins:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
enum UnTruc
{
    zero, // ==0
    un, // ==1
    cinq = 5, //=5
    six  //!!! ==5+1 = 6 ;)
};

Ton énumération peut très bien ressembler à un simple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
enum LOG_LEVEL
{
	DEBUG,
	INFO,
	NOTICE,
	WARNING,
	ERROR,
	CRITICAL,
	ALERT,
	EMERGENCY
};

Enfin, il faut te dire que si tu "perds ton temps" à créer une énumération, c'est, très clairement, pour donner un sens explicite aux différentes valeurs énumérées.

Il serait donc dommage de ne pas les utiliser de manière systématique et ton switch devrait dans l'idéal ressembler à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
std::string Log::levelToString(LOG_LEVEL level)
{
	std::string result;
 
	switch(level)
	{
		case DEBUG : result = "DEBUG";
				 break;
		case INFO : result = "INFO";
				 break;
		case NOTICE : result = "NOTICE";
				 break;
		case WARNING : result = "WARNING";
				 break;
		case ERROR : result = "ERROR";
				 break;
		case CRITICAL : result = "CRITICAL";
				 break;
		case CRITICAL : result = "ALERT";
				 break;
		case CRITICAL : result = "EMERGENCY";
				 break;
	}
 
	return result;
}

Ceci dit, non, il n'y a strictement aucune méthode "directe" pour arriver à faire en sorte que chaque valeur énumérée soit transformée en une chaine de caractères (ou en n'importe quoi d'autre d'ailleurs): il faudra forcément rajouter la chaine de caractères adéquate "quelque part" si tu rajoutes une valeur énumérée

Et, pour terminer, un dernier petit détail ("last but not least" disent les anglophones )

Ton type LOG_LEVEL va, a priori, toujours passer par un flux (qu'il s'agisse d'un flux de conversion, d'un flux vers un fichier ou d'un flux vers l'affichage standard).

A moins d'envisager l'utilisation de *printf, au lieu de créer une fonction qui converti la valeur en std::string (levelToString pour ne pas la nommer), tu aurais sans doute intérêt à surcharger l'opérateur << sur les flux de sorties sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
inline std::ostream& operator<<(std::ostream & os, LOG_LEVEL const  lvl)
{
	switch(lvl)
	{
		case 0 : os << "DEBUG";
				 break;
		case 1 : os <<  "INFO";
				 break;
		case 2 : os <<  "NOTICE";
				 break;
		case 3 : os << "WARNING";
				 break;
		case 4 : os <<  "ERROR";
				 break;
		case 5 : os <<  "CRITICAL";
				 break;
		case 6 : os <<  "ALERT";
				 break;
		case 7 : os <<  "EMERGENCY";
				 break;
	}
	return os;
}

(nécessite l'inclusion de iosfwd au minimum )

De cette manière, quel que soit le flux vers lequel tu enverras ta valeur énumérée, elle apparaitra sous la forme de la chaine de caractères correspondante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int main()
{
    std::ofstream ofs("fichier.txt");
   ofs<<NOTICE; // ca marche
   std::cout<<EMERGENCY; // ca marche aussi
   std::stringstream ss;
   ss<<DEBUG<<" "<<3<<" que peut on dire ici ?";//et ca marche toujours :D
   return 0;
}

Cela ne t'évitera pas d'avoir à modifier l'opérateur si tu rajoutes une valeur énumérée, mais, au moins, l'utilisation sera automatique

[manticore]

Merci de ta réponse complète, j'ai effectué les quelques modifications que tu m'as indiqué.

D'abord, il faut savoir que, contrairement à C, la définition d'un type personnalisé (structure, classe, enum ou union) équivaut à sa déclaration.

Cependant, n'est-on pas obligé d'utiliser le typedef, si l'on utilise l’énumération dans le même .h que celui de la déclaration ?

[koala01]

Cependant, n'est-on pas obligé d'utiliser le typedef, si l'on utilise l’énumération dans le même .h que celui de la déclaration ?

Absolument pas...

Que ce soit dans un fichier d'en-tête (*.h) ou dans un fichier d'implémentation (*.cpp), ne change absolument rien: tout ce qu'il faut, c'est que le compilateur ait croisé la définition de l'énumération au moment où elle est utilisée

[Médinoc]

Sinon, des macros et un fichier externe (ou même un simple copier-coller) peuvent aider.

[manticore]

C'est exactement ce que je cherchais

C'est simple, élégant, efficace j'adore.

[manticore]

En faite j'ai une question sur ta méthode, elle fonctionne bien mais j'ai de gros problèmes d'include. Voila l'erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
libJanusTools.a(netfilter.o):(.data+0x0): multiple definition of `LOG_LEVEL_STRING'
 
libJanusTools.a(netfilter.o):(.data+0x20): multiple definition of `LOG_TYPE_STRING'
 
libJanusTools.a(Log.o):(.data+0x0): multiple definition of `LOG_LEVEL_STRING'
build/debug/../../src/netfilterHook/netfilterHook.o:(.data+0x20): first defined here

J'utilise ces définitions pour une classe chargé de faire le logging, j'utilise donc ta méthode de macro pour définir automatiquement les éléments. Voici la déclaration que j'ai dans ma classe de log.h (host classe) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
enum LOG_LEVEL
{
	#define ITEM(id)\
	   id,
	#include "LogLevel.itm"
	#undef ITEM
 
   Log_lvl
};
 
static char const* LOG_LEVEL_STRING[] =
{
	#define ITEM(id)\
	   #id,
	#include "LogLevel.itm"
	#undef ITEM
};

J'ai bien la déclaration :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
#ifndef LOG_H_
#define LOG_H_

Sur tous mes fichiers .h, est-ce que je dois aussi le faire dans les fichiers .itm ?

Est-ce que je dois ajouter quelques choses dans la déclaration des enums ?

Merci

[Bousk]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static char const* LOG_LEVEL_STRING[]

déclare une variable.
Ca se trouve dans un header.
Le guard include empêchera la multiple inclusion pour une unité de compilation donnée.

[manticore]

Merci c'est bien cela, j'ai plusieurs librairie qui utilise la même classe.


J'ai corrigé en utilisant un .cpp dans lequel je déclare mes variables et je les mets en extern dans mon .h.

Merci

[bountykiler]

Sinon, tu peux aussi faire quelque chose du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
//dans le .h
enum LOG_LEVEL
{
	DEBUG,//0
	INFO,//1
	NOTICE,//2
	WARNING,//3
	ERROR,
	CRITICAL,
	ALERT,
	EMERGENCY,
	N_LOGS_LEVEL
};
static const char[][N_LOGS_LEVEL] LOG_LEVEL_NAMES;
inline std::ostream& operator<<(std::ostream & os, LOG_LEVEL const  lvl)
{
	os << LOG_LEVEL_NAMES[lvl];
}
 
//et dans le .cpp
const char[][N_LOGS_LEVEL] LOG_LEVEL_NAMES = {
	"DEBUG",
	"INFO",
	"NOTICE",
	"WARNING",
	"ERROR",
	"CRITICAL",
	"ALERT",
	"EMERGENCY"
}

J'avoue ne pas avoir testé, mais cela devrait à priori fonctionner.
L'avantage ici est que si jamais tu rajoutes un niveau de logs dans ton enum, ton .cpp ne compilera pas tant que tu ne l'aura pas ajouté dans ta variable LOG_LEVEL_NAMES;