Tout d'abord, j'ai trouvé que ce n'est pas possible de définir le type de la constante à l'aide de #define, pourquoi est-ce?
Pourquoi est-ce? Ce n'est pas vrai:
#define MY_INT_CONSTANT ((int) 12345)
Deuxièmement, quels sont les avantages à utiliser l'un d'eux sur l'autre?
Oui. #define
définit une macro qui est remplacé, même avant la compilation commence. const
seulement modifie une variable de sorte que le compilateur signalera une erreur si vous essayez de le changer. Il y a des contextes dans lesquels vous pouvez utiliser un #define
mais vous ne pouvez pas utiliser un const
(bien que j'ai du mal à en trouver un à l'aide de la dernière clang). En théorie, un const
prend de la place dans le fichier exécutable et nécessite une référence à la mémoire, mais dans la pratique, il est minime et peut être optimisé par le compilateur.
const
s sont beaucoup plus compilateur et débogueur de l'environnement qu' #define
s. Dans la plupart des cas, c'est le principal point que vous devriez considérer lors de la prise d'une décision sur laquelle utiliser.
Juste pensé à un contexte dans lequel vous pouvez utiliser #define
mais pas const
. Si vous avez une constante que vous souhaitez utiliser dans beaucoup d' .c
fichiers, avec un #define
vous venez de le coller dans un en-tête. Avec un const
vous devez avoir une définition dans un fichier C et
// in a C file
const int MY_INT_CONST = 12345;
// in a header
extern const int MY_INT_CONST;
dans un en-tête. MY_INT_CONST
ne peuvent pas être utilisés comme la taille d'un statique ou étendue globale tableau dans une C fichier à l'exception de celui sur lequel il est défini.
Cependant, pour des constantes entières, vous pouvez utiliser un enum
. En fait, c'est ce qu'Apple a fait à peu près invariablement. Il possède tous les avantages des deux #define
s et const
s, mais ne fonctionne que pour les constantes entières.
// In a header
enum
{
MY_INT_CONST = 12345,
};
Enfin, ce qui est plus efficace et/ou plus sécurisé?
#define
est plus efficace en théorie, bien que, comme je l'ai dit, les compilateurs modernes probablement s'assurer qu'il existe peu de différence. #define
est plus sûr en fait que c'est toujours une erreur de compilateur pour essayer de lui attribuer
#define FOO 5
// ....
FOO = 6; // Always a syntax error
const
s pouvez être trompés en être affecté, bien que le compilateur peut émettre des avertissements:
const int FOO = 5;
// ...
(int) FOO = 6; // Can make this compile
Selon la plate-forme, la cession pourrait encore échouer au moment de l'exécution si la constante est placé dans une lecture que l'segment et c'est officiellement le comportement indéfini selon la norme.
Personnellement, pour des constantes entières, j'ai toujours utiliser enum
s pour les constantes d'autres types, j'utilise const
, à moins que j'ai une très bonne raison de ne pas.