vector< int >, getVector()

Version imprimable

Bonjour j'ai fait une méthode qui "renvoie" les données d'un Vector<int> mais je ne sais pas comment les récupérer.

Mon Header
Code:

1 2 3 4 5 6 7 8 9 class Polynome { public: Polynome(); std::vector<int>& calculDerivee(); private: std::vector<int> m_polynomeDerivee; };
Mon Main
Code:

1 2 3 4 5 6 7 8 9 int main() { Polynome p1; std::vector<int> polynomeDerivee; polynomeDerivee = p1.calculDerivee(); }
merci d'avance.

03/09/2014, 10h15
Bousk

Salut,

quelle est la question ? :weird:
mise à part que tu retournes ton vecteur par référence, je suppose et j'espère un return m_polynomeDerivee, et en fais une copie dans ton main.
03/09/2014, 10h18
ternel

D'ailleurs, il y a du gaspillage, parce qu'un vecteur (certes vide) est construit avant d'être remplacé par celui de la classe.
03/09/2014, 10h21
Onelove
Oui dans mon source.c j'ai:
Code:

1 2 3 4 5 std::vector<int>& Polynome::calculDerivee() { return m_polynomeDerivee; }
ce que je voudrait c'est de récupérer m-polynomeDerivee mais malheureusement...

polynomeDerivee = p1.calculDerivee();

ne fonctionne pas.
03/09/2014, 10h27
ternel
Attention, "ne fonctionne pas" n'est pas une phrase valide pour nous, car on ne peut rien en faire.

Tu as trois choix possibles:
- Ca ne compile pas?
- Ca plante à l'exécution?
- Ca ne donne pas le bon résultat?
Et dans chaque cas, on a besoin du diagnostique: le message du compilateur, celui du plantage, ou le code de vérification, et le résultat obtenu et celui attendu.

En fait, idéalement, tu devrais préparer un "code compilable minimal d'exemple", c'est à dire quelque chose qu'on puisse nous compiler, et exécuter si le problème n'est pas à la compilation.

Ton code en l'état fonctionne parfaitement, mais ne fait rien de visible: pas d'affichage, pas de remplissage

Enfaite on me demande de renvoyer une classe ( de préférence ) mais lorsque j'exécute p2 le programme se ferme ( surement du à la mémoire ?)
voici mon code en entier. Dsl pour les premiers post j'essaye d'être plus claire.

ligne 54 pour le main et 155 pour le source
main

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
 
#include <iostream>
#include <vector>
#include "Polynomes.h"
 
using namespace std;
 
int main()
{
    Polynome p1,p2;
    int choix, x, pDeX;
 
    p1.ecrirePolynome();
    cout<<"\n";
 
    p1.inversionPolynome();
    p1.afficherPolynomeInverser();
    cout<<"\n";
    cout<<"\n";
 
    do
    {
        cout<<"\n";
        cout<<"Voulez vous retaper votre polynome (l_ancien sera ecrasse) ?  <entrez 1>"<<endl;
        cout<<"Voulez vous afficher votre polynome ?                         <entrez 2>"<<endl;
        cout<<"Voulez vous trouver P(x) ?                                    <entrez 3>"<<endl;
        cout<<"Voulez calculer la derivee?                                   <entrez 4>"<<endl;
        cout<<"Voulez calculer la primitive?                                 <entrez 5>"<<endl;
        cout<<"Voulez vous quitter ?                                         <entrez 0>"<<endl;
        cout<<"\n";
        cin>>choix;
 
    switch(choix)
    {
        case 1:
                p1.reinitializationPolynome();
                p1.ecrirePolynome();
                p1.inversionPolynome();
        break;
 
        case 2:
                p1.afficherPolynomeInverser();
        break;
 
        case 3:
                cout<<"Pour resoudre l_equation donnez X:";
                cin>>x;
 
                pDeX = p1.calculPolynomePdeX( x );
                cout<<"P(x)="<<pDeX<<"\n";
        break;
 
 
        case 4:
            cout<<"lzl";
                p1.calculDerivee( p2 );
                cout<<"lol";
                p2.inversionPolynome();
                cout<<"lil";
                p2.afficherPolynomeInverser();
                cout<<"lal";
        break;
 
        case 5:
/*                p1.calculPrimitive();
                p1.calculPrimitive();
                p1.afficherPolynomeInverser();*/
        break;
    }
    }while(choix!=0);
 
    return 0;
}

source

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
#include "Polynomes.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
using namespace std;
 
Polynome::Polynome()
: m_polynome(0,0)
{}
 
void Polynome::ecrirePolynome()
{
    unsigned short degre;
    unsigned short i;
    int tmp(0);
 
    do
    {
        cout << "Entrez le degre du polynome (degre de 1 a 10 seulement)" << endl;
        cin  >> degre;
    }while(degre<1 || degre > 11);/*On bloque le degré entre 0 et 10*/
 
 
    for(i=0;i<degre+1;i++)
    {
        cout << "Entrez le coefficient du polynome de degre x^" << i << endl;
        cin  >> tmp;
        m_polynome.push_back(tmp); /*On augmente la taille du tableau jusqu'à la valeur degre*/
    }
}
 
void Polynome::reinitializationPolynome()
{
    int i;
 
    for(i=m_polynome.size()-1;i>=0;i--)
    {
        m_polynome.pop_back(); /**/
    }
}
 
void Polynome::inversionPolynome()
{
    unsigned short i,j;
    int tmp;
 
    /*Inversion du tableau avec une médiane */
    for(i=0,j=m_polynome.size()-1; i<j ;i++,j--)
    {
     tmp = m_polynome[i];
     m_polynome[i] = m_polynome[j];
     m_polynome[j] = tmp;
    }
 
}
 
void Polynome::afficherPolynomeInverser()
{
    unsigned short i,j(m_polynome.size()-1);/*Le tableau de polynome est inversé alors on commence par la derniére case pour avoir le degré*/
    cout <<"P(x)= ";
 
    if(m_polynome.size()-1==1)
    {
 
        if(m_polynome[0] != 1 && m_polynome[0] != -1)cout <<m_polynome[0]<<"x ";
        else if(m_polynome[0]==-1)cout <<"-x ";
        else cout <<"x ";
 
        if(m_polynome[1]==-1)cout <<"-1 ";
        else if(m_polynome[1]==1)cout <<"+ 1 ";
        else cout <<"+ "<<m_polynome[1];
 
    }
 
    else
    {
        for(i=0;i<m_polynome.size();i++)
        {
            if(i==m_polynome.size()-1) /*Si le degré de x = 0, on affiche juste son multiplicateur*/
            {
                if(m_polynome[m_polynome.size()-1]!=1 && m_polynome[m_polynome.size()-1]!=-1)
                {
                        if(m_polynome[m_polynome.size()-1]<0) cout <<" "<<m_polynome[i];
                        else cout <<" + "<<m_polynome[i];
                }
                else if(m_polynome[m_polynome.size()-1]==1)cout <<" + 1";
                else if(m_polynome[m_polynome.size()-1]==-1)cout <<" -1";
 
            }
 
            else if(i==m_polynome.size()-2)/*Si le degré de x = 1, on n'affiche pas la ^1 */
            {
                if(m_polynome[m_polynome.size()-2]!=1 && m_polynome[m_polynome.size()-2]!=-1)
                {
                    if(m_polynome[m_polynome.size()-2]<0) cout <<" "<<m_polynome[i]<<"x";
                    else cout <<" + "<<m_polynome[i]<<"x";
                }
                else if(m_polynome[m_polynome.size()-2]==1)cout <<" + x";
                else if(m_polynome[m_polynome.size()-2]==-1)cout <<"  -x";
            }
 
            else if(i==0)
            {
                if(m_polynome[0]!=-1 && m_polynome[0]!=1 && m_polynome[0]!=0) cout <<"  "<<m_polynome[0]<<"x^"<<j;
                else if(m_polynome[0]==1) cout <<"  x^"<<j;
                else if(m_polynome[0]==-1) cout<<" -x^"<<j;
            }
 
            else
            {
                if(m_polynome[m_polynome.size()-i-1]!=-1 && m_polynome[m_polynome.size()-i]!=1) cout <<" + "<<m_polynome[i]<<"x^"<<j;
                else if(m_polynome[m_polynome.size()-i-1]==1) cout <<" + x^"<<j;
                else if(m_polynome[m_polynome.size()-i-1]==-1) cout<<" -x^"<<j;
            }
 
            j--;
        }
    }
 
}
 
/*cacul de la puissance par récursivité*/
int puissance(int x, int n)
{
    int resultat;
 
    if(n == 0)
    {
        return (resultat=1);
    }
 
    return(resultat = x * puissance(x,n-1));
}
 
int Polynome::calculPolynomePdeX( int x)
{
    int resultat(0);
    unsigned short i,j;
 
    j=m_polynome.size()-1;
 
    for(i=0;i<m_polynome.size();i++)
    {
        resultat = resultat + m_polynome[i]*puissance(x,j); /* x étant donné par l'untilisateur. On applique juste la formule P(x) = ...*/
        j--;
    }
 
    return resultat;
}
 
 
 Polynome& Polynome::calculDerivee( Polynome p)
{
    unsigned short i,j;
 
    j=m_polynome.size()-1;
 
    for(i=0;i<m_polynome.size();i++)
    {
        p.m_polynome.push_back(0);
        p.m_polynome[i]= j * m_polynome[i];
 
        if(i == m_polynome.size()-1)
        {
            p.m_polynome.pop_back();
        }
 
        j--;
    }
 
    return p;
}
 
/*
Polynome& Polynome::calculPrimitive()
{
    unsigned short i,j;
 
    j=m_polynome.size()-1;
 
    for(i=0;i<m_polynome.size();i++)
    {
        m_polynomePrimitive.push_back(0);
        m_polynomePrimitive[i]= j * m_polynome[i]/(j+1);
 
        if(i == m_polynome.size()-1)
        {
            m_polynomePrimitive.pop_back();
        }
 
        j--;
    }
 
    for(i=0;i<m_polynomePrimitive.size();i++)
    {
       cout <<m_polynomePrimitive[i];
    }
 
    return Polynome p;
}
 
Polynome& Polynome::calculDerivee()
 {
 
    return 0;
 }

le header

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
 
#ifndef POLYNOMES_H_INCLUDED
#define POLYNOMES_H_INCLUDED
#include <vector>
 
//typedef unsigned short Degre
 
class Polynome
{
    public:
        Polynome();
        void ecrirePolynome();
        void reinitializationPolynome();
        void inversionPolynome();
        void afficherPolynomeInverser();
        int  calculPolynomePdeX( int x );
        Polynome& calculDerivee( Polynome p);
        Polynome& calculPrimitive();
    private:
        std::vector<int> m_polynome;
 
};
 
 
#endif // POLYNOMES_H_INCLUDED

Citation:

Envoyé par leternel

D'ailleurs, il y a du gaspillage, parce qu'un vecteur (certes vide) est construit avant d'être remplacé par celui de la classe.

Un autre gros gaspillage potentiel (plus une remarque de design),
Quand est-ce que tu calcules la dérivée ?
Le calcul d'une dérivée te demande d'itérer sur tout le vecteur, certe ca se fait en O(n) mais si n est grand c'est le genre d'opération que tu n'as envie de faire qu'une seule fois.
Donc au niveau design, ca te demande de ne calculer la dérivée que si on te demande la dérivée et que celle-ci n'a pas encore été calculée. (Et d'ailleurs je te donne le même conseil si tu dois travailler sur des valeurs statistiques)
Voilà comment je ferais
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Class Polynome { public: std::vector<int> GetDerivative() { if (! m_derivative.IsCached()) ComputeDerivative return m_derivative.get(); } [...] private: ComputeDerivative() mutable Cached<std::vector<int> > m_derivative }
avec
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template<class T> class Cached { public: [...] bool IsCached(); T& get(); void SetCached() void SetNotCached() private T content; bool valid }
C'est simplement un moyen d'éviter de travailler avec des pointeurs NULL pour vérifier si une valeur est valide.
Il est possible que C++11/14 ou boost offre des méchanisme plus pratique.

Généralement dès que tu as besoin du résultats d'opérations mathématiques sur un vecteur de taille N, c'est rentable d'utiliser un méchanisme de cache (Si N est grand devant la taille de ta mémoire, dans ce cas là tu ne peux simplement pas te permettre de stocker l'objet mais ca ne semble pas être ton cas)

03/09/2014, 12h09
ternel

Ta console qui se ferme, c'est parce que tu n'as pas configuré ton EDI (visual ou code::blocs) pour laisser la console ouverte en fin d'exécution.

Un problème mémoire, tu aurais probablement un gros message de type "SEGFAULT"

enfaite le constructeur me dit que reference to local variable "p" returned

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
 
 Polynome& Polynome::calculDerivee(Polynome p)
{
 
    unsigned short i,j;
 
    j=m_polynome.size()-1;
 
    for(i=0;i<m_polynome.size();i++)
    {
        p.m_polynome.push_back(0);
        p.m_polynome[i]= j * m_polynome[i];
 
        if(i == m_polynome.size()-1)
        {
            p.m_polynome.pop_back();
        }
        j--;
    }
 
            for(i=0;i<m_polynome.size();i++)
        {
            cout<<p.m_polynome[i];
        }
 
    return p;
}

03/09/2014, 13h52
ternel
Ta fonction se résume à polynome& f(polynome p) {return p;}.
L'argument est pris par valeur. Donc p est une variable locale copie de l'argument donné à l'appel.
Et tu retourne une référence sur p.

C'est dommage, parce que p cesse d'exister à la fin de l'appel, laissant la référence retournée sans rien au bout (dangling reference)

Les solutions possibles sont:
- ne pas retourner de référence.
- prendre une référence en entrée.
C'est à dire T fonction(T that) {return that;} ou T& fonction(T& that) {return that;}.

Par ailleurs, je trouve bizarre cette signature de fonction.

Si tu veux une remplacer le contenu d'un polynome pour être la dérivée d'un autre, ca veut dire que le polynome cible préexiste.
Cela sous-entend qu'il avait soit une valeur significative que tu détruits au passage, soit qu'il avait une "non-valeur".
Dans les deux cas c'est dommage.

Personnellement, je vois deux choix:
- une fonction d'auto dérivation, qui modifie le polynome this: polynome& derivate_inplace() {...; return *this;}.
- une fonction créant un nouveau polynome, sans changer this: polynome derivate() const {polynome p; ...; return p;}.
03/09/2014, 14h00
Onelove

Merci pour vos aides !

Cordialement
03/09/2014, 14h03
foetus
Citation:
Envoyé par leternel

Les solutions possibles sont:

ne pas retourner de référence.
prendre une référence en entrée.
Si je ne dis pas de bêtises :wow: il y a une 3ième possibilité: la référence constante const polynome& p1 = f(p);.
03/09/2014, 14h33
koala01
Salut,

Citation:

Envoyé par foetus

Si je ne dis pas de bêtises :wow: il y a une 3ième possibilité: la référence constante const polynome& p1 = f(p);.

Malheureusement, tu en dis une...

Le seul cas où tu peux te permettre de renvoyer une référence, qu'elle soit constante ou non, c'est si la variable renvoyée existe déjà avant l'appel de la fonction, car tout objet créé dans le corps de la fonction est automatiquement détruit lorsque l'on sort de celle-ci, sauf s'il est renvoyé (par valeur).

Géléralement on explique les choses avec un code proche de
Code:

1 2 3 4 void foo(){ Type t; /* ... */ }//t est détruit ici
pour expliquer que la variable t est détruite lorsque l'on quitte la portée dans laquelle elle est déclarée. C'est juste dans le sens où la portée dans laquelle une variable est déclarée correspond à l'accolade fermante du bloc d'instructions qui contient la déclaration de la variable. Mais cela peut laisser -- à tord -- penser que, si l'on renvoie une référence (constante ou non) sur la variable, il n'y aura aucun problème, vu que l'instruction return apparait avant l'accolade fermante.

Or, le fait est que l'explication complète est qu'une variable (déclarée sur la pile) est automatiquement détruite lorsque l'on quitte la portée dans laquelle elle est déclarée, à moins qu'elle ne soit renvoyée par valeur. La raison pour laquelle on quitte cette portée n'a absolument rien à voir avec cette règle simple : que ce soit parce que le flux d'exécution atteint l'accolade fermante de la portée ou qu'une instruction return (ou autre, comme continue) nous fait quitter cette portée ne changera rien au fait que la variable sera automatiquement détruite parce que l'on sort de la portée dans laquelle elle a été déclarée ;)
03/09/2014, 14h58
ternel

Par contre, tu peux retourner une référence prise en argument. Qu'elle soit constante ou non.

Et que le code appelant prenne une copie ou une référence sur le retourné ne change rien non plus.
03/09/2014, 15h11
foetus
Je pensais à ce post de Herb Sutter

Une référence constante étend la durée de vie d'un temporaire ... mais ce n'est pas un retour par référence
Code:

1 2 3 4 5 6 string f() { return "abc"; } void g() { const string& s = f(); cout << s << endl; // can we still use the "temporary" object? }

en fait, ce n'est pas pareil.
Il y a théoriquement deux temporaires.

Regardons le flux réel du code de foetus:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 appel de g() ouverture du scope de g(). évaluation de const string& s = f(); appel de f() pas de création d'argument ouverture du scope de f. obtention du littéral "abc"; création de std::string temporaire (via son constructeur string(const char*)) mise sur la stack d une valeur créée par copie. (*) fermeture du scope de f() destruction de la temporaire création de référence de string constante, initialisée sur (*) la valeur de retour magie du C++, (*) est maintenue en vie. cout << s << endl; //j'abbrège, c'est hors de propos fermeture du scope de g() destruction de s destruction de (*)
je crois qu'il y a des optimisations internes de compilateur (NVRO et variantes, si mes souvenirs sont bons) pour ne pas créer la temporaire de string et la copier juste derrière.