repérer la procédure qui s'est branchée sur la function

Bonjour
Je m'explique
J'ai une function, par ex...

Code:

---

1 2 3 4 5

Function mafonction:boolean; begin bla bla bla... result:=true; end;

---

et plusieurs procédures qui font appel à cette function...

Code:

---

1 2 3 4 5

procedure maprocedure1; begin if mafonction then bla bla bla... end;

---

Code:

---

1 2 3 4 5

procedure maprocedure2; begin if not mafonction then bla bla bla... end;

---

Y a t-il un moyen de repérer, au moment de l'exécution de mafonction, la procédure qui l'a appelée: dans mon ex, maprocedure1 ou maprocedure2 ?

Et donc d'y mettre du code à exécuter qui dépendrait de la procédure appelante...

Merci :mrgreen:

Par définition une fonction sert à factoriser un traitement afin de l'appeler dans d'autres traitements.

Citation:

---

Envoyé par OutOfRange

Et donc d'y mettre du code à exécuter qui dépendrait de la procédure appelante...

---

Je te propose une approche sensiblement différente, en partant du principe que tu désires associer à ta fonction un traitement différent selon la procédure appelante.

On peut considérer que ta fonction n'est rien d'autre qu'un paramètre que tu passes à tes procédures.

Commence alors par déclarer ton prototype de fonction.

Par exemple :

Code:

---

1 2 3

type TMaFonction = function(x: integer):integer;

---

puis ta ou tes procédures qui possèderont un paramètre de type TMaFonction :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

procedure proc1(maFonction: TMaFonction; param: integer); begin showMessage(intToStr(maFonction(param))); end; // ou encore procedure proc2(maFonction: TMaFonction; param: integer); begin showMessage(intToStr(2*maFonction(param+1))); end;

---

ensuite tu crées toutes les fonctions que tu désires ayant pour prototype TMaFonction, par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

function carre(x: integer):integer; begin Result := x*x; end; // ou encore function double(x: integer):integer; begin Result := 2*x; end;

---

pour terminer tu peux associer ta fonction et ta procédure appelante. Dans cet exemple on utilise qu'une seule des deux procédures mais le principe est là.

utilisation :

Code:

---

1 2 3

proc1(carre,5); // va effectuer 5*5 soit 25 puis l'afficher

---

Code:

---

1 2 3

proc1(double,5); // va effectuer 2*5 soit 10 puis l'afficher

---

Tu peux encore compliquer le principe:

Code:

---

1 2 3 4 5 6 7

procedure proc3(maFonction1,maFonction2: TMaFonction; param: integer); begin if param mod 2 = 0 then showMessage(intToStr(maFonction1(param))) else showMessage(intToStr(maFonction2(2*param))) end;

---

à l'execution tu verras que :
proc3(carre,double,5);
et
proc3(double,carre,5);

donnent des résultats complétement différents.

Ce principe n'est pas très éloigné de la notion de programmation événementielle avec Delphi.
En effet, le prototype le plus basic d'un événement est TNotifyEvent soit :

Code:

---

1 2	TNotifyEvent = procedure(Sender: TObject) of object;

---

Il suffit alors de le déclarer ainsi dans une classe :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

TmaClasse = class private FmonEvent: TNotifyEvent; public property monEvent:TNotifyEvent read FmonEvent write FmonEvent; procedure doMonEvent(Sender: TObject); procedure proc3(Sender: TObject); procedure proc4(Sender: TObject); end;

---

Code:

---

1 2 3 4 5 6

procedure TmaClasse.doMonEvent(Sender: TObject); begin if assigned(FmonEvent) then FmonEvent(Self); end;

---

Tu peux ensuite déclarer des comportements différents respectant le prototype TNotifyEvent :

Code:

---

1 2 3 4 5 6 7 8 9 10

procedure TmaClasse.proc3(Sender: TObject); begin //un traitement end; procedure TmaClasse.proc4(Sender: TObject); begin //un autre traitement end;

---

et finalement assigner selon tes besoins l'événement de la façon suivante:

Code:

---

1 2 3 4 5 6

maClasse.monEvent := maClasse.proc3; //ou encore maClasse.monEvent := maClasse.proc4; //ou encore maClasse.monEvent := nil; // ne fait rien

---

ce qui aura pour conséquence de donner un comportement différent chaque fois que tu appelleras doMonEvent(Sender)

En espérant répondre à ta question.
Cordialement

Alors là, Pascal j'applaudi avec enthousiasme :P

Je la taggue FAQ celle-ci :P

:oops:

Ouah ! Super intéressant ! Vraiment !
Ca devrait pouvoir me servir aussi je pense...
Merci :D

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

function MAfonct(t:Integer):Boolean begin case t of 1:result:=.....; 2:result:=.....; 3:result:=.....; .... end; end; Procedure j1; begin if mafonct(1) then end; Procedure j2; begin if mafonct(2) then end; Procedure j3; begin if mafonct(3) then end;

---

par example , plus simple, non??? :?

Citation:

---

Envoyé par edam

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

function MAfonct(t:Integer):Boolean begin case t of 1:result:=.....; 2:result:=.....; 3:result:=.....; .... end; end; Procedure j1; begin if mafonct(1) then end; Procedure j2; begin if mafonct(2) then end; Procedure j3; begin if mafonct(3) then end;

---

par example , plus simple, non??? :?

---

Ha oui, c'est bien, ça aussi...;)

pour pascal je pance qu'on a déjà une début d'idée ici; http://delphi.developpez.com/faq/?pa...ajoutevenement
non???:oops:

Citation:

---

Envoyé par edam

pour pascal je pance qu'on a déjà une début d'idée ici; http://delphi.developpez.com/faq/?pa...ajoutevenement
non???:oops:

---

Exactement, Nono a décrit dans cette Question/Réponse (QR) une façon de modifier rapidement un événement. Cela revient exactement à ce qui est exposé ci-dessus. Manipuler les propriétés et les événements avec Delphi permet de produire un code assez propre et facilement maintenable. C'est d'ailleurs tout ce qui fait la force de Delphi.

En ce qui concerne la solution que tu exposes ci-dessus, elle est opérationnelle. Par contre, elle me dérange quelque peu car tout repose sur l'unique fonction Mafonct. Si de nombreux traitements différents sont à envisager, le code devient rapidement lourd et difficle à lire par conséquent un casse tête pour l'entretenir et aussi pour le réutiliser. ;)

Cordialement

Citation:

---

Envoyé par Pascal Jankowski

Si de nombreux traitements différents sont à envisager, le code devient rapidement lourd et difficle à lire par conséquent un casse tête pour l'entretenir et aussi pour le réutiliser. ;)

Cordialement

---

alors en doit passer par autre chose, car votre méthode est pour des événements différents et pas pour des traitements différents, pas vrai??
il y a une solution que j'ai oublié,, se base sur la même chose que créer des (*,+,-,/) de delphi,, c'est les traces que ma mémoire garde :lol:

Citation:

---

Envoyé par edam

car votre méthode est pour des evenemnt différent pas pour des traitment différent,, pas vrai??

---

La première partie du post, qui éventuellement devrait apporter une solution à notre tiers ne concerne que des "traitements". Cette particularité est apparue avec la version 5 de turbo Pascal avant même la première version objet de TP si mes souvenirs sont bons.

J'ai simplement spécifié dans la suite de mon post que la mise en oeuvre ressemble pour certains points à celle de la gestion des événements. Soit encore, on retrouve une certaine analogie, mais ce n'est pas du tout la même chose.

Citation:

---

Envoyé par edam

alors en doit passé par autre chose, car votre méthode est pour des evenemnt différent pas pour des traitment différent,, pas vrai??

---

je retir ce que j'ai dis :aie: :scarymov:

Citation:

---

Envoyé par edam

il y a une solution que j'ai oublié,, se base sur la meme chose que crée des (*,+,-,/) de delphi,, c'est les trasse que ma mémoir garde :lol:

---

et là si tu as une petit rapel tu le peut, il y a pas longtemps un des modérateur à expliqué cette méthode ,,,:koi:

Citation:

---

Envoyé par Edam

il y a une solution que j'ai oublié,, se base sur la meme chose que crée des (*,+,-,/) de delphi,, c'est les trasse que ma mémoir garde

---

Je veux bien expliquer cela mais donne moi plus de précisions car j'avoue que je ne vois pas ce que tu veux dire.

delphi implémente les fonction (+,-,*,...) comment???
alors sa revient??? :roll:

Bonjour
Pour Pascal Jankowski...
Admettons que je crée les fonctions et procédures comme tu me le proposes
Si dans mon code j'ai

Code:

---

proc1(carre,5);

---

et plus loin

Code:

---

proc2(carre,5)

---

Je ne vois pas comment savoir, au moment de l'exécution de

Code:

---

1 2 3 4

function carre(x: integer):integer; begin Result := x*x; end;

---

si c'est proc1 ou proc2 qui est la procédure appelante
Et c'est bien là mon souci :(
N'aurais-je pas tout compris ?
Ceci dit, ta démonstration est très intéressante
Et c'est toujours agréable de voir qu'une question parfois très simple peut susciter intérêt, voire passion chez les maîtres pascaliens (je n'en fais malheureusement pas partie :cry: )
Merci donc

Pour edam
J'avais bien pensé à une solution via un paramètre passé à la function, mais ça ne me paraissait pas intellectuellement satisfaisant...

à suivre...

oubli proc2 et proc3 il sont ici poue example de plus

Citation:

---

Envoyé par edam

alors en doit passé par autre chose, car votre méthode est pour des evenemnt différent pas pour des traitment différent,, pas vrai??
il y a une solution que j'ai oublié,, se base sur la meme chose que crée des (*,+,-,/) de delphi,, c'est les trasse que ma mémoir garde :lol:

---

La déclaration d'opérateurs ?

C'est en C++ça, en Delphi il ne me semble pas que cela fonctionne...

Citation:

---

edam a écrit :
oubli proc2 et proc3 il sont ici poue example de plus

---

Mais non je ne veux pas les oublier...
C'est le coeur de mon pb :aie:

Citation:

---

Envoyé par OutOfRange

Je ne vois pas comment savoir, au moment de l'exécution de

Code:

---

1 2 3 4

function carre(x: integer):integer; begin Result := x*x; end;

---

si c'est proc1 ou proc2 qui est la procédure appelante
Et c'est bien là mon souci
N'aurais-je pas tout compris ?

---

Si.
Sous dotNET on peut utiliser les attributs, mais nous sommes en Win32 (désolé j'ai pas pu m'en empêcher).
Donc de connaitre l'appelant sans donner d'autres informations à l'appelé, cela ne vas pas être facile !
La procédure appelant sait-elle déjà répondre à la question qui suis-je, avant de pouvoir répondre à la question qui m'appelle ?

J'ai pu dernièrement regarder rapidement le produit EurekaLog, ce qui me fait dire qu'à part ajouter des traitements liés au parcours de la pile d'appel je ne vois pas comment retrouver ces infos. Mais je n'ai pas la science infûse...

ps :
Avec l'approche procédurale on ne peut pas faire plus que ce que Pascal à proposé mais il reste l'approche objet...
Mais dans ce cas l'énoncé du pb est peut être différent.
En attendant je n'ai pas de réponse à proposer :?

Effectivement, je ne réponds pas à ton problème et j'ai bien peur de ne pas avoir de solution élégante à te proposer. C'est vrai qu'au niveau procédurale on ne peut pas faire beaucoup plus à moins que certaines petites choses m'aient échapé (avis aux traits de génis si souvent rencontrés sur dvp).

Comme le dit Laurent, il faut peut-être reconsidérer le problème dans ce cas précis ie dans une approche objet certainement.

Cordialement
Pascal