static const vs #define
Est-il préférable d'utiliser static const
vars que #define
préprocesseur? Ou peut-être que ça dépend du contexte?
Quels sont les avantages/inconvénients de chaque méthode?
- Scott Meyers couvre ce sujet très bien et à fond. Son Point#2 dans "Effective C++ Troisième Édition". Deux cas particuliers (1) static const est préféré à l'intérieur d'une étendue de classe pour la classe spécifique constantes; (2) d'espace de noms, d'anonymes ou de portée const est préféré à #define.
- Je préfère les Énumérations. Parce qu'il est hybride des deux. N'occupe pas l'espace, sauf si vous créez une variable d'elle. Si vous voulez juste utiliser comme une constante , enum est la meilleure option. Il a le type de la sécurité en C/C++11 mst et aussi un parfait constante. #define est de type dangereux , const prend de l'espace si le compilateur ne peut pas optimiser.
- Ma décision d'utiliser
#define
oustatic const
(pour les chaînes) est entraînée par la initialisation aspect (il n'a pas été mentionné par les réponses ci-dessous): si la constante est utilisée dans les unité de compilation, puis-je aller avecstatic const
, sinon j'utilise#define
- éviter statique de l'initialisation de la commande fiasco isocpp.org/wiki/faq/ctors#static-init-order - Si
const
,constexpr
ouenum
ou toute variation de travaux dans votre cas, alors la préfère à#define
- statique de l'initialisation de la commande fiasco" Comment est-ce un problème pour les constantes?
Vous devez vous connecter pour publier un commentaire.
Personnellement, je hais le préprocesseur, alors je serais toujours aller avec const.
Le principal avantage d'un #define est qu'il ne nécessite pas de mémoire pour les stocker dans votre programme, car il est vraiment juste de remplacer un texte avec une valeur littérale. Il a aussi l'avantage qu'il n'a pas de type, de sorte qu'il peut être utilisé pour n'importe quelle valeur entière sans générer des avertissements.
Avantages de "const"s qu'ils sont peut être portée, et ils peuvent être utilisés dans les situations où un pointeur vers un objet doit être passé.
Je ne sais pas exactement ce que vous obtenez avec la partie "statique" si. Si vous êtes déclarant globalement, je l'avais mis dans un anonomous espace de noms au lieu d'utiliser de l'électricité statique. Par exemple
#define
d, au moins si elles peuvent être utilisées comme des "blocs de construction" pour les grandes constantes de chaîne. Voir ma réponse par un exemple.#define
avantage de ne pas utiliser toute la mémoire est imprécise. Le "60" à l'exemple doit être stockée quelque part, peu importe si c'eststatic const
ou#define
. En fait, j'ai vu des compilateurs où à l'aide de #define causé (en lecture seule) la consommation de mémoire, et static const n'a pas utilisé de l'onu-mémoire nécessaire.const &
paramètres, ce qui implique qu'ils ont une adresse associée avec eux.static
, vous arrivez à les utiliser en déléguant les constructeurs (en.wikipedia.org/wiki/C%2B%2B11#Object_construction_improvement), puisqu'il est disponible à l'instanciation de temps.Des avantages et des inconvénients à tout, en fonction de l'utilisation:
enum class X
sont analysées par le champ d'applicationX::
int
mais peut être définie explicitement par le programmeurtemplate <typename T> void f(T t) { cout << ++t; }
ne compile pas, si vous pouvez l'envelopper d'un enum dans une classe implicite du constructeur, opérateur de coulée définies par l'utilisateur et les opérateurs)template <typename T> void f(T)
obtenir un distinct lors de l'instanciation passé de la même valeur numérique à partir de différentes énumérations, qui sont distinctes de toutef(int)
de l'instanciation. Chaque fonction de l'objet du code pourrait être identiques (en ignorant l'adresse de compensations), mais je ne m'attends pas à un compilateur/linker pour éliminer l'inutile copies, si vous pouvez vérifier que votre compilateur/linker si vous vous souciez.enum { A = 1, B = 2 }
- estA|B
"juridique" à partir d'une logique de programme en perspective?)make
et d'autres timestamp à base de recompilation des outils de déclencher client recompilation lorsqu'ils sont modifiés (mauvais!)#define
ala#define S std::string("abc")
, mais la constante permet d'éviter que plusieurs de construction de différentes temporaires à chaque point d'utilisationconst
valeur, qui minimise le travail et l'impact en cas de changement entre les deux#define X "x"
et parmi ses clients, l'utilisation de l'ala"pre" X "post"
, si vous voulez ou avez besoin de faire X à l'exécution variable variable plutôt qu'à une constante que vous vigueur des modifications de code client (plutôt que de simplement la recompilation), alors que la transition est plus facile à partir d'unconst char*
ouconst std::string
donné qu'ils ont déjà de la force à l'utilisateur d'intégrer la concaténation des opérations (par exemple,"pre" + X + "post"
pourstring
)sizeof
directement sur un définies littéral numériqueunsigned
){ 1, 2 }
qui peut être utilisée pour initialiser des tableaux, ou#define MICROSECONDS *1E-6
etc. (certainement ne la recommande pas!)__FILE__
et__LINE__
peuvent être incorporés dans la substitution macro#if
consolidés pour conditionnellement y compris le code (plus puissant qu'un post-prétraitement des "si" que le code n'a pas besoin d'être compilable si non sélectionné par le préprocesseur), l'utilisation#undef
-ine, redéfinir etc.make
et d'autres timestamp à base de recompilation des outils de déclencher client recompilation lorsqu'ils sont modifiés (mauvais!)En règle générale, j'utilise
const
s et d'en tenir compte le plus professionnel option pour utilisation générale (même si les autres sont d'une simplicité séduisante à ce vieux paresseux programmeur).Si c'est un C++, et il mentionne
#define
comme une alternative, alors il est "global" (c'est à dire le fichier-champ) constantes, pas sur les membres de la classe. Quand il s'agit de ces constantes en C++static const
est redondante. En C++const
avoir une liaison interne par défaut et il n'y a aucun point en déclarantstatic
. Donc il est vraiment surconst
vs#define
.Et, enfin, en C++
const
est préférable. Au moins parce que ces constantes sont tapés et étendue. Il y a tout simplement pas de raisons de préférer#define
surconst
, en dehors de quelques exceptions près.Constantes de chaîne, d'ailleurs, sont un exemple d'une telle exception. Avec
#define
d des constantes de chaîne, on peut utiliser au moment de la compilation de concaténation fonction de compilateurs C/C++, comme dansP. S. Encore une fois, juste au cas où, si quelqu'un parle de
static const
comme une alternative à#define
, cela signifie généralement qu'ils parlent C, pas du C++. Je me demande si cette question est correctement balisé...À l'aide d'un static const est comme l'utilisation de tout autre const variables dans votre code. Cela signifie que vous pouvez suivre partout où provient l'information, par opposition à un #define sera simplement remplacé dans le code de la pré-compilation.
Vous voudrez peut-être jeter un oeil à la C++ FAQ Lite pour cette question:
http://www.parashift.com/c++-faq-lite/débutant.html#faq-29.7
#define
peut conduire à des résultats inattendus:Renvoie un résultat incorrect:
Toutefois, si vous remplacez ce avec des constantes:
Elle donne le résultat correct:
C'est parce que
#define
remplace simplement le texte. Parce que faire ce peut sérieusement gâcher ordre des opérations, je vous conseille d'utiliser une constante variable à la place.y
avait la valeur5500
, un little-endian concaténation dex
et 5.Habituellement, vous devriez préférer statique consts. Il n'a pas d'inconvénient. Le prprocessor devrait principalement être utilisé pour la compilation conditionnelle (et parfois pour vraiment sale trics peut-être).
Veuillez voir ici: static const vs définir
généralement un const déclaration (remarquez qu'il n'a pas besoin d'être statique) est le chemin à parcourir
La définition de constantes en utilisant la directive de préprocesseur
#define
n'est pas recommandé d'appliquer non seulement dansC++
, mais aussi dansC
. Ces constantes n'auront pas le type. Même dansC
a été proposé d'utiliserconst
pour les constantes.Préfère toujours utiliser la langue dispose de plus de quelques outils supplémentaires comme le préprocesseur.
De C++ Lignes Directrices De Base
Si vous êtes à la définition d'une constante pour être partagée entre toutes les instances de la classe, utiliser static const. Si la constante est spécifique à chaque instance, il suffit d'utiliser const (mais notez que tous les constructeurs de la classe doit initialiser cette const membre de la variable dans la liste d'initialisation).