Re: Assignment operator=/copy constructor/temporaries, BROKEN!

From:

Bart van Ingen Schenau <bart@ingen.ddns.info>

Newsgroups:

comp.lang.c++

Date:

Tue, 21 Sep 2010 05:41:36 -0700 (PDT)

Message-ID:

<2bb80771-27ca-4b6a-b351-62602a77528c@j19g2000vbh.googlegroups.com>

On Sep 17, 8:32 pm, Fabrizio J Bonsignore <synto...@gmail.com> wrote:

I want this to be compilable and working AS IS:

Sorry, but you are out of luck here. The C++ language does not allow
it.
The const-qualification may be optional to be able to create a well-
formed copy-constructor, but that does not mean the const is optional
for all usage patterns of the copy-constructor.
When the source of the copy is a temporary (such as the return value
from a function call), then the const-qualification is most definitely
NOT optional.

class AO
{
public:
       int i;
void Aha();// {i=1;}

AO &operator=(AO &x);// {i=x.i; return *this;}//should not matter if
inline or not

AO();// : i(0) {}
AO(AO &x);// {i=x.i;}
virtual ~AO();// {}

};

void AO::Aha() {
     i=1;
     }

AO::AO()
: i(0) {
       }
AO::AO(AO &x) {
          i=x.i;
          }
AO &AO::operator=(AO &x) {
         i=x.i;
         return *this;
         }
AO::~AO() {}

class BO
{
      AO a;
public:

AO Retit();// {++a.i; return a;}
AO Retut();// {AO z; z.i = 10; return z;}
BO();

};

BO::BO() {
     AO b;
     b = a;
     AO c(a);
     AO d(b);
     AO e(c);

     a.Aha();
     b.Aha();
     c.Aha();
     d.Aha();
     e.Aha();

Up to here, the compiler should not have too many reasons for
complaining.

AO m = Retit();

Error: No suitable constructor for constructing m from a temporary.
  Available, but rejected constructors are:
    A0::A0(void)
    A0::A0(A0&)
  Minimal required, but missing constructor is 'A0::A0(const A0&)'

AO n = Retit();

AO o(Retit());

     AO p = n;
     AO q = o;

     AO f;
     AO g = Retut();

AO h(Retut());

     AO j = g;
     AO k = h;

     f = Retit();

Error: No suitable operator=() found.
  Available, but rejected operators are:
    A0::operator=(A0&)
  Possible, but missing signatures are:
    A0::operator=(A0)
    A0::operator=(const A0&)

f = Retut();

Error: No suitable operator=() found.
  Available, but rejected operators are:
    A0::operator=(A0&)
  Possible, but missing signatures are:
    A0::operator=(A0)
    A0::operator=(const A0&)

     }

AO BO::Retit() {
               ++a.i;
               return a;
               }
AO BO::Retut() {
               AO z;
               z.i = 10;
               return z;
               }

BO testbo;

Danilo J Bonsignore