Concatenation

Fermé
boss - 9 janv. 2010 à 10:29
 boss - 10 janv. 2010 à 15:35
Bonjour,
J'essaye de concatener 2 chaine de caractères dans un tableau malloc mais j'ai un problème voici tout d'abord le code:
#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(i = 0; a != '\0'; i++)
        p[i] = a[i];

    for(x = 0; b != '\0'; x++, i++)
    {
        p[i] = b[x];
    }

    p = '\0';
    /*____________________________________*/

    /* AFFICHAGE */
    /*___________*/
    printf("%s", p);
    /*___________*/
    return 0;
}

/* Calcul la taille des chaine */
int nbreCaractere(const char *chaine1)
{
    int cpt = 0;
    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;

}

Dans le code il me dise que je n'ai pas assez de mémoire donc c'est que lors de la l'allocation la compilation rencontre un problème mais je ne trouve pas l'erreur dans le code

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
Salut,
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;

}

@+
0
bon ben quand je copie ton code voila ce que sa me donne:
SALUTAnthonyrs\A&#9650;.­ÇÄü
Process returned 0 (0x0)   execution time : 0.025 s
Press any key to continue.


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 ?
0
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
while(cpt != '\0')??
plutot while(chaine1[nbreCaractere] != '\0') alors...non??

0
oui mais les 2 marche non ?
While(cpt != '\0')
 while(chaine1[nbreCaractere] != '\0')
0
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
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;

}
0
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 :
/* 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
0
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
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++)
0
dans cette fonction
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 ?
0

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
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....
0
oui mais quoi sa sert de retourner l'adresse de départ - l'adresse de fin ?
t'aurais pu renvoyer directement chaine1 puisque qu'elle vaut le nombre de caractere
0
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
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???
0
ah ok je viens de comprendre bon ben alors j'ai essayer de corriger mon code le voici:
#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
0
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
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;

}
0
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
0
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
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.
0
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
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) ^^
0
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
* p = '\0'; /* Rajout du caractere null */
/*____________________________________*/


/* AFFICHAGE */
/*___________*/
printf("%s", p-resultat);
/*___________*/
return 0;
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
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 ??
0
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
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.....
0
oula mdr toi tu me dit que c'est faux ce code alors que d'autre me dise que ce bout de code est plus pratique que de mettre directement le type dans sizeof j'ai pas encore assez le niveau en programmation pour dire ce qui est faux ou vrai je lit seulement le livre ^^
0
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
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!!!
0
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
ah ben oui c'est vraie j'avais jamais fait attention
0
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
Je dis pas que des bêtises quand même!!;)))))
0
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
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!!
0
ah bon on peut soustraire un pointeur a une variable ??
0
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
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)...
0
bon voici le code :
#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.
0
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
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--;
0
pourquoi je doit le retirer ?
0
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
Salut,
parce que tu va renvoyer nbreCaractere-1....
0
ben oui j'enleve le caractere null
0
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
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!!!!!
0
ah ok bon ben merci de ton aide
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
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 :
/*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,
0
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.
0
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
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!!
@+
0
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
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....
0
oui chez moi aussi mais je comprends pas sa veut dire que quand je compte les caractère d'un chaîne il comte pas le '\0' ??
0
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
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....
0
ah oui c'est vrai moi je commencais de nbreCaractere = 1 ^^
et fflush(stdout); sa sert a vider le buffer ??
0
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
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!!)
@+
0
j'ai pris un code dans le site du zero le voici
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
0
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
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!!!!
0
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
0
Bon alors je post ici car je ne trouve pas ou ta poster ton message fiddy bon bref
alors cette boucle je ne la comprend pas :
while((*(p++)=*(a++)));p--;

    while((*(p++)=*(b++)));p--;

si tu pourrais me l'expliquer j'ai déjà appris *(p++) mais la boucle par contre je ne comprends pas
0
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
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.
0
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
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
0
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
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 :
int i=0;
while(a[i]!='\0') {
  p[i]=a[i];
  i++;
}


Cdlt,
0
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
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!!
0