enum vs const vs #define [C embarqué]

[ee94]

Bonjour à tous et à toutes
Quelle est la différence entre enum vs const vs #define?
Au niveau Optimisation, quelle est la mieux utilisée ?
Merci d'avance
-----

[grosmatou75001]

Une des règles de base en programmation est qu'il ne faut jamais optimiser quand cela n'est pas nécessaire, puisque généralement le code obtenu est plus complexe / moins clair. Donc, dans ce cas précis, on utilisera ce qui est le plus adapté à chaque cas, sans se soucier de performance. On reviendra uniquement dessus si cela s'avère nécessaire.

énumération --> enum
constantes --> const ou #define (le dernier permettant plus de choses)

[Jack]

#define est interprété par le préprocesseur. Il est donc préférable d'éviter si possible, à moins que tu sois à te bagarrer pour gagner quelques octet puisqu'avec define les constantes sont symboliques et n'occupent aucune place mémoire à l'exécution.

Pour le reste, ça dépend du contexte et on ne peut pas annoncer une règle générale.

A+

[grosmatou75001]

Il est donc préférable d'éviter si possible,

éviter le préprocesseur? Ok, c'est vrai que les macros "complexes" c'est chiant à débugger, mais pour quelque constantes les #define c'est bien non? J'ai l'impression que c'est beaucoup plus utilisé que les const...

à moins que tu sois à te bagarrer pour gagner quelques octet puisqu'avec define les constantes sont symboliques et n'occupent aucune place mémoire à l'exécution.

Je suppose que les compilateurs optimisent pas mal, dans ce cas qu'on écrive

const int a=42;
const int b=45;
int c=a+b;

ou

#define A 42
#define B 45
int c=a+b;

ça ne doit pas faire de différence.

Prenons les choses de l'autre bout: @ee94: C'est une question générale ou un problème concret (de taille de code)?

[A voir en vidéo sur Futura]

[grosmatou75001]

Désolé pour le double-post... En cherchant un peu sur internet je suis tombé sur deux arguments en faveur des #define:

1.

Another drawback of const in C is that you can't use the value in initializing another const.

2. On peut (par accident et avec un pointeur) quand même modifier un const. Avec les #define à priori pas de risque de se retrouver dans ce genre de situations.

L'avantage des const est par contre effectivement que c'est "type-safe" et qu'on a facilement un pointeur à disposition si besoin (même si je ne vois pas de tels cas).

[ee94]

Merci à vous de vos réponses

@ee94: C'est une question générale ou un problème concret (de taille de code)?

C'est une question générale, je me suis posé telle question car les trois nous permettent de créer des constantes et puisque il y a trois façons donc sûrement il y a une différence.

[r4ph]

L'avantage des const est par contre effectivement que c'est "type-safe" et qu'on a facilement un pointeur à disposition si besoin (même si je ne vois pas de tels cas).

Les chaines de caractères, non ?!

[grosmatou75001]

Heu... D'accord, si on travaille avec des chaînes de caractères il faut des pointeurs, mais je ne vois pas le rapport avec la discussion const/#define... Si j'écris "abc" le compilateur va mettre ça quelque part en mémoire et me donner le pointeur vers cette position, donc je peux très bien utiliser des #define:

#include <stdio.h>
#define S "abc"

int main(void)
{
  printf("%s",S);
  return 0;
}

...
Ou alors on utilise des const mais encore sans "&" explicit:

#include <stdio.h>

int main(void)
{
  const char* s="abc";
  printf("%s",s);
  return 0;
}

[ftorama]

Heu... D'accord, si on travaille avec des chaînes de caractères il faut des pointeurs, mais je ne vois pas le rapport avec la discussion const/#define... Si j'écris "abc" le compilateur va mettre ça quelque part en mémoire et me donner le pointeur vers cette position, donc je peux très bien utiliser des #define:

Le C tel qu'on le connaît est un espèce de langage fourre-tout ou tout est permis, de divers façons différentes et, en général, avec beaucoup de chances d'avoir des problèmes. C'est un agglomérat de langages et de techniques qu'on a tenté d'uniformiser mais la standardisation du C n'a eu lieu qu'à posteriori.

Ceux qui ont appris à programmer avec le Pascal pourront te dire ce qu'est un langage propre qui, hélas, n'a pas eu le succès qu'il méritait.

[r4ph]

C'est vrai, je l'avais oublié, les 2 méthodes fonctionnent. Je fais partie de ceux qui ont appris à programmer en pascal, il y a bien longtemps. Aujourd'hui j'utilise essentiellement le C pour les uC et ai souvent utilisé les const en tableaux de conversion à 1 ou 2 dimensions. C'est bien plus commode à écrire et reste d'un type défini comme mentionné plus tôt. Pour les chaînes de caractères en général aussi, mais il est vrai qu'un define fait l'affaire. De la à savoir lequel est le mieux.....

[bobflux]

> Quelle est la différence entre enum vs const vs #define?

"#define" permet de faire à peu près n'importe quoi (macros, etc) et pas seulement des constantes, donc on a plus de souplesse.
Les principaux problèmes du préprocesseur c'est qu'on peut facilement faire des conneries et passer outre les vérifications de types.

"const" définit forcément un type, ce qui est un avantage pour une constante.

Mais, si j'écris :

#define ma_constante ((int32_t)123)

ou

static const int32_t ma_constante = 123;

Au final, j'ai quasiment le même effet : il y a bien vérification de types.

Le compilateur peut éliminer la variable si nécessaire.

Par contre, si j'écris dans un .h :

const uint32_t mon_flag; // déclaration

et dans un .c qui inclut le .h :

const uint32_t mon_flag = 0x100; // initialisation

puis plus loin :

if( mon_flag & 0x100 ) { ... }

Alors, dans le fichier où mon_flag est défini, sa valeur est connue, donc le compilateur éliminera le if(). Mais dans les autres fichiers, non !

Pour de la compilation conditionnelle, où on veut réellement compiler en dur et optimiser le code en fonction de valeurs connues à la compilation, c'est très important. Par exemple, en embarqué, si tu as un driver pour plusieurs variantes de périphériques, mettons un SPI ou autre, et que tu compiles pour un uC spécifique, tu vas vouloir faire de la compilation conditionnelle et éliminer tout le code qui ne correspond pas à ton uC. Donc il faut que la constante soit connue lors de la compilation, et pas un "const" défini et initialisé dans un autre fichier. Il faut aussi que la compilation conditionnelle marche pour tous les niveaux d'optimisation.

C'est pourquoi pour de la compilation conditionnelle on utilise de préférence #define et les #if.

[Seb.26]

mmmh ...

quand tu fais un #define, le prepro va remplacer chaque occurrence du #define par son contenu tel quel.
Avec une const tu a une variable en ROM.

Moralité : pour des string, il faut (évidement) faire des const, sauf si tu comptes sur ton compilo pour voir que tes #define sont en fait des const ...