[const] #define vs const

Bonjour

quelle est l adifference pour la delaration des constantes chaines de caracteres entre

Code:

---

#define CHAINE "bonjour"

---

et

Code:

---

const char chaine [] = "bonjour"

---

en terme d'utilsation memoire ?

de meme pour les constantes numerique

Code:

---

#define VALEUR 10

---

et

Code:

---

const int valeur = 10

---

Salut !

La différence est dans l'utilisation qu'on en fait : #define est utilisé pour des valeurs globales en général, qu'on ne veut pas trafiquer, toucher et qui sont les même quelque soit la chose que fait le programme.
const, c'est juste pour dire que la valeur de la variable n'est pas modifiable.

Ex :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#define N 100 void fonction_bidon(const char *chaine) { int i ; for( i = 0; i < N; i++) printf("%s\n",chaine); }   int main(void) { ... fonction_bidon("Coucou");   ... }

---

A+

bonjour

#define est une directive pré-compilation. Donc #define MAX 10 donne que toute occurence de MAX dans le source sera remplacé par la valeur 10. Donc rien en mémoire

const char bonjour[]"Bonjour" défini un tableau constant en mémoire ( zone statique ), le tableau est présent en mémoire mais est uniquement en mode lecture.

Je sais pas si ca t'avance ?

Citation:

---

const char bonjour[]"Bonjour" défini un tableau constant en mémoire ( zone statique ), le tableau est présent en mémoire mais est uniquement en mode lecture.

---

Juste un petit détail,

Code:

---

#define TXT "Bonjour"

---

Occupera aussi de la place mémoire....

Dans le cas d'utilisaton de

Code:

---

#define CHAINE "bonjour"

---

je me demande si a chaque fois que le compilateur va retrouver la chaine "bonjour" dans le code ( resultat de preprocesseur) il y aura une allocation statique de 8 caracteres ( sizeof("bonjour") )?

Citation:

---

Envoyé par fearyourself

Citation:

---

const char bonjour[]"Bonjour" défini un tableau constant en mémoire ( zone statique ), le tableau est présent en mémoire mais est uniquement en mode lecture.

---

Juste un petit détail,

Code:

---

#define TXT "Bonjour"

---

Occupera aussi de la place mémoire....

---

Code:

---

1 2 3

#define TXT "Bonjour"   printf("%s", TXT);

---

La place que cela prend se trouve dans l'executable mais pas en mémoire vive...

Citation:

---

je me demande si a chaque fois que le compilateur va retrouver la chaine "bonjour" dans le code ( resultat de preprocesseur) il y aura une allocation statique de 8 caracteres ( sizeof("bonjour") )?

---

Je ne pense pas que cela fait partie de la norme mais sur gcc 3.4.4, la chaîne se retrouvera une seule fois en mémoire...

Citation:

---

La place que cela prend se trouve dans l'executable mais pas en mémoire vive...

---

Sauf si je me trompe entièrement mais lorsqu'un programme est exécuté, le code du programme est chargé en mémoire vive y compris les chaînes de caractères "statiques"...

Il est possible que ce soit dépendant de l'OS mais sur ce point, cela m'étonnerait...

Jc

je pense que le plus sur pour les constantes chaines de caracters d'utiliser

Code:

---

const char buffer[] = "bonjour"

---

Bonjour,
reprenons depuis le début :mrgreen:

Premier cas :

Code:

---

#define TXT "bonjour"

---

La chaîne "bonjour" est stockée dans le fichier exécutable (ce sont ces chaînes que l'on voit lorsque l'on ouvre un exécutable en tant que fichier texte).
Ensuite lors de son utilisation, par exemple :

Code:

---

puts (TXT);

---

Le préprocesseur remplacera ceci par :

Code:

---

puts ("bonjour");

---

Qui renvoi l'adresse de la chaîne [1] à la fonction puts.

Deuxième cas :

Code:

---

const char chaine [] = "bonjour"

---

On commence par créer une zone mémoire de 8 bytes dans laquelle est recopiée la chaîne "bonjour" (cf premier cas pour ceux qui n'ont pas suivie).
Dans ce cas, il n'est pas nécessaire de déclarer le contenu de la variable chaine constant, cependant cela est fortement conseillé dans l'exemple ci dessous :

Code:

---

const char *chaine = "bonjour"

---

Puisque cette fois ci, on ne réserve pas d'espace mémoire, on se contente de stocker dans chaine l'adresse de la chaîne "bonjour" [1] qui peut être dans une zone de mémoire en lecture seule.

Les chaînes de caractères en C

---
[1] Lorsque l'exécutable est chargé en mémoire, la partie contenant les données l'est aussi par conséquent les chaînes de caractères stockées dans le fichier se retrouvent donc en mémoire, c'est cette adresse dont il est question ici.

Citation:

---

Envoyé par gege2061

Code:

---

const char chaine [] = "bonjour"

---

On commence par créer une zone mémoire de 8 bits

---

64 bits en fait ;) ... ou 8 octets :mrgreen:

Il y a pas mal de confusion dans ce post. Un #define pre-processeur ne declare rien du tout. C'est juste un "trouver-remplacer" qui sera execute sur le code source. Savoir si de la memoire sera allouee depend entierement de l'utilisation de la valeur definie.

Code:

---

1 2 3 4

#define STRING "This is a string" ... char string[] = STRING;

---

va evidemment occuper de la memoire.

De la meme facon,

Code:

---

1 2 3 4

#define LENGTH 10 ... char string[LENGTH];

---

ne va pas allouer de la memoire pour la variable LENGTH, puisqu'elle n'existe pas!

mais de point de vue de la taille de l'executable

est-ce que

Code:

---

1 2 3

puts("bonjour"); puts("bonjour"); puts("bonjour");

---

prend plus ou moins d'espace que

Code:

---

1 2 3 4 5

const char* chaine = "bonjour"; puts(chaine); puts(chaine); puts(chaine);

---

Exactement la même taille mais cela dépend du compilateur en fait. Est-il assez intelligent pour voir qu'il y a plusieurs fois la même chaîne de caractère?

Généralement oui

Citation:

---

Envoyé par Smortex

Citation:

---

Envoyé par gege2061

Code:

---

const char chaine [] = "bonjour"

---

On commence par créer une zone mémoire de 8 bits

---

64 bits en fait ;) ... ou 8 octets :mrgreen:

---

Nan désolé, je voulai dire bytes :oops: c'est corrigé.

Citation:

---

Envoyé par fearyourself

Exactement la même taille

---

Ah bon 8O dans le second cas, on déclare une variable de taille sizeof (char *) après si le compilateur s'amuse à faire des optimisations, forcement on ne va pas s'en sortir :fou:

Citation:

---

Envoyé par gege2061

Citation:

---

Envoyé par fearyourself

Exactement la même taille

---

Ah bon 8O dans le second cas, on déclare une variable de taille sizeof (char *) après si le compilateur s'amuse à faire des optimisations, forcement on ne va pas s'en sortir :fou:

---

Je ne suis pas convaincu... La taille de l'exécutable restera inchanger... Du moins c'est ce que dit mon petit doigt...

C'est la fin de la journée, je vais y réflechir...
:roll:

Il faut faire des tests, comme d'habitude. Dans mon cas (gcc sous Linux RedHat et cc sous HP-UX), l'executable genere est de meme taille et identique pour les deux facons proposees. Il semble donc que le compilateur factorise le code de facon a n'utiliser qu'une seule chaine dans le cas des puts("bonjour").

Mais je me demande bien pourquoi le posteur original se pose ce genre de questions. C'est pour faire une demo en moins de 64k?

Citation:

---

Envoyé par fearyourself

La taille de l'exécutable restera inchanger...

---

J'était partie sur la taille lors de l'exécution :oops:
Au niveau du fichier lui même, déjà on s'écarte du sujet de ce forum puisque tous les systèmes ne possèdent pas la notion de fichier.

Et comme le dis DaZumba

Citation:

---

Mais je me demande bien pourquoi le posteur original se pose ce genre de questions. C'est pour faire une demo en moins de 64k?

---

J'aimerai aussi connaitre le but de cette question, si c'est pour gagner quelque ko sur un programme destiné à tourner sous Windows XP, c'est inutile.

Non c'est pour un systeme embarqué qui tourne sous linux

Citation:

---

Envoyé par Mokhtar BEN MESSAOUD

quelle est l adifference pour la delaration des constantes chaines de caracteres entre

Code:

---

#define CHAINE "bonjour"

---

---

Pour le moment, ça ne définit qu'une substitution de caractères. Tant qu'on utilise pas la macro, aucune mémoire n'est réservé, aucun objet n'est crée...

Citation:

---

et

Code:

---

const char chaine [] = "bonjour"

---

---

Un espace mémoire non modifiable et initialisé est crée. C'est une tableau de type char. Il peut être de portée locale ou statique. Il peut être persistant ou non. La taille de l'objet crée est 'sizeof chaine' bytes. Il dispose d'une adresse.

Citation:

---

en terme d'utilisation memoire ?

de meme pour les constantes numerique

Code:

---

#define VALEUR 10

---

---

Pour le moment, ça ne définit qu'une substitution de caractères. La valeur numérique équivallente est une expression constante. Elle n'a n'a pas d'adresse et n'occupe aucune place en mémoire. On parle aussi de 'valeur immédiate'.

Citation:

---

et

Code:

---

const int valeur = 10

---

---

Un espace mémoire non modifiable et initialisé est crée. C'est un objet de type int Il peut être de portée locale ou statique. Il peut être persistant ou non. La taille de l'objet crée est 'sizeof valeur' bytes. Il dispose d'une adresse. Ce n'est pas une expression constante.

Citation:

---

Envoyé par hegros

const char bonjour[]"Bonjour" défini un tableau constant en mémoire ( zone statique ),

---

ou automatique (locale).

Citation:

---

Envoyé par fearyourself

Code:

---

#define TXT "Bonjour"

---

Occupera aussi de la place mémoire....

---

Non, tant qu'on n'utilise pas la macro.

Citation:

---

Envoyé par Mokhtar BEN MESSAOUD

Dans le cas d'utilisaton de

Code:

---

#define CHAINE "bonjour"

---

je me demande si a chaque fois que le compilateur va retrouver la chaine "bonjour" dans le code ( resultat de preprocesseur) il y aura une allocation statique de 8 caracteres ( sizeof("bonjour") )?

---

Ca dépend de l'implémentation et des reglages. Certains compilateurs créent une zone mémoire à chaque fois, d'autres une seule (option 'merge strings', par exemple), d'autres font des optimisations savantes du genre

Code:

---

1 2 3

char *sa = "bonjour"; char *sb = "jour"

---

avec 'sb' qui vaut 'sa + 3'... Beaucoup de choses sont possibles. En embarqué, on est friand de ce genre d'optimisations...

Citation:

---

Envoyé par Mokhtar BEN MESSAOUD

je pense que le plus sur pour les constantes chaines de caracters d'utiliser

Code:

---

const char buffer[] = "bonjour"

---

---

Ca dépend de l'usage. En embarqué, je fais :

Code:

---

static const char buffer[] = "bonjour";

---

, c'est ce qui prend le moins de place (mémoire statique initialisée).

Citation:

---

Envoyé par gege2061

Premier cas :

Code:

---

#define TXT "bonjour"

---

La chaîne "bonjour" est stockée dans le fichier exécutable (ce sont ces chaînes que l'on voit lorsque l'on ouvre un exécutable en tant que fichier texte).

---

Pas tant que la macro n'est pas utilisée. Si elle l'est, la substitution s'opère, et une (ou plusieurs) chaine statique non modifiable est créée.

Citation:

---

Ensuite lors de son utilisation, par exemple :

Code:

---

puts (TXT);

---

Le préprocesseur remplacera ceci par :

Code:

---

puts ("bonjour");

---

Qui renvoi l'adresse de la chaîne [1] à la fonction puts.

---

Ok.

Citation:

---

Deuxième cas :

Code:

---

const char chaine [] = "bonjour"

---

On commence par créer une zone mémoire de 8 bytes dans laquelle est recopiée la chaîne "bonjour" (cf premier cas pour ceux qui n'ont pas suivie).
Dans ce cas, il n'est pas nécessaire de déclarer le contenu de la variable chaine constant,

---

Ca dépend des cas. Si on veut réellement une chaine constante, mais sans le pointeur inutile, cette forme (avec 'static' permet de faire des économies de mémoire sustanciels, puisque qu'il suffit de disposer d'une seule zone initialisée. Pas de recopie à faire.

Si la variable est locale, et/ou non const, il y a bien sûr recopie obligatoire. (Perte de temps et de mémoire).

Citation:

---

Envoyé par Mokhtar BEN MESSAOUD

mais de point de vue de la taille de l'executable

est-ce que

Code:

---

1 2 3

puts("bonjour"); puts("bonjour"); puts("bonjour");

---

prend plus ou moins d'espace que

Code:

---

1 2 3 4 5

const char* chaine = "bonjour"; puts(chaine); puts(chaine); puts(chaine);

---

---

Le deuxième est est certainement plus optimisé. Mais si le premier cas est optimisé, il est lègèrement plus performant, car on fait l'économie du pointeur. Si il est statique, ça peut compter...

Citation:

---

Envoyé par fearyourself

Citation:

---

Envoyé par gege2061

Citation:

---

Envoyé par fearyourself

Exactement la même taille

---

Ah bon 8O dans le second cas, on déclare une variable de taille sizeof (char *) après si le compilateur s'amuse à faire des optimisations, forcement on ne va pas s'en sortir :fou:

---

Je ne suis pas convaincu... La taille de l'exécutable restera inchanger... Du moins c'est ce que dit mon petit doigt...

C'est la fin de la journée, je vais y réflechir...
:roll:

---

C'est tout réfléchi, il y a un pointeur en plus.

Hum, quoiqu'il pourrait être transformé en expression constante si
- on ne le modifie pas
- on ne prend jamais son adresse.

Dans ce cas, les deux cas pourraient occuper la même place mémoire. Tout celà dépend fortement de l'implémentation.

Citation:

---

Envoyé par DaZumba

Mais je me demande bien pourquoi le posteur original se pose ce genre de questions. C'est pour faire une demo en moins de 64k?

---

En embarqué, la question peut se poser... Notamment si le code est truffé de debugs avec __FILE__ ...

J'ai déjà eu des gags...

Citation:

---

Envoyé par Mokhtar BEN MESSAOUD

Non c'est pour un systeme embarqué qui tourne sous linux

---

Bienvenu au club !

Bon ca y est j'ai fait le test

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#include <stdio.h> #define CHAINE "bonjour" #define SOUSCHAINE "onjour"     int main() {   printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE);   printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE);   printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE); printf(" address of %s = %p\n", CHAINE, &CHAINE);   printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE); printf(" address of %s = %p\n", SOUSCHAINE, &SOUSCHAINE);     }

---

le resultat est

Citation:

---

address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of bonjour = 0x80486a8
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of onjour = 0x80486c5
address of onjour = 0x80486c5

---

donc le compilateur optimise si les chaine sont identiques mais il n'optimise les sous chaines

Si je reprends ton code, voici ce que j'obtiens:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

#include <stdio.h>   #define TXT "Bonjour" #define TXT1 "onjour"   int main() { printf("%p %s\n",TXT, TXT); printf("%p %s\n",TXT1, TXT1); return 1; }

---

En effet en compilant comme ceci:

Code:

---

gcc texte.c

---

J'obtiens:

Citation:

---

0x8048518 Bonjour
0x8048527 onjour

---

On voit bien qu'il ne gère pas les sous-chaîne... Mais si je compile comme ceci:

Code:

---

gcc texte.c -O3

---

J'obtiens:

Citation:

---

0x8048508 Bonjour
0x8048509 onjour

---

Il a géré correctement les sous-chaînes... Mais bien-sûr, il ne peut pas gérer toutes les sous-chaînes vu qu'il faut que la chaîne termine par '\0'

Donc lorsqu'on fait:

Code:

---

1 2 3

#define TXT "Bonjour" #define TXT1 "onjou"

---

On obtient (avec l'option -O3):

Citation:

---

0x8048508 Bonjour
0x8048517 onjou

---

Tout ceci pour dire que ce n'est pas aussi simple, que cela dépend de beaucoup de choses et bien sûr pas tous les compilateurs le feront, cela dépendera des options utilisées...

Jc

Citation:

---

Envoyé par fearyourself

Code:

---

gcc texte.c -O3

---

J'obtiens:

Citation:

---

0x8048508 Bonjour
0x8048509 onjour

---

---

Très intéressant. Je sais maintenant pourquoi je vais passer en -O3 ...
Merci pour ce test.

Tu a vu que ça n'optimisait pas en -O2 ?

Citation:

---

Tu as vu que ça n'optimisait pas en -O2 ?

---

:roll: J'ai tellement l'habitude de compiler en O3 (à cause des temps de performances des benchmarks) que je ne tente que très rarement les options O1, O2... Lorsque t'as posé ta question, je me suis dit: c'est quand même un truc basique, pourquoi il faudrait un O3... Et en effet, dès O1 c'est bon... :wink:

Jc

Citation:

---

Envoyé par fearyourself

Citation:

---

Tu as vu que ça n'optimisait pas en -O2 ?

---

:roll: J'ai tellement l'habitude de compiler en O3 (à cause des temps de performances des benchmarks) que je ne tente que très rarement les options O1, O2... Lorsque t'as posé ta question, je me suis dit: c'est quand même un truc basique, pourquoi il faudrait un O3... Et en effet, dès O1 c'est bon... :wink:

Jc

---

OK, je laisse donc en -O2 jusqu'à nouvel ordre.

L'option O3 mets au moins en place généralement (et sur ma machine utilisant gcc 4.0 mais je pense que c'est pareil sur le 3.3):

- inlining: qui n'est quand même pas négligeable
- prefetch: sur les machines actuelles, cela peut considérablement réduire le temps d'exécution...

De toute façon, si j'ai bien compris, tu travailles sur des systèmes embarqués. Généralement, la taille du code est plus petit en O3, le fait que le compilateur impémente le "inlining" fait que le nombre d'appel de fonctions est amoindri...

Cela devrait être un point positif pour toi,
Jc

Citation:

---

Envoyé par fearyourself

L'option O3 mets au moins en place généralement (et sur ma machine utilisant gcc 4.0 mais je pense que c'est pareil sur le 3.3):

- inlining: qui n'est quand même pas négligeable
- prefetch: sur les machines actuelles, cela peut considérablement réduire le temps d'exécution...

De toute façon, si j'ai bien compris, tu travailles sur des systèmes embarqués. Généralement, la taille du code est plus petit en O3, le fait que le compilateur impémente le "inlining" fait que le nombre d'appel de fonctions est amoindri...

Cela devrait être un point positif pour toi,

---

Exact, j'ai gagné 20 % de code.