21 réponses
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 10:48
9 janv. 2010 à 10:48
Salut,
peut-etre un trunc du style pourrait faire l'affaire....
@+
peut-etre un trunc du style pourrait faire l'affaire....
#include <stdio.h> #include <stdlib.h> int nbreCaractere(char *chaine1); int main() { /* chaine */ char *a = "SALUT"; char *b = "Anthony"; char *p = NULL; int nbre_a, nbre_b, resultat = 0, i, x; /* APPEL DE LA FONCTION */ nbre_a = nbreCaractere(a); nbre_b = nbreCaractere(b); resultat = nbre_a + nbre_b; /* ALLOCATION */ /*____________*/ p = malloc(sizeof(char) * resultat); if(p == NULL) { puts("Vous avez pas assez de memoire"); exit(0); } /*____________*/ /* METTRE LES 2 CHAINE DANS LE MALLOC */ /*____________________________________*/ for(; *a != '\0';a++,p++) *p = *a; for(; *b != '\0'; p++, b++) *p = *b; /*____________________________________*/ /* AFFICHAGE */ /*___________*/ printf("%s", p-resultat); /*___________*/ return 0; } /* Calcul la taille des chaine */ int nbreCaractere(char *chaine1) { char* nbreCaractere = chaine1; /*_______________*/ /*On compte les caractères */ while(*chaine1 != '\0') chaine1++; return chaine1-nbreCaractere; }
@+
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 10:56
9 janv. 2010 à 10:56
while(cpt != '\0')??
plutot while(chaine1[nbreCaractere] != '\0') alors...non??
plutot while(chaine1[nbreCaractere] != '\0') alors...non??
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 11:06
9 janv. 2010 à 11:06
comme cela oui:
int nbreCaractere(char *chaine1)
{
/* Calcul la taille des chaine */
char cpt = ' ';//avant int cpt = 0;
int nbreCaractere = 0;//avant char nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while(cpt != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
/*_______________*/
nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
int nbreCaractere(char *chaine1)
{
/* Calcul la taille des chaine */
char cpt = ' ';//avant int cpt = 0;
int nbreCaractere = 0;//avant char nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while(cpt != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
/*_______________*/
nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
ah ben oui c'est vrai j'avais pas vue ^^ et il y une autre boucle aussi que j'arrive pas a faire la difference entre la mienne et la tienne :
içi je stocke dans p[i] le tableau a puis je fais une deuxième boucle ou je stocke dans la suite de p[i] le tableau b
alors quetoi dans ta boucle :
tu stocke le tableau a dans p et tu stocke le tableau b a la suite de p mais a la différence de moi c'est que tu increment les tableau dans la boucle alors que moi j'incrémente directement avec p[i] donc je ne vois pas ou ce qu'il y comme erreur dans ma boucle
/* METTRE LES 2 CHAINE DANS LE MALLOC */ /*____________________________________*/ for(i = 0; a != '\0'; i++) p[i] = a[i]; for(x = 0; b != '\0'; x++, i++) { p[i] = b[x]; } p = '\0'; /* Rajout du caractere null */ /*____________________________________*/
içi je stocke dans p[i] le tableau a puis je fais une deuxième boucle ou je stocke dans la suite de p[i] le tableau b
alors quetoi dans ta boucle :
/* METTRE LES 2 CHAINE DANS LE MALLOC */ /*____________________________________*/ for(; *a != '\0';a++,p++) *p = *a; for(; *b != '\0'; p++, b++) *p = *b; /*____________________________________*/
tu stocke le tableau a dans p et tu stocke le tableau b a la suite de p mais a la différence de moi c'est que tu increment les tableau dans la boucle alors que moi j'incrémente directement avec p[i] donc je ne vois pas ou ce qu'il y comme erreur dans ma boucle
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 11:18
9 janv. 2010 à 11:18
for(i = 0; a != '\0'; i++)
ta variable a etant un pointeur, la valeur ne sera jamais egal à '\0'..mais une valeur du style 0x18CE (en hexa..)
Ce que tu veux c'est la comparaison de la valeur à cette adresse
donc modifie comme suit:
for(i = 0; a[i] != '\0'; i++)
ta variable a etant un pointeur, la valeur ne sera jamais egal à '\0'..mais une valeur du style 0x18CE (en hexa..)
Ce que tu veux c'est la comparaison de la valeur à cette adresse
donc modifie comme suit:
for(i = 0; a[i] != '\0'; i++)
dans cette fonction
il y a un truc que je ne comprends, pas pourquoi incrémenter chaine1 alors que normalement c'est nbrecaratere
et sa
int nbreCaractere(char *chaine1) { char* nbreCaractere = chaine1; /*_______________*/ /*On compte les caractères */ while(*chaine1 != '\0') chaine1++; return chaine1-nbreCaractere; }
il y a un truc que je ne comprends, pas pourquoi incrémenter chaine1 alors que normalement c'est nbrecaratere
et sa
return chaine1-nbreCaractere;je ne comprends pas a quoi sa sert ?
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 11:42
9 janv. 2010 à 11:42
En fait;
char* nbreCaractere = chaine1;//nbreCaractere=adresse de depart de ta chaine (par exemple 0X1235)
while(*chaine1 != '\0')
chaine1++; //tant que la valeur du pointeur est different de '\0', tu incrementes ton pointeur-> le pointeur //etant de type char, tu te deplace en memoire d'un octet, donc tu incremente l'adresse de 1!!
donc chaine=0x1236,puis 0x1237,puis etc.....
return chaine1-nbreCaractere;//adresse de fin-adresse de debut=nbr de caractere....
char* nbreCaractere = chaine1;//nbreCaractere=adresse de depart de ta chaine (par exemple 0X1235)
while(*chaine1 != '\0')
chaine1++; //tant que la valeur du pointeur est different de '\0', tu incrementes ton pointeur-> le pointeur //etant de type char, tu te deplace en memoire d'un octet, donc tu incremente l'adresse de 1!!
donc chaine=0x1236,puis 0x1237,puis etc.....
return chaine1-nbreCaractere;//adresse de fin-adresse de debut=nbr de caractere....
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 12:09
9 janv. 2010 à 12:09
Ben tu l'a plus l'adresse de depart.....
chaine1++ à deplacé le pointeur...comment tu sais à quelle adresse il débutait après la boucle???
chaine1++ à deplacé le pointeur...comment tu sais à quelle adresse il débutait après la boucle???
ah ok je viens de comprendre bon ben alors j'ai essayer de corriger mon code le voici:
mais il plante la alors que quand j'essaye le tien il marche je comprends pas ou est l'erreur
#include <stdio.h> #include <stdlib.h> int nbreCaractere(const char *chaine1); int main() { /* chaine */ char *a = "SALUT"; char *b = "Anthony"; char *p = NULL; int nbre_a, nbre_b, resultat = 0, i, x; /* APPEL DE LA FONCTION */ nbre_a = nbreCaractere(a); nbre_b = nbreCaractere(b); resultat = nbre_a + nbre_b; /* ALLOCATION */ /*____________*/ p = malloc(sizeof(p) * resultat); if(p == NULL) { puts("Vous avez pas assez de memoire"); exit(0); } /*____________*/ /* METTRE LES 2 CHAINE DANS LE MALLOC */ /*____________________________________*/ for(; *a != '\0'; a++, p++) *p = *a; for(; *b != '\0'; p++, b++) *p = *b; p = '\0'; /* Rajout du caractere null */ /*____________________________________*/ /* AFFICHAGE */ /*___________*/ printf("%s", p); /*___________*/ return 0; } /* Calcul la taille des chaine */ int nbreCaractere(const char *chaine1) { char cpt = 0; int nbreCaractere = 0; /*_______________*/ /*On compte les caractères */ while(*chaine1 != '\0') { cpt = chaine1[nbreCaractere]; nbreCaractere++; } /*_______________*/ nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */ return nbreCaractere; }
mais il plante la alors que quand j'essaye le tien il marche je comprends pas ou est l'erreur
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 12:22
9 janv. 2010 à 12:22
Alors:
p = malloc(sizeof(p) * resultat);??? essaye plutot p = malloc(sizeof(char) * resultat);
et
int nbreCaractere(const char *chaine1)
{
int nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while( chaine1[nbreCaractere]!= '\0')
{
nbreCaractere++;
}
/*_______________*/
nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
p = malloc(sizeof(p) * resultat);??? essaye plutot p = malloc(sizeof(char) * resultat);
et
int nbreCaractere(const char *chaine1)
{
int nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while( chaine1[nbreCaractere]!= '\0')
{
nbreCaractere++;
}
/*_______________*/
nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
p = malloc(sizeof(p) * resultat);??? essaye plutot p = malloc(sizeof(char) * resultat);
ici j'ai lu dans un livre que p = malloc(sizeof(p) * resultat); est plus pratique car si on change de type on aurat pas a la changer dans la malloc puisque le pointeur point sur le type de variable
donc voila j'ai tout corrigé la normalement:
#include <stdio.h> #include <stdlib.h> int nbreCaractere(const char *chaine1); int main() { /* chaine */ char *a = "SALUT"; char *b = "Anthony"; char *p = NULL; int nbre_a, nbre_b, resultat = 0, i, x; /* APPEL DE LA FONCTION */ nbre_a = nbreCaractere(a); nbre_b = nbreCaractere(b); resultat = nbre_a + nbre_b; /* ALLOCATION */ /*____________*/ p = malloc(sizeof(p) * resultat); if(p == NULL) { puts("Vous avez pas assez de memoire"); exit(0); } /*____________*/ /* METTRE LES 2 CHAINE DANS LE MALLOC */ /*____________________________________*/ for(; *a != '\0'; a++, p++) *p = *a; for(; *b != '\0'; p++, b++) *p = *b; p = '\0'; /* Rajout du caractere null */ /*____________________________________*/ /* AFFICHAGE */ /*___________*/ printf("%s", p); /*___________*/ return 0; } /* Calcul la taille des chaine */ int nbreCaractere(const char *chaine1) { char cpt = 0; int nbreCaractere = 0; /*_______________*/ /*On compte les caractères */ while(chaine1[nbreCaractere] != '\0') { cpt = chaine1[nbreCaractere]; nbreCaractere++; } /*_______________*/ nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */ return nbreCaractere; }
et maintenant il mette (NULL) quand je test le code
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 844
>
boss
10 janv. 2010 à 12:24
10 janv. 2010 à 12:24
Salut,
ici j'ai lu dans un livre que p = malloc(sizeof(p) * resultat)
Eh bien tu as mal lu. Il s'agit de sizeof(*p) et non de sizeof(p).
sizeof(p) vaut sizeof(char*) et sizeof(*p vaut sizeof(char) soit 1.
De plus, il ne faut pas oublier de rajouter +1 pour laisser de la place pour le \0.
Tout ça, je te l'ai dit dans mon post. Mais faut prendre la peine de le lire.
ici j'ai lu dans un livre que p = malloc(sizeof(p) * resultat)
Eh bien tu as mal lu. Il s'agit de sizeof(*p) et non de sizeof(p).
sizeof(p) vaut sizeof(char*) et sizeof(*p vaut sizeof(char) soit 1.
De plus, il ne faut pas oublier de rajouter +1 pour laisser de la place pour le \0.
Tout ça, je te l'ai dit dans mon post. Mais faut prendre la peine de le lire.
boss
>
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
10 janv. 2010 à 12:32
10 janv. 2010 à 12:32
oh mais je l'ai lu sauf je pense que tu t'est trompé car cette discution a la qu'elle ta répondu date d'hier
boss, le 9 jan 2010 à 12:28:15 donc je pouvais pas savoir que j'avais mal lu jusqu' a ce que tu me dise qu'il fallait mettre sizeof(*p) et pas sizeof(p) ^^
boss, le 9 jan 2010 à 12:28:15 donc je pouvais pas savoir que j'avais mal lu jusqu' a ce que tu me dise qu'il fallait mettre sizeof(*p) et pas sizeof(p) ^^
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 12:34
9 janv. 2010 à 12:34
* p = '\0'; /* Rajout du caractere null */
/*____________________________________*/
/* AFFICHAGE */
/*___________*/
printf("%s", p-resultat);
/*___________*/
return 0;
/*____________________________________*/
/* AFFICHAGE */
/*___________*/
printf("%s", p-resultat);
/*___________*/
return 0;
eu ben la je ne comprends plus rien je croyais que on mettait le signe * pour le pointeur que dans la déclaration ici pourquoi on doit mettre *p = '\0'; alors que on l'a déclaré avant
alors ce bout de code
je ne comprend pas on indique bien la fin de la chaine on mettant la valeur null donc pourquoi mettre p-resultat ??
alors ce bout de code
printf("%s", p-resultat);
je ne comprend pas on indique bien la fin de la chaine on mettant la valeur null donc pourquoi mettre p-resultat ??
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 12:38
9 janv. 2010 à 12:38
Néanmois, je pense que cela est faux:
p = malloc(sizeof(p) * resultat);
car p etant un char*, sizeof(char*)=4 (car un pointeur en 32 bits est sur 4 octets...) alors que tu veux la taille en pour des char.....
p = malloc(sizeof(p) * resultat);
car p etant un char*, sizeof(char*)=4 (car un pointeur en 32 bits est sur 4 octets...) alors que tu veux la taille en pour des char.....
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
>
boss
9 janv. 2010 à 12:52
9 janv. 2010 à 12:52
ben fais juste cela:
printf("%d",sizeof(p)); //affiche 4
printf("%d",sizeof(char));//affiche 1
je n'ai pas dis que ce code est faux mais si tu veux créer un emplacement memoire egale au nombre de caracteres souhaités, utilise la deuxieme declaration!!!
printf("%d",sizeof(p)); //affiche 4
printf("%d",sizeof(char));//affiche 1
je n'ai pas dis que ce code est faux mais si tu veux créer un emplacement memoire egale au nombre de caracteres souhaités, utilise la deuxieme declaration!!!
boss
>
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
9 janv. 2010 à 12:59
9 janv. 2010 à 12:59
ah ben oui c'est vraie j'avais jamais fait attention
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
>
boss
9 janv. 2010 à 13:03
9 janv. 2010 à 13:03
Je dis pas que des bêtises quand même!!;)))))
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 12:50
9 janv. 2010 à 12:50
Si tu as la declaration
char*p="Bonjour";
tu utilises p pour modifier l'adresse en memoire, et *p pour modifier la valeur à l'adresse memoire d'ou est p!!
char*p="Bonjour";->lors de l'initialisation, p va avoir une adresse en memoire (0x1231 par exemple)
La valeur à cette adresse (*p) va etre 'B'.Si tu deplace ton pointeur à l'adresse +1 (0x1232) la valeur de *p='o'.
Donc tu utilise la notation p ou *p suivant ce que tu veux faire...modifier l'adresse (faire avancer ou reculer le pointeur par exemple p++) ou modifier la valeur à 'adresse pointée par p (*p='\0')
printf("%s", p-resultat);//car tu as bougé l'adresse du pointeur dans les boucles for(;;) precedente!!donc pour revenir à l'adresse initial tu dois faire reculer le pointeur à son adresse initiale!!
char*p="Bonjour";
tu utilises p pour modifier l'adresse en memoire, et *p pour modifier la valeur à l'adresse memoire d'ou est p!!
char*p="Bonjour";->lors de l'initialisation, p va avoir une adresse en memoire (0x1231 par exemple)
La valeur à cette adresse (*p) va etre 'B'.Si tu deplace ton pointeur à l'adresse +1 (0x1232) la valeur de *p='o'.
Donc tu utilise la notation p ou *p suivant ce que tu veux faire...modifier l'adresse (faire avancer ou reculer le pointeur par exemple p++) ou modifier la valeur à 'adresse pointée par p (*p='\0')
printf("%s", p-resultat);//car tu as bougé l'adresse du pointeur dans les boucles for(;;) precedente!!donc pour revenir à l'adresse initial tu dois faire reculer le pointeur à son adresse initiale!!
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 13:18
9 janv. 2010 à 13:18
Tu peux soutraire un pointeur!!
et le contraire et vrai mais le resultat ne sera certainement pas celui voulu!!!
Ici:
printf("%s", p-resultat)//tu soustrait à l'adresse du pointeur p (par exemple (0x1230)-resultat (qui vaut 10 par exemple) et donc le pointeur sera à l'adresse (0x1220)...
et le contraire et vrai mais le resultat ne sera certainement pas celui voulu!!!
Ici:
printf("%s", p-resultat)//tu soustrait à l'adresse du pointeur p (par exemple (0x1230)-resultat (qui vaut 10 par exemple) et donc le pointeur sera à l'adresse (0x1220)...
bon voici le code :
voila ce que ca m'affiche :
#include <stdio.h> #include <stdlib.h> int nbreCaractere(const char *chaine1); int main() { /* chaine */ char *a = "SALUT"; char *b = "Anthony"; char *p = NULL; int nbre_a, nbre_b, resultat = 0, i, x; /* APPEL DE LA FONCTION */ nbre_a = nbreCaractere(a); nbre_b = nbreCaractere(b); resultat = nbre_a + nbre_b; /* ALLOCATION */ /*____________*/ p = malloc(sizeof(p) * resultat); if(p == NULL) { puts("Vous avez pas assez de memoire"); exit(0); } /*____________*/ /* METTRE LES 2 CHAINE DANS LE MALLOC */ /*____________________________________*/ for(; *a != '\0'; a++, p++) *p = *a; for(; *b != '\0'; p++, b++) *p = *b; *p = '\0'; /* Rajout du caractere null */ /*____________________________________*/ /* AFFICHAGE */ /*___________*/ printf("%s", p-resultat); /*___________*/ return 0; } /* Calcul la taille des chaine */ int nbreCaractere(const char *chaine1) { char cpt = 0; int nbreCaractere = 0; /*_______________*/ /*On compte les caractères */ while(chaine1[nbreCaractere] != '\0') { cpt = chaine1[nbreCaractere]; nbreCaractere++; } /*_______________*/ nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */ return nbreCaractere; }
voila ce que ca m'affiche :
LUTAnthony Process returned 0 (0x0) execution time : 0.010 s Press any key to continue.
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 13:22
9 janv. 2010 à 13:22
int nbreCaractere(const char *chaine1)
{
char cpt = 0;
int nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while(chaine1[nbreCaractere] != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
/*_______________*/
// nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
retire nbreCaractere--;
{
char cpt = 0;
int nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while(chaine1[nbreCaractere] != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
/*_______________*/
// nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
retire nbreCaractere--;
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 13:32
9 janv. 2010 à 13:32
Salut,
parce que tu va renvoyer nbreCaractere-1....
parce que tu va renvoyer nbreCaractere-1....
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
9 janv. 2010 à 14:08
9 janv. 2010 à 14:08
Le compteur commence à 0!!
Quand tu va arriver à ta condition (pour "SALUT")Tu aura lu en effet 6 caracteres mais nbreCaractere=5!!! (car il commence à 0!!!!!
Quand tu va arriver à ta condition (pour "SALUT")Tu aura lu en effet 6 caracteres mais nbreCaractere=5!!! (car il commence à 0!!!!!
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 844
9 janv. 2010 à 15:14
9 janv. 2010 à 15:14
Salut,
Je vois plusieurs problèmes.
nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
Surtout pas. Le -1 ne sera pas pris lorsque la condition du while sera vérifiée. Donc en effectuant cette opération, tu enlèves un caractère de trop.
p = malloc(sizeof(p) * resultat);
Il ne faut pas oublier de stocker le '\0'. Et ce n'est pas sizeof(p) mais sizeof(*p). Tu peux aussi complètement omettre le sizeof puisque le char vaut toujours un byte.
Il faudrait donc mettre : p=malloc(resultat+1) ou p=malloc(sizeof(*p) *(resultat +1));
printf("%s", p-resultat);
Il ne faut pas oublier de mettre fflush(stdout) après ton printf puisque tu n'as pas vidé le buffer stdout implicitement.
N'oublie pas de libérer les ressources allouées avec free(p);
Sinon quelques conseils sur le code :
Dans ta fonction nbreCaractere, ton char cpt est inutile. Tu peux donc enlever les deux lignes qui y font appel.
Ceci suffit :
Si tu connais les notations du style *(p++), tu peux même faire des trucs encore plus concis.
printf("%s", p-resultat);
Oui, mais pourquoi pas mettre p-=resultat ? Cela repositionnerait le pointeur au début de la chaîne.
Dans ce cas, tu pourras l'afficher simplement : printf("%s",p);
S'agit-il d'un entraînement ? Sinon, je te mentionne l'existence des fonctions standards strcat et strlen. La fonction strcat réalise la concaténation et strlen renvoie la longueur. Leurs prototypes se trouvent dans string.h
Cdlt,
Je vois plusieurs problèmes.
nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
Surtout pas. Le -1 ne sera pas pris lorsque la condition du while sera vérifiée. Donc en effectuant cette opération, tu enlèves un caractère de trop.
p = malloc(sizeof(p) * resultat);
Il ne faut pas oublier de stocker le '\0'. Et ce n'est pas sizeof(p) mais sizeof(*p). Tu peux aussi complètement omettre le sizeof puisque le char vaut toujours un byte.
Il faudrait donc mettre : p=malloc(resultat+1) ou p=malloc(sizeof(*p) *(resultat +1));
printf("%s", p-resultat);
Il ne faut pas oublier de mettre fflush(stdout) après ton printf puisque tu n'as pas vidé le buffer stdout implicitement.
N'oublie pas de libérer les ressources allouées avec free(p);
Sinon quelques conseils sur le code :
Dans ta fonction nbreCaractere, ton char cpt est inutile. Tu peux donc enlever les deux lignes qui y font appel.
Ceci suffit :
/*On compte les caractères */ while(chaine1[nbreCaractere] != '\0') { nbreCaractere++; }
Si tu connais les notations du style *(p++), tu peux même faire des trucs encore plus concis.
printf("%s", p-resultat);
Oui, mais pourquoi pas mettre p-=resultat ? Cela repositionnerait le pointeur au début de la chaîne.
Dans ce cas, tu pourras l'afficher simplement : printf("%s",p);
S'agit-il d'un entraînement ? Sinon, je te mentionne l'existence des fonctions standards strcat et strlen. La fonction strcat réalise la concaténation et strlen renvoie la longueur. Leurs prototypes se trouvent dans string.h
Cdlt,
oui il s'agit bien d'un entraînement
Surtout pas. Le -1 ne sera pas pris lorsque la condition du while sera vérifiée. Donc en effectuant cette opération, tu enlèves un caractère de trop.
Mais moi en faite ce que je voulais faire c'est ca :
il y a une chaine "SALUT'\0' " et une 2eme chaine "ANTHONY'\0' "
donc je compte les caractère qu'il y a en enlevant les '\0' donc ca 14 -2 = 12 (le - 2 car il y a 2 valeur null dans les chaines) puis après j'alloue un bloc de mémoire puis je stocke les chaines dedans et comme j'ai enlever les valeur null sa donne cela "SALUTANTHONY" et il me reste juste à mettre un valeur nul en fin de chaine
alors que quand tu me dit qu'il ne faut pas retirer -1 moi je vois les choses comme ca après "SALUT'\0' "
"ANTHONY'\0' " donc comme j'ai pas retirer les valeur sa donne et que je vais les mettre dans le bloc de mémoire allouer sa va donner "SALUT'\0'ANTHONY'\0' '\0' " et dedans il y aurais 3 valeur null alors une de la 1er chaine, la 2eme est de la fin de la 2eme chaine, et la 3 eme celle quand rajoute pour mettre fin a la chaîne.
Surtout pas. Le -1 ne sera pas pris lorsque la condition du while sera vérifiée. Donc en effectuant cette opération, tu enlèves un caractère de trop.
Mais moi en faite ce que je voulais faire c'est ca :
il y a une chaine "SALUT'\0' " et une 2eme chaine "ANTHONY'\0' "
donc je compte les caractère qu'il y a en enlevant les '\0' donc ca 14 -2 = 12 (le - 2 car il y a 2 valeur null dans les chaines) puis après j'alloue un bloc de mémoire puis je stocke les chaines dedans et comme j'ai enlever les valeur null sa donne cela "SALUTANTHONY" et il me reste juste à mettre un valeur nul en fin de chaine
alors que quand tu me dit qu'il ne faut pas retirer -1 moi je vois les choses comme ca après "SALUT'\0' "
"ANTHONY'\0' " donc comme j'ai pas retirer les valeur sa donne et que je vais les mettre dans le bloc de mémoire allouer sa va donner "SALUT'\0'ANTHONY'\0' '\0' " et dedans il y aurais 3 valeur null alors une de la 1er chaine, la 2eme est de la fin de la 2eme chaine, et la 3 eme celle quand rajoute pour mettre fin a la chaîne.
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
10 janv. 2010 à 12:32
10 janv. 2010 à 12:32
Salut Fiddy!!
pour le fflush(stdout), c'est une pratique de bonne programmation??
L'OS ne gere pas cela à la fin du programme?(liberation des ressources allouées)
Si t'as un peu plus de detail je suis preneur!!
@+
pour le fflush(stdout), c'est une pratique de bonne programmation??
L'OS ne gere pas cela à la fin du programme?(liberation des ressources allouées)
Si t'as un peu plus de detail je suis preneur!!
@+
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
10 janv. 2010 à 11:31
10 janv. 2010 à 11:31
Salut,
Combien te retourne resultat?? 12 non...
avec cette fonction (c'est le resultat que j'ai chez moi...):
Int nbreCaractere(const char *chaine1)
{
char cpt = 0;
int nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while(chaine1[nbreCaractere] != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
/*_______________*/
// nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
Je vois pas où est le problème....
Combien te retourne resultat?? 12 non...
avec cette fonction (c'est le resultat que j'ai chez moi...):
Int nbreCaractere(const char *chaine1)
{
char cpt = 0;
int nbreCaractere = 0;
/*_______________*/
/*On compte les caractères */
while(chaine1[nbreCaractere] != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
/*_______________*/
// nbreCaractere--; /* onretire -1 pour la valeur nul '\0' */
return nbreCaractere;
}
Je vois pas où est le problème....
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
10 janv. 2010 à 11:51
10 janv. 2010 à 11:51
Exemple avec "SALUT"
nbreCaractere=0;
while(chaine1[nbreCaractere] != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
chaine1[nbreCaractere] ='S' ->nbreCaractere=0;nbreCaractere++=>nbreCaractere=1
chaine1[nbreCaractere] ='A' ->nbreCaractere=1;nbreCaractere++=>nbreCaractere=2
chaine1[nbreCaractere] ='L' ->nbreCaractere=2;nbreCaractere++=>nbreCaractere=3
chaine1[nbreCaractere] ='U' ->nbreCaractere=3;nbreCaractere++=>nbreCaractere=4
chaine1[nbreCaractere] ='T' ->nbreCaractere=4;nbreCaractere++=>nbreCaractere=5
chaine1[nbreCaractere] ='\0' ->nbreCaractere=5; //Fin de la boucle while
Donc en sortie si tu fais nbreCaractere-- le resultat sera 4 et non 5...
Car nbreCaractere=0 en debut de fonction....
nbreCaractere=0;
while(chaine1[nbreCaractere] != '\0')
{
cpt = chaine1[nbreCaractere];
nbreCaractere++;
}
chaine1[nbreCaractere] ='S' ->nbreCaractere=0;nbreCaractere++=>nbreCaractere=1
chaine1[nbreCaractere] ='A' ->nbreCaractere=1;nbreCaractere++=>nbreCaractere=2
chaine1[nbreCaractere] ='L' ->nbreCaractere=2;nbreCaractere++=>nbreCaractere=3
chaine1[nbreCaractere] ='U' ->nbreCaractere=3;nbreCaractere++=>nbreCaractere=4
chaine1[nbreCaractere] ='T' ->nbreCaractere=4;nbreCaractere++=>nbreCaractere=5
chaine1[nbreCaractere] ='\0' ->nbreCaractere=5; //Fin de la boucle while
Donc en sortie si tu fais nbreCaractere-- le resultat sera 4 et non 5...
Car nbreCaractere=0 en debut de fonction....
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
10 janv. 2010 à 11:59
10 janv. 2010 à 11:59
Je pense que fiddy sera plus à meme de te renseigner correctement que moi...j'utilise pas ce type de fonction...
Mais je pense que la sortie standard est un buffer où tu lui envoie tes données pour les afficher...
Apres question de sortir de ton programme proprement, vider le buffer ne fait pas de mal...
Mais à la fin du programme, je pense que l'OS (mais à verifier fortement!!!!!) libère ce type de ressource!!
Mais c'est une habitude de bonne programmation à prendre (ainsi que le free!!)
@+
Mais je pense que la sortie standard est un buffer où tu lui envoie tes données pour les afficher...
Apres question de sortir de ton programme proprement, vider le buffer ne fait pas de mal...
Mais à la fin du programme, je pense que l'OS (mais à verifier fortement!!!!!) libère ce type de ressource!!
Mais c'est une habitude de bonne programmation à prendre (ainsi que le free!!)
@+
j'ai pris un code dans le site du zero le voici
lui il retire bien - 1pour la valeur null
int longueurChaine(const char* chaine) { int nombreDeCaracteres = 0; char caractereActuel = 0; do { caractereActuel = chaine[nombreDeCaracteres]; nombreDeCaracteres++; } while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0 nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter l'\0 return nombreDeCaracteres; }
lui il retire bien - 1pour la valeur null
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
10 janv. 2010 à 12:08
10 janv. 2010 à 12:08
Car c'est un
do{} while.....
chaine1[nbreCaractere] ='S' ->nbreCaractere=0;nbreCaractere++=>nbreCaractere=1
chaine1[nbreCaractere] ='A' ->nbreCaractere=1;nbreCaractere++=>nbreCaractere=2
chaine1[nbreCaractere] ='L' ->nbreCaractere=2;nbreCaractere++=>nbreCaractere=3
chaine1[nbreCaractere] ='U' ->nbreCaractere=3;nbreCaractere++=>nbreCaractere=4
chaine1[nbreCaractere] ='T' ->nbreCaractere=4;nbreCaractere++=>nbreCaractere=5
chaine1[nbreCaractere] ='\0' ->nbreCaractere=5;nbreCaractere++=>nbreCaractere=6 //Fin de la boucle while
Donc en effet tu dois retirer 1!!!!
do{} while.....
chaine1[nbreCaractere] ='S' ->nbreCaractere=0;nbreCaractere++=>nbreCaractere=1
chaine1[nbreCaractere] ='A' ->nbreCaractere=1;nbreCaractere++=>nbreCaractere=2
chaine1[nbreCaractere] ='L' ->nbreCaractere=2;nbreCaractere++=>nbreCaractere=3
chaine1[nbreCaractere] ='U' ->nbreCaractere=3;nbreCaractere++=>nbreCaractere=4
chaine1[nbreCaractere] ='T' ->nbreCaractere=4;nbreCaractere++=>nbreCaractere=5
chaine1[nbreCaractere] ='\0' ->nbreCaractere=5;nbreCaractere++=>nbreCaractere=6 //Fin de la boucle while
Donc en effet tu dois retirer 1!!!!
chaine1[nbreCaractere] ='\0' ->nbreCaractere=5;nbreCaractere++=>nbreCaractere=6 //Fin de la boucle while
pourquoi continuer a nbreCaractere = 6 ??
la seule truc que je connais sur do{...}while; c'est que elle s'exécute au moin une fois au début même si la condition est fausse mais la elle est pas fausse donc elle s'exécute comem si c'était while
pourquoi continuer a nbreCaractere = 6 ??
la seule truc que je connais sur do{...}while; c'est que elle s'exécute au moin une fois au début même si la condition est fausse mais la elle est pas fausse donc elle s'exécute comem si c'était while
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 844
>
boss
10 janv. 2010 à 13:39
10 janv. 2010 à 13:39
while((*(p++)=*(a++)));p--;
Tu connais *(p++). Ceci renvoie *p et incrémente p.
Donc ceci pourrait aussi s'écrire while((*p=*a)) { p++;a++; }
Cette boucle va donc copier *a dans *p tant que *a est vraie. Et comme seul le '\0' est faux, cela copiera tout jusqu'au dernier caractère.
J'ai mis p--; car lorsque *a retournera '\0', le pointeur p sera quand même incrémenté. Donc on retire la dernière incrémentation.
Mais tu peux faire avec une boucle for sinon.
Tu connais *(p++). Ceci renvoie *p et incrémente p.
Donc ceci pourrait aussi s'écrire while((*p=*a)) { p++;a++; }
Cette boucle va donc copier *a dans *p tant que *a est vraie. Et comme seul le '\0' est faux, cela copiera tout jusqu'au dernier caractère.
J'ai mis p--; car lorsque *a retournera '\0', le pointeur p sera quand même incrémenté. Donc on retire la dernière incrémentation.
Mais tu peux faire avec une boucle for sinon.
boss
>
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
10 janv. 2010 à 13:46
10 janv. 2010 à 13:46
j'ai compris jusqu' a là :
Cette boucle va donc copier *a dans *p (est vraie après le reste j'ai pas compris )
bon alors tant que *a est vrai mais pourquoi tant que *a est vrai ici je ne vois pas de condition dasn la boucle moi ce que je vois c'est que comme tu la dit la boucle va copier a dans puis retiré -1 a *p
Cette boucle va donc copier *a dans *p (est vraie après le reste j'ai pas compris )
bon alors tant que *a est vrai mais pourquoi tant que *a est vrai ici je ne vois pas de condition dasn la boucle moi ce que je vois c'est que comme tu la dit la boucle va copier a dans puis retiré -1 a *p
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 844
>
boss
10 janv. 2010 à 13:57
10 janv. 2010 à 13:57
mais pourquoi tant que *a est vrai
Lorsque tu écris a=b cela affecte b dans a ET renvoie la valeur b. C'est d'ailleurs pour ça que tu peux enchaîner les affectations comme a=b=c=d. Cela affecte d dans c puis renvoie c qui permet d'affecter b etc.
Ainsi lorsque tu fais *p=*a, cela copie *a dans *p et renvoie *a. Si *a est différence de '\0', la condition sera 1 (toujours vraie). Par contre si *a vaut '\0', le while deviendra while(0); et donc elle ne continuera pas plus loin car la condition est fausse.
Si tu as du mal avec la notation, n'hésite pas à utiliser plutôt :
Cdlt,
Lorsque tu écris a=b cela affecte b dans a ET renvoie la valeur b. C'est d'ailleurs pour ça que tu peux enchaîner les affectations comme a=b=c=d. Cela affecte d dans c puis renvoie c qui permet d'affecter b etc.
Ainsi lorsque tu fais *p=*a, cela copie *a dans *p et renvoie *a. Si *a est différence de '\0', la condition sera 1 (toujours vraie). Par contre si *a vaut '\0', le while deviendra while(0); et donc elle ne continuera pas plus loin car la condition est fausse.
Si tu as du mal avec la notation, n'hésite pas à utiliser plutôt :
int i=0; while(a[i]!='\0') { p[i]=a[i]; i++; }
Cdlt,
chuka
Messages postés
965
Date d'inscription
samedi 11 octobre 2008
Statut
Membre
Dernière intervention
29 juillet 2010
378
10 janv. 2010 à 12:15
10 janv. 2010 à 12:15
Parce que, comme tu l'a dis, la condition est testé apres!!! donc meme si Chaine1[nbreCaractere] ='\0' dans la boucle, les instructions qui suive s'exécute!!
9 janv. 2010 à 10:53
et je ne comprend ou est mon erreur dans la boucle ce qua ta changé revient au même a ce que j'ai fais ?