[comp.lang.c++] The supplied vector.h and operator= function.

beshers@sylvester.columbia.edu (Clifford Beshers) (04/01/87)

Summary:

Expires:

Sender:

Followup-To:

Distribution:

Keywords:


I've been perusing the files supplied with C++ v1.2 and have come
across something I don't understand.

In the file vector.h, there is an assignment operator defined like
this:


class vector(type) {
	type* v;
	int sz;
public:
	//...
	vector(type)& operator=(vector(type)&);
	//...
};

vector(type)& vector(type)::operator=(vector(type)& a)
{
	register i = a.sz;
	if (i != sz)
		callerror(vector,type,3,"different vector sizes in assignment");
	register type* vv = &v[i];
	register type* av = &a.v[i];
	while (i--) *--vv = *--av;

	// ???????????????
	delete[i] v;
	// ???????????????

	return *this;
}


I thought I understood everything until I got to the delete call
that I have marked off.  In the immortal words of Cindy Lou Who,
"Why Santy Claus, why?"

It seems to me there are exactly two objects in this operation,
namely 'a' and 'this', both of which should have been initialized.
At least they *can* have been initialized, as in the code below.
Therefore each has some storage allocated for the array v.  The
purpose of the assignment is to copy the contents of a->v onto
this->v, isn't it?  Why, after we go to the trouble of copying this,
do we then delete it?

I could understand this if there was a new copy of v created, but
the only new variables are the walking pointers.  I thought this
code would remove one of two v's, leaving only one for two objects.


I tried this out with the following code and it worked; I looked
at the C code produced and it seemed to say the same thing.
What's going on?

/*******  Code follows. *********/



#include <CC/stream.h>
#include <CC/vector.h>

#define FLOAT float

declare(vector,FLOAT)
implement(vector,FLOAT)


ostream& operator<<(ostream& s, vector(FLOAT) v)
{
	register int sz = v.size();
	s << "(";
	for (int i=0; i < sz-1; i++)
		s << v.elem(i) << ",";

	return s << v.elem(sz-1) << ")";
}

main()
{
	int i;
	vector(FLOAT) fred(5);
	vector(FLOAT) bob(5);

	for (i=0; i<fred.size(); i++)
	{
		fred[i] = i;
		bob[i] = bob.size() - i;
	}

	cout << (fred = bob);
}

Cliff Beshers
Columbia University Computer Science Department
beshers@sylvester.columbia.edu

bs@alice.UUCP (04/08/87)

(beshers @ Columbia University CS Department) writes:

 > I've been perusing the files supplied with C++ v1.2 and have come
 > across something I don't understand.
 > 
 > vector(type)& vector(type)::operator=(vector(type)& a)
 > {
 >	register i = a.sz;
 ...
 > 	// ???????????????
 > 	delete[i] v;
 > 	// ???????????????
 ...
 > }
 > 
 > I thought I understood everything until I got to the delete call
 > that I have marked off.  In the immortal words of Cindy Lou Who,
 > "Why Santy Claus, why?"S
 > 
 > It seems to me there are exactly two objects in this operation,
 > namely 'a' and 'this', both of which should have been initialized.
 > At least they *can* have been initialized, as in the code below.
 > Therefore each has some storage allocated for the array v.  The
 > purpose of the assignment is to copy the contents of a->v onto
 > this->v, isn't it?  Why, after we go to the trouble of copying this,
 > do we then delete it?

The short answer is look at pages 92 and 259 in the C++ book (where the
index directs you to). The longer answer is that a pointer type
doesn't allow the compiler to determine whether you point to an object
or an array of objects. This typically doesn't matter since the free
store ``knows''. However, the free store doesn't know about destructors,
so consider a vector(T) where T::~T() has been declared. Then, when we
delete a vector(T) with 10 elements the destructor T::~T() needs to be
called 10 times - once for each element. ``The system'' is too dump to
know, so you must tell it, hence the ``spurious'' [i] in the example.