Re: ADA Objects Help!

[ncohen@watson.ibm.com (Norman H. Cohen)]

In C++, members may be static or nonstatic and may be data members or
function members: 

   class C {
      public: 
         int nonstatic_data_member;
         static int static_data_member;
         void nonstatic_function_member(int x);
         static void static_function_member(int x);
   };

   static void C::nonstatic_function_member(int x) {
      [references to static_data_member or nonstatic_data_member]
   }

   static void C::static_function_member(int x) {
      [references to static_data_member, but not nonstatic_data_member]
   }

These reflect the unified/confused role of a class as a type definition
and as a module.  The equivalent in Ada is: 

   package C_Module is

      type C_Type is
         record
            Nonstatic_Data_Member: Integer;
         end record;

      Static_Data_Member: Integer;

      procedure Nonstatic_Function_Member
         (This: access C_Type; X: in Integer);

      procedure Static_Function_Member (X: in Integer);

   end C_Module;

   package body C_Module is

      procedure Nonstatic_Function_Member
         (This: access C_Type; X: in Integer) is
         ...
      begin
         [references to Static_Data_Member or This.Nonstatic_Data_Member]
      end Nonstatic_Function_Member;

      procedure Static_Function_Member (X: in Integer) is
         ...
      begin
         [references to Static_Data_Member]
      end Static_Function_Member;

   end C_Module;

The Ada formulation is actually a more accurate depiction of the usual
C++ implementation than is the C++ formulation.  The C++ formulation
suggests that each object of class C has space set aside for its own copy
of the function, or at least of a pointer to the function.  (This effect
can be achieved in Ada with a record component belonging to an
access-to-subprogram type.)  In reality, since the function is not
virtual, the function body is the same for all members of the class, so
there is only one copy of it and it is called directly, without going
through any pointers.  A pointer to the object "containing" the called
function is passed to this single copy through the implicit parameter
"this", and a reference to nonstatic_function_member in the function body
is just a shorthand for this->nonstatic_function_member.

--
Norman H. Cohen    ncohen@watson.ibm.com