blocage bizarre sur un malloc

Version imprimable

20/01/2006, 19h52
gilux

blocage bizarre sur un malloc

Bonjour à tous,
Je m'arrache les cheveux depuis plusieurs heures sur un prog et je viens d'isoler un bug plus que bizarre :

Code:

char *c = (char *) malloc(51*sizeof(char));

Vu comme ça, ça paraît tout bête, hein ?
Eh ben, ça marche po :(
Je m'explique :
ça compile tout bien, tout normal... Evidemment...
Mais à l'exécution mon gentil prog s'arrête pile sur cette instruction, il semble être dans l'état bloqué !
qqn comprend pourquoi ?

Merci pour votre aide
20/01/2006, 19h56
gilux

petite précision

PS : j'ai essayé de remplacer par :

Code:

char c[51];

Evidemment ça marche mieux mais j'ai un warning à la compilation car ma fonction doit renvoyer l'adresse de c.
Il semble que d'autres erreurs viennent de là...
20/01/2006, 20h02
PRomu@ld

D'une : enlève ton cast, ça ne résoudra pas ton problème, mais c'est plus beau !!!

t'es sur que l'erreur vient de là (en tout cas ton bloquage.)

Envoie un peu plus de code (la fonction dans laquelle tu utilises cet appel), pour qu'on t'aide.

le code source :

La fonction fait la même chose que strcat.
Voici le code sans les printf du debbugage (+ lisible) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
char *concat(char *a, char *b) {
/* Retourne la chaîne c qui est la concaténation des chaines a et b.
 * NB : a, b et c sont des chaînes standards (i.e. terminée par '\0').
 */
   int i, j;
   int lengthA = strlen(a);
   int lengthB = strlen(b);
   int length = lengthA + lengthB + 1;
   char *c = (char *) malloc(length*sizeof(char));
   j = 0;
   for (i=0; i<lengthA; i++) {
      c[j] = a[i];
      j++;
   }
   for (i=0; i<lengthB; i++) {
      c[j] = b[i];
      j++;
   }
   c[j] = '\0';
   return c;
}

Et le voici avec les printf:

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
 
char *concat(char *a, char *b) {
/* Retourne la chaîne c qui est la concaténation des chaines a et b.
 * NB : a, b et c sont des chaînes standards (i.e. terminée par '\0').
 */
   printf("Entrée dans concat\n");
   int i, j;
   int lengthA = strlen(a);
   printf("strlen(a)=%d\n", lengthA);
   int lengthB = strlen(b);
   printf("strlen(b)=%d\n", lengthB);
   int length = lengthA + lengthB + 1;
   printf("strlen(c)=%d\n", length);
   char *c = (char *) malloc(51*sizeof(char));
   //char c[length];
   j = 0;
   printf("Fin des alloc\n");
   for (i=0; i<lengthA; i++) {
      c[j] = a[i];
      printf("%c", c[j]);
      j++;
   }
   for (i=0; i<lengthB; i++) {
      c[j] = b[i];
      printf("%c", c[j]);
      j++;
   }
   c[j] = '\0';
   printf("\nFin des copies\nretour:%d\n", strlen(c));
   return c;
}

Et voila

20/01/2006, 20h16
gilux

J'ai un peu avancé...

Euh, j'ai du nouveau.
Pour être sûr, j'ai compiler la fonction toute seul avec un petit main() qui sert juste à la tester. Là ça marche sans soucis !
Mais ce qui me chagrine quand même, c'est que mon prog s'arrête bien au milieu de cette fonction, ni avant, ni après !
Comment est-ce possible, ça ?
20/01/2006, 20h21
gilux

encore une précision

Le coefficient 51 dans le malloc, c'était pour du debuggage. Normalement, c'est la variable length qui est multipliée à sizeof()
20/01/2006, 20h27
PRomu@ld
Tu sais tout est possible, tout est réalisable, ...

Bon personnellement je suis pour la séparation entre la déclaration des variables et leur affectation (surtout lorsque tu fais une affectation avec une fonction). Mais ça devrait marcher.

Autre chose, lorque tu fais des printf, ce que tu vois affiché ne l'est pas forcément au moment ou tu le veux, par exemple l'affichage réel peut se produire après.

Pour éviter celà, soit tu écris sur la sortie d'erreur (ce que je préfère):
Code:

1 2 fprintf(stderr,"message");
ou encore tu peux effectuer un flush après tes écritures.

Teste en utilisant ce que je t'ai donné et vérifie que tu as bien une taille correcte.
20/01/2006, 21h10
gilux

suite et fin

Merci pour ton conseil, je m'en souviendrais
Entre temps, j'ai résolu le problème. Je ne sais pas trop comment mais je l'ai résolu !
A +
Gilux
21/01/2006, 00h22
Emmanuel Delahaye

Re: blocage bizarre sur un malloc

Citation:

Envoyé par gilux

Code:

char *c = (char *) malloc(51*sizeof(char));

C'est une façon drôlement compliqué d'écrire

Code:

char *c = malloc (51);

Ensuite, s'assurer que <stdlib.h> est bien visible.

http://emmanuel-delahaye.developpez....tes.htm#malloc
21/01/2006, 09h14
PRomu@ld
Citation:

Je ne sais pas trop comment mais je l'ai résolu !

C'est simple, tu regardes le code qui marche et tu le compare avec celui qui ne marche pas.
Citation:
Citation:

Envoyé par gilux

Code:

1 2 char *c = (char *) malloc(51*sizeof(char));

C'est une façon drôlement compliqué d'écrire

Code:

1 2 char *c = malloc (51);
Oulà raccourci un peu trop rapide, malloc, comme tu me l'as montré n'alloue pas des octets mais des bytes ...

Citation:

Ensuite, s'assurer que <stdlib.h> est bien visible.

Si c'était le cas, il y aurait surement eu erreur soit à la compilation soit à l'édition de lien.
21/01/2006, 09h40
Emmanuel Delahaye
Citation:
Envoyé par PRomu@ld

Citation:

Citation:

Envoyé par gilux

Code:

1 2 char *c = (char *) malloc(51*sizeof(char));

C'est une façon drôlement compliqué d'écrire

Code:

1 2 char *c = malloc (51);

Oulà raccourci un peu trop rapide, malloc, comme tu me l'as montré n'alloue pas des octets mais des bytes ...
Je ne vois pas le rapport. char est l'unité de compte de la taille mémoire en C. Comme toutes les unités, elle vaut 1 par définition. sizeof (char) vaut donc 1 par définition.

Par contre, tu aurais pu objecter que si on change de type, il y a une modification à faire.

Pour cete raison, la bonne façon de faire est effectivement :

Code:

T *c = malloc (sizeof *c);

ce qui donne ici

Code:

char *c = malloc (sizeof *c);

qui devient

Code:

wchar_t *c = malloc (sizeof *c);

si besoin est.

Citation:

Citation:

Ensuite, s'assurer que <stdlib.h> est bien visible.

Si c'était le cas, il y aurait surement eu erreur soit à la compilation

Pas en C. Des warnings, oui (ou alors il fait activer une option spéciale comme '-Werror-implicit-function-declaration' avec gcc...)

Citation:

soit à l'édition de lien.

Alors là, je ne vois pas comment. Tu ne confonds quand même pas entête et bibliothèque ? Pas toi ?
21/01/2006, 11h15
PRomu@ld

Citation:

Je ne vois pas le rapport. char est l'unité de compte de la taille mémoire en C. Comme toutes les unités, elle vaut 1 par définition. sizeof (char) vaut donc 1 par définition.

Oui je m'en suis rendu compte après avoir écrit, en fait c'est moi qui avait fait un raccourcis un peu trop rapide ...

Citation:

Pour cete raison, la bonne façon de faire est effectivement :
Code:
T *c = malloc (sizeof *c);

On est d'accord, et ça devrait être d'ailleur la seule méthode autorisée.

Citation:

Pas en C. Des warnings, oui

Désolé, je me suis mal exprimé mais pour moi un warning est une erreur (je ne tolère pas un warning dans mes sources).

Citation:

Alors là, je ne vois pas comment. Tu ne confonds quand même pas entête et bibliothèque ? Pas toi ?

Non, aucun doute là dessus. Je m'étais laissé entendre il y a quelques années que certains compilateurs peut scrupuleux reconnaissaient les fonctions standard et du coup à la compilation il ne lançaient pas de warning. En revanche lorsqu'arrivait l'édition de lien, la dite fonction standard n'ayant pas été compilée, il y avait une erreur de lien.

Je n'ai jamais eu ce problème, je n'utilise pas ce type de compilateur (si tant est qu'il en existe encore ...)
24/01/2006, 00h53
leonardoo

peut etre devra tu utiliser calloc ? (j'aimerai aussi savoir si c'est plus adequat ici .)
24/01/2006, 10h36
Emmanuel Delahaye

Citation:

Envoyé par leonardoo

peut etre devra tu utiliser calloc ? (j'aimerai aussi savoir si c'est plus adequat ici .)

Le problème de calloc() est qu'il met les bits à 0, ce qui n'est pas forcément une représentation valide, notamment pour les flottants et les pointeurs.

Ce n'est pas grave si on pense à initialiser les champs correctement après et qu'on ne se contente pas de la mise à all-bit-to-zero de calloc().