是否可以在Ada中扩展Enum类型? 如果我有例如:
type ABC_Type is (A, B, C);
现在我想要新类型ABCDE_Type,它将包含ABC_Type所具有的所有内容以及(D,E)。 有没有办法做到这一点?
答案 0 :(得分:7)
不,你不能在Ada中扩展Enum类型,你只能创建覆盖原始子集的派生/子类型。
你必须反过来这样做:
type ABCDE_Type is (A, B, C, D, E);
type ABC_Type is new ABCDE_Type range A .. C;
-- or
subtype ABC_Type is ABCDE_Type range A .. C;
答案 1 :(得分:1)
一个人给出的答案是正确的;您不能扩展枚举(或数字)类型。 你可以扩展标记类型,使用Yony的Animal / Fox示例我将其翻译成Ada的OO模型:
-- Percent defines an integer-value between zero and one-hundred, inclusive.
Subtype Percent is Natural Range 0..100;
-- Attribute defines an integer between one and ten, inclusive.
Subtype Attribute is Positive Range 1..10;
-- Animal, the base object-class.
Type Animal is Abstract Tagged Record
-- All Animals have a survivability attribute.
Survivability : Percent:= Percent'Last; -- Default "survivability" to Max.
End Record;
-----------------------------------------------------
-- Declaration of Primitive Operations for Animal. --
-----------------------------------------------------
-- Name; returns the name of the type of the animal.
Function Name( Object : In Animal'Class ) Return String;
-------------------------------------------------------
-- Implementation of Primitive Operations for Animal --
-------------------------------------------------------
Function Name( Object : In Animal'Class ) Return String is
Use Ada.Tags;
begin
-- This is implementation dependent; with the compiler I'm using the Uppercased
-- type-name of the actual object will be returned.
Return External_Tag(Object'Tag);
end Name;
---------------------------
-- The Fox object-class. --
---------------------------
Type Fox is New Animal with record
Cunning : Attribute:= Attribute'First;
end record;
实际上,扩展(OO继承)和排除(子类型)都可以在同一个程序中使用,并且相同的子程序可以在一个类型上运行。
package Windowing is
Type Window is tagged private;
-- Pointers for windows.
Type Window_Pointer is Access Window'Class; -- Normal pointer
Subtype Handle is Not Null Window_Pointer; -- Pointer with Null excluded.
-- A light 'vector' of handles.
Type Window_List is Array (Positive Range <>) of Handle;
-- Primitive operations
Function Get_Child_Windows( Object : In Handle ) Return Window_List;
Procedure Set_Window_Height( Object : In Handle; Height : In Positive );
Function Get_Window_Height( Object : In Handle ) Return Positive;
-- more primitive operations... including subprograms to create windows
-- and perhaps assign them as children.
Private
Package Win_Vectors is new
Ada.Containers.Vectors(Index_Type => Positive, Element_Type => Handle);
Type Window is Tagged Record
-- X & Y may be negative, or zero.
X, Y : Integer:= Positive'First;
-- Height & Width must be positive.
Height, Width : Positive:= Positive'First;
-- Child-list
Children : Win_Vectors.Vector:= Win_Vectors.Empty_Vector;
End Record;
End Windowing;
package body Windowing is
Procedure Set_Window_Height( Object : In Handle; Height : In Positive ) is
begin
Object.Height:= Set_Window_Height.Height;
end Set_Window_Height;
Function Get_Window_Height( Object : In Handle ) Return Positive is
begin
Return Object.Height;
end Get_Window_Height;
Function Get_Child_Windows ( Object : In Handle ) Return Window_List is
begin
-- Return a null-array if there are no child windows.
if Object.Children.Is_Empty then
Return (2..1 => Object);
end if;
-- Create an array of the proper size, then initialize to self-referential
-- handle to avoid null-exclusion error.
Return Result : Window_List( 1..Positive(Object.Children.Length) ):=
(others => Object) do
Declare
Procedure Assign_Handle(Position : Win_Vectors.Cursor) is
Use Win_Vectors;
Index : Positive:= To_Index( Position );
begin
Result(Index):= Element(Position);
end Assign_Handle;
Begin
-- Replace the self-referential handles with the correct ones.
Object.Children.Iterate( Process => Assign_Handle'Access );
End;
End Return;
end Get_Child_Windows;
end Windowing;
子类型本身可以成为一个强大的概念。实际上,在对数学进行建模时,Ada的子类型可以允许函数与其数学定义完全匹配,或者以某种检查完全不合理的方式实现事物。
-- Remove non-normal representations.
Subtype Real is Float Range Float'Range;
-- Constrain to non-negative numbers.
Subtype Natural_Real is Real Range 0.0 .. Real'Last;
-- Because of the parameter-type, we do not need to implement any checks
-- for negative numbers in the subprogram body.
Function Square_Root( X : In Natural_Real ) Return Natural_Real;
-- Because Divisor is positive, we need not worry about ddivide-by-zero.
Function Good_Divide( Quotient: Integer; Divisor: Positive ) Return Natural;