renvoyer un tableau

Version imprimable

23/05/2006, 20h16
dadagos

renvoyer un tableau

Bonjour à tous,
Je voulais juste savoir si il était possible de renvoyer un tableau de valeurs à la fin d'une fonction avec l'instruction "return".
Si oui, comment?
23/05/2006, 20h44
Myth_Titans
eh bien je ne sais pas si c'est la meilleure solution, mais tu peux faire un pointeur vers ta variable si elle n'est pas déclarée localement à la fonction :
Code:

1 2 3 4 5 char coucou[10] = "coucou"; char *test() { return coucou; }
23/05/2006, 20h50
Pragmateek
Citation:
Envoyé par Myth_Titans

eh bien je ne sais pas si c'est la meilleure solution, mais tu peux faire un pointeur vers ta variable si elle n'est pas déclarée localement à la fonction :

Code:

1 2 3 4 5 char coucou[10] = "coucou"; char *test() { return coucou; }
Les variables globales sont déconseillées.
Soit passer un pointeur sur le tableau en paramètre.
Soit créer dynamiquement le tableau dans la fonction.
Ou plus simple utiliser la classe "vector".
23/05/2006, 21h38
dadagos

Je vais essayer de creer un pointeur.
Je reposterais pour vous dire si j'y arrive ou pas.:lol:

Je viens juste d'essayer rapide avant de me coucher et voici mes premiers résultats pas tres concluant mais mieux que rien.
crétaion du pointeur:

Code:

float * liste_val = new float[somme_effect()];

crétion de la fonction qui rassemble 2 tableau en un seul:
Code:

1 2 3 4 5 6 7 8 9 float liste(){ int m=0; for(int i=0; i<nbvaleurs; i++){ for(int n=0; n<peffect[i]; n++){ liste_val[m]= pval[i]; m++; } } }
Dans main:
Code:

1 2 3 4 case 2: liste(); for (int i=0; i<somme_effect(); i++){ cout<<liste_val[i]; }
La boucle for affiche le résultat voulu à l'écran mais fait tout planter part la suit et affichent une énorme série de nombre (avec plein de puissance de 10 je croit)
Il n'y a aucun code apres la fin de la boucle for et la fin de la fonction main normale (
Code:

1 2 system("PAUSE"); return EXIT_SUCCESS;
)

Que se passe-t-il?

PS:c'est peut etre un truc tout con mais ce soir je n'ai plus l'esprit clair....

23/05/2006, 22h57
Pragmateek
Code:

i<somme_effect()

plutôt:
Code:

1 2 int n=somme_effect(); for(int i=0;i<n;i++)
24/05/2006, 14h16
dadagos

Merci beaucoup !!!
Mais pourquoi ne peut-on pas écrire

Code:

i<somme_effect()
24/05/2006, 15h32
socrate

Si tu fais cela, somme_effect() sera évalué à chaque tour ce boucle, ce qui est inutile. On calcule donc une fois pour toutes avant la boucle
24/05/2006, 15h35
socrate

Citation:

Envoyé par seriousme

Les variables globales sont déconseillées.
Soit passer un pointeur sur le tableau en paramètre.
Soit créer dynamiquement le tableau dans la fonction.
Ou plus simple utiliser la classe "vector".

Entre une variable globale et une allocation locale avec new on a vite choisi, car la mémoire allouée avec le new ne sera sans doute jamais libérée (en tous cas on risque de l'oublier).
Le plus courant, c'est de passer un tableau en paramètre
Si tu es un kamikaze, tu peux aussi retourner un tableau local, a condition de l'utiliser tout de suis après (ne pas faire d'appel de fonction ou déclaration de variable locales par exemple, car ca effacerait le tableau retourné)

Dite j'au encors un problème mais cette fois fois c'est dans le code complet je pense ....
En fait il ne fonctionne que des fois pour la médiane suivant les valeurs que je rentre aux debuts (mais lequels précisement je sais pas), les autre il se ferme directement sans rien affiché comme s'il efféctuer une fonction "quitter".
En même il y a quelque chose que je ne comprend pas, je l'ai mi en commentaire rouge.
Voici le code (il est peut être pas super mais bon je debute je l'ai fais comme je pouvais mais la je cale..):

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include <cstdlib>
#include <iostream>
using namespace std;
    float somme_val();
    int somme_effect();
    float somme_totale();
    float liste();
    int nbvaleurs, choix, med;
    float moy; 
 
    float * pval = new float[nbvaleurs];
    int * peffect = new int[nbvaleurs];
    float * liste_val = new float[somme_effect()];
 
 
int main(int argc, char *argv[])
{
    cout<<"rentrez le nombre de valeurs differentes."<<endl;
    cin>>nbvaleurs;
 
    for(int i=0; i<nbvaleurs; i++){
            cout<<"rentrez une valeur";
            cin>>pval[i];
            cout<<"rentrez son effectif";
            cin>>peffect[i];
            }
 
    for(int i=0; i<nbvaleurs; i++){
            cout<<pval[i]<<"\t";
            }
    cout<<endl;
    for(int i=0; i<nbvaleurs; i++){
            cout<<peffect[i]<<"\t";
            }
 
    cout<<endl<<"pour calculer la moyenne tapez1, la mediane tapez2."<<endl;
    cin>>choix;
    switch(choix){
                  case 1: moy = somme_totale()/somme_effect();
                          cout<<"la moyenne est de:"<<moy<<endl;
                          break;
                  case 2: liste();//pour somme_effect impaire
                          int j = somme_effect();
                          med = ((j+1)/2)-1;//le -1 sert a cerner la bonne case du tableau.
                          cout<<"la mediane est:\t"<<liste_val[med];
 
 
                  }
    delete pval, peffect, liste_val;
    system("PAUSE");
    return EXIT_SUCCESS;
}
 
    float somme_val(){
                float x;
                for(int i=0; i<nbvaleurs; i++){
                         x += pval[i];
                         }
                 return x;
                 }
 
    int somme_effect (){
                 float x; //ici  si je met int pour correspondre au type de la fonction, la moyenne est fausse.
                 for(int i=0; i<nbvaleurs; i++){
                         x += peffect[i];
                         }
                 return x;
                 }
 
    float somme_totale(){
                   float x;
                   for(int i=0; i<nbvaleurs; i++){
                          x += pval[i] * peffect[i];
                          }
                   return x;
                   }
 
    float liste(){
 
          int m= 0;
          for(int i=0; i<nbvaleurs; i++){
                  for(int n=0; n<peffect[i]; n++){
                          liste_val[m]= pval[i];
                          m++;
                          }
                  }
          }

PS: Je sais pas si le forum est fait pour vérifier des codes entiers mais bon, je ne sais pas a qui m'adresser..
Aidez-moi s'il vous plait.

24/05/2006, 16h24
Pragmateek

Citation:

Si tu es un kamikaze, tu peux aussi retourner un tableau local, a condition de l'utiliser tout de suis après

Pas toujours, comportement indéfini.

Citation:

Si tu fais cela, somme_effect() sera évalué à chaque tour ce boucle, ce qui est inutile. On calcule donc une fois pour toutes avant la boucle

Normalement non, c'était juste pour clarifier le code.
24/05/2006, 17h09
Médinoc

Je corrige sa phrase:

Citation:

Si tu es un kamikaze, tu peux aussi retourner un tableau local déclaré static, a condition de l'utiliser tout de suite après

... Et de ne pas travailler en multithread.

En fait, le tableau static correspond à une variable globale, mais en un peu plus propre puisque seule la fonction peut y accéder.
24/05/2006, 17h16
socrate

Citation:

Envoyé par seriousme

Normalement non, c'était juste pour clarifier le code.

Ben si, pourquoi l'évaluation ne serait-elle pas faite a chaque fois?
24/05/2006, 17h26
Pragmateek

Citation:

Je corrige sa phrase:

A partir de quand ce tableau devient il invalide?
Plus précisément quand sa mémoire est elle libérée?
24/05/2006, 17h46
dadagos

En ayant réfléchi un peu je pense que le bug du logiciel vient de ce que je n'ai pas compris, là ou j'ai mis le commentaire en rouge, non?
Comment puis-je faire?
24/05/2006, 20h58
Luc Hermitte

Citation:

Envoyé par socrate

Entre une variable globale et une allocation locale avec new on a vite choisi, car la mémoire allouée avec le new ne sera sans doute jamais libérée (en tous cas on risque de l'oublier).

Ouais. Je fais une alloc dynamique et renvoie un auto_ptr<> ou un auto_array<> selon s'il s'agit d'un élément isolé ou d'un tableau.

Ca, c'est si j'ai peur pour les perf / qu'il m'a été prouvé que j'ai un problème de perf là. Sinon, c'est toujours et systématiquement le vecteur renvoyé par copie, ou pris par référence (afin de faire des resize à chaque passage dans la boucle du traitement -- ce qui sera encore plus performant que l'allocation à chaque itération).

Une variable globale ? Certainement pas!!!
24/05/2006, 21h54
Médinoc

Citation:

Envoyé par seriousme

(en parlant de ce que je disais sur les tableaux static)
A partir de quand ce tableau devient il invalide?
Plus précisément quand sa mémoire est elle libérée?

Comme pour les variables globales: "Jamais".

En pratique, c'est lorsque le processus se termine, quoi. Une variable locale static, c'est juste une variable globale à accès restreint (Pour les objets, il me semble avoir lu ici (ou sur MSDN) que le C++ garantit que l'objet sera construit au plus tard juste avant le premier appel à la fonction).
24/05/2006, 22h22
JolyLoic

C'est un peu plus précis que ça : L'objet ne sera pas appelé avant le premier appel de la fonction. C'est ce point qui permet au pattern singleton de résoudre les problèmes d'ordre d'initialisation entre variables "globales".
25/05/2006, 10h51
dadagos

Excusez-moi mais je me pose une question: est-ce que vous parlez entre vous ou vous repondez a ma question? Je prefererais que ce soit la première solution car je ne comprend rien....:)

PS: de temp en temp il plante aussi, je suis obliger d'aller dans le gestionnaire des taches.
25/05/2006, 11h20
Médinoc

Je te rassure tout de suite:
On s'est mis à parler entre nous quand socrate t'a proposé de retourner l'adresse d'un tableau local, pour l'utiliser immédiatement après.

Moi, j'ai ensuite précisé "retourner un tableau local static" et précisé les inconvénients (les mêmes que pour des variables globales, mais si tu fais "un petit programme tout simple", il y a des chances que tu n'aies pas de problèmes en faisant cela).

Le reste n'est que discussions entre nous.
25/05/2006, 11h37
dadagos

Tant mieux :mrgreen:

mais vous avez pas d'idée pour mon problème?

Code:

1
2
float somme_effect (){
                 float x;

25/05/2006, 12h12
Matthieu Brucher

Citation:

Envoyé par socrate

Entre une variable globale et une allocation locale avec new on a vite choisi, car la mémoire allouée avec le new ne sera sans doute jamais libérée (en tous cas on risque de l'oublier).

Je n'ai jamais rien entendu d'aussi :aie:
Soit tu retourne un std::vector<> par copie, soit tu renvoies un float*, et pour être sûr qu'il sera libéré, tu l'encapsules dans un pointeur intelligent, le std::auto_ptr<> ou les pointeurs intelligents de boost.
25/05/2006, 12h27
dadagos

Seriousme,
Si je met comme tu as dit, le tableau liste_val ne peut se creer car le nombre de case (somme_effect()) n'est pas un type d'entier.

Autrement je me suis renseigné un peu sur les vectors et je vais essayer.
25/05/2006, 12h32
Pragmateek

Citation:

Envoyé par dadagos

le tableau liste_val ne peut se creer car le nombre de case (somme_effect()) n'est pas un type d'entier.

Il suufit de caster le retour de la fonction:

Code:

static_cast<int>(somme_effect())

ce qui revient à tronquer.
Ou alors faire un arrondi.
25/05/2006, 12h41
dadagos

Ok c'est cool ca je ne conaissais pas j'essaye et je te dirai ce soir ce qu'il en ai
25/05/2006, 14h25
loufoque

Pour revenir au sujet initial, à savoir retourner un tableau, cela n'est pas possible tout simplement parce qu'il s'agit des mêmes tableaux qu'en C qui ont un comportement totalement différent des autres types de variables.
Tu peux régler cela en utilisant une couche objet qui enrobe les tableaux, comme array dans TR1 (std::tr1::array) qui est aussi disponible dans boost (boost::array).
Il est aussi possible d'utiliser std::vector, mais ce n'est plus exactement un tableau.

Ce code a l'air de marcher:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <cstdlib>
#include <iostream>
#include <vector> 
using namespace std;
    float somme_val();
    float somme_effect();
    float somme_totale();
    float liste();
    int nbvaleurs, choix, med;
    float moy, med1; 
    std::vector <float> pval;
    std::vector <int> peffect;
    std::vector <float> liste_val;
 
 
 
int main(int argc, char *argv[])
{
    cout<<"rentrez le nombre de valeurs differentes."<<endl;
    cin>>nbvaleurs;
 
    for(int i=0; i<nbvaleurs; i++){
            int j;
            cout<<"rentrez une valeur";
            cin>>j;
            pval.push_back(j);
            cout<<"rentrez son effectif";
            cin>>j;
            peffect.push_back(j);
            }
 
    for(int i=0; i<nbvaleurs; i++){
            cout<<pval[i]<<"\t";
            }
    cout<<endl;
    for(int i=0; i<nbvaleurs; i++){
            cout<<peffect[i]<<"\t";
            }
 
    cout<<endl<<"pour calculer la moyenne tapez1, la mediane tapez2."<<endl;
    cin>>choix;
    switch(choix){
                  case 1: moy = somme_totale()/somme_effect();
                          cout<<"la moyenne est de:"<<moy<<endl;
                          break;
                  case 2: liste();
                          int j = static_cast<int>(somme_effect());
                          med = ((j+1)/2)-1;//le -1 sert a cerner la bonne ncase du tableua.
                          cout<<"la mediane est:\t"<<liste_val[med];
 
 
                  }
    pval.clear();
    peffect.clear();
    liste_val.clear();
 
    system("PAUSE");
    return EXIT_SUCCESS;
}
 
    float somme_val(){
                float x;
                for(int i=0; i<nbvaleurs; i++){
                         x += pval[i];
                         }
                 return x;
                 }
 
    float somme_effect (){
                 float x; 
                 for(int i=0; i<nbvaleurs; i++){
                         x += peffect[i];
                         }
                 return x;
                 }
 
    float somme_totale(){
                   float x;
                   for(int i=0; i<nbvaleurs; i++){
                          x += pval[i] * peffect[i];
                          }
                   return x;
                   }
 
    float liste(){
          for(int i=0; i<nbvaleurs; i++){
                  for(int n=0; n<peffect[i]; n++){
                          liste_val.push_back(pval[i]);
                          }
                  }
          for(int i=0 ; i <liste_val.size() ; i++){//affiche la liste du tableau
          cout <<liste_val[i]<< endl;}
          }

Qu'en pensez vous?

25/05/2006, 18h49
Matthieu Brucher

Om est le return de la dernière fonction ?

A oui c'est vrai en fait c'est une fonction "void" :lol:
Par la meme occasion j'ai affecter 0 aux variables "x" dans mes fonctions:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#include <cstdlib>
#include <iostream>
#include <vector> 
using namespace std;
    float somme_val();
    float somme_effect();
    float somme_totale();
    void liste();
    int nbvaleurs, choix, med;
    float moy, med1;
 
    std::vector <float> pval;
    std::vector <int> peffect;
    std::vector <float> liste_val;
 
 
 
int main(int argc, char *argv[])
{
    cout<<"rentrez le nombre de valeurs differentes."<<endl;
    cin>>nbvaleurs;
 
    for(int i=0; i<nbvaleurs; i++){
            int j;
            cout<<"rentrez une valeur";
            cin>>j;
            pval.push_back(j);
            cout<<"rentrez son effectif";
            cin>>j;
            peffect.push_back(j);
            }
 
    for(int i=0; i<nbvaleurs; i++){
            cout<<pval[i]<<"\t";
            }
    cout<<endl;
    for(int i=0; i<nbvaleurs; i++){
            cout<<peffect[i]<<"\t";
            }
 
    cout<<endl<<"pour calculer la moyenne tapez1, la mediane tapez2."<<endl;
    cin>>choix;
    switch(choix){
                  case 1: moy = somme_totale()/somme_effect();
                          cout<<"la moyenne est de:"<<moy<<endl;
                          break;
                  case 2: liste();
                          int j = static_cast<int>(somme_effect());
                          med = ((j+1)/2)-1;//le -1 sert a cerner la bonne ncase du tableua.
                          cout<<"la mediane est:\t"<<liste_val[med];
 
 
                  }
    pval.clear();
    peffect.clear();
    liste_val.clear();
 
    system("PAUSE");
    return EXIT_SUCCESS;
}
 
    float somme_val(){
                float x=0;
                for(int i=0; i<nbvaleurs; i++){
                         x += pval[i];
                         }
                 return x;
                 }
 
    float somme_effect (){
                 float x=0; 
                 for(int i=0; i<nbvaleurs; i++){
                         x += peffect[i];
                         }
                 return x;
                 }
 
    float somme_totale(){
                   float x=0;
                   for(int i=0; i<nbvaleurs; i++){
                          x += pval[i] * peffect[i];
                          }
                   return x;
                   }
 
    void liste(){
          for(int i=0; i<nbvaleurs; i++){
                  for(int n=0; n<peffect[i]; n++){
                          liste_val.push_back(pval[i]);
                          }
                  }
          for(int i=0 ; i <liste_val.size() ; i++){//affiche la liste du tableau
          cout <<liste_val[i]<< endl;}
          }

Je post peut être un peu trop souvent mon code, non?

25/05/2006, 20h18
Charlemagne
Je comprends pas bien ces discussions récurrentes sur les retours de gros objets par copie.

Car le standard C++ prévoit un retour sans copie pour une variable temporaire.
Code:

1 2 3 4 5 6 GrosseClasse f() { ... return GrosseClasse(...); }
Je crois que le compilo utilise directement la variable de la pile où le temporaire aurait dû être copié.
Certes c'est pas très fréquent d'appeler le constructeur dans l'instruction 'return', en général on initialise la grosse classe dans la fonction sur une variable locale.
Code:

1 2 3 4 5 6 7 GrosseClasse f() { GrosseClasse une_grosse_classe. ... //modification de une_grosse_classe return une_grosse_classe; }
Mais mon compilo (ICL: Intel C++ Compiler) sait très bien gérer ça sans faire de copie (en mode release bien sûr), et donc je n'ai jamais à me soucier du volume de la variable retournée.

Ca serait intéressant de contrôler sur d'autres compilos...
26/05/2006, 08h35
JolyLoic

Le standard prévoit de pouvoir éviter la copie de la valeur de retour dans tous les cas, le cas que tu cites étant juste un cas où il est plus facile pour le compilateur d'utiliser cette permission, et étant donc le seul cas que certains compilateurs implémentent (sauf erreur de ma part, certains compilos n'implémentent même pas ce cas, comme VC++ qui commence à l'implémenter dans sa version 2005).
26/05/2006, 10h12
Charlemagne

Citation:

Le standard prévoit de pouvoir éviter la copie de la valeur de retour dans tous les cas, le cas que tu cites étant juste un cas où il est plus facile pour le compilateur d'utiliser cette permission, et étant donc le seul cas que certains compilateurs implémentent

Ce que j'avais lu datait un peu, on dirait que le standard a évolué.

C'est bizarre que les compilos n'implémentent pas tous les "retours rapides". J'y vois a priori un bon potentiel de gain de vitesse.

Quelqu'un a t-il l'info sur d'autres compilos? (GCC?)
26/05/2006, 11h05
Luc Hermitte

SunWSPro sait faire. J'ai même eu l'impression qu'il fait les RVO & cie en mode debug. Il faudrait que je revérifie à l'occasion.
Un bon rapport, qui parle aussi de ça est le n1666. Il ne doit pas citer les compilos pour autant.
26/05/2006, 11h52
Charlemagne

Je viens de lire la partie concernant ces "retours rapides" (RVO??).
Il semblerait que seul le retour d'un temporaire soit explicitement concerné. Le document mentionne seulement que les compilateurs modernes peuvent optimiser le retour de variables locales de la même manière => VC2005 n'est pas moderne ;-)

ICL ne fait de toute évidence pas l'optimisation en mode debug car le debugger saute bien dans le constructeur de copie.