Re: Help needed for STL ifstream class

From:

Kai-Uwe Bux <jkherciueh@gmx.net>

Newsgroups:

comp.lang.c++

Date:

Fri, 05 Oct 2007 23:28:01 -0700

Message-ID:

<fe79u9$stb$1@murdoch.acc.Virginia.EDU>

Kira Yamato wrote:

On 2007-10-06 00:46:28 -0400, Kai-Uwe Bux <jkherciueh@gmx.net> said:

Kira Yamato wrote:

If so, is there a good reason why the C++ designer chose it this way?

It helps avoiding some issues arising from integral promotion. Otherwise,
it is just a nuisance. For instance, you can do:

  MyClass & operator= ( MyClass const & other ) {
    MyClass( other ).swap( *this );
    return ( *thid );
  }

but not

  MyClass & operator= ( MyClass const & other ) {
    this->swap( MyClass( other ) );
    return ( *this );
  }

You also cannot use a temporary to initialize a default non-const
parameter:

  void search ( SearchClass & initial_pos = SearchClass() );

but if you provide a member function

  class SearchClass {
    ...

    SearchClass & me ( void ) {
      return ( *this );
    }

  };

you can do:

  void search ( SearchClass & initial_pos = SearchClass().me() );

And for standard classes that do not support a me() method, you could do:

  void grow ( std::vector<int> & the_list =
                 ( std::vector<int>() = std::vector<int>() ) );

Since the assignment operattor returns a non-const reference, the result
will happily bind to the parameter.

As you can see, it is not very logical at all.

The next version of the standard will include r-value references which
hopefully will put an end to this nonsense.

As far as I know, a temporary object lives on the stack, and there
should be no reason why it should not be modified.

There isn't and you can modify temporaries at will. You just cannot bind
them to non-const references directly.

Best

Kai-Uwe Bux

Thank you for your very detailed explanation.

It's beginning to dawn on me that many rules in C++ can be bent.

For example, your code above shows a way to "bind" a temporary object
to a non-const reference (by using the returned value of the operator =
).

Be careful when bending the rules :-)

For instance, binding a temporary to a non-const reference is subject to
livetime issues. The following is not good:

int_vector & iv = ( int_vector() = int_vector() );

The reason is that the temporary int_vector is destroyed right away. For
const-references, the standard makes a special guarantee that the temporary
that is bound to the reference (which may not be the one you think it is)
lives as long as the reference.

The reason that you can use these tricks to bind a temporary to a parameter
in a function call expression is that the temporary is guaranteed to live
as long as the maximal enclosing expression. As for initializing the
default parameter, I am actually not sure (I think I checked it once and
convinced myself that it is OK, but my memory might play a prank on me).

In another thread I started last week, someone showed me how to declare
a const member function that can modify its own member variable without
using 'volatile'

you mean 'mutable'

nor 'const_cast'. Essentially, his code was as follow:

class Obj
{
private:
        Obj *that;
        int state;

public:
        Obj() : that(this), state(0) {}

        void changeMe() const
        {
                that->state++; // changing state!
        }
};

Now, that is evil (and if the object was actually declared const, it is also
undefined behavior).

Best

Kai-Uwe Bux