Re: Help needed for STL ifstream class
Kira Yamato wrote:
On 2007-10-05 22:20:13 -0400, "Victor Bazarov" <v.Abazarov@comAcast.net>
said:
Kira Yamato wrote:
I've posted this in another thread, but I suppose I should've started
a new thread for it instead.
I cannot get the following short program to compile under g++:
#include <iostream>
#include <fstream>
#include <iterator>
#include <algorithm>
using namespace std;
int main(int argc, char **argv)
{
copy(istream_iterator<char>(argc >= 2 ? ifstream(argv[1]) : cin),
'istream_iterator's constructor that accepts a stream object takes the
argument by non-const reference. A non-const reference cannot be bound
to a temporary.
I see. So in C++, temporary variables are always treated as const?
No, and Victor did not say that.
Temporaries cannot be used to initialize non-const references. That does not
imply that temporaries are const objects. You can call non-const member
functions on temporaries. For temporaries of class type, that includes even
the assignment operator (if it is accessible). So, temporaries are by no
means const (unless you created them const). Moreover, any non-const
reference returned by a member function (e.g., the assignment operator)
will happily bind to a non-const reference.
The following snippet illustrates the first point about temporaries being
non-const:
#include <iostream>
struct demo {
demo ( void ) {}
void print ( char const * msg ) {
std::cout << "non-const: " << msg << '\n';
}
void print ( char const * msg ) const {
std::cout << "const: " << msg << '\n';
}
};
typedef demo const const_demo;
int main ( void ) {
demo obj;
obj.print( "object");
const_demo c_obj;
c_obj.print( "const object" );
demo().print( "temporary" );
const_demo().print( "const temporary" );
}
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