Re: Ada OO Mechanism

[Ray Blaak <blaak@infomatch.com>]

Hyman Rosen <hymie@prolifics.com> writes:
> ...and follows up with code demonstrating the superiority of Ada
> array handling over the C++ version.
[...]
> Array indexing, however, does not normally fall under the heading
> of object-oriented techniques.

Well, here is an OO example showing difficulties with the C++ model as compared
to Ada. It is about a generic/template vector class with binary operators
involving scalars. In Ada, due to its method(obj,parm) notation, things are
declared in a straight forward way. In C++, friend procedures are required,
which is no suprise. The problem with C++, however, is that friend functions
cannot be implicitly instantiated when the vector class is instantiated.

Ada:

generic
   type ScalarType is (<>); -- Is this right? My Ada is rusty.
package Vector is
   type T is private;

   function Create(size : Natural) : T;

   function "*" (vector : in T; scalar : in ScalarType) : T;
   function "*" (scalar : in ScalarType; vector : in T) : T;
private
   -- whatever
end;

declare
   package IntVector is new Vector(Integer); 
   use type IntVector;
   package FloatVector is new Vector (Float); 
   use type FloatVector;

   I : IntVector.T := IntVector.Create(3);
   F : FloatVector.T := FloatVector.Create(3);
begin
   I := I*2;
   I := 2*I;
   F := F*2;
   F := 2*F;
end;


C++:

template <typename ScalarType>
class Vector
{
public:
  Vector (int size) { /* whatever */ };
  ~Vector() {};

  Vector operator* (ScalarType scalar)
  {return Vector(0); /* whatever */};

  friend Vector operator* (ScalarType scalar, Vector & V);
};

Vector<int> operator* (int scalar, Vector<int> & V)
{
  return V * scalar;
}

// later:

  Vector<int> I(3);
  I = I * 2;
  I = 2 * I;

  Vector<float> F(3);
  F = F * 2;
  F = 2 * F;

In this example, things won't link because I "forgot" to declare the
Vector<float> friend function. Not a big deal, since I can just do
it. However, it is tedious that I don't get what I need as soon as
Vector<float> is instantiated. I could make a mistake in defining it.

If one could have template namespaces, then maybe the class and friend
function could be defined together, but then one would have to switch to the
instantiated namespace (analogous to the "use type" in the Ada above, I
suppose).

The point is the C++ is a little more clumsy in this regard. If anyone has a
way to do the C++ example cleanly, I would be most interested, since I
currently use C++ in my projects. In particular, I was playing with defining
the friend function as:

template<typename ScalarType> Vector<ScalarType> operator*(...)
{...}

but couldn't get it to work.

-- 
Cheers,                                        The Rhythm is around me,
                                               The Rhythm has control.
Ray Blaak                                      The Rhythm is inside me,
blaak@infomatch.com                            The Rhythm has my soul.