Discussion :

[gtapes]

Bonjour,
ce que je voudrais est découper une chaîne de caractère en fonction d'un nombre.
le nombre de caractère étant le maximum autoriser.
par exemple :
la chaîne :"salut je suis un chat blanc , qui mange des souris."
le nombre : 20.
une fois la découpe je dois avoir comme chaîne :
"salut je suis un cha" , "t blanc , qui mange " , "des souris."

j'utilise le code ci-dessous sauf que je n'est aucune valeur lorsque j'affiche la découpe.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
void decoupe(char * chaine, int nb)
{
	int nombreDeCaracteres = 0;
    char caractereActuel = 0;
	char * texte;
    do
    {
        caractereActuel = chaine[nombreDeCaracteres];
		if (nombreDeCaracteres%nb ==0){
		    printf("\n%s",texte);
			texte = "";
 
		} else {
		strcat(texte,chaine[nombreDeCaracteres]);
		}
 
        nombreDeCaracteres++;
    }
    while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0
	printf("\n%s",texte);
}

est-ce que vous savez pourquoi ?

[foetus]

Ton code devrait planter parce que tu passes à la fonction strcat une chaîne de caractères non allouée (et en plus de cela ton pointeur n'est pas initialisé).

Et au passage, texte = ""; c'est n'importe quoi. La variable texte est un pointeur. Tu ne fais pas du C++.

Et tu ne précises pas quel résultat veux-tu avoir ? parce que si on découpe une chaîne de caractères c'est pour en créer un certains nombres.

Et donc en C, il faut 1) compter le nombre de morceaux 2) pour chaque morceau, allocation puis copie.

[gtapes]

1)

tu passes à la fonction strcat une chaîne de caractères non allouée (et en plus de cela ton pointeur n'est pas initialisé).

je ne comprend pas ce que tu m'explique.

2)
j'ai remplacer le

Code :

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

 texte = "";

par

Code :

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

texte[0] = '\0';

3)
Ce que je voudrais est que si j'ai une chaîne de plus de 20 caractère de long, elle soit affiché en X chaîne de 20 caractère de long. (X étant le nombre de chaîne créer suivant la longueur de ma chaîne d’orgie).

[foetus]

je ne comprend pas ce que tu m'explique.

Est-ce que tu connais malloc ? (<- lien cplusplus en anglais)

elle soit affiché en X chaîne de 20 caractère de long

Laisse moi deviner, et au prochain T.P., 20 sera une variable

[gtapes]

Pour ce qui est du malloc() , dans la documentation de l'environnement ou l'application doit être il m'est déconseiller d'utiliser cette fonction.
Non le 20 ne changera jamais.
l'application doit être installer sur une douchette dont la taille de l'écran ne peut prendre que 20 caractère maximum ( avec la taille de font que j'utilise).

[Sve@r]

Bonjour

je ne comprend pas ce que tu m'explique.

La notion de "chaine" en tant qu'entité manipulable n'existe pas en C. Toutefois on en a besoin. Les développeurs ont alors établi la convention qu'une chaine serait représentée par un tableau de caractères dont l'un de ces caractères vaut impérativement '\0'.
Ainsi, en ayant le début du tableau et en sachant où s'arrêter (au '\0') on peut traiter (compter, copier, afficher, concaténer) le contenu du tableau comme si c'était une vraie chaine. Et si on ne peut pas distinguer à l'usage "ce qui ressemble à une chaine" d'une vraie chaine, alors c'est qu'on n'a pas besoin de les distinguer. Et donc ça se traduit par ce résumé qu'une chaine c'est un tableau contenant un '\0'.

Si de ton côté tu utilises une fonction strXXX() destinée à manipuler un tableau de caractères sensé être vu comme une chaine, tu dois t'assurer que ce que tu lui passes est bien une chaine donc contient bien un '\0'. Tu peux t'en assurer de 2 façons

1. si c'est toi qui crées le tableau => tu lui rajoutes impérativement un '\0' et tu veilles ensuite à ce qu'il ne soit jamais effacé
2. si tu remplis le tableau via une fonction de création/remplissage de chaine (strcpy(), strcat(), fgets()). Tu es alors assuré que ces fonctions mettront toujours un '\0' en fin de remplissage (à l'exception de strncpy() qui ne met pas de '\0' si elle a copié n caractères => mais si on le sait ce n'est pas grave => suffit de le rajouter manuellement).

Dans tous les cas, tu dois t'assurer que ton tableau aura assez d'espace de prévu pour stocker à la fois ta chaine (ce dont tu as besoin pour travailler) et à la fois le '\0'. Et ça, tu ne peux le faire là aussi que de 2 façons

1. tu connais d'avance la taille maximale que peut avoir ta chaine => tu définis un tableau de cette taille + 1
2. tu ne connais pas la taille mais tu peux la calculer "en direct" (et aussi avant d'avoir besoin de réellement stocker la chaine) grâce à un mécanisme quelconque => tu calcules donc cette taille nécessaire puis tu alloues de la mémoire pour pouvoir stocker et la chaine et le '\0' (d'où la remarque de foetus sur malloc)

Tu peux même avoir plusieurs '\0' dans le tableau ce n'est pas grave. Toute fonction de traitement s'arrétant au premier '\0', ce qu'il y a après ne sera pas considéré (c'est d'ailleurs une des méthodes les plus usuelles pour tronquer une chaine => on place simplement un '\0' à l'endroit voulu). L'important c'est qu'il y en ait toujours un avant de faire traiter ce tableau par une fonction de traitement de chaine.

Si en revanche tu passes à une fonction de traitement un tableau qui n'est pas garanti contenir de '\0', la fonction part du début du tableau et lit jusqu'à ce qu'elle trouve ce '\0' qui n'y est pas. Elle dépasse donc les limites du tableau et continue à balayer au delà jusqu'à ce qu'elle tombe enfin sur un octet valant '\0'. Fatalement il doit y en avoir dans la mémoire vu que tout octet possède une valeur comprise entre 0 et 255. Mais ayant dépassé la zone autorisée, ça produit un comportement indéterminé qui se traduit par un programme erratique (et foetus a (de façon tout à fait exceptionnellement rarissime) tort sur ce point car le comportement est vraiment indéterminé c.a.d. imprévisible => on ne peut même pas dire que ça plantera ou que ça devrait planter).

De ton côté tu définis un pointeur char *texte que tu fais pointer vers une zone statique de ton code contenant une chaine (ici ""). Tu en as tout à fait le droit. Mais comme la zone est statique, tu ne peux pas la modifier. Donc ni écrire par exemple texte[0]='x' ni même demander à strcat() de la modifier pour toi (parce que faut pas te leurrer, ce que fait strcat(dest, source) c'est simplement balayer le tableau "source" caractère par caractère et le copier dans le tableau "dest" ; donc à un moment donné elle écrit fatalement dest[i]=source[i]).

Ce que je voudrais est que si j'ai une chaîne de plus de 20 caractère de long, elle soit affiché en X chaîne de 20 caractère de long. (X étant le nombre de chaîne créer suivant la longueur de ma chaîne d’orgie).

Chaine d'orgie. Romaine l'orgie ???

Code c :

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

1
2
3
4
5
6
7
8
9
10
void affiche(char *s) {
	char tab[20 + 1];
	tab[20]='\0';		// Application bête et con du principe "1" => je sais que mon tableau aura 20 caractères "utiles" (indicés de 0 à 19), je sais donc que l'indice "20" ne sera jamais modifié
	unsigned short i;
	unsigned short len=strlen(s);
	for (i=0; i < len; i+=20) {
		strncpy(tab, s+i, 20);		// Je sais que si strncpy() n'a pas atteint les 20 caractères copiés (typiquement pour le dernier bout de "s"), elle mettra un '\0' en fin de copie (donc avant tab[20]) et que ce '\0' sera vu avant le mien.
		printf("%s\n", tab);
	}
}

[exe2bin]

Salut ,
nonobstant les remarques de Sve@r (qui est l'expert sur ce forum) je voudrais ajouter que :

Code :

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

1
2
3
4
5
6
 
...
else {
            strcat(texte,chaine[nombreDeCaracteres]);
        }
....

ne fonctionne tout simplement pas car la fonction strcat(char*,char*) attend que tu fournisse 2 pointeurs sur
des chaînes de caractère ; hors ,tu lui passe en deuxième argument un caractère
?! Bref ,si tu avais compilé ton code tu le saurais ...
mieux :

Code :

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

1
2
3
4
5
6
 
.....
else {
            strcat(texte,chaine+nombreDeCaracteres);
        }
.....

qui ne résout pas tout puisque on assiste alors à un plantage du programme
Un conseil : relis le post de Sve@r et tâches de bosser les fonctions de <string.h> !!

[Matt_Houston]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <assert.h>
#include <stdio.h>
 
 
void print_justified(const char *s, int len) {
    assert(s);
    assert(len > 0);
 
    while (printf("%.*s\n", len, s) == len + 1 /* strlen("\n") */)
        s += len;
}
 
 
#define LINE_LEN 20
 
int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; ++i)
        print_justified(argv[i], LINE_LEN);
    return 0;
}

Code :

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

1
2
3
4
5
$ ./a.out "salut je suis un chat blanc , qui mange des souris."
salut je suis un cha
t blanc , qui mange 
des souris.
$

[gtapes]

Mon problème a était corriger par le message de Sve@r.
voici le code Final pour ce que sa intéresse.

nbsaut sert a savoir combien de saut (retour a la ligne) l’application a effectuer afin de pouvoir afficher la saisie de l'utilisateur au bon endroit.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int decoupe(char * chaine, int nb)
{
 
	int nbsaut=0;
	char tab[nb + 1];
	tab[nb]='\0';		
	unsigned short i;
	unsigned short len=strlen(chaine);
	for (i=0; i < len; i+=nb) {
		strncpy(tab, chaine+i, nb);		
		printf("\n%s", tab);
		nbsaut++;
	}
	return nbsaut;
}

[foetus]

voici le code Final pour ce que sa intéresse.

Le seul hic, c'est qu'on ne peut pas créer de tableau statique avec un nombre variable

Édit : Après vérification, c99 au minimum (gcc XXX -std=c89 -pedantic -Wall ougcc XXX -std=c90 -pedantic -Wall)
De toute manière, il y a aussi l'initialisation de la variable nbsaut qui est trop tôt.