Bonjour,
Je voudrais avoir votre aide, sur un truc que j'arrive pas moi aussi à saisir, si çà existe déjà ou non.
 
* J'ai une fonction Copier qui retourn un Char* chaine :
char* COPIER(char* bloc, int pas1, int pas2);
- Je copie tous les caractères entre un pas1 et pas2 ( pas1 et pas2 désignons le numero des espaces: bloc = AAA_pas1_BBB CCC_pas2_DDD EEE [ici je vais copier BBB CCC]).
- bloc est une chaine de caractères, les mots de dans sont séparés par des espaces.
* Dans le main : pour récuperer le résultat de la fonction copier,
je fais, exemple : char* chaine = COPIER(char* bloc, int pas1, int pas2);
 
Ce que je veux , est-ce qu'il y a u une possibilté pour que le retour de la fonction copier soit parmi les paramétres d'entrées de la fonction? je m'explique
au lieu de faire :
++ char* chaine =  COPIER(char* bloc, int pas1, int pas2);
j'aurais un truc comme :
++ COPIER(char* bloc, int pas1, int pas2, char* chaine);
c-à-d le résultat va être directement stocké dans chaine,
et sa veut dire dans le main , je directement écrire :
COPIER(char* bloc, int pas1, int pas2, char* chaine);
 
Même si j'ai pensé à définir la fonction comme étant un int COPIER(char* bloc, int pas1, int pas2, char* chaine);
je reçois toujrs une segmentation fault.(Code Blocks)
 
J'en ai besoin pour mon travail.Merci

ais gaffe à ton français.
Tu peux utiliser l'opérateur & pour obtenir un pointeur sur une variable, du coup, ton prototype aurait plutôt le style :

Bonjour theshockwave et merci pour ta réponse rapide.
 
Je vais essayer ton truc.
 
Et dans le main , je vais écrire directement copier( char* input, int pas1, int pas2, char** output ) et je sais que le résultat soit directement stocké dans output ?
 
c'est çà ce que je veux.
 
Merci et cordialement theshockwave.

cela dit, en y repensant, j'ai quelques doutes sur la validité de tes données. Tu pourrais donner le contexte ?
 
Est-ce que ta fonction copier se charge d'allouer de la mémoire ou bien se charge-t-elle simplement de remplir un buffer alloué par l'appelant ?
Dans le premier cas, tu as effectivement besoin de passer un pointeur sur ton pointeur puisque tu comptes le modifier (mais ca n'a pas d'avantage vis-à-vis de le retourner)
Dans le deuxième cas, ca n'est pas utile d'utiliser un pointeur de pointeur mais il serait surement plus sûr de fournir la taille de ton tableau à la fonction.

Je vais vous expliquer :
 
J'ai une chaine de type AAAA  BBBB CCCC DDDD EEEE. des ocets de quatre caractéres.
 
je veux copier par exemple : BBBB CCCC avec l'espace ( je compte le nombre des espaces, donc pas1 = 1 et pas2 = 3, c-à-dire tous les caractéres mm l'espace entre l'espace numero 1 et espace numero 2).
 
J'ai fait déja tout çà et sa marche nikel.
 
Mais je veux le faire avec une méthode , exemple voila le fct que je veux avoir ( bloc c input)
 
void CP(char* bloc, int pas, int pas2, char** OUTPUT)
{
    if (bloc != NULL)
 {
     int longueur = strlen(bloc);
     int i=0, g=0, compteur=0, d=0;
     char* retour;
     MEM = malloc((longueur + 1) * sizeof *retour);
     int compteur1=0;
     for (i=0; i<=longueur; i++)
                {
                    if (bloc[i]==' ')
                    {
                         compteur++;
 
                         if (compteur>=pas && compteur<=pas2)
                             {
 
                                for (g=i+1; g<=i+5; g++)
 
                                {
                                    do {
                                     compteur1++;
                                     retour[d]=bloc[g];
                                     d++;
                                       }
                                 while (d<compteur1);
                                 retour[d] = '\0';
 
 
                                }
                             }
                    }
                }
/* trim est une fonction que j'ai écrit pour enlever les espaces avant la chaine de caractéres et à la fin */
OUTPUT= trim(retour);
}
 
}
Ce que je veux, c'est qu'on je vais au Main , je veux écrire juste : CP(char* bloc, int pas, int pas2, char** OUTPUT), et le résultat sera directement stocké dans OUTPUT,, c-à-d éviter de déclarer une variable char** OUTPUT = CP(char* bloc, int pas, int pas2, char** OUTPUT);
 
Je veux pas mettre le résultat dans une variable, je veux justement que la variable résultat (OUTPUT) soit déclarée parmi les paramétres de la fct, est-ce que vous m'avez compris ?
 
Merci encore pour votre aide
 
}

Bonjour,

Si mes souvenirs sont bons, une chaine assignee a la creation de la variable est une constante..

Tu ne peux pas faire :

Tu dois faire :

EDIT :
Je confirme. Essaye ces deux mains l'un apres l'autre:

 
Ce n'est pas une question d'initialisation / assignation. Dans ton premier main, test pointe sur une donnée qui est dans le segment  data de ton application, donc à un endroit où ton processus n'a pas les droit sen écriture dans les OS modernes Dans ton deuxième exemple, strdup fait une allocation sur le tas et donc ton pointeur se trouve dans une zone sur laquelle tu as les droits en écriture.
 

 
ok, ton code est perclus d'erreurs, mais je crois voir l'idée. Je ne suis pas vraiment amateur des fonctions qui allouent la mémoire comme ca mais soit, si tu veux allouer le résultat, tu te retrouves dans mon premier cas de figure.
Quoi qu'il arrive, dans ton main, tu devras nécessairement déclarer une variable pour stocker ton résultat, que ta fonctionne prenne un pointeur sur cette variable ou que tu passes par la valeur de retour de cette fonction pour assigner ta variable, la différence est ténue.