Can someone explain why the two classes defined below exhibit different
behavior?  The class without the default copy constructor does not make
a copy of the *this argument for the + operator.  There is a related
comment in Ellis & Stroustrup (12.6.1): "Had no copy constructor been
declared...all would have happened exactly as before because a copy
constructor would have been generated.  Again, a good compiler would
eliminate the use of the generated copy constructor."  I'm not convinced
that this statement applies in this case.  Any enlightenment on this
subject would be welcome.  I'm using ATT C++ 2.0 on a Sparc.


#include <iostream.h>
#include <iomanip.h>

class NoCopy {
public:
  int x;
  NoCopy (int a) { x = a; };
  NoCopy &operator +=(int a) { x += a; return *this; };
  NoCopy  operator + (int a) { return NoCopy(*this) += a; };
};

class Copy {
public:
  int x;
  Copy(const Copy &c) : x(c.x) {};
  Copy (int a) { x = a; };
  Copy &operator =(int a) { x = a; return *this; };
  Copy &operator +=(int a) { x += a; return *this; };
  Copy  operator + (int a) { return Copy(*this) += a; };
};

void main()
{
  NoCopy xNo(1), xNo2(-1);
  Copy xYes(2), xYes2(-2);
  cout << "No=" << xNo.x << " Yes=" << xYes.x << endl;
  cout << "No2=" << xNo2.x << " Yes=" << xYes2.x << endl;
  xNo2 = xNo + 2;
  xYes2 = xYes + 2;
  cout << "No=" << xNo.x << " Yes=" << xYes.x << endl;
  cout << "No2=" << xNo2.x << " Yes=" << xYes2.x << endl;
}

Output of the program:
No=1 Yes=2
No2=-1 Yes=-2
No=3 Yes=2
No2=3 Yes=4

In article <253@blsouth.UUCP> klein@blsouth.UUCP (Michael Klein) writes:
>
>Can someone explain why the two classes defined below exhibit different
>behavior?  The class without the default copy constructor does not make
>a copy of the *this argument for the + operator.  There is a related
>comment in Ellis & Stroustrup (12.6.1): "Had no copy constructor been
>declared...all would have happened exactly as before because a copy
>constructor would have been generated.  Again, a good compiler would
>eliminate the use of the generated copy constructor."  I'm not convinced
>that this statement applies in this case.  Any enlightenment on this
>subject would be welcome.  I'm using ATT C++ 2.0 on a Sparc.
>
>
>#include <iostream.h>
>#include <iomanip.h>
>
>class NoCopy {
>public:
>  int x;
>  NoCopy (int a) { x = a; };
>  NoCopy &operator +=(int a) { x += a; return *this; };
>  NoCopy  operator + (int a) { return NoCopy(*this) += a; };
>};

Replacing the line

   NoCopy  operator + (int a) { return NoCopy(*this) += a; };

with

   NoCopy  operator + (int a) { NoCopy tmp = *this; return tmp += a; };

you will get what you expected.  This could be taken to be a bug, but
I'm inclined to think that it's just another grey area in the
language which is best avoided.  No where in E&S is there any example
or text that I can find which states that one can explicitely call a
copy constructor which the compiler generates for you.  My
understanding is that if you make use of a construct which requires a
copy constructor, the "right thing" will be done, where the "right
thing" is a bitwise copy.

It is interesting to note that when I tried the original code with
g++, I got an error to the effect that the argument in
`NoCopy(*this)' is wrong - g++ was expecting an int since the only
constructor which had been defined was NoCopy::Nocopy(int).
Seemingly g++ doesn't allow one to explicitely call a copy
constructor which you haven't explicitely defined.  I would suggest
that this is the more correct behavior.  Certainly it is better than
silently allowing the construct and then doing the wrong thing.

>class Copy {
>public:
>  int x;
>  Copy(const Copy &c) : x(c.x) {};
>  Copy (int a) { x = a; };
>  Copy &operator =(int a) { x = a; return *this; };
>  Copy &operator +=(int a) { x += a; return *this; };
>  Copy  operator + (int a) { return Copy(*this) += a; };
>};
>
>void main()
>{
>  NoCopy xNo(1), xNo2(-1);
>  Copy xYes(2), xYes2(-2);
>  cout << "No=" << xNo.x << " Yes=" << xYes.x << endl;
>  cout << "No2=" << xNo2.x << " Yes=" << xYes2.x << endl;
>  xNo2 = xNo + 2;
>  xYes2 = xYes + 2;
>  cout << "No=" << xNo.x << " Yes=" << xYes.x << endl;
>  cout << "No2=" << xNo2.x << " Yes=" << xYes2.x << endl;
>}
>
>Output of the program:
>No=1 Yes=2
>No2=-1 Yes=-2
>No=3 Yes=2
>No2=3 Yes=4


--
Mike Lijewski  (H)607/272-0238 (W)607/254-8686
Cornell National Supercomputer Facility
ARPA: mjlx@eagle.cnsf.cornell.edu  BITNET: mjlx@cornellf.bitnet
SMAIL:  25 Renwick Heights Road, Ithaca, NY  14850