Re: proposal for new assignment operators

[mheaney@on2.com (Matthew Heaney)]

Richard Riehle <richard@adaworks.com> wrote in message news:<3F038B77.2F2E41B7@adaworks.com>...
> 
> One reason for the peculiarity is that Ada, unlike C++, has limited
> types.   For limited types, assignment is never possible.  Therefore,
> overloading assignment is not possible.   Limited types are used for
> most container classes.

The statement that C++ doesn't have limited types is false.  To make a
limited type in C++, you simply have to declare the assignment
operator and copy constructor as private, and not define them:

class Limited_Type is
public:
   void f();
private:
   Limited_Type& operator=(const Limited_Type&);
   Limited_Type(const Limited_Type&);
};


Also, most container types are not limited, because containers that
are limited are hard to compose.  (It should be easy to instantiate a
container type using another container type as the element type.)

The reason you need non-limited types is for composition, not for
assignment (which has dubious value for a container).  There are many
ways to copy a container without using the assignment operator.

Also, the assignment operator only allows you to copy from the same
type, but it's often the case that the source or target of the
assignment is some other kind of container (e.g. an array).


> It is rare that one even needs to override the assignment operator
> on a non-limited type.   There is a distinction here that will not
> be immediately obvious to the C++ programmer.

You almost always need to override the assignment operator for a
non-limited type, if the type allocates internal storage from a pool.