Allocation dynamique dans une fonction

Version imprimable

Bonjour.

J'ai un problème avec lequel j'ai un peu de mal.
Si je fais :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
void mafonction(unsigned long long int par_min64[],unsigned long long int par_max64[])
{
        par_min64=new unsigned long long int[1];
        par_max64=new unsigned long long int[1];
        par_min64[0]=2;
        par_max64[0]=3;
} 
 
int main()
{
    unsigned long long int *par_min64;
    unsigned long long int *par_max64;
 
    mafonction(par_min64,par_max64);
 
    std::cout<<" "<<par_min64[0]<<" "<<par_max64[0];
 
    delete[] par_min64;
    delete[] par_max64;
 
    return 0;
}

Cela plante et je n'arrive pas bien à comprendre pourquoi.
Comment allouer dynamiquement mes tableaux dans ma fonction et les récupérer à l'extérieur ?
Merci ;-)

C'est peut-etre une histoire de pointeur et de passage de paramètre (si c'est le cout qui plante) vu que tu alloues dans la fonction.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void mafonction(unsigned long long int *par_min64[],unsigned long long int *par_max64[])
{
        *par_min64=new unsigned long long int[1];
        *par_max64=new unsigned long long int[1];
        (*par_min64)[0]=2;
        (*par_max64)[0]=3;
} 
 
int main()
{
    unsigned long long int *par_min64;
    unsigned long long int *par_max64;
 
    mafonction(&par_min64,&par_max64);
 
    std::cout<<" "<<par_min64[0]<<" "<<par_max64[0];

Salut,
il faut que ta fonction retourne les deux pointeurs sur les tableaux crées, sinon, leurs adresses sont perdues, mais continuent à occuper de la mémoire inutilement!!! De plus, puisque les tableaux sont crées par ta fonction, il est plus simple de ne pas les mettre en paramètres. En plus un compilo comme VisualC++ ( que j'utilise ) plante à la compilation si on transmet en paramètre des pointeurs non initialisés!

Je tenterai quelque chose comme ça pour voir :
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 33 34 struct retourFonction { unsigned long long int* pt1; unsigned long long int* pt2; }; retourFonction mafonction() { par_min64=new unsigned long long int[1]; par_max64=new unsigned long long int[1]; par_min64[0]=2; par_max64[0]=3; retourFonction rF; rF.pt1 = par_min64; rF.pt2 = par_max64; return rF; } int main() { unsigned long long int *par_min64; unsigned long long int *par_max64; retourFonction rF; rF = mafonction(); std::cout<<" "<<rF.pt1[0]<<" "<<rF.pt2[0]; delete[] rF.pt1; delete[] rF.pt2; return 0; }
Ca peut marcher, je crois!

PS : Si tu peux dire ce qui plante : compilation, éxécution, et le message d'erreur ça évite de répondre en 'aveugle' merci

22/04/2011, 12h55
white_tentacle
Citation:

Envoyé par Kaluza

Cela plante et je n'arrive pas bien à comprendre pourquoi.

Pour comprendre pourquoi, je t’invite à faire la chose suivante :
Code:

1 2 std::cout << (int) par_min64 << ' ' << (int) par_max64;
À divers endroits dans ton code :
- avant l’appel à f
- dans f, avant leur initialisation
- dans f, après leur initialisation
- après l’appel à f

Tu devrais alors comprendre pourquoi ça plante, et trouver tout seul la correction à apporter.
22/04/2011, 13h26
JolyLoic

Juste pour rappeler qu'en C++, utiliser directement des tableaux alloués dynamiquement est assez rare, on leur préfère généralement des conteneurs plus simples à gérer, comme std::vector.

Citation:

Envoyé par bertry

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
33
34
 
struct retourFonction
{    unsigned long long int* pt1;
      unsigned long long int* pt2;
};
 
retourFonction mafonction()
{
        par_min64=new unsigned long long int[1];
        par_max64=new unsigned long long int[1];
        par_min64[0]=2;
        par_max64[0]=3;
 
      retourFonction rF;
      rF.pt1 = par_min64;
      rF.pt2 = par_max64;
     return rF;
} 
 
int main()
{
    unsigned long long int *par_min64;
    unsigned long long int *par_max64;
    retourFonction rF;
 
    rF = mafonction();
 
    std::cout<<" "<<rF.pt1[0]<<" "<<rF.pt2[0];
 
    delete[] rF.pt1;
    delete[] rF.pt2;
 
    return 0;
}

Ca peut marcher, je crois!

Ou pas !!!

Code:

1
2
3
4
5
6
7
8
retourFonction mafonction()
{
        .....
 
      retourFonction rF;
     ......
     return rF;
}

Je crains le pire au niveau retour de fonction. Retourner une variable déclarée localement, c'est source de gros problème.

23/04/2011, 10h21
Invité
Citation:

Envoyé par fregolo52

Retourner une variable déclarée localement, c'est source de gros problème.

???????

La variable va être simplement copiée ! (et donc les pointeurs aussi)
Suffit voir l'implémentation (très) souvent conseillée des operateurs binaires, on retourne bien une variable 'locale'
Code:

1 2 3 4 5 6 7 MonType operator+(MonType const& a, MonType const& b) { MonType retour(a); retour += b; return retour; }
26/04/2011, 08h56
bertry

Je suis d'accord avec Joe. Ca fait longtemps que je retourne des variables locales avec mes fonctions, et en général elles sont recopiées dans la variable qui la recueil...
26/04/2011, 10h23
oxyde356

C'est la fontaine des évidences ce topic :D