Discussion :

[OutOfRange]

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

Code :

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

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 :

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

1
2
3
4
5
procedure maprocedure1;
begin
if mafonction then
bla bla bla...
end;

Code :

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

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

[Pascal Jankowski]

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

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 :

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

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 :

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

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 :

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

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 :

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

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

Code :

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

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

Tu peux encore compliquer le principe:

Code :

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

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 :

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

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

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

Code :

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

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 :

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

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 :

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

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 :

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

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

[LadyWasky]

Alors là, Pascal j'applaudi avec enthousiasme

Je la taggue FAQ celle-ci

[Pascal Jankowski]

[ryko]

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

[edam]

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
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???