Discussion :

[membreComplexe12]

Salut tous,

je suis débutant en C++ (je n'ai jamais eu de cours dessus) et je l'utilise donc de façon basique mais j'essai petit à petit de m'améliorer.
En ce moment j'essai d'utiliser des pointeurs sur fonctions et de les échanger entre mes classes.

grâce à ce tuto trouvé sur un autre site, j'ai pu commencer à faire quelque chose :

=> mais par contre, comme je pars de très loin, j'ai encore pas mal de difficultés à comprendre et à l'appliquer, et encore pire dans mon cas réel où il y a plusieurs classes en jeu

J'ai fais ci dessous un projet qui ressemble exactement à ce que je veux faire réellement
=> mais bien entendu la manière de faire est pas la bonne, ça ne marche pas du tout...

=> pourriez vous s'il vous plait me dire ce qui ne vas pas ?

Voici ce que j'ai fais :
main.cpp

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
#include <iostream>
#include <string>
#include "dataClass.h"
#include "calculation.h"
using namespace std;
int main() {
    //je remplis un vecteur avec les chiffres 1 et 2
    int nombreDeChiffres=2;
    DataClass dataClass;
    dataClass.remplissage(nombreDeChiffres);
    //dans mon autre classe je vais récupérer les nombres et les appeler dans un algo de resolution
    //et c'est là que je vais utiliser un pointeur sur fonction
    Calculation calculation;
    calculation.monCalcul(dataClass);
    return 0;
}

dataClass.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef DATACLASS_H
#define DATACLASS_H
#include <vector>
class DataClass
{
public:
    DataClass();
    ~DataClass();
    void remplissage(int const &quantite);
    std::vector<double> getNombres();
private:
    std::vector<double> mesNombres;
};
#endif // DATACLASS_H

dataClass.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <iostream>
#include <vector>
#include "dataClass.h"
using namespace std;
DataClass::DataClass() {mesNombres.clear();}
DataClass::~DataClass() {}
void DataClass::remplissage(int const &quantite)
{
    for (int i=0;i<quantite;i++){   mesNombres.push_back(i+1);    }
}
 
vector<double> DataClass::getNombres() {return mesNombres;}

calculation.h

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
#ifndef CALCULATION_H
#define CALCULATION_H
#include "dataClass.h"
#include "fonction.h"
class Calculation
{
public:
    Calculation();
    ~Calculation();
    void monCalcul(DataClass &objetData);
    double fonctionQuiestPointee(double x);
private:
    Fonction fonction;
    double resultat;
};
#endif // CALCULATION_H

calculation.cpp

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
#include <iostream>
#include <vector>
#include "calculation.h"
#include "dataClass.h"
using namespace std;
Calculation::Calculation() {}
Calculation::~Calculation() {}
 
typedef double (*pointeur)(double);
void Calculation::monCalcul(DataClass &objetData)
{   //mes 2 donnees que j'ai recupérés ailleurs
    vector<double> variablesEntree=objetData.getNombres();
    //definition de mon pointeur
    double (*pointeurSurFonction)(double);                /*déclaration du pointeur*/
    pointeurSurFonction = fonctionQuiestPointee;          /*Initialisation*/
    //appel de ma fonction de calcul qui utilisera ce pointeur
 resultat=fonction.additionBizarre(variablesEntree,fonctionQuiestPointee);
}
double Calculation::fonctionQuiestPointee(double x) {return x*2;}

fonction.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef FONCTION_H
#define FONCTION_H
#include <vector>
#include "calculation.h"
class Fonction
{
public:
    Fonction();
    ~Fonction();
    double additionBizarre(std::vector<double>,pointeur ptr);
private:
};
#endif // FONCTION_H

fonction.cpp

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
#include <iostream>
#include "fonction.h"
#include <vector>
using namespace std;
Fonction::Fonction() {}
Fonction::~Fonction() {}
double Fonction::additionBizarre(vector<double>coeff,pointeur ptr)
{   
    double resultatFinal=0;
    //appel de mon pointeur
    double resultat1Fonction = (*ptr)(coeff[0]);
    double resultat2Fonction = (*ptr)(coeff[1]);
    //resultat final
    resultatFinal=coeff[0]*resultat1Fonction+coeff[1]*resultat2Fonction;
    //sortie
    return resultatFinal;
}

Comme vous pouvez le voir j'ai deux soucis :
1°) comment définir proprement mon pointeur sur fonction
2°) comment le renvoyer à des methodes d'autres classes ...

pourriez vous me dire comment modifier cet exemple type pour qu'il fonction ?

je vous remercie d'avance !

[gbdivers]

Bonjour

Pour le problème directement posé : FAQ C++ Pourquoi ne peut-on pas passer une fonction membre là où on attend un pointeur de fonction ?

Pour répondre aux autres questions que tu ne poses pas :

Est-ce qu'il est recommandé d'utiliser les pointeurs de fonction en C++ ?
Non, faire une recherche sur le forum pour le pourquoi détaillé (pas de vérification de la signature des fonction à la compilation).
Plus généralement, n'utilise pas de pointeur nu en ++ si tu débutes

Existe-t-il des alternatives plus propres aux pointeurs de fonction ?
Oui, plein.
Cela va du design pattern Stratégie (lire Présentation des principaux design patterns en C++) à l'utilisation des foncteurs, des objets fonction, des lambdas ou de bind (C++11)

A toi de voir si tu utilises le C++11 et ce que tu préfères comme syntaxe

[membreComplexe12]

merci beaucoup de ta réponse !

j'ai regardé les foncteurs mais ça à l'air super hard !!!

tu aurais pas un exemple simple pour m'illustrer ceci ?

[gbdivers]

FAQ + foncteur de donne : Qu'est-ce qu'un foncteur ?
C'est juste une classe avec l'opérateur ()

[Médinoc]

Évidemment, ça veut dire qu'on se retrouve à écrire des fonctions template juste pour pouvoir accepter le foncteur.

Est-ce qu'il est recommandé d'utiliser les pointeurs de fonction en C++ ?
Non, faire une recherche sur le forum pour le pourquoi détaillé (pas de vérification de la signature des fonction à la compilation).

Ça, c'est archi-faux, sauf dans le cas signalé dans ma signature.

Par contre, en C++, on préfère utiliser le polymorphisme par héritage et redéfinition de fonctions, sauf quand on ne veut pas écrire une nouvelle classe par fonction.