operator=(const &myclass)

I've just spent a couple of hours tracking down an error, which turned out to be that a copy assignment operator was mistyped - what should have been

myclass& myclass::operator=(const myclass& m);

was actually written as

myclass& myclass::operator=(const &myclass m);

My question is - why did the second version compile at all?  Does it mean anything?
LVL 4
IainHereAsked:
Who is Participating?
 
jasonclarkeConnect With a Mentor Commented:
> CMyClass& operator=(const &CMyClass)

this is actually a real nasty, what this actually means is:
 
  CMyClass& operator=(const int& CMyClass)

i.e. declare an operator that takes a variable of type int (implicit) with name CMyClass.

try the following code to show it better:

class X
{
    operator=(const &X)
    {
         int i = X;
    }
};

this compiles just fine with VC++ -

it appears to be a VC++ failure, if you try to compile the same code with gcc, you get the following messages:

test.cpp:4: ISO C++ forbids declaration of `operator=' with no type
test.cpp:4: `X::operator= (...)' must take exactly one argument
test.cpp:4: `X::operator= (...)' must take exactly one argument
0
 
DanRollinsCommented:
What compiler?  In VC++,

class CMyClass {
public:
     int n;
     CMyClass& operator=(const &CMyClass m);

};

returns:

 error C2146: syntax error : missing ',' before identifier 'm'
 error C2061: syntax error : identifier 'm'

-- Dan
0
 
mblatCommented:


const& myclass m would mean "m is a const reference to a myclass". But that is redundant, since references are always const. You can't change a reference. Never.

In other words, "myclass& const m" is the same thingequivalent to "myclass& x". Since you're gaining nothing by adding the const after the &, you shouldn't add.
 So it is actually suprising that your compiler didn't complain, because this constact is nonsence.
0
Never miss a deadline with monday.com

The revolutionary project management tool is here!   Plan visually with a single glance and make sure your projects get done.

 
IainHereAuthor Commented:
Dan - my apologies.  It was actually
CMyClass& operator=(const &CMyClass)
the operator was declared as private to stop anything using the default one, so the parameter wasn't actually being used so it wasn't named.

mblat - "references are always const".  I think I must be misunderstanding what you're saying - references don't have to to be const - if you pass them non-const, you can alter them as if they were pointers, but with object semantics.  Am I missing something?  Anyway, I'm sure the two things you state are equivalent are not.
0
 
IainHereAuthor Commented:
Excellent!  Thanks for the description.

[apologies for leading you the merry dance, Dan - I'm sure you'll forgive me]
0
 
DanRollinsCommented:
>>Dan - my apologies.  It was actually CMyClass& operator=(const &CMyClass)

Well that is irritating beyond words.  But I accept your appology :-)

-- Dan
0
All Courses

From novice to tech pro — start learning today.