Comment obtenir ce package générique à compiler

Question

J'ai le programme à l'endroit où il lit le paquet générique, mais je ne peux pas comprendre quoi faire à propos des clauses de contexte pour obtenir les numéros à imprimer et/ou être lus à partir du fichier. Dans le programme client en ce moment, j'ai que Element_Type devrait être un entier, mais toutes mes déclarations sont de type element, comment puis-je faire quelque chose avec ceci quand il n'y a pas Ada.Element_text_IO; s'il vous plaît faites le moi savoir, je suis coincé depuis un certain temps.

programme client

WITH Ada.Text_IO; 
WITH Ada.Integer_Text_IO; 
WITH Ada.Float_Text_IO; 
WITH Min_Max; 

PROCEDURE Min_Max_Average_File IS 
------------------------------------------------------------------ 
--| Finds and displays the minimum, maximum, and average 
--| of a list of data items; the data items are read from a file.         
------------------------------------------------------------------ 

package Grades is new Min_Max(Element_Type => Integer); 
use Grades; 



    NumValues: Element; -- input - the number of items to be averaged 
    CurrentValue: Element; -- input - the next data item to be added 
    Smallest:  Element; -- output - minimum of the data values 
    Largest:  Element; -- output - maximum of the data values 
    Average:  Element; -- output - average of the data values 
    Sum:   Element; -- program variable - the sum being accumulated 
    TestScores: Ada.Text_IO.File_Type; 

BEGIN -- Min_Max_Average_File 
    -- Open the file and associate it with the file variable name 
    Ada.Text_IO.Open 
    (File => TestScores, Mode => Ada.Text_IO.In_File, Name => "scores.txt"); 

    -- Read from the file the number of items to be averaged 
      Ada.Integer_Text_IO.Get(File => TestScores, Item => NumValues); 
      Ada.Text_IO.Put("The number of scores to be averaged is "); 
      Ada.Integer_Text_IO.Put(Item => NumValues, Width => 1); 
      Ada.Text_IO.New_Line; 
    -- Initialize program variables 
    Smallest := Element'Last; 
    Largest := Element'First; 
    Sum := 0; 

    -- Read each data item, log to the screen, add it to Sum, 
    -- and check if it is a new minimum or maximum 
    FOR Count IN 1 .. NumValues LOOP 
    Ada.Integer_Text_IO.Get(File => TestScores, Item => CurrentValue); 
    Ada.Text_IO.Put("Score number "); 
    Ada.Integer_Text_IO.Put(Item => Count, Width => 1); 
    Ada.Text_IO.Put(" is "); 
    Ada.Text_IO.Put(Item => CurrentValue, Width => 1); 
    Ada.Text_IO.New_Line; 
    Sum := Sum + CurrentValue; 
    Smallest := Grades.Minimum(Value1 => Smallest, Value2 => CurrentValue); 
    Largest := Grades.Maximum(Value1 => Largest, Value2 => CurrentValue); 

    END LOOP; 

    -- compute the average; since Sum and NumValues are integers, 
    -- the average is truncated, that is, the fractional part is discarded 
    Average := Sum/NumValues; 

    -- display the results 
    Ada.Text_IO.Put(Item => "The Smallest is "); 
    Ada.Integer_Text_IO.Put(Item => Smallest, Width => 1); 
    Ada.Text_IO.New_Line; 
    Ada.Text_IO.Put(Item => "The Largest is "); 
    Ada.Integer_Text_IO.Put(Item => Largest, Width => 1); 
    Ada.Text_IO.New_Line; 
    Ada.Text_IO.Put(Item => "The Average is "); 
    Ada.Integer_Text_IO.Put(Item => Average, Width => 1); 
    Ada.Text_IO.New_Line; 

END Min_Max_Average_File; 

spec package

generic 

    Type Element_Type is private; 


PACKAGE Min_Max IS 

------------------------------------------------------------------ 
--| specifications of functions provided by Min_Max package          
------------------------------------------------------------------ 
    Type Element is new Element_Type; 
    FUNCTION Minimum (Value1, Value2: Element_Type) RETURN Element_Type; 
    -- Pre: Value1 and Value2 have been assigned values 
    -- Post: Returns the smaller of the two input values 

    FUNCTION Maximum (Value1, Value2: Element_Type) RETURN Element_Type; 
    -- Pre: Value1 and Value2 have been assigned values 
    -- Post: Returns the larger of the two input values 

corps paquet

PACKAGE BODY Min_Max IS 
------------------------------------------------------------------ 
--| bodies of functions provided by Min_Max package          
------------------------------------------------------------------ 

    FUNCTION Minimum (Value1, Value2: Element_Type) RETURN Element_Type IS 
    Result: Element_Type; 
    BEGIN 

    IF Value1 < Value2 THEN 
     Result := Value1; 
    ELSE 
     Result := Value2; 
    END IF; 
    RETURN Result; 

    END Minimum; 

    FUNCTION Maximum (Value1, Value2: Element_Type) RETURN Element_Type IS 
    Result: Element_Type; 
    BEGIN 

    IF Value1 > Value2 THEN 
     Result := Value1; 
    ELSE 
     Result := Value2; 
    END IF; 
    RETURN Result; 

    END Maximum; 

END Min_Max; 

Answer 1

Lorsque je tente de compiler le cahier des charges pour Min_Max, je reçois le message d'erreur:

min_max.ads:16:71: missing "end Min_Max;" 

Corriger cela devrait être assez trivial.

Answer 2

Quand vous dites

package Grades is new Min_Max(Element_Type => Integer); 

cela signifie que la fonctionnalité de Grades est celle de Min_Max, pour Integers.

Vous ne devez donc pas déclarer NumValues etc. du type Element, mais au lieu du type Integer. Cela résoudra vos problèmes de pouvoir lire/écrire des valeurs.

Cependant, vous aurez des problèmes pour compiler le générique. Vous avez déclaré Element_Type en tant que private; cela restreint ce que vous pouvez faire avec des objets de ce type à affectation et comparaison pour l'égalité. Il fait pas support "<", "< =", "> =", ">".

Si vous êtes heureux de soutenir les types entiers signés, on peut dire (ARM 12.5.2(3))

type Element_Type is range <>; 

Sinon (que vous vouliez être en mesure de soutenir les types de virgule flottante ainsi), vous devez importer les opérations pertinentes (ARM 12.6(18)):

type Element_Type is private; 
with function "<" (L, R : Element_Type) return Boolean is <>; 
with function ">" (L, R : Element_Type) return Boolean is <>; 

(le is <> des moyens pour utiliser l'opération de Element_Type avec le même nom, s'il y en a un).