Discussion :

[Onelove]

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 C++ :

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

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 C++ :

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

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

merci d'avance.

[Bousk]

Salut,

quelle est la question ?
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.

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

[_zzyx_]

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 :

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

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 :

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

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)

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

[Onelove]

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

Code c++ :

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
 
 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;
}

[Onelove]

Oui dans mon source.c j'ai:

Code C++ :

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

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.

[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

[Onelove]

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 c++ :

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
 
#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 c++ :

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
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 c++ :

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