Discussion :

[touta1]

bonjour!
en pascal, est ce que je peux appeler une fonction à partir d'une autre fonction.
que vet dire: une fonction est un module paramétrable.
SVP aidez moi.
merci d'avance.

[droggo]

Xoe,

Bien sûr que c'est possible.

Pour plus d'aide, il faudra nous en dire plus, les boules de cristal ayant tendance à ne pas très bien répondre en ce moment.

[Dr.Who]

question 1:


oui on peut, a condition que la fonction appelante soit après la déclaration de la fonction à appeler.

exemple bon :

Code :

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

1
2
3
4
5
6
7
8
9
procedure A;
begin
  // quelque chose
end;
 
procedure B;
begin
  A;
end;

exemple faux :

Code :

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

1
2
3
4
5
6
7
8
9
procedure A;
begin
  B; // B n'est pas visible par A
end;
 
procedure B;
begin
  A; // A est visible par B
end;

c'est pour cela qu'il existe la directive "forward" qui permet de déclarer l'entête de la fonction avant sa declaration.

exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure B; forward;
 
procedure A;
begin
  B; // B est maintenant visible par A
end;
 
procedure B;
begin
  A; // A est toujours visible par B
end;

bien sur, l'exemple ne fonctionnera pas puisque les fonctions s'appelle de façon cyclique et finira par un débordement de pile.



question 2 : une fonction est un module paramétrable

Le mots "module" définis un bloc de code qui exécute une action. On parle de "parametrable" car une fonction accepte des arguments en entré et si l'on veux, elle peut retourner des valeurs.

exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure B(const callA: boolean); forward;
 
procedure A(const callB: boolean);
begin
  if callB then
    B(false);
end;
 
procedure B(const callA: boolean);
begin
  if callA then
    A(false);
end;

ici A et B accepte un paramètre qui permet de bloquer ou non l'appel à l'autre fonction.

quand on appel B implicitement on écrira B(true) pour que B appel A mais A n'appellera pas B pour éviter l'erreur d'appel cyclique infini.
idem pour A, ou on écrira A(true) pour que A appel B mais B n'appelera pas A.

Le fait, donc d'avoir un paramètre nous permet d'obtenir un nouveau comportement qui permet de contrôler l'exécution des deux fonctions.

dans un exemple concret A pourrait filtrer les bits pair d'une donnée et B retourner l'inverse de la donnée (not)

exemple :

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
procedure B(var D: integer; const callA: boolean); forward;
 
procedure A(var D: integer; const callB: boolean);
begin
  D := D and $AAAAAAAA;
  if callB then
    B(D, false);
end;
 
procedure B(var D: integer; const callA: boolean);
begin
  D := not D;
  if callA then
    A(D, false);
end;

nous avons maintenant 2 paramètres, l'un pour la donnée et l'autre pour le contrôle d'appel.

cela nous donne deux fonctionnement different selon si on appel A ou B en premier.

A puis B donne : not (D and $AAAAAAAA);
B puis A donne : (not D) and $AAAAAAAA;

si j'assigne à D = 0b01101010 (0x6A)

Code :

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

1
2
3
4
5
D := $6A;
A(D, true); // D = 0b11010101 (0xD5)
 
D := $6A;
B(D, true); // D = 0b10000000 (0x80)

Voila ce qu'on appel "module paramétrable" car on peut jouer, grâce a des paramètres sur le comportement des méthodes.

pour le prochain exemple, je t'invite à te mettre dans l'ambiance :
http://www.deezer.com/listen-1541631

c'est bon ?
on pourrait également supprimer A et B et donner naissance à une fonction C qui reproduirais le même comportement, mais il faudra donc ajouter un nouveau paramètres selon si on veux le résultat AB ou BA.

voici ce que cela peut donner, avec C que l'on nomera GimmeGimme pour l'occasion :

Code :

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

1
2
3
4
5
6
7
8
9
10
type
  TABBAMethode = (AB, BA);
 
procedure GimmeGimme(var D: integer; const Methode: TABBAMethode); 
begin
  case Methode of
    AB : D := not (D and $AAAAAAAA);
    BA : D := (not D) and $AAAAAAAA;
  end;
end;

cette nouvelle méthode sera d'ailleurs plus performante que A et B puisqu'on évite 2 test et 1 call. les case ABBA c'est puissant!

hahaha.