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 !