Discussion :

[dadagos]

Tant mieux

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

[Pragmateek]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
float somme_effect (){
                 float x;

[Matthieu Brucher]

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

[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.

[Pragmateek]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

static_cast<int>(somme_effect())

ce qui revient à tronquer.
Ou alors faire un arrondi.

[dadagos]

Ok c'est cool ca je ne conaissais pas j'essaye et je te dirai ce soir ce qu'il en ai

[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.

[dadagos]

Ce code a l'air de marcher:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[Matthieu Brucher]

Om est le return de la dernière fonction ?

[dadagos]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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).

[Charlemagne]

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

[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.

[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.