Initialisation, const char *, malloc

Bonjour. Je voudrai savoir quelle conséquence ça a d'initialiser des const char * à NULL. Car je sais que allouer dynamiquement de la mémoire avec calloc initialise la chaîne par des 0, à proscrire donc pour l'allocation des const char * (on ne peut plus modifier la chaîne après). Mais est-ce que le mot clé const interdit de modifier le const char* avec une allocation et/ou la recopie d'une chaîne par exemple s'il est initialisé à NULL au préalable ?

Citation:

---

Envoyé par kromartien

Bonjour. Je voudrai savoir quelle conséquence ça a d'initialiser des const char * à NULL. Car je sais que allouer dynamiquement de la mémoire avec calloc initialise la chaîne par des 0, à proscrire donc pour l'allocation des const char * (on ne peut plus modifier la chaîne après).

---

Je ne vois pas le rapport avec calloc(). A partir du moment où un pointeur est qualifié const, la zone pointée devient non modifiable via ce pointeur.

Mais on a le droit de faire :

Code:

---

1 2 3 4 5 6

char *p = malloc(123);   strcpy (p, "Hello");   char const *pc = p;

---

et maintenant, on ne peut plus modifier la chaine avec pc. (mais on peut toujours le faire avec p).

L'intérêt est évidemment dans le cas d'un paramètre de fonction. On autorise ou non la fonction à modifier la zone pointée.

Citation:

---

Mais est-ce que le mot clé const interdit de modifier le const char* avec une allocation et/ou la recopie d'une chaîne par exemple s'il est initialisé à NULL au préalable ?

---

Définir un pointeur directement sur une zone allouée non modifiable est évidemment un non sens (initialisation impossible, ou alors au prix d'un gros mensonge au système de développement : cast).

Code:

---

char const *p = malloc(123);

---

c'est à peu près aussi absurde que :

Code:

---

int const x;

---

Pour programmer correctement, il faut avoir un peu de bon sens...

Oui c'est ce que j'essaie d'acquérir un pitit peu et le forum ça m'y aide beaucoup (j'en profite pour saluer la qualité des intervenants:king:)

Oui, merci, en fait pour les const char je fais souvent des déclaration du type

Code:

---

1 2 3

const char * machaine; machaine=malloc(10000); machaine = "Bonjour. Voulez vous un peu de thé?"

---

J'en déduis que la zone initialisée ainsi devient non modifiable (les valeurs) mais que la zone suivant peut peut être être écrite (grosse incertitude).

Mais je me suis posé des questions en fait par rapport au test sur la valeur de malloc, car j'initialise souvent les pointeurs à NULL lors de leur déclaration, en faisant quelque chose du genre

Code:

---

1 2 3 4 5 6 7 8 9 10

char * monpointeur = NULL; monpointeur = malloc(10000); if(monpointeur!=NULL) { puts("allocation reussie"); } else { puts("allocation ratee"); }

---

je voulais savoir si c'était une méthode générique ou pas et si je pouvais l'utiliser pour des const char * en réalité.

Car la page de manuel de malloc précise que la zone mémoire allouée par malloc n'est pas initialisée, contrairement à celle pointée par calloc qui est initialisée avec des zéros. Je crois que c'est ce qui fait la différence. Si la zone n'est pas initialisée, il est encore possible d'y écrire d'après mon expérience en tous cas.

Car en fait j'ai des problèmes de gestion de mémoire, pas simple :koi:, par exemple ce message :

Code:

---

main.c:117: warning: passing argument 1 of ‘free’ discards qualifiers from pointer target type

---

et des glibc corrupted à l'exécution :aie: j'ai peur alors j'essaie de savoir pourquoi ça ne marche pas.

Quand le man dis que la mémoire n'est pas initialisé avec malloc cela signifie simplement que dans chaque case mémoire se trouve une valeur mais qu'on ne connait pas.

Ce que tu fais reste un nom sens.

Les char const * s'utilisent comme ça (entre autres)

Code:

---

char const * p = "bonjour";

---

Donc voilà.

Je ne comprends pas ce que tu cherches à faire.

Citation:

---

Envoyé par kromartien

...Car la page de manuel de malloc précise que la zone mémoire allouée par malloc n'est pas initialisée, contrairement à celle pointée par calloc qui est initialisée avec des zéros. Je crois que c'est ce qui fait la différence. Si la zone n'est pas initialisée, il est encore possible d'y écrire d'après mon expérience en tous cas.

---

Comme on vient de te le dire, mais je vais réexpliquer, tu n'as pas compris :

malloc et calloc font la même chose : réserver un certain nombre de bytes dans la mémoire.

L'utilisation de cette plage d'adresse disponibles est la même dans les 2 cas.

La seule différence est que calloc initialise à 0 (memset (.. 0L..) ) l'ensemble de la plage.

Dans le cas de malloc, ça ne fait rien. Donc tu as ce qu'il y a dans la mémoire à ces adresses à ce moment-là.

Dans 99% des cas ça ne pose aucun problème, vu que tu remplis ta plage. Le seul cas où cela peut poser un problème, c'est si tu avais un pointeur de char, et que tu effectues un strncpy ou strncat, qui n'ajoutent pas un '\0' à la fin. Dans ce cas, lorsque tu voudrais lire, comme il n'y aura pas de terminateur, en général il y aura crash car on ne saura pas où la chaîne s'arrête.

Est-ce que ça veut dire que faire une allocation dynamique sur un const char ne sert à rien?

tu lis les réponses ? qu'est-ce qu'a dit Emmanuel ??

oui d'accord j'ai bien compris.

Citation:

---

Envoyé par kromartien

Oui, merci, en fait pour les const char je fais souvent des déclaration du type

Code:

---

1 2 3

const char * machaine; machaine=malloc(10000); machaine = "Bonjour. Voulez vous un peu de thé?"

---

---

Complètement absurde. Tu as alloué 10000 bytes pour rien et en plus ils sont perdus. (Impossible de les libérer). Peux-tu expliquer par quelle raisonnement tortueux tu es-tu arrivé à écrire une telle ânerie ?

Ton code est une façon tordue et dispendieuse en mémoire allouée d'écrire :

Code:

---

const char * machaine = "Bonjour. Voulez vous un peu de thé?"

---

Quand je dis qu'il faut du bon sens, c'est par exemple de se rendre compte que quand on écrit 2 fois dans la même variable sans avoir fait de lecture entre les deux est forcément une ânerie. Exemple flagrant :

Code:

---

1 2 3

machaine=malloc(10000); machaine = "Bonjour. Voulez vous un peu de thé?"

---

Citation:

---

J'en déduis que la zone initialisée ainsi devient non modifiable (les valeurs) mais que la zone suivant peut peut être être écrite (grosse incertitude).

---

Tu raisonnes de travers.

La qualification d'un pointeur ne change pas la qualification de la zone pointée. Elle se contente de la rendre cohérente avec sa nature (modifiable ou pas) et avec l'usage qu'on en fait (inutile de donner un droit d'écriture à une fonction qui ne dois que lire les données).

Par exemple :

Code:

---

char *s = "hello";

---

est incohérent, bien que techniquement correct. En effet, une chaine littérale n'est pas garantie être modifiable. Pour être portable, elle doit donc être considérée comme non modifiable. Il est donc plus cohérent d'écrire :

Code:

---

char const *s = "hello";

---

Citation:

---

Mais je me suis posé des questions en fait par rapport au test sur la valeur de malloc, car j'initialise souvent les pointeurs à NULL lors de leur déclaration, en faisant quelque chose du genre

Code:

---

1 2	char * monpointeur = NULL; monpointeur = malloc(10000);

---

---

Ce qui, en passant, est une façon compliquée d'écrire :

Citation:

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11

char * monpointeur = malloc(10000);   if(monpointeur!=NULL) { puts("allocation reussie"); } else { puts("allocation ratee"); }

---

je voulais savoir si c'était une méthode générique ou pas et si je pouvais l'utiliser pour des const char * en réalité.

---

Comme je me tue à te l'expliquer, utiliser const pour des données allouées est une absurdité, puis qu'on ne sait pas allouer et initialiser d'un coup. Pour les chaines, il existe une fonction qui fait ça, c'est strdup(). (Non standard C, mais POSIX.1, donc très portable) :

Code:

---

char *s = strdup ("hello");

---

on pourrait théoriquement écrire :

Code:

---

char const *s = strdup ("hello");

---

maintenant, est-ce que ça a un intérêt ? Il faut voir le contexte.

Citation:

---

Car la page de manuel de malloc précise que la zone mémoire allouée par malloc n'est pas initialisée, contrairement à celle pointée par calloc qui est initialisée avec des zéros. Je crois que c'est ce qui fait la différence.

---

OK.

Citation:

---

Si la zone n'est pas initialisée, il est encore possible d'y écrire d'après mon expérience en tous cas.

---

Là, je ne te suis pas. Le fait qu'une zone soit modifiable ou non n'a rien avoir avec le fait qu'elle ait été initialisée ou non par la fonction d'allocation. Heureusement, toute variable crée dynamiquement est modifiable, sinon, l'intérêt serait plutôt limité, tu ne penses pas ?

Citation:

---

Car en fait j'ai des problèmes de gestion de mémoire, pas simple :koi:, par exemple ce message :

Code:

---

main.c:117: warning: passing argument 1 of ‘free’ discards qualifiers from pointer target type

---

et des glibc corrupted à l'exécution :aie: j'ai peur alors j'essaie de savoir pourquoi ça ne marche pas.

---

Si c'est à la suite de l'ânerie du départ, le bons sens suffit à trouver d'où vient l'erreur. Je rappelle que free() doit recevoir la valeur exacte qui a été données par malloc().

Je rappelle aussi que pour copier une chaine, on utilise pas '=', mais 'strcpy()'...