fonction initialisation char*

Version imprimable

Bonjour

J'ai fait une petite fonction "petite(int *longueur,char *retour)" qui est appelée par un fonction principale "principale(void)", or petite initialise correctement retour mais principal me dit que retour est nulle, savez vous comment resoudre ce problème?

merci d'avance

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
void petite(int *longueur,char *retour) {
    *longueur = 6;
    retour = new char[*longueur+1];
    if (retour) {
       memset(retour,0,*longueur);
       strcpy(retour,"petite");
    }
    // à ce stade retour="petite\0" et son adresse mémoire est par exemple 0x003b486e
}
 
void principale(void) {
    char *tmp_retour=NULL;
    int tmp_longueur=0;
    petite(&tmp_longueur,tmp_retour);
    if (longueur>0) {
        printf("longueur:%d\n",longueur);
        if (tmp_retour) {
            printf("%s\n",tmp_retour);
        }
        else
            printf("tmp_retour est nulle\n");
    }
    else
        printf("longueur est negative ou nulle\n");
}

Ca m'incrit à l'écran,

Citation:

longueur:6
tmp_retour est nulle

24/07/2007, 15h58
befalimpertinent
:salut:
Tu devrais :
1. utiliser std::string ---> cf FAQ
2. ou faire l'allocation en dehors de ta fonction petite
3. penser au delete
24/07/2007, 16h13
maxantz

Pour le delete, c'est déjà fait, j'ai juste trop écourté mon exemple pour le forum.

Pour le type string, je n'y avais pas pensé.

Pour l'allocation en dehors ce n'est pas possible, sans une certaine petite gymnastique.
a) je demande la taille de retour à petite
b) je initialise retour dans principale
c) je rappelle petite pour "remplir" retour

Je vais voir pour avec le type string.

Voici ton exemple modifié

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
void petite(int *longueur,char *retour) {
    *longueur = 6;
    retour = new char[*longueur+1];
    if (retour) {
       memset(retour,0,*longueur);
       strcpy(retour,"petite");
    }
	std::cout << "address char*:"<<&retour << std::endl;
 
    // à ce stade retour="petite\0" et son adresse mémoire est par exemple 0x003b486e
}
int main (int argc, char** argv)
{
 
    char *tmp_retour=NULL;
    int tmp_longueur=0;
	std::cout << "address char*:"<<&tmp_retour << std::endl;
 
    petite(&tmp_longueur,tmp_retour);
    if (tmp_longueur>0) {
        printf("longueur:%d\n",tmp_longueur);
        if (tmp_retour) {
            printf("%s\n",tmp_retour);
        }
        else
            printf("tmp_retour est nulle\n");
    }
    else
        printf("longueur est negative ou nulle\n");
 
	return 0;

voici la sortie:

Code:

1
2
3
4
5
address char*:0012FF7C
address char*:0012FF28
longueur:6
tmp_retour est nulle
Press any key to continue

L'adresse change puisque tu fait un new...

24/07/2007, 16h49
befalimpertinent

Bonne idée :king:
Tu verras ça va te simplifier la vie sur ce genre de problème de flux.

Bon courage

C'est normal que cela ne fonctionne pas, il ne faut pas passer un pointeur de char mais un pointeur de pointeur (de char) à la fonction petite :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void petite(int *longueur,char **retour) {
    *longueur = 6;
    *retour = new char[*longueur+1];
    if (retour) {
       memset(retour,0,*longueur);
       strcpy(retour,"petite");
    }
     std::cout << "address char*:"<<retour << std::endl;
}
 
void principale(void) {
    char *tmp_retour=NULL;
    int tmp_longueur=0;
    petite(&tmp_longueur,&tmp_retour);
    if (longueur>0) {
        printf("longueur:%d\n",longueur);
        if (tmp_retour) {
            printf("%s\n",tmp_retour);
        }
        else
            printf("tmp_retour est nulle\n");
    }
    else
        printf("longueur est negative ou nulle\n");
}

Merci de vos réponses.

Celà fonctionne avec un pointeur de pointeur de char.
Pour ceux que celà interresse voilà le code corrigé, et fonctionnel.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
void petite(int *longueur,char **retour) {
    *longueur = 6;
    *retour = new char[*longueur+1];
    if (retour) {
       memset(*retour,0,*longueur);
       strcpy(*retour,"petite");
    }
}
 
void principale(void) {
    char *tmp_retour=NULL;
    int tmp_longueur=0;
    petite(&tmp_longueur,&tmp_retour);
    if (tmp_longueur>0) {
        printf("longueur:%d\n",tmp_longueur);
        if (tmp_retour) {
            printf("%s\n",tmp_retour);
            delete tmp_retour;
        }
        else
            printf("tmp_retour est nulle\n");
    }
    else
        printf("longueur est negative ou nulle\n");
}

on peut aussi le faire à l'aide du type string.
Pour ceux que celà interresse voilà le code fonctionnel.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void petitebis(std::string* retour) {
    *retour="petite";
}
 
void principalebis(void) {
    std::string tmp_retour;
    petitebis(&tmp_retour);
    if (tmp_retour.size()>0) {
        printf("longueur:%d\n",tmp_retour.size());
        printf("%s\n",tmp_retour.c_str());
    }
    else
        printf("longueur est negative ou nulle\n");
}

25/07/2007, 11h45
stillman

Entre parenthèses, en C++, plutôt que de passer des paramètres à une fonction par adresse, on préfère généralement les passer par référence.
Du coup, tu pourrait appeler ta fonction "petitebis" de la façon suivante :

Code:

petitebis(tmp_retour);

Mais tu pourrais aussi bien renvoyer une string plutôt que de modifier celle passée en paramètre :

Code:

std::string tmp_retour = petitebis();

PS : je n'ai volontairement pas détaillé les différentes implémentations de la fonction petitebis, à toi d'essayer afin de te familiariser avec les différentes méthodes.