Chaînes de caractères bloquées par 256 ?

Version imprimable

Bonjour à tous !
Dans le cadre d'un projet de codage/décodage, je dois réaliser une fonction (que j'ai appelée ajout_debut) qui me permette d'ajouter un caractère donné d'une chaîne au début de chaînes d'un tableau de chaînes.
Cette fonction marche impec, sauf que si la taille de mes tableaux dépasse 16, c'est-à-dire qu'on aura 16 chaînes de 16 caractères (=256 caractères), elle fait n'importe quoi et m'affiche n'importe quoi, souvent seulement 1 caractère par chaîne au lieu de 16.
J'ai du mal à comprendre ce quota, est-il dû à un blocage quelconque ?
Merci d'avance !

Voici mon code :
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 /* Fonction dep Argument : une chaîne de caractères code résultat : d, une chaîne équivalente à code mais décalée vers la droite et avec un espace comme premier caractère (donc plus longue d'un caractère) */ char * dep (char * code) { char * d = (char *) malloc ((strlen(code)+1)*sizeof(char)); // on fait strlen(code)+1 car on décale tout vers la droite int i; for (i=0;i<=strlen(code);i++) { d[i+1]=code[i]; } d[0]=' '; // on met un espace en premier return d; } /* Fonction ajout_debut Arguments : une chaîne de caractères code, un tableau de chaînes de caractères tab, un entier nb longueur de la chaine code Résultat : un tableau de chaînes de caractères newtab qui correspond à tab mais avec le j-eme caractère de code rajouté en premier caractère de tab et les autres caractères décalés vers la droite */ char ** ajout_debut (char * code, char ** tab, int nb) { char ** newtab = (char **) malloc ((nb+1)*sizeof(char *)); // +1 pour le \0 int i,j; for (i=0;i<nb;i++) { newtab[i]=dep(tab[i]); // on déplace tout vers la droite } for (j=0;j<nb;j++) { newtab[j][0]=code[j]; // et on remplace le premier caractère (un espace) par le j-eme caractère de code newtab[j][nb]='\0'; // on met à la fin le caractère de fin de chaîne } return newtab; }

Bonjour,
Citation:
Envoyé par Snebz
Voici mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 /* Fonction dep Argument : une chaîne de caractères code résultat : d, une chaîne équivalente à code mais décalée vers la droite et avec un espace comme premier caractère (donc plus longue d'un caractère) */ char * dep (char * code) { char * d = (char *) malloc ((strlen(code)+1)*sizeof(char)); // on fait strlen(code)+1 car on décale tout vers la droite int i; for (i=0;i<=strlen(code);i++) { d[i+1]=code[i]; } d[0]=' '; // on met un espace en premier return d; }
Tu prévois « +1 » pour le caractère à insérer, mais tu oublies que strlen() te renvoie la longueur de la chaîne sans le zéro final. Il faut donc faire un « +2 », pour le prévoir lui aussi ;
Tu pourrais utiliser strcpy() pour copier ta chaîne plutôt que faire une boucle ;
Et surtout, tu ne remets pas ce zéro en place. Tes chaînes ne sont donc plus terminées. C'est pour cela que tu obtiens des résultats bizarres. Le fait que ça marche quand même en dessous de 16 caractères est probablement dû aux valeurs qui se trouvaient déjà en mémoire. À noter que strcpy() remet bien le zéro en place.
Citation:
Code:

1 2 3 4 5 6 /* Fonction ajout_debut Arguments : une chaîne de caractères code, un tableau de chaînes de caractères tab, un entier nb longueur de la chaine code Résultat : un tableau de chaînes de caractères newtab qui correspond à tab mais avec le j-eme caractère de code rajouté en premier caractère de tab et les autres caractères décalés vers la droite */ char ** ajout_debut (char * code, char ** tab, int nb) { char ** newtab = (char **) malloc ((nb+1)*sizeof(char *)); // +1 pour le \0
Attention ! Ici, c'est un tableau de pointeurs sur des chaînes que tu redéclares. Pas les chaînes elles-mêmes. Il n'y a pas lieu de réserver un espace supplémentaire à cet endroit.
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 int i,j; for (i=0;i<nb;i++) { newtab[i]=dep(tab[i]); // on déplace tout vers la droite } for (j=0;j<nb;j++) { newtab[j][0]=code[j]; // et on remplace le premier caractère (un espace) par le j-eme caractère de code newtab[j][nb]='\0'; // on met à la fin le caractère de fin de chaîne } return newtab; }
Si dep() n'est pas utilisée ailleurs, c'est dommage de faire une fonction qui insère un espace pour ensuite le remplacer par le caractère définitif. Autant passer directement le caractère à insérer à dep() pour qu'elle le place elle-même. En plus, ton code sera beaucoup plus clair ;
Tes deux boucles ne sont pas imbriquées. Tu n'as donc pas besoin d'utiliser deux indices distincts i et j ;
La ligne « newtab[j][nb] » est incorrecte. « nb » représente à la fois la longueur de la code et la taille de ton tableau de chaînes, mais pas la longueur des chaînes qu'il contient (qui d'ailleurs peut être variable). Tu ne peux pas t'en servir pour placer le zéro final ici.

Merci pour ta réponse rapide !
J'ai donc changé mon code la façon suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 char * dep (char * code) { char * d = (char *) malloc ((strlen(code)+2)*sizeof(char)); // on fait strlen(code)+2 car on décale tout vers la droite et pour le \0 int i; for (i=0;i<=strlen(code);i++) { d[i+1]=code[i]; } d[0]=' '; // on met un espace en premier d[i+1]='\0'; //on met ici le \0 return d; } char ** ajout_debut (char * code, char ** tab, int nb) { char ** newtab = (char **) malloc (nb*sizeof(char *)); int i; for (i=0;i<nb;i++) { newtab[i]=dep(tab[i]); // on déplace tout vers la droite } for (i=0;i<nb;i++) { newtab[i][0]=code[i]; // et on remplace le premier caractère (un espace) par le j-eme caractère de code newtab[i][nb]='\0'; } return newtab; }
Je laisse newtab[j][nb]='\0'; parce qu'en fait la longueur des chaînes que newtab contient est effectivement égale à la longueur du code et du tableau.
Mais ça ne marche toujours pas (au-dessus de 16 caractères) :/
Effectivement je pourrais fusionner dep et ajout_debut mais j'essaye d'abord de faire fonctionner le code comme ça, je verrais après pour rendre tout le code plus clair :)

EDIT : Ca a l'air de marcher une fois. Mais si j'essaye de le faire dans une boucle de type for de i à nb ça fait de nouveau n'importe quoi..
RE-EDIT : Ca marche jusqu'à ce que les mots fassent 4 lettres, et après pof, seul le premier mot grandit. J'ai vraiment du mal à saisir mon erreur :/
RE-RE-EDIT : Apparemment le problème vient quand même du newtab[i][nb]='\0'; !

RE..(dernier normalement)-EDIT : Je crois que c'est reglé, j'ai remplacé newtab[i][nb]='\0' par newtab[i][strlen(newtab[i])+1] = '\0' et ça m'a l'air bon pour l'instant.
Encore merci !