Discussion :

[micoudev]

Bonjour,
Je n'arrive pas à appeler une fonction définie dans une autre unité. Si cette fonction est dans la même unité que la procédure l'executant, pas de problème. Mais si je déplace le code de la fonction dans une autre unité, rien ne va plus (voir messages d'erreur plus bas).

Pourtant, dans le petit programme de test ci-dessous, ca fonctionne tres bien.
J'ai beau chercher partout (docs, internet), je ne trouve pas d'explication à ce problème :
Où placer la définition de la fonction, comment la codifier, y a-t-il des interdictions ?
Je teste dans tous les sens, mais rien n'y fait

Programme de test
1ere unité
==========

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
unit U_Fonction_et_unites;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, U_Fonction;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
// =====================================
procedure TForm1.Button2Click(Sender: TObject);
begin
  Label1.Caption := MEF(12345);
end;
 
// =====================================
procedure TForm1.Button1Click(Sender: TObject);
begin
  Application.Terminate;
end;
 
// =====================================
end.

2eme unité

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
23
24
unit U_Fonction;
 
interface
 
uses
  SysUtils;
 
type
  TFunction = function:String;
    function MEF(CleNum : Integer) : String;
 
implementation
 
// ======================================
function MEF(CleNum : Integer) : String;
var
CleAlpha : String;
begin
  CleAlpha := 'Clé Alpha = ' + IntToStr(Clenum);
  Result := CleAlpha;
end;
 
// =====================================
end.

Cela fonctionne parfaitement.
Mais dans des unités comportant beaucoup de procédures, j'obtiens le message :

[Erreur] SFM_DM.pas(341): Identificateur non déclaré : 'MEF_CleAlpha'
[Erreur fatale] SFM_00.pas(156): Impossible de compiler l'unité utilisée 'SFM_DM.pas'

Voici un extrait des mes deux unités :

1- La fonction, dans SFM_00 :

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
unit SFM_00;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, DB, DBTables, Menus, ComCtrls, Printers, IniFiles, idGlobal;
 
type
  TSFM00 = class(TForm)
  ...
    function MEF_CleAlpha(WClenum: Integer): String;    
    { Que je laisse cette instruction ou non, cela ne change rien }
  ...
    procedure Quitter1Click(Sender: TObject);
  ... 
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  SFM00: TSFM00;
  ...
 
implementation
 
uses SFM_DM;
 
{$R *.dfm}
 
 
// --------------------------------------------------------------------
//  Fonction Mise en forme clé alpha
// --------------------------------------------------------------------
function MEF_CleAlpha(WClenum: Integer): String;
var
 .....
begin
// Init Clé alpha  (mise en forme)
// ===============================
.....
  Result := R;
end;

2- L'unité executant la fonction

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
unit SFM_DM;
 
interface
 
uses
  SysUtils, Classes, DB, DBTables, BDE, Dialogs, Windows, IniFiles, SFM_MD,
  DateUtils, Graphics;
 
{uses
  Windows,
  Dialogs, DB,  ComCtrls, }
 
type
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  SFMDM: TSFMDM;
   ...
 
implementation
 
uses SFM_00, SFM_01, SFM_13, SFM_02, SFM_CT;
 
{$R *.dfm}
 
// --------------------------------------------------------------------
//  Init Clé alpha & Libelle "Radié"
// --------------------------------------------------------------------
procedure TSFMDM.MembresCalcFields(DataSet:TDataSet);
begin
  // Mise en forme Clé alpha membre
  MembresWCle_alpha.Value := MEF_CleAlpha(MembresA_AKLE.Value);
end;

Comment et où déclarer cette fonction ?

[Paul TOTH]

La règle est simple, en Pascal tout ce qui est utilisé doit avoir été déclaré explicitement "plus haut".

La fonction d'une unité peut être utilisée dans une autre si elle remplit 2 conditions
1) elle est présente dans l'Interface de l'unité
2) son unité apparaît dans une des clauses Uses de la seconde unité.

[BuzzLeclaire]

Bonjour,

Comme le Dit Paul DECLARATION

Pourquoi dans ton unité tu déclares

Code :

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

uses SFM_00, SFM_01, SFM_13, SFM_02, SFM_CT;

Alors que ta fonction est dans une autre unité appelé SFM_DM ?

Tu devrais donc avoir :

Code :

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

uses SFM_00, SFM_01, SFM_13, SFM_02, SFM_CT, SFM_DM;

A+

[ShaiLeTroll]

Sinon, il y a une différence aussi !
MEF est une fonction simple !

MEF_CleAlpha a été déclarée comme méthode de TSFM00 !
Hors dans la partie implémentation, MEF_CleAlpha n'a pas son qualificateur de portée !
Incohérence !

Je pense que tout ça reste en procédural, il faut donc sortir le prototype MEF_CleAlpha de TSFM00

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
23
 
type
  TSFM00 = class(TForm)
  ...
    // rien
  ...
    procedure Quitter1Click(Sender: TObject);
  ... 
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
// ici les forwards déclarations qui rendent "publique" ces fonctions ! 
function MEF_CleAlpha(WClenum: Integer): String;    
 
...
 
implementation
 
...

Tout ce qui suit "implementation" est considéré comme "privé", seul les éléments dans la section interface qui précède seront visibles de l'extérieur de l'unité lors d'un uses.

Je subodore une mauvaise compréhension de ce passage aussi (l'indentation semblait hiérarchisé les éléments !

Code :

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

1
2
3
type
  TFunction = function:String;
    function MEF(CleNum : Integer) : String;

c'est la même chose que ceci

Code :

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

1
2
3
4
5
 
function MEF(CleNum : Integer) : String;
 
type
  TFunction = function:String;

MEF et TFunction n'ont AUCUN lien !
J'ai l'impression que c'est l'origine de la confusion MEF_CleAlpha et TSFM00 !
Est-ce que TFunction est utilisée ??? un CallBack ? A mon avis, sa présence est inutile !

[micoudev]

Merci a tous pour vos réponses.

Je vais regarder tout ça dès demain.

Il est vrai que je ne maîtrise pas bien ces mécanismes, et je n'ai rien trouvé de vraiment clair sur le sujet. Si quelqu'un peut m'indiquer un tuto ou autre, je suis preneur.

En attendant, petite précision, car je crains une petite confusion, dans mes sources :

Les deux 1eres unités sont les deux unités d'un programme de test.

Les 3e et 4e unités sont des extraits de mon programme, qui en comporte bien d'autres.

La fonction MEF n'a donc strictement rien à voir avec la fonction MEF_CleAlpha.

Mes excuses pour n'avoir pas été plus précis

BuzzLeclaire :
Ma fonction est bien dans SFM_00 et je veux pouvoir l'exécuter dans SFM_DM (et dans d'autres unités par la suite)

[micoudev]

Hourra ! Ca marche

Le petit bout de code de ShaiLeTroll m'a sauvé

Je ne savais tout simplement pas que je devais déclarer ma fonction ici

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  ...
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
  function MEF_CleAlpha(WClenum: Integer): String;  
 
var
  SFM00: TSFM00;
 ...

Je vais pouvoir attaquer les autres unités.

Un grand merci

[Paul TOTH]

c'est le premier point de ma réponse

la partie Interface d'une unité reprend (entre autre) les déclarations des fonctions de la partie Implementation pour les rendre publiques.

[micoudev]

c'est le premier point de ma réponse

la partie Interface d'une unité reprend (entre autre) les déclarations des fonctions de la partie Implementation pour les rendre publiques.

Oui Paul. C'est sur ces notions que je suis vraiment léger (je suis un autodidacte).
Je connaissais bien la nuance entre variables décrites dans l'unité et variables décrites dans la procédure, mais là, c'est un peu flou pour moi

[Paul TOTH]

Oui Paul. C'est sur ces notions que je suis vraiment léger (je suis un autodidacte).
Je connaissais bien la nuance entre variables décrites dans l'unité et variables décrites dans la procédure, mais là, c'est un peu flou pour moi

ben moi aussi je suis autodidacte mais depuis plus longtemps sans doute

je te recommanderais bien l'excellent "Delphi 7 Studio" aux éditions Eyrolles mais tu ne le trouveras plus qu'en occasion et ça ne me rapporte rien du coup ^^

[megs]

oué, ses notions là on les intègres avec les versions non windows de turbo pascal 5,7. là ou on est pas noyé sous les Big components et les forms mais les simples "object". soupir.... quelle belle époque.....