Re: auto_ptr<istream> problem
On 23 Jun, 03:51, Rolf Magnus <ramag...@t-online.de> wrote:
Your program below doesn't compile here on my compiler (and I wouldn't
expect it to), neither with the #define, nor without.
Thank you for pointing it out. In fact, I hadn't explicitly turned off
the "language extensions" in Visual Studio, and it was optimising away
the copy constructor without so much as a warning for my pointer
class.
For auto_ptr, it implicitly converted to auto_ptr_ref, then
constructed from that, which is fair enough. In fact, my actual
pointer class does have an implicit conversion and pseudo-copy-
constructor similar to auto_ptr, so that wasn't my problem.
I found my problem in the full program, and I show it below in the
function loadResource. Rather than (as I hoped) using
auto_ptr<istream>::auto_ptr( istream * ), the return statement is in
fact calling auto_ptr_ref<istream>::auto_ptr_ref( void * ) then
auto_ptr( auto_ptr_ref<istream> & ). The pointer stored in the
auto_ptr_ref is statically cast to (auto_ptr<istream> *) when it is
really a (ifstream *) at heart. Cue problems.
istream_ptr loadResource( string const & name ) {
return new fstream( name.c_str(), ios::binary );
// Above line should be the following
//return istream_ptr( new fstream( name.c_str(), ios::binary ) );
}
int main() {
istream_ptr in = loadResource( "ptr_test.cpp" );
char ch;
in->read( &ch, 1 );
return 0;
}
// ---------- Begin ptr_test.cpp ----------
#include <algorithm>
#include <istream>
#include <fstream>
#include <memory>
using namespace std;
// Ownership transfering pointer to input
stream //////////////////////
//#define USE_AUTO_PTR
#if defined(USE_AUTO_PTR)
typedef auto_ptr<istream> istream_ptr;
#else
/* Not using copy constructor in example, so I won't bother writing
* a standards compliant one here. Nor assignment operator. Instead
* I'll make them private to be sure they're not generated.
*/
template <class T>
struct ptr {
ptr( T * ptr ) : _ptr( ptr ) {}
//ptr( ptr<T> & other ) : _ptr( 0 ) { swap( other ); }
~ptr() { if ( _ptr ) delete _ptr; }
T * operator->() const { return _ptr; }
private:
ptr( ptr<T> const & );
ptr<T> & operator=( ptr<T> const & );
//void swap( ptr<T> & other ) { std::swap( _ptr, other._ptr ); }
T * _ptr;
};
typedef ptr<istream> istream_ptr;
#endif
// Simple test
case ///////////////////////////////////////////////////
int main() {
istream_ptr in = new fstream( "ptr_test.cpp", ios::binary );
Try:
istream_ptr in(new fstream( "ptr_test.cpp", ios::binary ));
That avoids creating a temporary, for which a copy constructor would be
needed that takes a const istream_ptr as argument. std::auto_ptr doesn't
have that (and neither does your class, so it shouldn't compile either).
char ch;
in->read( &ch, 1 );
return 0;
}
// ---------- End ptr_test.cpp ----------