i need advice

[vova]

i have the next source code:

class myClass
{
public:
myClass(ostream &out=cout) : m_out(out) { }
myClass(string &filename) :
_out(new ofstream(filena me.c_str())),
m_out(*_out) { }

write(cons string &text) { m_out << text; }
protected:
ostream &m_out;
auto_ptr<ostrea m> _out;
}

this is good (and nice). i can make a objects of this class like:
ofstream ofs("test");
myClass mclass(ofs);
or:
myClass mclass();
or:
myClass mclass("test");
and all will be good while i do not decide to make new member function
like this changeFile(stri ng &newfilename ), then i can write the next
code:

void changeFile(stri ng &newfilename )
{
_out = auto_ptr<ofstre am>(new ofstream(newfil ename));
// now _out is ok
m_out = *_out;
// this is not valid; the reference to object can't be changed
// in write function i will be need make checks and run *_out << text
// i don't like this variant
}

are you can help me?
10x in advance :)

[Victor Bazarov]

vo**@softhome.n et wrote:

i have the next source code:

class myClass
{
public:
myClass(ostream &out=cout) : m_out(out) { }
myClass(string &filename) :
_out(new ofstream(filena me.c_str())),
m_out(*_out) { }

write(cons string &text) { m_out << text; }
protected:
ostream &m_out;
auto_ptr<ostrea m> _out;
}

this is good (and nice).
It may be nice, but it's definitely not so good. You try to initialise
the member '_out' before 'm_out', but in fact, they are initialised in
the order they are declared in the class, IOW 'm_out' is initialised
first, then '_out'. What happens in that case is that 'm_out' is getting
its value from an uninitialised pointer. What you need is to swap the
declaration statements for 'm_out' and '_out' in your class definition.
i can make a objects of this class like:
ofstream ofs("test");
myClass mclass(ofs);
or:
myClass mclass();
No, that would be a function declaration.
or:
myClass mclass("test");
and all will be good
No, it won't be good.
while i do not decide to make new member function
like this changeFile(stri ng &newfilename ), then i can write the next
code:

void changeFile(stri ng &newfilename )
{
_out = auto_ptr<ofstre am>(new ofstream(newfil ename));
// now _out is ok
m_out = *_out;
// this is not valid; the reference to object can't be changed
// in write function i will be need make checks and run *_out << text
// i don't like this variant
}

are you can help me?

No, I am can't help you. References, once initialised, cannot be
changed to refer to something else. You need to drop the 'm_out' and
always use (*_out) in your code.

V

[vovata]

Hi Victor,
What you thing about this modifications:

class myClass
{
public:
myClass(ostream &out=cout) : m_out(out) { }
myClass(string &filename) :
_out(new ofstream(filena me.c_str())),
m_out(*_out) { }
~myClass() { }

write(cons string &text) { m_out << text; }
void changeFile(stri ng &newfilename )
{
this->~myClass();
new (this) myClass(newfile name);
}

protected:
auto_ptr<ostrea m> _out;
ostream &m_out;
}

and again:

ofstream ofs("test");
myClass mclass(ofs);
or:
myClass mclass;
or:
myClass mclass("test");

Regards,
Vladimir

[vovata]

Hi Victor,
What you thing about this modifications:

class myClass
{
public:
myClass(ostream &out=cout) : m_out(out) { }
myClass(string &filename) :
_out(new ofstream(filena me.c_str())),
m_out(*_out) { }
~myClass() { }

write(cons string &text) { m_out << text; }
void changeFile(stri ng &newfilename )
{
this->~myClass();
new (this) myClass(newfile name);
}

protected:
auto_ptr<ostrea m> _out;
ostream &m_out;
}

and again:

ofstream ofs("test");
myClass mclass(ofs);
or:
myClass mclass;
or:
myClass mclass("test");

Regards,
Vladimir

[Victor Bazarov]

vovata wrote:

What you thing about this modifications:

class myClass
{
public:
myClass(ostream &out=cout) : m_out(out) { }
myClass(string &filename) :
You should pass the string by a ref to const:

myClass(string const &filename) :
_out(new ofstream(filena me.c_str())),
m_out(*_out) { }
~myClass() { }

write(cons string &text) { m_out << text; }
'write' has no return value type. I recommend

ostream& write(const string &text) { return m_out << text; }
void changeFile(stri ng &newfilename )
Again, by a ref to _const_.
{
this->~myClass();
new (this) myClass(newfile name);
Well, legally this trick is allowed. And it's known to work.
Personally I don't like it.
}

protected:
auto_ptr<ostrea m> _out;
ostream &m_out;
The reordering of _out and m_out in the class definition is certainly
what you ought to do.
} ;

It looks OK, and is OK if it works for you. I just cringe every time
I see somebody uses that 'call the destructor and re-construct in place'
trick. Ah, don't mind me...

and again:

ofstream ofs("test");
myClass mclass(ofs);
or:
myClass mclass;
or:
myClass mclass("test");

It will be OK as soon as you change the 'string&' to 'string const&'.

V