Operator= overloading in C++

Question

In the book C++ Primer it has a code for C - style character arrays, and shows how to overload the = operator in the Article 15.3 Operator =.

String& String::operator=( const char *sobj )
{
   // sobj is the null pointer,
   if ( ! sobj ) {
      _size = 0;
      delete[] _string;
      _string = 0;
   }
   else {
      _size = strlen( sobj );
      delete[] _string;
      _string = new char[ _size + 1 ];
      strcpy( _string, sobj );
   }
   return *this;
}

Now i would like to know why is there the need to return a reference String & when this code below does the same job, without any problem:

void String::operator=( const char *sobj )
{
   // sobj is the null pointer,
   if ( ! sobj ) {
      _size = 0;
      delete[] _string;
      _string = 0;
   }
   else {
      _size = strlen( sobj );
      delete[] _string;
      _string = new char[ _size + 1 ];
      strcpy( _string, sobj );
   }

}

please help out.

Note that the solution as presented in the book is not exception safe (and it would be *really* simple to do so, I don't really understand why they did not). — David Rodríguez - dribeas, Mar 28 '11 at 19:15

Fred Foo · Accepted Answer · 2011-11-21T22:01:38.290

20

It supports the following idiom:

String a, b;
const char *c;

// set c to something interesting

a = b = c;

For this to work, b = c must return an appropriate object or reference to assign to a; it's actually a = (b = c) according to the C++ operator precedence rules.

If you'd return the pointer this, you'd have to write a = *(b = c), which doesn't convey the intended meaning.

edited Nov 21 '11 at 22:01

answered Mar 28 '11 at 18:35

Fred Foo

355,277
75
744
836

1

Now, that was a one-liner - Why dint you write that book. Thanks. Got my answer. – Sadique Mar 28 '11 at 18:38
1

@Acme: that's right, you have to wait until everybody else has had the opportunity to prove me wrong. – Fred Foo Mar 28 '11 at 18:44
:Well at least people didn't say -- "Stupid Question"!! – Sadique Mar 28 '11 at 18:45

score 8 · Answer 2 · edited May 23 '17 at 12:19

@larsmans already answered your precise question, so I'll actually digress: This is some crappy code!

The issue here is 3-fold:

You just duplicated the code of the copy constructor (somewhat)
strcpy could be better replaced by strncpy, which does some bound checking
It is not exception safe

1) and 2) are more stylistic than anything, but the 3) is a big concern

EDIT: as pointed out by @Jerry Coffin, this does not protected against self-assignment. That is if sobj and _string point to the same array of characters, you're in big troubles. The easy solution at the end of this post also covers this situation.

Not exception safe

Let's have a look at a portion of the code, namely, the else part:

  _size = strlen( sobj );
  delete[] _string;
  _string = new char[ _size + 1 ];
  strcpy( _string, sobj );

What happens if, for some reason, new throws ?

_size has the value of the new string
_string points to the old pointer... which has been freed

Therefore not only the object is left in an unusable state (half of its data from the new object, half from the old), but it cannot even be destroyed (unless the destructor leaks... ?)

Adding exception safety, the hard way

  _size = strlen( sobj );
  delete[] _string;

  try {
    _string = new char[ _size + 1 ];
  } catch(...) {
    _size = 0; _string = 0;
    throw;
  }
  strcpy( _string, sobj );

Okay, it's really bottom-line, but it brings us the Basic Exception Guarantee: no functional guarantee, but a guarantee that the code is technically correct (no crash, no leak).

Adding exception safety, the easy way: The Copy-And-Swap idiom

Find a more complete description at: What is the copy-and-swap idiom ?

void swap(String& lhs, String& rhs) {
  using std::swap;
  swap(lhs._size, rhs._size);
  swap(lhs._string, rhs._string);
}

String& String::operator=(String other) { // pass-by-value
  swap(*this, other);
  return *this;
}

How does it work ?

we reuse the copy constructor for the actual copy
we reuse the swap function for exchanging values
we reuse the destructor for the clean-up

And it's even better than the previous version too, for now we have the Strong Exception Guarantee: it's transactional, thus if it fails, the string we assigned to is unchanged (as if nothing had happened).

More about Exception Guarantees.

I am a bit daunted that a C++ tutorial would promote such dubious code, pray tell me it's an example of what not to do :/

score 3 · Answer 3 · answered Mar 28 '11 at 18:37

3

Convention. Built-in types do it, auto-generated assignment operators do it, it allows you to do this:

a = b = c;

or this:

if ( foo = come_function() ) {
   // use foo here
}

answered Mar 28 '11 at 18:37

Tim

8,912
3
39
57

+1 for the assignment-as-conditional, I forgot that one. In short, this convention gives you all the gun-aimed-at-foot power that C++ programmers love ;) – Fred Foo Mar 28 '11 at 18:46
Note that the latter one is bad style and should be avoided. – Björn Pollex Mar 28 '11 at 18:47
Note that whether the latter is bad style or not is a matter of taste that has been discussed on SO before. I catch myself using that idiom sometimes, and I'm still not terribly embarrassed when I do. I'm less fond of it then I used to, though; it is an old C programmers' habit. – Fred Foo Mar 28 '11 at 18:49

score 0 · Answer 4 · answered Mar 28 '11 at 18:36

0

The returning from operator = is so you can chain things. See here without strings:

x = y = 2;

The y=2 part of that line returns 2. That's how x gets a value. If op= returned void, you couldn't chain = operations.

answered Mar 28 '11 at 18:36

Kate Gregory

18,808
8
56
85

score 0 · Answer 5 · answered Mar 28 '11 at 18:37

By convention, you're able to do e.g:

int x, y, z;
x = y = z = 0;

if ((x = 1) != 0) { ... }

In order to keep these semantics for instances of your class, you need to return *this - allowing chained assignment. If you return just this you'd be returning a pointer to your instance, and chained assignment wouldn't work - there's no operator= for String *, there is one for String

Operator= overloading in C++

5 Answers5

Linked

Related