Discussion :

[Jaizu]

Bien le bonjour !

Après avoir eu un mini-projet consistant à coder un jeu de le vie circulaire en C, j'ai eu l'idée de refaire le dit projet, mais en Ada cette fois-ci. J'utilise GPS pour coder.

Concernant le jeu de la vie en lui-même, je vous laisse regarder wikipedia qui vous expliquera bien mieux que moi son fonctionnement. Les choses "vitales" à savoir ici sont :

– La taille de la matrice 2d sera donnée à l'instanciation (logique).
– Le voisin d'une cellule se trouvant au bord de la matrice est la cellule se trouvant sur le bord opposé.

Voilà ce que donne la signature pour le moment :

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
generic
   type Lines is mod <>;
   type Columns is mod <>;
 
package Grids is
 
   type Cell is limited private;
 
   DEAD : constant Cell;
   ALIVE : constant Cell;
 
   type Grid (<>) is limited private;
 
   type Neighbours is limited private;
 
   function State(c : Cell) return Cell;
 
   procedure Switch_State(c : IN OUT Cell);
 
   function init return Grid;
 
   function Get_Neighbours(g : Grid; line : Lines; column : Columns)
                           return Neighbours;
 
   function Next(current : Grid) return Grid;
 
   procedure Next(current : IN OUT Grid);
 
   procedure Put(g : IN Grid);
 
private
 
   type Cell is range 0..1;
   for Cell'size use 1;
 
   DEAD : constant Cell := 0;
   ALIVE : constant Cell := 1;
 
   type Neighbours is range 0..8;
   for Neighbours'size use 4;
 
   type Grid is array (Lines, Columns) of Cell;
 
   function "+"(left : Cell; right : Neighbours) return Neighbours;
 
end Grids;

L'intérêt du type modulaire ici est de pouvoir gérer les bords de la grille comme n'importe quelle autre case. Là où ça foire, c'est à l'instanciation du type modulaire dans le main... Qui ressemble à ça :

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
with Grids;
with Ada.Command_Line; use Ada.Command_Line;
 
procedure main is
 
   n_lines : constant Natural := Natural'Value(Argument(1));
   n_columns : constant Natural := Natural'Value(Argument(2));
 
   type lines is mod n_lines;
   type columns is mod n_columns;
 
   package t is new Grids(lines => lines, columns => columns);
begin
   -- inutile pour la compréhension
end main;

Et à la compilation, ça donne les messages suivants :

"Non-static expression used for modular type bound"
"n_lines is not a static constant (RM 4.9(5))"
(Idem pour n_columns)

Je comprends bien pourquoi Ada n'apprécie pas au point de mettre une erreur et non une mise-en-garde, mais... Y a-t-il un moyen de "rassurer" le compilateur quant à la constante non-statique ou vaut-il mieux passer à autre chose ?

[Blackknight]

En fait, d'après l'ARM, la grammaire n'autorise pas une expression non statique dans la définition d'un type modulaire.
J'ai bien peur que tu ne doives trouver autre chose.

[Jaizu]

C'était bien ce que je craignais... Dommage, j'aimais bien cette approche. Merci pour la réponse.