Discussion :

[GraaaL]

Bonjour à tous,
Je développe actuellement mon premier projet en C++. J'ai étudié ce langage en cours, mais rien de très sérieux, toujours deux ou trois classes maximum pour comprendre les concepts de base... J'ai donc simplement quelques notions de programmation orientée objet.

Et aujourd'hui, je dois avouer que certains points me semblent un peu flous, j'ai du mal à concevoir et à articuler mon programme autour des classes. Je m'explique :

Le projet part de zéro, aucun développement n'a été fait au préalable. Le point de départ est de définir un problème mathématique, un ensemble de fonctions (1), qui seront utilisées par mon programme principal. L'utilisateur donne alors les dimensions du problème, et fait quelques choix. On doit ensuite discrétiser le résultat de ces fonctions sur un intervalle donné (créer des vecteurs (2) contenant la valeur de chaque fonction en un certain nombre de points). Puis ces vecteurs sont exploités par d'autres fonctions (3) pour calculer des intégrales ou des dérivées (au sens "discret"). L'utilisateur peut choisir parmi plusieurs méthodes d'intégration (4)...

Je souhaiterais créer un grand ensemble "Probleme" regroupant :
- les fonctions continues et les dimensions (1)
- les vecteurs (2) de résultats discrétisés, et les fonctions qui discrétisent le problème
- les fonctions (3) utilisant les vecteurs (2)
- les différentes méthodes d'intégration (4)

J'ai pris l'exemple de la discrétisation, mais en réalité, l'utilisateur aura plusieurs choix à faire, pour différentes options.

Pour le moment, j'ai créé une grande classe "problème", qui possède toutes les fonctions, mais celles-ci sont en dur (pas de choix de discrétisation possible) pour une discrétisation simple... Je commence à douter de l'utilité des classes pour ce projet, je ne vois pas où les bénéfices qu'elles apportent pourraient m'être utiles.

Je souhaiterais que la méthode de discrétisation apparaisse sous la forme d'une fonction "discretisation" dont le contenu (et le nombre de variables d'entrée) varierait selon le choix de méthode fait par l'utiilisateur...
En gros le choix de la discrétisation va également intervenir dans les fonctions (3), qui appellent la fonction de discrétisation. On pourrait imaginer un simple switch, à chaque fois que la fonction de discrétisation est appelée, selon le choix fait par l'utilisateur, on appelle l'une ou l'autre fonction... Cependant, ce switch serait évalué très fréquemment, ce qui ne me parait pas optimal. Je ne vois donc pas comment organiser mon programme.

Mes deux questions donc :
- Les classes peuvent-elles m'aider?
- Comment faire pour gérer les choix de l'utilisateur?

J'espère que je suis à peu près clair, c'est pas facile à expliquer...
Merci d'avance à tous pour vos réponses

[dragonjoker59]

As-tu pensé à l'héritage et au polymorphisme ? J'ai l'impression que ça pourrait correspondre à ta recherche.

[JolyLoic]

Par exemple, pour la méthode d'intégration, tu peux définir une classe de base abstraite qui présente juste l'interface utilisateur nécessaire pour intégrer numériquement, puis toute une série de classe dérivées, qui implémentent chacune une méthode d'intégration.

Ta classe Problème contiendrait alors un pointeur sur une méthode d'intégration, qui pourrait à un instant particulier pointer sur du RK4, par exemple.

C'est ce qu'on appelle le design pattern Strategy.

De même, il pourrait y avoir plusieurs façons de représenter tes fonctions (par exemple une fonction, et les dérivées sont calculées discrètement, ou bien deux fonctions, et les dérivées sont calculées en exécutant la seconde fonction). Si cette dimension de variabilité t'intéresse, c'est encore une fois l'occasion de mettre en œuvre le pattern Strategy.

[GraaaL]

Bonjour,
Merci à tous les deux pour vos réponses, ça m'aide bien!
J'ai regardé le concept du design pattern Strategy, ça semble très adapté à ce que je veux faire en effet! Par contre, est-il possible de faire ça sans pointeur de fonctions? L'exemple donné sur Wikipedia n'utilise pas de pointeurs... (Wiki : Strategy)

As-tu pensé à l'héritage et au polymorphisme ? J'ai l'impression que ça pourrait correspondre à ta recherche.

Concernant le polymorphisme, j'avais imaginé une telle solution, mais ça me semble moins clair. La fonction "intégration" par exemple, aurait plusieurs définitions selon le type de ses arguments. Le problème, c'est que je peux avoir deux méthodes d'intégration avec exactement les mêmes paramètres en entrée et en sortie, donc je ne pense pas que le polymorphisme soit adapté... Pour l'héritage, est-ce que tu penses au même type d'implémentation que le design pattern Strategy, ou est-ce qu'il peut y avoir d'autres solutions?

[dragonjoker59]

Pour l'héritage, j'y pensais en le couplant au polymorphisme, mais effectivement, si tes fonctions n'ont pas toujours le même nombre de paramètres ni le même type de retour, ça ne correspond pas vraiment à ce que tu recherches.

[pyros]

Tu peux peut être utiliser des foncteur pour modéliser tes fonction. Un foncteur est une classe possédant un operator(). Par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Class Sum{
 
  float operator(std::vector<float> list){
     float res = 0;
     for( int i = 0; i < list.size(); ++i)
       res += list[i]
     return res;
  }
}

Tu peux l'utiliser de la manière suivante:

Code :

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

1
2
3
 
Sum s;
float a = s(maList);

Ainsi, tu peux imaginer une classe mère Integral avec un operator() virtuel, et des classes filles IntegralRectangle, IntegralTrapeze, etc... qui implémentent l'operator() selon algorithme voulu.

Comme les foncteurs sont des objets comme les autres, tu peux les passer en paramètre d'autre fonction, sans passer par des pointeurs de fonctions.