Problème d'Enum

Bonsoir à tous,

Voilà j'ai un petit problème. J'ai fais un couple .c/.h de fonctions génériques que je vais sans doute réutiliser dans plusieurs programmes. Néanmoins, ces fonctions retournent un type enum que j'ai crée qui s'appelle enCodeRetour (qui me permet de détecter le type d'erreur que me donne ma fonction). Néanmoins,  je vais réutiliser cet enum dans mon programme et donc fatalement je vais ajouter des codes erreur qui ne sont pas définis à l'avance. Donc mon enum est définie dans mon programme, et non pas dans le couple .h. J'aurai voulu savoir si il y avait une solution pour éviter d'inclure le typedef enum dans mon .h sans qu'il me fasse une erreur du type 'type non définie' ou 'type déclaré deux fois'. Ci-dessous un exemple, pour que vous compreniez mieux :

fichier1.h

#include "fichier2.h"
typedef enum enCodeRetour {
OK,
} enCodeRetour;


fichier2.h

enCodeRetour function1();
enCodeRetour function2();

fichier1.c intègre mon programme est l'appel à mes fonctions de fichier2.h
fichier2.c est inclu dans mon projet
-------------------------------
En gros, pour utiliser les fonctions du fichier2.h, le compilateur me dit qu'il faut que je définisse mon enum enCodeRetour (donc dans fichier2.h). Mais le problème est que mon enum est définie dans fichier1.h et que si je le définie deux fois, le compilateur va gueuler. Mais si je le définie dans fichier2.h, je ne pourrai pas ajouer de valeurs dans fichier1.h (si j'ai bien compris). Et dans l'absolu je ne sais pas les codes erreurs que je rajouterai, donc je ne peux les définir à l'avance. Il y aurai bien la possibilité de créer deux enum, mais après ça serait le bazar par rapport à mon switch case qui gère les erreurs. Quelqu'un aurait-il une solution ? Existe-il une solution pour que deux enum soient compatible entre eux ? Est-il possible de faire passer mon enum de fichier1.h dans fichier2.h ?

Je ne suis pas sur d'avoir tout bien compris, mais si je peut me permettre, tu n'a pas a redefinir l'enum 2 fois.
Une fois l'enum defini dans ton .h, ne fais que inclure ce ".h" dans lekelle lenum est definit et tu pourra lutiliser.
Pepsidrinker

exemple :
(ficher1.h):
enum Rien {BOB,GEORGE};


( fichier1.cpp)
#include "fichier1.h"
int main()
{
Rien monEnum;
nomEnum = BOB;
}


voila, jespere t'avoir aider.

Mon problème est que je fais appel à des fonctions qui ne sont pas dans fichier1.cpp mais dans fichier2.cpp. Or, pour suivre ton exemple, c'est comme si j'avais:
fichier2.cpp

Rien haha (int hoho)
{
    // mon programme
    return haha;
}

fichier2.h

Rien haha (int hoho);

Le problème est que j'inclue mon couple fichier2 dans fichier1 mais que l'enum est créé dans fichier1. Et donc du coup le compilateur me sort une erreur comme quoi l'enum est pas créé. Exactement il dit:
[C++ Erreur] generik.h(17): E2238 Déclaration multiple pour 'enCodeRetour'
[C++ Erreur] generik.h(15): E2344 Déclaration plus récente de 'enCodeRetour'

Voici mes sources exactes, ca vous parlera ptète mieux:
fichier1.h

#include <Dialogs.hpp>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <dir.h>
#include "C:\Documents and Settings\ABM\Bureau\Baptiste\Convertisseur\Fonctions génériques\generik.h"
#define MAX_SIZE 200
//---------------------------------------------------------------------------
typedef enum enCodeRetour {
                        OK,
                        ER_fopen,
                        ER_copyfile,
                        ER_genopenf,
                        ER_cliopenf,
                        ER_samelib,
                        ER_noequal,
                        ER_nolib,
                        ER_char,
                        ER_nogui,
                        ER_nullstruct,
                        ER_nbarg,
                        ER_modif,
                        ER_choix,
                        ER_write,
                        ER_genempty,
                        ER_cliempty,
                        ER_client,
                        ER_gen13,
                        ER_genchar,
                } enCodeRetour;

fichier generik.h

//---------------------------------------------------------------------------
#ifndef generikH
#define generikH
//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dir.h>
#include <time.h>
#include <conio.h>
#define MAX_SIZE 200
//---------------------------------------------------------------------------
// enum struct
//---------------------------------------------------------------------------
enCodeRetour enCrCopyfile (unsigned char *aucSource, unsigned char *aucDest,
                           unsigned char *aucErreur);
enCodeRetour enCrangefiles (unsigned char *aucPath, unsigned char *aucName,
                            unsigned char *aucExt, unsigned char *aucErreur);
enCodeRetour enCrIngecrypt (unsigned char *aucPathExe, unsigned char *aucPath,
                            unsigned char *aucName, unsigned char *aucExt);
//---------------------------------------------------------------------------
#endif

envois la source des ton prog au complet svp
Pepsidrinker

hello, laisse tomber les enums, retourne un int.
Et pour que ce soit facile à utiliser, met des defines dans ton programme, comme ça, c'est générique et adaptable, jamais compris l'interet des énums de toute facon ...


/* MuPuF®

Il faut simplement que tu mettes l'enum dans generic.h au lieu de fichier 1.
tu l'auras aussi puisque tu fais l'inclusion à ralonge (generic.h) dans fichier1

De plus fichier 1 n'est pas encadré de #ifndef ect...

On peut voir les enum comme des :
static const int OK    = 0;
static const int ERR1 = 1;
static const int ERR2 = 2;

Pour mupuf : une enum est plutot encapsulée dans une struct, ou elle sera vu comme un type intégrée a la struct, impossible à faire avec des #define.