Ada中的构造函数

Question

I am trying to implement a constructor like it is used in Java or C++ in Ada 2005.

I have this class in Java:

public class MyClass {
    private static int intTest = 0; 
    private float floatTest = 0.0f; 
    private float floatTest2 = 0.0f; 

    public MyClass(float f_test, float f_test1) {
        MyClass.intTest++;
        this.floatTest = f_test;
        this.floatTest2 = f_test1;       
    }
}

And now I am trying to implement this in Ada 2005. This is what I did but I get an error.

with Ada.Finalization; use Ada.Finalization;
package MyClasses is    
    type MyClass (f_test, f_test1 : float)
        is new Controlled with private; 
    type MyClass is access all MyClass'Class;   
    private
        intTest : Integer := 0;
        type MyClass( f_test, f_test1: float )
            is new Controlled with
            record
                floatTest : float := f_test;
                floatTest2 : float := f_test1;
            end record;
overriding procedure Initialize (This : in out MyClass);    
end MyClass;

with Ada.Text_IO; 
use Ada.Text_IO;
package body MyClasses is
    procedure Initialize( This : in out MyClass ) is
    begin       
        intTest := intTest + 1;     
    end Initialize;
end MyClass;

On this line I get the error "discriminants must have a discrete or access type".

type MyClass (f_test, f_test1 : float)
    is new Controlled with private;

How can I implement the constructor like it is in the java class?

Answer 1

Float is not a discrete type and "discriminants must have a discrete or access type". Ada does not have the kind of constructors you find in the C++ inspired family of languages. Trying to repurpose discriminants for that is like trying to hammer a screw into the wall. If it does happen to work the result still won't be pretty.

Rather you should have a creator function that returns your initialized object:

type MyClass is new Controlled with private;
function Create(f_test, f_test1 : float) return MyClass;

Other things to note:

• Your access type MyClass has the same name as the record type. That won't work.
• You declared intTest as private static in the Java example, but declared it in the private part of the Ada package. This is equivalent to protected since child packages can access it. Declare it in the package body instead, this is the true equivalent of private static .

Answer 2

Here is an Ada package which implements a tagged type with similar properties to your Java class:

package My_Class is
   type Instance is tagged private;

   function Create (F_Test, F_Test_1 : Float) return Instance;
private
   type Instance is tagged
      record
         Float_Test, Float_Test_2 : Float := 0.0;
      end record;
end My_Class;

package body My_Class is
   Constructed_Objects : Natural := 0;

   function Create (F_Test, F_Test_1 : Float) return Instance is
   begin
      Constructed_Objects := Constructed_Objects + 1;
      return (Float_Test   => F_Test,
              Float_Test_2 => F_Test_1);
   end Create;
end My_Class;

I have omitted to make the tagged type controlled, as I can't see the point in doing so.

Ada doesn't allow you to postpone the full declaration of a publicly visibile type further than to the private part of the package specification. The private part of a package specification is visible to children of the package (not the same as derived classes/tagged types), which mean that the "private" attributes in Ada are somewhat similar to "protected" attributes in Java.

Answer 3

You can use a generic package as a form of pseudo object or you can use ada controlled record. A generic package has the advantage of being able to take types as constraints much like a template (arrays, types, non discriminate), however an ada controlled record is much more simple and easy to use but is limited to discrete types as parameters (which is what you did). I used a similar strategy when i created task safe console variables for doom 3.

• Cvar test
• Cvar spec
• Cvar body

Here is an example of a generic package as a object with a constructor and deconstructor

with Ada.Finalization; use Ada.Finalization;
with Ada.Text_IO; use Ada.Text_IO;
generic
  F_Test_1 : Float;
  F_Test_2 : Float := 2.0;
package Pretend_Class is
  procedure Set_Total(Amount : Integer);
  function Get_Total return Integer;
private
  Total : Integer := 0; -- Total : Integer := Integer(F_Test_1 + F_Test_2) + 1;
                        -- Could just do this and ignore the executable section
                        -- and the controller object, but you may run into an
                        -- elaboration check failure if a function is called 
                        -- in the assignment that was a member function of
                        -- the Pretend_Class package (e.g.
-- Total : Integer := Integer(F_Test_1 + F_Test_2) + 1 + Get_Total; -- Error!
  type Record_Controller is new Ada.Finalization.Controlled with null record;
  overriding procedure Initialize (Controller : in out Record_Controller);
  overriding procedure Finalize   (Controller : in out Record_Controller);
  Controller : Record_Controller;
end Pretend_Class;

package body Pretend_Class is
  procedure Set_Total(Amount : Integer) is
    begin
      Put_Line(" Total is now" Integer'image(Total));   
      Total := Amount;
    end Set_Total;
  function Get_Total return Integer is
    begin
      return Total;
    end Get_Total;
  procedure Initialize(Controller : in out Record_Controller) is
    begin       
      Total := Integer(F_Test_1 + F_Test_2);
      Total := Total + 1;     
    end Initialize;
  procedure Finalize(Controller : in out Record_Controller) is
    begin       
      Total := 0;     
    end Finalize;
begin
  null; -- Total := Integer(F_Test_1 + F_Test_2) + 1 + Get_Total; -- Works here!
        -- You can also just initialize in the executable section
        -- and remove the controller object but you lose the ability
        -- to finalize
end Pretend_Class;

with Pretend_Class;
procedure Test is
  package My_Pretend_Class is new Pretend_Class(F_Test_1 => 3.0);
  begin
    My_Pretend_Class.Set_Total(Amount => 2);
  end Test;