Bonsoir tout le monde, j'aimerais savoir ce que vous pensez quand à l'insertion des constantes en C++. J'ai lu dans un livre que faire une constante avec #DEFINE était obsolète et qu'il faut utiliser const. Par contre sur des forums, je vois des commentaires qui disent que les #DEFINE sont beaucoup mieux...

Pour mon avis personnel, je suis plutot de l'avis du livre qui dit qu'il faut plutot utiliser les const.

En C++, on utilise le mot const. Parce que:
1) les variables déclarées avec const sont typées.
2) Elles sont castables.
3) On peut déclarer des types avancé constants dans de cette manière.
4) Les #define sont créés à la compilation et pas à l'éxécution

Ils y a certainement d'autres raisons encore. Mais en tout cas, oublie le #define pour les constantes.

Tu est de mon avis, donc déjà sa me rassure.
Sinon, pourrais-tu m'expliquer ce que tu entends par des variables typées (1) et des types avancés (2) ?

1) et bien ta constante sera soit int, soit double,... alors qu'avec un define, elle n'est rien.

2) Tu peux par exemple créer une classe et en créer une instance constante. Par exemple:

Chose que tu ne peux pas faire avec les define.

Ah, merci beaucoup =). Je comprend déjà mieux .

Mais les const sont des variables, donc elle vont prendre de la place dans la mémoire, demander une allocation ... alors qu'on define est remplacé à la compilation donc ne prend pas de mémoire et ne demande pas de traitement, nen ?

Donc pourquoi préférer les constantes si elles bouffent des ressources (à part lorsque la valeur quelle prenne est dynamique, auquel cas on a pas le choix) ? Parce que bon, les typer je n'en vois pas l'intérêt (c'est remplacer donc si on se goure (on met une chaine à la place d'un entier), le compilateur va gueuler), je ne vois pas où on ne peut pas catser un define, par contre c'est vrai que du fait que ça ne fait que remplacer, ça devient lourd pour les classes (il reconstruit une nouvelle classe à chaque fois, au lieu de la construire une fois pour toute).

Enfin bref, je ne vois pas pourquoi bannir totalement des define au profit des const, chacun a son utilité (si quelqu'un à d'autres arguments contre les define ...).

Espérer économiser de la place avec des define pour des petits types style int, ça sert à rien. Il te faudrait des variables de l'ordre de 10000 pour beaucoup faire varier.

Ensuite, un define pour une chaine de caractères constante "xxxxx" risque de prendre plus de place qu'un const char[], si le compilateur ne détecte pas que les différentes chaînes remplacées sont strictement identiques. Comme tu dis, ça pose un problème aussi pour des classes.

Maintenant, il y a quelque chose de plus dangereux et pervers : si une variable porte le même nom qu'un 'define', tu risques d'avoir des erreurs incompréhensibles. Tu peux casser du code existant, parce le préprocesseur va faire son boulot silencieusement avant que le compilateur ne le fasse, et du code parfaitement correct pourra devenir incorrect à cause de ça.

Après en pratique, il y a peu de problèmes vu qu'en général on nomme les defines avec des belles majuscules pour les différencier. C'est plutôt d'ordre idéologique et une question de bonne pratique.

D'accord. Mais pourquoi pas en C (on a aussi des chaines et des structures en C) ?

Hein ? const existe aussi en C, et j'ai pas compris ta question.

Ba en C++ il faudrait mettre des const plutôt que des define. Mais en C, il faudrait faire le contraire (du moins, c'est ce que j'ai cru comprendre) ! pourquoi ?

Euh, bah je ne sais pas, peut-être question d'habitude (?)
Les programmeurs C ont peut être pris plus l'habitude avec les #DEFINE...

Je ne crois pas que se soit réellement la même chose. Une constante déclarée via const est une variable (je devrais plutôt dire qu'une variable déclarée via const est une constante, 'fin bon), un #define n'est pas une variable, c'est juste une directive de préprocesseur dont la valeur remplacera toutes les "instances" du #define dans le code.

L'avantage avec les #define (si s'en est un ) est que la constante est globale à toutes les méthodes fonctions (pardon ) devant l'utiliser, sinon je vois pas trop ...

Pour ma part j'utilise les #define pour les constantes universelles physiques etc etc ...

Si on déclare la variable hors de toute fonction, elle est globale.

Bref, je retiendrais que pour les pointeurs et les classes, il vaut mieux utiliser des const (du moins si on la réutilise plusieurs fois), pour les nombres, les define restent meilleurs (pas d'utilisation de mémoire, les calculs du style 2+CONSTANTE sont faits à la compilation, enfin ça doit dépendre du compilateur) mais l'utilisation d'un const n'est pas un gros problème (et on peut toujours remplacer plus tard pour optimiser).

Sinon, define et const ne sont pas la même chose, mais dans le cas de constantes définies par le programmeur, les deux peuvent être utilisés. Par contre, define permet aussi de remplacer des commandes entières, et const peut prendre avoir une valeur non connue à la compilation lorsqu'il est déclaré dans une fonction.


Merci d'avoir pris le temps de me répondre.

Donc, si je résume, l'usage de const est préférable. Comme aujourd'hui les ordinateurs ont beaucoup de mémoire, l'usage de const est mieux que DEFINE (au pire allocation dynamique...). Donc, DEFINE est bel et bien obsolète.

P.S : Voici le livre que j'ai acheté il n'y a pas longtemps Le Langage C++.

Si quelqu'un possède ce livre ou l'a déjà lu, j'aimerais qu'il me dise son avis dessus.

(Ce n'est pas vrai ça, je m'étais déjà exprimé sur la question et n'arrive pas à retrouver où ...)

Bref.
Les #define
- traités par le pré-compilateur => jamais vus par le compilo
- implictement typés (en fait, c'est une chaine que le pré-compilo va remplacer dans le code que le compilo compilera véritablement ; ça peut être tout et n'importe quoi, pas seulement des constantes)
- les constantes litérales ainsi mises en dur dans le code seront dans l'espace mémoire qui va bien, ou juste en dur dans le code ; je ne sais pas comment les couples compilo+linker se débrouillent en cas de multiples utilisations
- polluent absolument tous les espaces de noms, codes clients/bibliothèques) (c'est une telle plaie que cela justifie l'interdiction d'utiliser #define là où const est utilisable)
- peuvent provoquer des erreurs de compilation (et parfois d'exécution) incompréhensibles
- Ce n'est généralement connu ni du compilo, ni du débuggueur ! (et oui, le code compilé ne correspond pas directement au code source original)

Les const
-- attention deux catégories : les constantes litérales (je crois que l'on dit), et les variables immuables. Je ne vais parler que de la première catégorie : celle qui remplace les définitions par macro
- explicitement typés
- appartiennent à un espace de noms et un seul
- les constantes litérales ainsi mises en dur dans le code seront dans l'espace mémoire qui va bien, ou juste en dur dans le code ; normalement le linker sait fusionner les multiples occurrences des constantes.
- C'est connu du compilo et du débuggueur !
- Le C a ses const depuis 99. Ils sont subtilement différents de ceux du C++, mais je ne me souviens jamais en quoi.
- complément ignorés par le préprocesseur (=> n'espérez pas ainsi compiler un morceau de code ou un autre en fonction d'une situation particulière (architecture de complation, compilo, architecture cible, bibliothèques trouvées par les auto-tools, etc)

const existe en C depuis C99. Ce qui ne change rien car les vieux programmeurs C vont continuer avec #define. Question d'habitude.

En C++ on aime énormément nos espaces de noms : Namespaces, classes, etc...

Donc une constante peut être définie dans un espace propre...

Voici pourquoi : prenez un nom comme "MAX". MAX est utilisé comme define dans plusieurs compilos. Donc partout où j'écris MAX le pré-compilateur va le remplacer par la valeur du #define. Mais MAX peut vouloir spécifier un nombre énorme de choses. Imaginez maintenant que je n'ai pas de #define MAX ... et que je fais 2 classes : PanierFruits et PanierLégumes qui contiennent tout les 2 une contante MAX. l'une constante et un Maximum de fruits contenus dans le panier et l'autre un maximum de légumes... Par définition ils ne sont pas la même chose. (duh!)

On a donc
PanierFruits::MAX
PanierLégumes::MAX

Ils existent dans un espace restraint dans lequels ils signifient quelque chose. Et on a pas besoin de nommer nos constantes MAX_FRUITS_DANS_PANIERFRUITS_H__, MAX_LEGUMES_DANS_PANIERLEGUMES_H__

Et je vous assure par expérience que dans un projet C de plusieurs centaines de fichiers c'est le genre de noms qu'on rencontre.


De plus les #define sont très utilisé dans les concours de codes obscurs pour leur manière d'être complètement incompréhensible par l'esprit humain.

Sans parler de la macro "max" sous VC++ (ou MFC?). Allez utiliser std::max, ou appeler une variable max après ...
Bonjour les dégats.

Hmmm, j'ai pas trop trop compris les deux derniers commentaires :s
Finalement, c'est bien vrai, il est mieu d'utiliser const plutot que #DEFINE, c'est ça ? !!

Oui.
Sinon, fais les expériences décrites et tu comprendras pourquoi les macros ne sont pas à préférer à "const".

Ah, ok, merci beaucoup ! mon livre a l'air d'être juste alors ! Si quelqu'un l'a, j'aimerais qu'il me donne son avis !

Pour finir, une anecdote qui tombe justement à pic : j'étais en train de faire quelques bindings entre C++ et OCaml, et je me rends compte que les headers nécessaires à ça utilisent un #define qui s'appelle "flush", du coup un code qui compile pas sans que je comprenne. Sympa!

C'est vrai qu'il fait au moins mettre un antécédent explicite aux define (de la même manière qu'on mais les const dans un namespace).