bjaspan@athena.mit.edu (Barr3y Jaspan) (04/10/91)
(To prevent a large-scale flame war, please respond directly to me,
bjaspan@mit.edu. I'll summarize responses here, if desired.)
I am currently writing a parameterized Array class, using templates.
I have a general question about the design. For reference, the
declaration of Array looks like this:
template <class T> class Array {
T& operator[](int index);
// other stuff
};
One of the things an Array should do is resize itself if it is indexed
out of bounds, ie:
{
Array<int> a;
a[5] = 10; // creates the first 6 elements, too
}
This, however, presents a problem. The Array class has a member "T
**array" in which it stores pointers to copies of all the objects
added to the array. When operator[] sees the out of bound index, it
immediately resizes the array to be large enough. However, it then
wants to do "return *array[index]". However, that won't work because
so far array[index] is an uninitialized pointer, not a pointer to a T.
Clearly, array[index] needs to be initialized to something before the
function can return. (In this example, it needs to be initialized to
something that is immediately going to get assigned to. If there was
some magic []= operator the problem wouldn't exist. Alas...)
I have two solutions so far.
(1) After resizing the array, do "array[index] = new T" for all the
new indeces created. This works; in the example above, the new T just
created would get written over by T::operator=(T&).
The disadvantage is that it REQUIRES all classes T to have a default
constructor.
(2) Create another template, say, "template <class T> class Ref" that
acts as a "reference" for a T, and have the internal array of Array be
"Ref<T> *array" instead of "T **array". Ref<T> would initialize an
internal T* variable to NULL and, when something was assigned to it,
would reset that pointer. Ref<T> would export Ref<T>::operator T&()
so that a Ref<T> could be used anywhere a T could be used.
The disadvantage here is lost efficiency -- in memory, because there
is an overhead of one Ref<T> for every entry in the array, and in
speed because of all the extra frobbing around with Ref<T> objects.
However, this method does not require that T have a default
constructor.
The implementation of Ref is not too complicated. Here's an
(untested, not even compiled) example:
template <class T> class Ref {
protected:
T *obj;
public:
Ref() { obj = NULL; }
Ref(T& o) { obj = new T(o); }
~Ref() { delete obj; }
operator T&(Ref& ref) { assert(obj != NULL); return *obj; }
T& operator=(T& o) {
delete obj;
obj = new T(o);
}
}
So, does anyone have some comments/suggestions/etc? Thanks.
---
Barr3y Jaspan, bjaspan@mit.edu
Watchmaker Computing