Surcharge de fonction virtuelle pure

Version imprimable

Bonjour à tous

Aller, tout de suite, un petit ECM, pour présenter le problème, que je commente ensuite:
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 #include <iostream> #include <string> #include <vector> #include <math.h> #include <cassert> class FitFonction { /// classe abstraite public: /// Accesseurs std::vector<double> getParams() const { return _params; }; int getNbParams() const { return _params.size(); }; double get( int i ) const { return _params[i]; }; /// Setters void setParams(const std::vector<double>& param){ assert(param.size()==_params.size()); _params=param; }; /// Pour evaluer la fonction virtual double eval(double x) const=0; // le "= 0" à la fin indique que c'est une fonction virtuelle pure std::vector<double> eval(const std::vector<double>& x) const { /// <----- ici je surcharge la fonction eval std::vector<double> res(x.size(),0.0); for (int i=0;i<x.size();i++) res[i]=eval(x[i]); return res; }; protected: std::vector<double> _params; }; class Gaussienne : public FitFonction { /// 1 Gaussienne = 3 paramètres public: Gaussienne(double h, double c, double e){ _params.resize(3); _params[0]=h; _params[1]=c; _params[2]=e; }; double eval(double x) const {return _params[0]*exp(pow((x-_params[1])/_params[2],2.0));}; }; int main( int argc, char* argv[] ){ Gaussienne fct(1.3,2.0,5.3); std::vector<double> xx(7,0.2),yy(7); //yy=fct.eval(xx); std::cout << "Hello World !" << std::endl; }
Je créé une classe FitFonction, qui va donc regrouper plusieurs type de fonction mathématique de base.
Ces fonctions de bases dépendent de paramètres (que je met en attribut de classe).
Quelquesoit la fonction mathématique, je vais avoir envie de l'évaluer, en un point ou en un vecteur de points.
Je créer donc la méthode "virtual double eval(double)" en virtuelle pure, car elle dépendra de ma fonction mathématique (dans l'exemple j'ai pris une gaussienne, mais on pourrait très bien y ajouter des fonctions affines, logarithmiques, etc...).
Je définis ensuite ma méthode d'évaluation dans ma classe fille Gaussienne.
Jusque là tout va bien.

Maintenant, je vais souvent avoir besoin d'évaluer, non pas un seul point, mais un vecteur de point.
Je veux donc surcharger ma fonction eval: "std::vector<double> eval( const std::vector<double>& )".
Et c'est ce que j'essaie de faire ligne 19 à 23, mais il semble que ca ne marche pas ...
Dans le main, je veux pouvoir décommenter la ligne 40. Si je le fais je me fais insulter par le compilo :

Citation:

test.cxx:91:15: error: no viable conversion from 'std::vector<double>' to 'double'
yy=fct.eval(xx);
^~

Merci pour votre aide.

06/11/2014, 18h06
Médinoc

Il est possible que la redéfinition d'une des fonctions cache ses surcharges.
Peut-être qu'un using dans la classe dérivée pourrait aider?
06/11/2014, 19h00
bacelar
Comme je pense que la seconde méthode eval n'a strictement rien à faire dans la classe, je serai partisan d'une fonction libre, d'une lambda expression ou d'une méthode statique.
Code:

1 2 std::transform(v.begin(), v.end(), v.begin(),[](double d) {fct.eval(d);});
06/11/2014, 20h27
JolyLoic

Une autre version, respectant le NVI (non virtual interface) : Tu rends tes deux fonctions eval non virtuelles, et tu les fait utiliser une fonction privée virtuelle pure doEval.

Alors pour répondre à vos propositions dans l'ordre :

@Médinoc: J'ai essayé plusieurs choses à base de "using" dans la classe Gaussienne, en vain.
Cela dit en lui disant explicitement de reprendre la fonction de la classe mère ca se passe bien :

Code:

1
2
3
4
5
class Gaussienne : public FitFonction {
public:
// ...
std::vector<double> eval(const std::vector<double>& x) const { return FitFonction::eval(x); };
};

@bacelar : Effectivement, on pourrait externaliser la méthode. J'ai donc penser à ceci :

Code:

1
2
3
4
5
6
7
std::vector<double> feval(const FitFonction& fct, const std::vector<double>& x){
		std::vector<double> y(x);
		//std::transform(y.begin(), y.end(), y.begin(),[](double d) {fct.eval(d);});
		//std::transform(y.begin(), y.end(), y.begin(), fct.eval );
		for (int i=0;i<y.size();i++) y[i]=fct.eval(x[i]); 	
		return y;
}

J'ai procédé avec un "for" car les essais commentés avec std::tranform ne compile pas...

@JolyLoic : Pas mal cette idée, en créant juste une indirection, on peut ainsi s'en sortir :

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
class FitFonction { /// classe abstraite
public:
    /// Accesseurs
    std::vector<double> getParams() const { return _params; };
    int getNbParams() const { return _params.size(); };
    double get( int i ) const { return _params[i]; };
 
    /// Setters
    void setParams(const std::vector<double>& param){ assert(param.size()==_params.size()); _params=param; }; 
 
    /// Pour evaluer la fonction     
    double eval(double x) const { return doEval(x);  }
    std::vector<double> eval(const std::vector<double>& x) const {
    		std::vector<double> res(x.size(),0.0);
    		for (int i=0;i<x.size();i++) res[i]=doEval(x[i]); 
    		return res; 
    };
protected:
		virtual double doEval(double x) const=0;
 
		std::vector<double> _params;
};
 
class Gaussienne : public FitFonction { /// 1 Gaussienne = 3 paramètres
public:
		Gaussienne(double h, double c, double e){ _params.resize(3);
				_params[0]=h; _params[1]=c; _params[2]=e; };
 
protected :
		double doEval(double x) const {return _params[0]*exp(pow((x-_params[1])/_params[2],2.0));};
};

Merci à vous pour vos solutions.
Si vous voulez réagir je laisse le topic quelque jours avant de le passer en résolu.