Discussion :

[graphicsxp]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[norac]

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

[graphicsxp]

ha oui mais dans ce cas quel est le mieux ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
#define CHAR_PER_LINE 25

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
const int charperline = 25

[graphicsxp]

et peux t-on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

ou doit on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 
#define VAR 25
char line[VAR];

merci

[ggnore]

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.

[ggnore]

et peux t-on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...

ou doit on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 
#define VAR 25
char line[VAR];

merci

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

[magic corp.]

Avec un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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-

[2Eurocents]

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+

[Selenite]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Emmanuel Delahaye]

ha oui mais dans ce cas quel est le mieux ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
#define CHAR_PER_LINE 25

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Emmanuel Delahaye]

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

Quoi ?

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 ?

[Emmanuel Delahaye]

et peux t-on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

ou doit on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
#define VAR 25
char line[VAR];

Ce code est portable.

[Emmanuel Delahaye]

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

C'est faux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 */

[2Eurocents]

Et dire que certains me traitent de pinailleur !!

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.

[Anomaly]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ).

[Emmanuel Delahaye]

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

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

[Anomaly]

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

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

D'accord, mais tu disais ici :

et peux t-on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[gl]

et peux t-on faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

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.

[Emmanuel Delahaye]

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.

[Gandalf]

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.