Discussion :

[localghost]

Bonjour,

Je tatone un peu avec la programmation orientée objet.
Je souhaiterez à la déclaration d'un type abstrait avec les méthodes abstraite contraindre le développeur à écrire les méthode correspondante pour un type concret.
Voilà ce que j'ai fait.

Code ada :

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

1
2
3
4
5
6
7
8
 
package Adaline is
 
 
   pragma Pure (Adaline);
 
 
end Adaline;

Code ada :

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

1
2
3
4
5
6
7
8
package Adaline.Abstracts is
 
   type Abstract_Type is abstract new controlled with null record;
   procedure Initialize(Item : in out Abstract_Type'Class) is abstract;
   procedure Finalize(Item : in out Abstract_Type'Class) is abstract;
   procedure Print(Item : in Abstract_Type'Class) is abstract;   
 
end Adaline.Abstracts;

Code ada :

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

1
2
3
4
5
6
7
8
9
10
11
 
with Adaline.Abstracts;
package Adaline.Objects is
 
   type Object_Type is abstract new Abstracts.Abstract_Type with null record;   
   procedure Initialize(Object : in out Object_Type'Class) is abstract;
   procedure Finalize(Object : in out Object_Type'Class) is abstract;
   procedure Print(Object : in Object_Type'Class) is abstract;
   type Object_Access is access all Object_Type'Class;   
 
end Adaline.Objects;

Code ada :

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
 
package Adaline.Objects.Computing is
 
   type Text_Type is new String;   
   type Text_Access is access all Text_Type;
 
   package Directories is
 
      type Inode_type is new Long_Integer range 0..Long_Integer'Last;
 
      type Directory_Type is
 
        new Object_Type with
 
         record
            Name        : Text_Access;
            Created     : Time := Time_Of(1970, 1, 1, 0.0);
            Modified    : Time := Time_Of(1970, 1, 1, 0.0);
            Last_Access : Time := Time_Of(1970, 1, 1, 0.0);
            Owner       : Text_Access;
            Group       : Text_Access;
            Inode       : Inode_Type := 0;
         end record;
 
   end Directories;
 
   use Directories;
 
end Adaline.Objects.Computing;

Mais à la compilation aucun message d'erreur ni warning.

Merci pour votre aide.

[Zerte]

En ajoutant les clauses "with" qui manquent, effectivement ça compile sans rechigner.
Mais ce que tu voudrais faire est plutôt:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
with Ada.Finalization;
 
package Adaline.Abstracts is
 
   type Abstract_Type is abstract new Ada.Finalization.Controlled with null record;
   overriding procedure Initialize(Item : in out Abstract_Type) is abstract;
   overriding procedure Finalize(Item : in out Abstract_Type) is abstract;
   procedure Print(Item : in Abstract_Type) is abstract;   
   procedure Test_class_wide(Item : in Abstract_Type'Class) is abstract;   
 
end Adaline.Abstracts;

c-à-d sans les "'Class". Dans ce cas on obtient les messages d'insulte attendus.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
gcc -c -gnatf adaline-objects-computing.ads
adaline-objects-computing.ads:14:12: type must be declared abstract or "Finalize" overridden
adaline-objects-computing.ads:14:12: "Finalize" has been inherited at adaline-objects.ads:4
adaline-objects-computing.ads:14:12: "Finalize" has been inherited from subprogram at adaline-abstracts.ads:7
adaline-objects-computing.ads:14:12: type must be declared abstract or "Initialize" overridden
adaline-objects-computing.ads:14:12: "Initialize" has been inherited at adaline-objects.ads:4
adaline-objects-computing.ads:14:12: "Initialize" has been inherited from subprogram at adaline-abstracts.ads:6
adaline-objects-computing.ads:14:12: type must be declared abstract or "Print" overridden
adaline-objects-computing.ads:14:12: "Print" has been inherited at adaline-objects.ads:4
adaline-objects-computing.ads:14:12: "Print" has been inherited from subprogram at adaline-abstracts.ads:8
gnatmake: "adaline-objects-computing.ads" compilation error

J'ai ajouté les "overriding" pour s'assurer qu'on masque (terme correct ?) les Initialize / Finalize parents, ainsi que "Test_class_wide".

A mon tour, une question aux spécialistes: puisque la compilation de Test_class_wide passe, à quoi peut servir cette procédure abstraite ?

[Zerte]

A mon tour, une question aux spécialistes: puisque la compilation de Test_class_wide passe, à quoi peut servir cette procédure abstraite ?

D'un type class-wide à un type "normal", il n'y a qu'un pas. J'essaie:

Code :

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

1
2
3
4
5
6
7
procedure Abstract_nonsense is
 
  procedure Test(Item : in Integer) is abstract;   
 
begin
  Test(1);
end;

• OA 7.2.2: abstract_nonsense.adb: Error: line 6 col 3 LRM:3.9.3(7), A call on an abstract subprogram shall be a dispatching call, Continuing
• GNAT GPL 2015: abstract_nonsense.adb:6:03: cannot call abstract subprogram "Test"

En mettant "null;" à la place de "Test(1);", ça compile sans broncher.
Étonnant !...

[localghost]

Merci Zerte.

Je suis incapable de répondre à ta question.

[localghost]

Bonjour,

Donc je poursuis ici avec une nouvelle question.

J'ai une classe Human_Type qui déscend de la class Abstracts.Objects.Object_Type que voici :

Code Ada :

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
 
package Libroot.Es.Abstracts.objects is
 
   type Object_Type is abstract limited new Abstract_Type with null record;
 
   type Object_Access is access all Object_Type'Class;
 
   type Variadic_Array_Type is array (Natural range <>) of Object_Access;
 
 
   procedure Hello (Object : in out Object_Type; Var : in Variadic_Array_Type) is abstract;
 
   type Procedure_Access is access
     procedure (Object : in out Object_Type'Class;
                Var    : in Variadic_Array_Type);
 
end Libroot.Es.Abstracts.objects;

Voici le type Human_Type :

Code Ada :

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
 
with Libroot.Es.Abstracts.Objects;
use Libroot.Es.Abstracts.Objects;
 
package Libroot.Es.Cybernetic.Human is
 
   type String_Access is access all String;
 
   type Human_Attributs_Type is
      record
         Solde : Float := 0.0;
         Name  : String_Access;
      end record;
 
   type Human_Type is limited new Object_Type with
     record
        Attributs : Human_Attributs_Type := (0.0, null);
     end record;
 
   procedure Hello(Human : in out Human_Type; Parameters : in Variadic_Array_Type);
end Libroot.Es.Cybernetic.Human;

A présent, je cherche comment collé ma procédure Hello à un objet de type Procedure_access.
Le compilateur me dit simplement que ce n'est pas la même chose.

Comment procéder ? ou est mon erreur ?
Merci pour votre expertise.
S'il vous plait ! Bien entendu.

[Zerte]

A présent, je cherche comment collé ma procédure Hello à un objet de type Procedure_access.
Le compilateur me dit simplement que ce n'est pas la même chose.

C'est pareil avec tous les types de données.

Code :

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

1
2
3
4
5
6
7
8
a: Integer;
 
type My_record is record
  a: Float;
  b: Integer;
end record;
 
b: My_Record;

a et b représentent les objets eux-mêmes et non des accès à ces objets. Si tu veux leur accès, tu as l'attribut 'Access: a'Access, b'Access.

Une procédure est aussi un paquet de données, constant, avec du code en langage machine dedans.
On a donc la même règle: l'accès à Hello sera Hello'Access.

Là les choses se compliquent un peu: les concepteurs d'Ada ont voulu éviter des accès à des procédures utilisant des données ou des pointeurs de pile caduques. Du coup le compilateur va protester sur Hello'Access pour une procédure Hello se trouvant à l'intérieur d'un autre sous-programme. Là on peut essayer Unrestricted_Access (mais attention: c'est seulement GNAT). Pour être portable, les procédures en question doivent être ou bien une unité à part (un "main") ou dans une unité paquetage (c'est à dire dans un paquetage non imbriqué dans qqch d'autre).

[localghost]

Bonjour, Zerte.
D'abord merci. T'en sais des chose...
Ok ! je vais voir comment je peux faire mieux que ce que j'ai fait en sachant ce que je sais à présent.
Merci encore.