Skip to main content

Posts

Showing posts from February, 2006

Functions inside constructor should throw (if they fail)

This is a for constructors, which do non-trivial resource allocation
and initialization using helper member functions in the class. Exceptions
raised in such member functions should be propagated upto the constructor
and not eat them. In other words, such member functions should throw
exception if they can't satisfy their contract even though they provide
strong exception safety guarantee. Exception propagated upto
the constructor will be automatically propagated where the object is being
constructed indicating failure in object construction. Otherwise, silently
eating exceptions during object initialization will create an object in
an inconsistent state. The scope in which it is created will never know
that actually the object construction failed. If object construction can
be reasonably performed even in the face of exception, then it need not be
propagated out.

Example, LStack: A Stack implemented as a linked-list.

LStack::LStack (const LStack & s)
{
this->copy_all_nodes (s);
}

/// Fo…

Why overloaded ++ operator signatures are different?

The canonical form of overloaded pre-increment and post-increment
operators for class Foo are declared in the following way in C++.

/// Preincrement operator
Foo & operator++ (void);

/// Postincrement operator
const Foo operator++ (int);

The int in the post-increment operator is obviously to disambiguate
between post and pre forms of the operator. Then, why is the return type
different? As many other C++ features, this one also has a subtle
meaning!

In C++, for ints, you can write

++i = k;

but not,

i++ = k;

This is because, i++ results in a Rvalue to which you can't assign.
Unlike i++, ++i results in a Lvalue to which you can assign which
is infact ( incremented ) i itself. Not that ++i = k; has a great
importance, but it is a fact that C++ has been designed that way.
I would be interested in knowing the reason. One reason is that
i++ = k; is not allowed is that it is just ambiguous.
but ++i = k; is not ambiguous.

A const in the return type is also required to disallow passing
the ret…