Class that can log what it's doing...sometimes

[Eric Lilja]

Hello, I have a class that I want to be able to output detailed information
about what it's doing either
to a file or to the screen. What I first tried was adding a
std::ostream-reference member variable to
the class and then adding a constructor that, apart from the "normal"
arguments, also took an std::ostream&.
I then intended to set a boolean member variable called logging to true and
have the other member functions
check that variable to determine whether they should perform logging or not.
Something like:

class foo
{
public:
foo(args); /* logging set to false, m_out set to nothing */
foo(args, std::ostream& out); /* logging set to true, m_out set to out */

void bar(); /* log to m_out if logging == true */

private:
std::ostream& m_out;
bool logging;
};

I thought about what would happen if I in a member function forgot to check
the value of logging and tried
to use m_out without it referencing something. However, I didn't get that
far because the compiler stopped
me saying that I must initialize m_out (which I didn't do in the first
constructor).
I understand why...there is no such thing as a NULL reference, it has to be
a reference to a valid object
and it may never be set to reference something else.
So I was thinking having the second constructor accepting a const
std::string& instead and that string would
hold a file name and then I would open a file with that name and log to it.
But that variant isn't very
satisfying because then the user wont be able to log directly to cout or
cerr...how do I proceed? I could solve
it by using the preprocessor...#ifndef LOGGING, and that would probably
yield faster code for the times
when I dont want logging turned on because I never would have to check any
flags or something (and yield
a smaller program), but it's not very flexible.

/ Eric

[Victor Bazarov]

Eric Lila wrote:

Hello, I have a class that I want to be able to output detailed information
about what it's doing either
to a file or to the screen. What I first tried was adding a
std::ostream-reference member variable to
the class and then adding a constructor that, apart from the "normal"
arguments, also took an std::ostream&.
I then intended to set a boolean member variable called logging to true and
have the other member functions
check that variable to determine whether they should perform logging or not.
Something like:

class foo
{
public:
foo(args); /* logging set to false, m_out set to nothing */
foo(args, std::ostream& out); /* logging set to true, m_out set to out */

void bar(); /* log to m_out if logging == true */

private:
std::ostream& m_out;
bool logging;
};

I thought about what would happen if I in a member function forgot to check
the value of logging and tried
to use m_out without it referencing something. However, I didn't get that
far because the compiler stopped
me saying that I must initialize m_out (which I didn't do in the first
constructor).
I understand why...there is no such thing as a NULL reference, it has to be
a reference to a valid object
and it may never be set to reference something else.
So I was thinking having the second constructor accepting a const
std::string& instead and that string would
hold a file name and then I would open a file with that name and log to it.
But that variant isn't very
satisfying because then the user wont be able to log directly to cout or
cerr...how do I proceed? I could solve
it by using the preprocessor...#ifndef LOGGING, and that would probably
yield faster code for the times
when I dont want logging turned on because I never would have to check any
flags or something (and yield
a smaller program), but it's not very flexible.

I would give 'out' a default value, which is, say, a static member of
your 'foo' class, and is essentially a /dev/null kind of stream:

class foo {
foo(args, std::ostream &s = foo::nullstream);
static std::ostream& nullstream;
};

std::ostream& foo::nullstream = ??? ;

You would have to find a decent implementation of the nullstream (I am
not that good with streams to give you a one-liner for it). All you
need is a stream whose buffer would just eat all and do nothing. I bet
there are implementations of it out there.

V

[Eric Lilja]

"Victor Bazarov" <v.********@comAcast.net> wrote in message
news:Kg*****************@newsread1.dllstx09.us.to. verio.net...

Eric Lila wrote:

Hello, I have a class that I want to be able to output detailed
information about what it's doing either
to a file or to the screen. What I first tried was adding a
std::ostream-reference member variable to
the class and then adding a constructor that, apart from the "normal"
arguments, also took an std::ostream&.
I then intended to set a boolean member variable called logging to true
and have the other member functions
check that variable to determine whether they should perform logging or
not. Something like:

class foo
{
public:
foo(args); /* logging set to false, m_out set to nothing */
foo(args, std::ostream& out); /* logging set to true, m_out set to out
*/

void bar(); /* log to m_out if logging == true */

private:
std::ostream& m_out;
bool logging;
};

I thought about what would happen if I in a member function forgot to
check the value of logging and tried
to use m_out without it referencing something. However, I didn't get that
far because the compiler stopped
me saying that I must initialize m_out (which I didn't do in the first
constructor).
I understand why...there is no such thing as a NULL reference, it has to
be a reference to a valid object
and it may never be set to reference something else.
So I was thinking having the second constructor accepting a const
std::string& instead and that string would
hold a file name and then I would open a file with that name and log to
it. But that variant isn't very
satisfying because then the user wont be able to log directly to cout or
cerr...how do I proceed? I could solve
it by using the preprocessor...#ifndef LOGGING, and that would probably
yield faster code for the times
when I dont want logging turned on because I never would have to check
any flags or something (and yield
a smaller program), but it's not very flexible.

I would give 'out' a default value, which is, say, a static member of
your 'foo' class, and is essentially a /dev/null kind of stream:

class foo {
foo(args, std::ostream &s = foo::nullstream);
static std::ostream& nullstream;
};

std::ostream& foo::nullstream = ??? ;

You would have to find a decent implementation of the nullstream (I am
not that good with streams to give you a one-liner for it). All you
need is a stream whose buffer would just eat all and do nothing. I bet
there are implementations of it out there.

V

That seems to be a nice solution! I am googling right now to see what I
can find, no luck yet though. Lots of hits, just not found what I'm looking
for yet.

Thanks Victor

/ Eric

[Ron Natalie]

Eric Lilja wrote:

private:
std::ostream& m_out;
bool logging;
};

One option to your problem would be to add a null output
device.

class NullStreamBuf : public streambuf {
int_type overflow(int_type c) { return c; }

} ;

class NullStream : public ostream
public:
NullStream() : ostream(new NullStreamBuf) { }
~NullStream() { delete rdbuf(); }

};

You can then output to the stream to your heart's content
and the data is just discarded.

[Victor Bazarov]

Eric Lilja wrote:

[...] I am googling right now to see what I
can find, no luck yet though. Lots of hits, just not found what I'm looking
for yet.

See Ron's post.

[Vyacheslav Kononenko]

Eric Lilja wrote:

Hello, I have a class that I want to be able to output detailed information
about what it's doing either
to a file or to the screen. What I first tried was adding a
std::ostream-reference member variable to
the class and then adding a constructor that, apart from the "normal"
arguments, also took an std::ostream&.
I then intended to set a boolean member variable called logging to true and
have the other member functions
check that variable to determine whether they should perform logging or not.
Something like:

class foo
{
public:
foo(args); /* logging set to false, m_out set to nothing */
foo(args, std::ostream& out); /* logging set to true, m_out set to out */

void bar(); /* log to m_out if logging == true */

private:
std::ostream& m_out;
bool logging;
};

I thought about what would happen if I in a member function forgot to check
the value of logging and tried
to use m_out without it referencing something. However, I didn't get that
far because the compiler stopped
me saying that I must initialize m_out (which I didn't do in the first
constructor).
I understand why...there is no such thing as a NULL reference, it has to be
a reference to a valid object
and it may never be set to reference something else.
So I was thinking having the second constructor accepting a const
std::string& instead and that string would
hold a file name and then I would open a file with that name and log to it.
But that variant isn't very
satisfying because then the user wont be able to log directly to cout or
cerr...how do I proceed? I could solve
it by using the preprocessor...#ifndef LOGGING, and that would probably
yield faster code for the times
when I dont want logging turned on because I never would have to check any
flags or something (and yield
a smaller program), but it's not very flexible.

/ Eric

You can use something like this:
#include <iostream>

class Logger {
public:
Logger() : stream(0) {}
Logger( std::ostream &out ) { enable( out ); }

template <class T>
Logger &operator<<(T t) { if( stream ) *stream << t; return *this; }

Logger &operator<<( std::ostream&(*manip)(std::ostream&) ) { if(
stream ) *stream << manip; return *this; }

void enable( std::ostream &out ) { stream = &out; }
void disable() { stream = 0; }
private:
std::ostream *stream;
};

int main()
{
Logger log( std::cout );

log << "hello world" << std::endl;
log.disable();
log << "hello world again" << std::endl;

return 0;
}

So just create an instance of Logger as member in your class and use it
for logging in methods.
--
Regards,
Slava

[Vyacheslav Kononenko]

Eric Lilja wrote:

Hello, I have a class that I want to be able to output detailed information
about what it's doing either
to a file or to the screen. What I first tried was adding a
std::ostream-reference member variable to
the class and then adding a constructor that, apart from the "normal"
arguments, also took an std::ostream&.
I then intended to set a boolean member variable called logging to true and
have the other member functions
check that variable to determine whether they should perform logging or not.
Something like:

class foo
{
public:
foo(args); /* logging set to false, m_out set to nothing */
foo(args, std::ostream& out); /* logging set to true, m_out set to out */

void bar(); /* log to m_out if logging == true */

private:
std::ostream& m_out;
bool logging;
};

I thought about what would happen if I in a member function forgot to check
the value of logging and tried
to use m_out without it referencing something. However, I didn't get that
far because the compiler stopped
me saying that I must initialize m_out (which I didn't do in the first
constructor).
I understand why...there is no such thing as a NULL reference, it has to be
a reference to a valid object
and it may never be set to reference something else.
So I was thinking having the second constructor accepting a const
std::string& instead and that string would
hold a file name and then I would open a file with that name and log to it.
But that variant isn't very
satisfying because then the user wont be able to log directly to cout or
cerr...how do I proceed? I could solve
it by using the preprocessor...#ifndef LOGGING, and that would probably
yield faster code for the times
when I dont want logging turned on because I never would have to check any
flags or something (and yield
a smaller program), but it's not very flexible.

/ Eric

You can use something like this:
#include <iostream>

class Logger {
public:
Logger() : stream(0) {}
Logger( std::ostream &out ) { enable( out ); }

template <class T>
Logger &operator<<(T t) { if( stream ) *stream << t; return *this; }

Logger &operator<<( std::ostream&(*manip)(std::ostream&) ) { if(
stream ) *stream << manip; return *this; }

void enable( std::ostream &out ) { stream = &out; }
void disable() { stream = 0; }
private:
std::ostream *stream;
};

int main()
{
Logger log( std::cout );

log << "hello world" << std::endl;
log.disable();
log << "hello world again" << std::endl;

return 0;
}

So just create an instance of Logger as member in your class and use it
for logging in methods.
--
Regards,
Slava

[Eric Lilja]

"Ron Natalie" wrote:

Eric Lilja wrote:

private:
std::ostream& m_out;
bool logging;
};

One option to your problem would be to add a null output
device.

class NullStreamBuf : public streambuf {
int_type overflow(int_type c) { return c; }

} ;

class NullStream : public ostream
public:
NullStream() : ostream(new NullStreamBuf) { }
~NullStream() { delete rdbuf(); }

};

You can then output to the stream to your heart's content
and the data is just discarded.

Thanks Ron, your version was a bit simpler than the one I found at
http://www.msobczak.com/prog/downloads.html (nullstream).

My constructor now takes a std::ostream& as its last argument and that
argument
has a default value:
foo(args, std::ostream& out = foo::nullstream);
where nullstream is a static data member of foo defined as:
std::ostream& LinearHashTable::nullstream = *( new NullStream());
The fact that I am using new is a bit troubling but then again, I cannot
reference a temporary. I guess I don't have to worry about deleting it,
because
it will be destroyed when the program exits and then all memory is returned
to OS, right?

Now I wonder if should check if out is actually a NullStream (and how would
I do that?) or not and set
the logging member variable accordingly or just skip that and always write
to
the stream (thinking about performance here).

/ Eric

[Ron Natalie]

Vyacheslav Kononenko wrote:

class Logger {
public:
Logger() : stream(0) {}
.... int main()
{
Logger log( std::cout );

log << "hello world" << std::endl;
log.disable();
log << "hello world again" << std::endl;

return 0;
}

So just create an instance of Logger as member in your class and use it
for logging in methods.

I don't suppose you actually tried the above. It isn't going
to work. Logger isn't derived from ostream, those endls aren't
going to work and you'll end up with other issues.

[Eric Lilja]

"Eric Lilja" <er*******************@yahoo.com> wrote in message
news:cn**********@news.island.liu.se...

"Ron Natalie" wrote:

Eric Lilja wrote:

private:
std::ostream& m_out;
bool logging;
};
One option to your problem would be to add a null output
device.

class NullStreamBuf : public streambuf {
int_type overflow(int_type c) { return c; }

} ;

class NullStream : public ostream
public:
NullStream() : ostream(new NullStreamBuf) { }
~NullStream() { delete rdbuf(); }

};

You can then output to the stream to your heart's content
and the data is just discarded.

Thanks Ron, your version was a bit simpler than the one I found at
http://www.msobczak.com/prog/downloads.html (nullstream).

My constructor now takes a std::ostream& as its last argument and that
argument
has a default value:
foo(args, std::ostream& out = foo::nullstream);
where nullstream is a static data member of foo defined as:
std::ostream& LinearHashTable::nullstream = *( new NullStream());
The fact that I am using new is a bit troubling but then again, I cannot
reference a temporary. I guess I don't have to worry about deleting it,
because
it will be destroyed when the program exits and then all memory is
returned
to OS, right?

Now I wonder if should check if out is actually a NullStream (and how
would I do that?) or not and set
the logging member variable accordingly or just skip that and always write
to
the stream (thinking about performance here).

I am testing if the std::ostream reference passed to the constructor is in
fact
a nullstream by performing a dynamic_cast. If the cast returns NULL, I set
logging to true.
/ Eric

/ Eric

[Rob Williscroft]

Ron Natalie wrote in news:41***********************@news.newshosting.co m in
comp.lang.c++:

So just create an instance of Logger as member in your class and use it
for logging in methods.
I don't suppose you actually tried the above.

Worked for me.
It isn't going
to work. Logger isn't derived from ostream, those endls aren't
going to work and you'll end up with other issues.

Such as?

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Victor Bazarov]

"Eric Lilja" <er*******************@yahoo.com> wrote...

[...]
I am testing if the std::ostream reference passed to the constructor is in
fact
a nullstream by performing a dynamic_cast. If the cast returns NULL, I set
logging to true.

Actually comparing addresses would be simpler, I believe:

foo(blah, std::ostream& s)
: m_out(s), logging(&s != &foo::nullstream) {}

V

[Buster]

Eric Lilja wrote:

Now I wonder if should check if out is actually a NullStream (and how
would I do that?) or not and set
the logging member variable accordingly or just skip that and always write
to
the stream (thinking about performance here).

I am testing if the std::ostream reference passed to the constructor is in
fact
a nullstream by performing a dynamic_cast. If the cast returns NULL, I set
logging to true.

If you're willing to put an if statement around every logging statement,
there's no point using a null_stream at all. You can just change the
reference to a pointer in your original class:

#include <ostream>

struct args { };

class foo
{
public:
foo (args) : m_out (0) { }
foo (args, std::ostream & out) : m_out (& out) { }

void bar ()
{
if (m_out)
{
(* m_out) << "Barring." << std::endl;
}
}
private:
std::ostream * m_out;
};

The gain in readability is small. How about something a little dirtier
for maximum performance:

#ifdef NDEBUG
#define IFDEBUG(a) 0
#else
#define IFDEBUG(a) a
#endif

#endif

#include <iostream>
#include <ostream>

int main ()
{
IFDEBUG ((std::cout << "Logging." << std::endl));
}

[Eric Fournier]

While using a nullstream sure provide a more elegant solution(Since it
cleans up the logging code), a simpler approach would simply have been to
switch from references to pointers, since pointers can indeed be null.

-Eric Fournier

"Eric Lilja" <er*******************@yahoo.com> a écrit dans le message de
news:cn**********@news.island.liu.se...

Hello, I have a class that I want to be able to output detailed information about what it's doing either
to a file or to the screen. What I first tried was adding a
std::ostream-reference member variable to
the class and then adding a constructor that, apart from the "normal"
arguments, also took an std::ostream&.
I then intended to set a boolean member variable called logging to true and have the other member functions
check that variable to determine whether they should perform logging or not. Something like:

class foo
{
public:
foo(args); /* logging set to false, m_out set to nothing */
foo(args, std::ostream& out); /* logging set to true, m_out set to out */
void bar(); /* log to m_out if logging == true */

private:
std::ostream& m_out;
bool logging;
};

I thought about what would happen if I in a member function forgot to check the value of logging and tried
to use m_out without it referencing something. However, I didn't get that
far because the compiler stopped
me saying that I must initialize m_out (which I didn't do in the first
constructor).
I understand why...there is no such thing as a NULL reference, it has to be a reference to a valid object
and it may never be set to reference something else.
So I was thinking having the second constructor accepting a const
std::string& instead and that string would
hold a file name and then I would open a file with that name and log to it. But that variant isn't very
satisfying because then the user wont be able to log directly to cout or
cerr...how do I proceed? I could solve
it by using the preprocessor...#ifndef LOGGING, and that would probably
yield faster code for the times
when I dont want logging turned on because I never would have to check any
flags or something (and yield
a smaller program), but it's not very flexible.

/ Eric

[John Harrison]

> My constructor now takes a std::ostream& as its last argument and that

argument
has a default value:
foo(args, std::ostream& out = foo::nullstream);
where nullstream is a static data member of foo defined as:
std::ostream& LinearHashTable::nullstream = *( new NullStream());
The fact that I am using new is a bit troubling but then again, I cannot
reference a temporary. I guess I don't have to worry about deleting it,
because
it will be destroyed when the program exits and then all memory is
returned
to OS, right?

No need for new. Just make nullstream an object not a reference

NullStream LinearHashTable::nullstream;

john

[Eric Lilja]

"John Harrison" <jo*************@hotmail.com> wrote in message
news:2v*************@uni-berlin.de...

My constructor now takes a std::ostream& as its last argument and that
argument
has a default value:
foo(args, std::ostream& out = foo::nullstream);
where nullstream is a static data member of foo defined as:
std::ostream& LinearHashTable::nullstream = *( new NullStream());
The fact that I am using new is a bit troubling but then again, I cannot
reference a temporary. I guess I don't have to worry about deleting it,
because
it will be destroyed when the program exits and then all memory is
returned
to OS, right?

No need for new. Just make nullstream an object not a reference

NullStream LinearHashTable::nullstream;

john

Thanks John, I've changed the type of the static data member nullstream from
std::ostream& to just NullStream.
When I first tried to define it I wrote NullStream
LinearHashTable::nullstream = NullStream();
I didn't realise that that code tried to use the copy constructor (which, as
you know, is private for ostreams), I changed to
your variant which invokes the default constructor.

/ Eric

[Vyacheslav Kononenko]

Eric Lilja wrote:

Now I wonder if should check if out is actually a NullStream (and how would
I do that?) or not and set
the logging member variable accordingly or just skip that and always write
to
the stream (thinking about performance here).
Look at my solution there is no such problem there.
/ Eric

--
Regards,
Slava

[Vyacheslav Kononenko]

Ron Natalie wrote:

Vyacheslav Kononenko wrote:

class Logger {
public:
Logger() : stream(0) {}

...

int main()
{
Logger log( std::cout );

log << "hello world" << std::endl;
log.disable();
log << "hello world again" << std::endl;

return 0;
}

So just create an instance of Logger as member in your class and use
it for logging in methods.

I don't suppose you actually tried the above. It isn't going
to work. Logger isn't derived from ostream, those endls aren't
going to work and you'll end up with other issues.

You are wrong. You just did not pay attention to this:
Logger &operator<<( std::ostream&(*manip)(std::ostream&) ) { if( stream
) *stream << manip; return *this; }

What are other issues?
--
Regards,
Slava

[Eric Lilja]

"Vyacheslav Kononenko" <vy********@NOkononenkoSPAM.net> wrote in message
news:%i*****************@mencken.net.nih.gov...

Eric Lilja wrote:

Now I wonder if should check if out is actually a NullStream (and how
would I do that?) or not and set
the logging member variable accordingly or just skip that and always
write to
the stream (thinking about performance here).

Look at my solution there is no such problem there.

/ Eric

--
Regards,
Slava

I will, thanks for your help, Slava. I'm always interested in different
approaches to problems. Even if I choose one
over the other this time it might be the other way around next time.

/ Eric

[Ron Natalie]

You are wrong. You just did not pay attention to this:
Logger &operator<<( std::ostream&(*manip)(std::ostream&) ) { if( stream
) *stream << manip; return *this; }

Sorry, you are right. What are other issues

It means you can't use this stream with things expecting
ostream. If your entire world is limitted to operator<<
that's fine.