«Const statique» vs «#define» vs «enum»

Lequel est préférable d'utiliser parmi les déclarations ci-dessous en C?

static const int var = 5;

ou

#define var 5

ou

enum { var = 5 };

Cela dépend de la valeur dont vous avez besoin. Vous (et tout le monde jusqu'à présent) avez omis la troisième alternative:

1. static const int var = 5;
2. #define var 5
3. enum { var = 5 };

Ignorer les problèmes liés au choix du nom, puis:

• Si vous devez passer un pointeur, vous devez utiliser (1).
• Puisque (2) est apparemment une option, vous n'avez pas besoin de passer des pointeurs.
• (1) et (3) ont un symbole dans la table des symboles du débogueur - ce qui facilite le débogage. Il est plus probable que (2) n'aura pas de symbole, vous laissant vous demander ce que c'est.
• (1) ne peut pas être utilisé comme dimension pour des tableaux à portée mondiale; (2) et (3) le peuvent.
• (1) ne peut pas être utilisé comme dimension pour les tableaux statiques au niveau de la fonction; (2) et (3) le peuvent.
• Sous C99, tous ces éléments peuvent être utilisés pour les tableaux locaux. Techniquement, l'utilisation de (1) impliquerait l'utilisation d'un VLA (tableau de longueur variable), bien que la dimension référencée par 'var' soit bien sûr fixée à la taille 5.
• (1) ne peut pas être utilisé dans des endroits comme les instructions switch; (2) et (3) le peuvent.
• (1) ne peut pas être utilisé pour initialiser des variables statiques; (2) et (3) le peuvent.
• (2) peut changer le code que vous ne vouliez pas changer car il est utilisé par le préprocesseur; (1) et (3) n'auront pas d'effets secondaires inattendus comme ça.
• Vous pouvez détecter si (2) a été défini dans le préprocesseur; ni (1) ni (3) ne le permettent.

Donc, dans la plupart des contextes, préférez l'énumération aux alternatives. Sinon, le premier et le dernier point sont probablement les facteurs déterminants - et vous devez réfléchir davantage si vous devez satisfaire les deux à la fois.

Si vous posiez des questions sur C ++, alors vous utiliseriez l'option (1) - la constante statique - à chaque fois.

En général:

static const

Parce qu'il respecte la portée et est de type sécurisé.

La seule mise en garde que j'ai pu voir: si vous voulez que la variable soit éventuellement définie sur la ligne de commande. Il y a encore une alternative:

#ifdef VAR // Very bad name, not long enough, too general, etc..
  static int const var = VAR;
#else
  static int const var = 5; // default value
#endif

Dans la mesure du possible, au lieu de macros / points de suspension, utilisez une alternative de type sécurisé.

Si vous avez vraiment besoin d'aller avec une macro (par exemple, vous voulez __FILE__ou __LINE__), alors vous feriez mieux de nommer votre macro TRÈS attentivement: dans sa convention de dénomination, Boost recommande tout en majuscules, en commençant par le nom du projet (ici BOOST_ ), en parcourant la bibliothèque, vous remarquerez qu'il est (généralement) suivi du nom de la zone particulière (bibliothèque) puis d'un nom significatif.

Cela donne généralement de longs noms :)

En C, plus précisément? En C, la bonne réponse est: utiliser #define(ou, le cas échéant, enum)

Bien qu'il soit avantageux d'avoir les propriétés de portée et de typage d'un constobjet, en réalité, les constobjets en C (par opposition à C ++) ne sont pas de vraies constantes et sont donc généralement inutiles dans la plupart des cas pratiques.

Ainsi, en C, le choix doit être déterminé par la façon dont vous prévoyez d'utiliser votre constante. Par exemple, vous ne pouvez pas utiliser un const intobjet comme caseétiquette (alors qu'une macro fonctionnera). Vous ne pouvez pas utiliser un const intobjet comme largeur de champ binaire (alors qu'une macro fonctionnera). En C89 / 90, vous ne pouvez pas utiliser un constobjet pour spécifier une taille de tableau (alors qu'une macro fonctionnera). Même en C99, vous ne pouvez pas utiliser un constobjet pour spécifier une taille de tableau lorsque vous avez besoin d'un tableau non VLA .

Si cela est important pour vous, cela déterminera votre choix. La plupart du temps, vous n'aurez pas d'autre choix que d'utiliser #defineen C. Et n'oubliez pas une autre alternative, qui produit de vraies constantes en C - enum.

En C ++, les constobjets sont de vraies constantes, donc en C ++ il est presque toujours préférable de préférer la constvariante (pas besoin d'explicite staticen C ++ cependant).

La différence entre static constet #defineest que le premier utilise la mémoire et le dernier n'utilise pas la mémoire pour le stockage. Deuxièmement, vous ne pouvez pas transmettre l'adresse d'un #definealors que vous pouvez transmettre l'adresse d'un static const. En fait, cela dépend de la situation dans laquelle nous nous trouvons, nous devons en sélectionner un parmi ces deux. Les deux sont à leur meilleur dans des circonstances différentes. Veuillez ne pas supposer que l'un est meilleur que l'autre ... :-)

Si cela avait été le cas, Dennis Ritchie aurait gardé le meilleur seul ... hahaha ... :-)

En C #defineest beaucoup plus populaire. Vous pouvez utiliser ces valeurs pour déclarer des tailles de tableau, par exemple:

#define MAXLEN 5

void foo(void) {
   int bar[MAXLEN];
}

ANSI C ne vous permet pas d'utiliser static consts dans ce contexte pour autant que je sache. En C ++, vous devez éviter les macros dans ces cas. Tu peux écrire

const int maxlen = 5;

void foo() {
   int bar[maxlen];
}

et même laisser de côté staticparce que la liaison interne est impliquée par constdéjà [en C ++ uniquement].

Un autre inconvénient de constC est que vous ne pouvez pas utiliser la valeur pour en initialiser un autre const.

static int const NUMBER_OF_FINGERS_PER_HAND = 5;
static int const NUMBER_OF_HANDS = 2;

// initializer element is not constant, this does not work.
static int const NUMBER_OF_FINGERS = NUMBER_OF_FINGERS_PER_HAND 
                                     * NUMBER_OF_HANDS;

Même cela ne fonctionne pas avec un const car le compilateur ne le voit pas comme une constante:

static uint8_t const ARRAY_SIZE = 16;
static int8_t const lookup_table[ARRAY_SIZE] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // ARRAY_SIZE not a constant!

Je serais heureux d'utiliser tapé constdans ces cas, sinon ...

Si vous pouvez vous en tirer, cela static constprésente de nombreux avantages. Il obéit aux principes de portée normaux, est visible dans un débogueur et obéit généralement aux règles auxquelles les variables obéissent.

Cependant, au moins dans la norme C d'origine, ce n'est pas réellement une constante. Si vous utilisez #define var 5, vous pouvez écrire int foo[var];comme une déclaration, mais vous ne pouvez pas le faire (sauf en tant qu'extension de compilateur "avec static const int var = 5;. Ce n'est pas le cas en C ++, où la static constversion peut être utilisée partout où la #defineversion le peut, et je crois que cela c'est aussi le cas avec C99.

Cependant, ne nommez jamais une #defineconstante avec un nom en minuscule. Il remplacera toute utilisation possible de ce nom jusqu'à la fin de l'unité de traduction. Les macros constantes doivent être dans ce qui est effectivement leur propre espace de noms, qui est traditionnellement composé de majuscules, peut-être avec un préfixe.

Il est TOUJOURS préférable d'utiliser const, au lieu de #define. C'est parce que const est traité par le compilateur et #define par le préprocesseur. C'est comme si #define lui-même ne faisait pas partie du code (en gros).

Exemple:

#define PI 3.1416

Le nom symbolique PI peut ne jamais être vu par les compilateurs; il peut être supprimé par le préprocesseur avant même que le code source ne parvienne à un compilateur. Par conséquent, le nom PI peut ne pas être entré dans la table des symboles. Cela peut être déroutant si vous obtenez une erreur lors de la compilation impliquant l'utilisation de la constante, car le message d'erreur peut faire référence à 3.1416, pas à PI. Si PI était défini dans un fichier d'en-tête que vous n'avez pas écrit, vous n'auriez aucune idée d'où vient ce 3.1416.

Ce problème peut également apparaître dans un débogueur symbolique, car, encore une fois, le nom avec lequel vous programmez peut ne pas figurer dans la table des symboles.

Solution:

const double PI = 3.1416; //or static const...

#define var 5vous causera des problèmes si vous avez des choses comme mystruct.var.

Par exemple,

struct mystruct {
    int var;
};

#define var 5

int main() {
    struct mystruct foo;
    foo.var = 1;
    return 0;
}

Le préprocesseur le remplacera et le code ne se compilera pas. Pour cette raison, le style de codage traditionnel suggère que toutes les constantes #defineutilisent des majuscules pour éviter les conflits.

J'ai écrit un programme de test rapide pour démontrer une différence:

#include <stdio.h>

enum {ENUM_DEFINED=16};
enum {ENUM_DEFINED=32};

#define DEFINED_DEFINED 16
#define DEFINED_DEFINED 32

int main(int argc, char *argv[]) {

   printf("%d, %d\n", DEFINED_DEFINED, ENUM_DEFINED);

   return(0);
}

Cela se compile avec ces erreurs et avertissements:

main.c:6:7: error: redefinition of enumerator 'ENUM_DEFINED'
enum {ENUM_DEFINED=32};
      ^
main.c:5:7: note: previous definition is here
enum {ENUM_DEFINED=16};
      ^
main.c:9:9: warning: 'DEFINED_DEFINED' macro redefined [-Wmacro-redefined]
#define DEFINED_DEFINED 32
        ^
main.c:8:9: note: previous definition is here
#define DEFINED_DEFINED 16
        ^

Notez que enum donne une erreur lorsque define donne un avertissement.

La définition

const int const_value = 5;

ne définit pas toujours une valeur constante. Certains compilateurs (par exemple tcc 0.9.26 ) allouent simplement de la mémoire identifiée avec le nom "const_value". En utilisant l'identifiant "const_value" vous ne pouvez pas modifier cette mémoire. Mais vous pouvez toujours modifier la mémoire en utilisant un autre identifiant:

const int const_value = 5;
int *mutable_value = (int*) &const_value;
*mutable_value = 3;
printf("%i", const_value); // The output may be 5 or 3, depending on the compiler.

Cela signifie que la définition

#define CONST_VALUE 5

est le seul moyen de définir une valeur constante qui ne peut en aucun cas être modifiée.

Bien que la question porte sur les entiers, il convient de noter que #define et les énumérations sont inutiles si vous avez besoin d'une structure ou d'une chaîne constante. Ceux-ci sont généralement transmis aux fonctions en tant que pointeurs. (Avec les chaînes, c'est obligatoire; avec les structures, c'est beaucoup plus efficace.)

En ce qui concerne les entiers, si vous êtes dans un environnement intégré avec une mémoire très limitée, vous devrez peut-être vous soucier de l'emplacement de stockage de la constante et de la façon dont les accès sont compilés. Le compilateur peut ajouter deux consts au moment de l'exécution, mais ajouter deux #defines au moment de la compilation. Une constante #define peut être convertie en une ou plusieurs instructions MOV [immédiates], ce qui signifie que la constante est effectivement stockée dans la mémoire du programme. Une constante const sera stockée dans la section .const de la mémoire de données. Dans les systèmes avec une architecture Harvard, il pourrait y avoir des différences de performances et d'utilisation de la mémoire, bien qu'elles soient probablement petites. Ils peuvent être importants pour l'optimisation du noyau dur des boucles internes.

Ne pensez pas qu'il y ait une réponse pour "ce qui est toujours le meilleur" mais, comme l'a dit Matthieu

static const

est sûr de type. Ma plus grande bête noire #define, cependant, est que lors du débogage dans Visual Studio, vous ne pouvez pas regarder la variable. Cela donne une erreur indiquant que le symbole est introuvable.

Soit dit en passant, une alternative à #define, qui fournit une portée appropriée mais se comporte comme une constante "réelle", est "enum". Par exemple:

enum {number_ten = 10;}

Dans de nombreux cas, il est utile de définir des types énumérés et de créer des variables de ces types; si cela est fait, les débogueurs peuvent afficher les variables en fonction de leur nom d'énumération.

Cependant, une mise en garde importante: en C ++, les types énumérés ont une compatibilité limitée avec les entiers. Par exemple, par défaut, on ne peut pas effectuer d'arithmétique sur eux. Je trouve que c'est un comportement par défaut curieux pour les énumérations; alors qu'il aurait été bien d'avoir un type "enum strict", étant donné le désir d'avoir C ++ généralement compatible avec C, je pense que le comportement par défaut d'un type "enum" devrait être interchangeable avec des entiers.

Une simple différence:

Au moment du prétraitement, la constante est remplacée par sa valeur. Vous ne pouvez donc pas appliquer l'opérateur de déréférence à un define, mais vous pouvez appliquer l'opérateur de déréférence à une variable.

Comme vous le supposez, define est plus rapide que const statique.

Par exemple, avoir:

#define mymax 100

tu ne peux pas faire printf("address of constant is %p",&mymax); .

Mais ayant

const int mymax_var=100

tu peux faire printf("address of constant is %p",&mymax_var); .

Pour être plus clair, le define est remplacé par sa valeur au stade du prétraitement, donc nous n'avons aucune variable stockée dans le programme. Nous avons juste le code du segment de texte du programme où la définition a été utilisée.

Cependant, pour const statique, nous avons une variable qui est allouée quelque part. Pour gcc, les const statiques sont alloués dans le segment de texte du programme.

Ci-dessus, je voulais parler de l'opérateur de référence, alors remplacez la déréférence par la référence.

Nous avons regardé le code assembleur produit sur le MBF16X ... Les deux variantes donnent le même code pour les opérations arithmétiques (ADD Immediate, par exemple).

Il const intest donc préférable pour la vérification de type alors qu'il #defineest à l'ancienne. C'est peut-être spécifique au compilateur. Vérifiez donc votre code assembleur produit.

Je ne sais pas si j'ai raison mais à mon avis, appeler #define valeur d est beaucoup plus rapide que d'appeler toute autre variable normalement déclarée (ou valeur const). C'est parce que lorsque le programme est en cours d'exécution et qu'il doit utiliser une variable normalement déclarée, il doit sauter à l'endroit exact en mémoire pour obtenir cette variable.

En revanche, lorsqu'il utilise la #definevaleur d, le programme n'a pas besoin de passer à la mémoire allouée, il prend simplement la valeur. Si #define myValue 7et le programme appelant myValue, il se comporte exactement de la même manière que lorsqu'il appelle simplement 7.