c efficace les macros ?

bonjour,
J'ai une ligne de code en plein dans une fonction qui est :

Code:

---

1 2	#define CHAR_PER_LINE 25

---

Normalement ce genre de trucs est declare haut dans un programme.
N'est-il pas mieux de simplement declarer un int charperline = 25 ?
Est-ce plus efficace de faire un define ?

:salut:

Il y a une difference entre les 2 :

#define est une constante donc elle ne doit pas changer durant le programme
int .. est une variable qui peut changer dans le programme

C'est vrai que c'est pas très logique de la déclarer dans du code

ha oui mais dans ce cas quel est le mieux ?

Code:

---

1 2 3

#define CHAR_PER_LINE 25

---

ou

Code:

---

1 2 3

const int charperline = 25

---

et peux t-on faire :

Code:

---

1 2 3

const int var = 25; char line[var];

---

ou doit on faire :

Code:

---

1 2 3 4

#define VAR 25 char line[VAR];

---

merci

Pour moi, une macro ça contient un appel de fonction.

Si tu fais un define, la constante qui en résulte est accessible par toutes les fonctions de ton programme.
les 'const int' ne le sont pas.

Citation:

---

Envoyé par graphicsxp

et peux t-on faire :

Code:

---

1 2 3

const int var = 25; char line[var];

---

---

ça me paraît déconseillé, mais il semble que mon compilateur avec l'option -Wall ne dise rien ...

Citation:

---

ou doit on faire :

Code:

---

1 2 3 4

#define VAR 25 char line[VAR];

---

merci

---

ça, je suis quasiment sûr que c'est bon.

Avec un

Code:

---

#define TOTO 25

---

tu remplaces, enfin le préprocesseur, dans le code toutes les chaîne TOTO par 25 (comme si dans NotePad tu faisais Edition/Remplacer "TOTO" par "25") et ensuite c'est compilé. La valeur 25 est inscrite en dur dans l'exécutable.

Alors que si tu fait un

Code:

---

int toto = 25;

---

Lorsque que tu exécute ton programme, il alloue de l'espace mémoire pour y mettre 25. C'est de l'espace alloué inutilement.

Je sais pas si je suis très clair :?: :!: :?: j'en doute :?

En tout cas dans les exemples cité plus haut, l'utilisation de DEFINE me semble plus approprié.
-Magic-

Salut,

Par contre, il peut y (parfois) avoir parfois un avantage à utiliser

const int TOTO=25;

c'est que l'on dispose ainsi de controles sur les types utilisés.

En effet, TOTO défini avec un #define n'est pas typé, alors que si l'on a un const int, le type est explicite et l'on peut obtenir des avertissements du compilateur pour une utilisation mal-à-propos.


Le vrai danger du #define vient des macro-fonctions.

En effet, un
#define _2x(a) a + a
Définit une macro-fonction qui double son paramètre.

C'est cool, ça marche quand on fait
int i=10, j ; j = _2x(i);
aussi bien que quand on fait
float f=10., g ; g = _2x(f);

C'est valable pour tous les types "calculables".

Mais s'il nous vient l'envie de faire (je sais, c'est bête, mais je l'ai vu !) :
int i =10, j; j = _2x(i++);
on a de grosses surprises sur la valeur de i en sortie.

On devrait trouver 11, mais on obtient 12 avec la plupart des preproc/compilos.

En effet, le a du #define est substitué partout par le paramètre effectif, et comme ça se passe avant la compilation, c'est "i++" qui est mis partout, et non son résultat. C'est donc comme si on avait écrit "i++ + i++" !!

Le tout, c'est d'être prévenu !!!

A+

Code:

---

1 2 3 4 5 6

#define TOTO 23   // et   const int TOTO = 23;

---

Les deux déclarations sont identiques au final. En effet, la norme autorise le compilateur à mettre en dur les variables const, pour peu qu'il ne soit jamais fais allusion à l'adresse de la variable.

Citation:

---

Envoyé par graphicsxp

ha oui mais dans ce cas quel est le mieux ?

Code:

---

1 2	#define CHAR_PER_LINE 25

---

ou

Code:

---

1 2	const int charperline = 25

---

---

C'est pas pareil. La macro est une substitution de texte. La valeur numérique est une expression constante de type int. Elle peut servir de dimension pour définir un tableau.

La variable en lecture seule n'est pas une expression constante.

Citation:

---

Envoyé par ggnore

Pour moi, une macro ça contient un appel de fonction.

---

Quoi ?

Citation:

---

Si tu fais un define, la constante qui en résulte est accessible par toutes les fonctions de ton programme.
les 'const int' ne le sont pas.

---

Ah ? Pourquoi donc ? Est-tu sûr de bien savoir de quoi tu parles ?

Citation:

---

Envoyé par graphicsxp

et peux t-on faire :

Code:

---

1 2 3

const int var = 25; char line[var];

---

---

Ce code ne fonctionne qu'en C99 sous certaines conditions.

Citation:

---

ou doit on faire :

Code:

---

1 2 3

#define VAR 25 char line[VAR];

---

---

Ce code est portable.

Citation:

---

Envoyé par 2Eurocents

En effet, TOTO défini avec un #define n'est pas typé,

---

C'est faux.

Code:

---

1 2 3 4 5 6 7

#define A 123 /* int */ #define B 123u /* unsigned int */ #define C 123l /* long */ #define D 123ul /* unsigned long */ #define E 12.3F /* float */ #define E 12.3 /* double */

---

Et dire que certains me traitent de pinailleur !! :D

Bon, d'accord, je reformule :

Lorsque l'on effectue des operations (arithmétique) en mixant avec d'autres types de données , l'information de type associée à l'écriture de la valeur du #define n'est pas toujours suffisante pour que le compilateur signale les transtypages hasardeux.

A priori, avec un typage fort en const, le compilateur se plaint plus rapidement.

Ceci dit, personnellement, je privilégie les #define pour les fichiers d'entête (pas de code ... que de la "nourriture pour préprocesseur") et j'utilise parfois les const dans mes fichiers de code.

Mais je ne prétend pas non plus détenir la science infuse. Ce n'est qu'une de mes habitudes de programmation.

En C89, const int ne déclare pas une constante, mais bien une variable non modifiable.

La différence c'est qu'elle prendra en elle-même de la mémoire et que dans les calculs il y aura un accès mémoire pour lire la constante (sauf si le compilateur est suffisamment optimiseur pour savoir substituer). Donc, const int = perte de performance en général.

C'est pour ça que je préfère les #define, ou, mieux, les enums, pour déclarer mes constantes :

Code:

---

1 2 3 4

enum { CONSTANTE1 = 500, CONSTANTE2 = 600 };

---

L'avantage des enums c'est qu'il n'y a pas de risque de remplacement au mauvais endroit, et qu'il s'agit d'une réelle constante. L'inconvénient, c'est que la constante ne peut être qu'un int.

En C++, const int déclare réellement une constante. En C99, je ne sais pas (si quelqu'un sait, je suis preneur :D).

Citation:

---

Envoyé par Anomaly

En C++, const int déclare réellement une constante. En C99, je ne sais pas (si quelqu'un sait, je suis preneur :D).

---

Pareil qu'en C90. C'est une variable, et non une expression constante. Elle a une adresse.

Citation:

---

Envoyé par Emmanuel Delahaye

Citation:

---

Envoyé par Anomaly

En C++, const int déclare réellement une constante. En C99, je ne sais pas (si quelqu'un sait, je suis preneur :D).

---

Pareil qu'en C90. C'est une variable, et non une expression constante. Elle a une adresse.

---

D'accord, mais tu disais ici :

Citation:

---

Envoyé par Emmanuel Delahaye

Citation:

---

Envoyé par graphicsxp

et peux t-on faire :

Code:

---

1 2	const int var = 25; char line[var];

---

---

Ce code ne fonctionne qu'en C99 sous certaines conditions.

---

Si la signification de const int n'a pas changé depuis l'ancienne norme, pourquoi ce code marcherait-il en C99, et quelles sont ces fameuses conditions ? 8O

Citation:

---

Envoyé par Anomaly

Citation:

---

Envoyé par Emmanuel Delahaye

Citation:

---

Envoyé par graphicsxp

et peux t-on faire :

Code:

---

1 2	const int var = 25; char line[var];

---

---

Ce code ne fonctionne qu'en C99 sous certaines conditions.

---

Si la signification de const int n'a pas changé depuis l'ancienne norme, pourquoi ce code marcherait-il en C99, et quelles sont ces fameuses conditions ? 8O

---

Ce n'est pas lie au changement de comportement du const mais au changement de comportement des tableau (j'ai oublie le nom exact du mecanisme).
En C99, la taille d'un tableau n'est plus obligatoirement une expression constante.

Citation:

---

Envoyé par Anomaly

Citation:

---

Ce code ne fonctionne qu'en C99 sous certaines conditions.

---

Si la signification de const int n'a pas changé depuis l'ancienne norme, pourquoi ce code marcherait-il en C99, et quelles sont ces fameuses conditions ?

---

Ce qui change c'est la notion de VLA (Variable Length Array) qui accepte une variable. Si j'ai bien compris, un VLA ne peut exister que dans un bloc, et son adresse n'est pas transmissible à l'appelant. D'autre part, comme avec les variables automatiques, on a pas le moyen de savoir si la création d'un VLA s'est bien déroulée ou non.

Citation:

---

Envoyé par Emmanuel Delahaye

Citation:

---

Envoyé par Anomaly

Citation:

---

Ce code ne fonctionne qu'en C99 sous certaines conditions.

---

Si la signification de const int n'a pas changé depuis l'ancienne norme, pourquoi ce code marcherait-il en C99, et quelles sont ces fameuses conditions ?

---

Ce qui change c'est la notion de VLA (Variable Length Array) qui accepte une variable. Si j'ai bien compris, un VLA ne peut exister que dans un bloc, et son adresse n'est pas transmissible à l'appelant. D'autre part, comme avec les variables automatiques, on a pas le moyen de savoir si la création d'un VLA s'est bien déroulée ou non.

---

les VLA sont equivalent (en fonctionnalité, pas en syntaxe) à la fonction non standard, mais largement repandue alloca.