Concatenation

bon ben quand je copie ton code voila ce que sa me donne:

SALUTAnthonyrs\A▲.­ÇÄü
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 ?

oui mais les 2 marche non ?

While(cpt != '\0')
 while(chaine1[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

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 ?

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

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

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

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 ??

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 ^^

ah bon on peut soustraire un pointeur a une variable ??

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.

pourquoi je doit le retirer ?

ben oui j'enleve le caractere null

ah ok bon ben merci de ton aide

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.

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!!
@+

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' ??

ah oui c'est vrai moi je commencais de nbreCaractere = 1 ^^
et fflush(stdout); sa sert a vider le buffer ??

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

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