templatized logging

I'd like to include some very simple logging in my app - removable at
compile time.

Avoiding macros .. I want to make sure this nonsense would be
optimized away by the compiler if I don't need it.


template<bool b>
void
log(const char* msg)
{
if (b == true)
{
std::cout << msg << std::endl;
}
}

....

const bool is_log_on = false;

int
main(int argc, char* argv)
{
...
log<is_log_on>("I am here.");
...
}



Since "is_log_on" evaluates to false at compile time, I'm hoping the
compiler optimizes it away so there is absolutely no affect on
performance. Is there a well-known problem with this approach or
extending it into a full blown out logging template class?

<offtopic>
Google and my ISPs newsgroup servers are so slow. Can anyone recommend
a free or relatively inexpensive good newgroup server to use?
</offtopic>

Thanks,

-Luther

re: templatized logging

Luther Baker wrote:[color=blue]
> I'd like to include some very simple logging in my app - removable at
> compile time.[/color]

Why not run-time?
[color=blue]
> Avoiding macros .. I want to make sure this nonsense would be
> optimized away by the compiler if I don't need it.[/color]

Once you get used to logging, you will always need it.
[color=blue]
> template<bool b>
> void
> log(const char* msg)
> {
> if (b == true)
> {
> std::cout << msg << std::endl;
> }
> }
>
> ...
>
> const bool is_log_on = false;
>
> int
> main(int argc, char* argv)
> {
> ...
> log<is_log_on>("I am here.");[/color]

That doesn't _remove_ it. It just prevents it from outputting.
[color=blue]
> ...
> }
>
>
>
> Since "is_log_on" evaluates to false at compile time, I'm hoping the
> compiler optimizes it away so there is absolutely no affect on
> performance.[/color]

If performance is your concern, you should simply turn the logging off by
default when running. And turn it on if needed.
[color=blue]
> Is there a well-known problem with this approach or
> extending it into a full blown out logging template class?[/color]

A problem I know of is often poor knowledge of available solutions that
leads to spending too much time on re-inventing wheels making them square
or triangular. Look at

http://logging.apache.org/log4cxx/

Victor

re: templatized logging

"Luther Baker" <lutherbaker@yahoo.com> wrote in message
news:46d514a2.0405211010.1964715b@posting.google.c om...[color=blue]
> I'd like to include some very simple logging in my app - removable at
> compile time.
>
> Avoiding macros .. I want to make sure this nonsense would be
> optimized away by the compiler if I don't need it.
>
>
> template<bool b>
> void
> log(const char* msg)
> {
> if (b == true)
> {
> std::cout << msg << std::endl;
> }
> }
>
> ...
>
> const bool is_log_on = false;
>
> int
> main(int argc, char* argv)
> {
> ...
> log<is_log_on>("I am here.");
> ...
> }
>
>
>
> Since "is_log_on" evaluates to false at compile time, I'm hoping the
> compiler optimizes it away so there is absolutely no affect on
> performance. Is there a well-known problem with this approach or
> extending it into a full blown out logging template class?[/color]

If you use a template class then you can specialise it rather than using a
runtime if statement.

template <bool on>
class Logger
{
public:
static void log()
{
cout << "here\n";
}
};

template <>
class Logger<false>
{
public:
void log()
{
}
};

const bool logging = true;

int main()
{
X<logging>::f();
}

More chance of the compiler performing the necessary optimisation if you
give it a little help.

john

re: templatized logging

lutherbaker@yahoo.com (Luther Baker) wrote in message
[color=blue]
> I'd like to include some very simple logging in my app - removable at
> compile time.
>
> Avoiding macros .. I want to make sure this nonsense would be
> optimized away by the compiler if I don't need it.
>
>
> template<bool b>
> void
> log(const char* msg)
> {
> if (b == true)
> {
> std::cout << msg << std::endl;
> }
> }
>
> ...
>
> const bool is_log_on = false;
>
> int
> main(int argc, char* argv)
> {
> ...
> log<is_log_on>("I am here.");
> ...
> }
>
>
>
> Since "is_log_on" evaluates to false at compile time, I'm hoping the
> compiler optimizes it away so there is absolutely no affect on
> performance. Is there a well-known problem with this approach or
> extending it into a full blown out logging template class?[/color]

The optimization may happen on your compiler -- check the assembly to
be sure. To improve the chances of optimization, make the function
inline. If this doesn't work, provide a specialization of log<false>
which does nothing and dispense with the if statement inside
log<true>. Let us know your findings, what compiler you used,
compiler flags, etc.

Note one normally says,

log << "hello" << x+1;

So even if logging is off, the compiler may still evaluate "hello" and
x+1. If it knows that evaluating x+1 has no side effects and
operator<< does nothing if bool is_log_on = false, then it need not
evaluate x+1. But I don't think most compilers do this level of
optimization.

As a design issue, I'd declare const bool _log_on = true or false at
the top, and so in code I just write log("I am here."); instead of
log<is_log_on>("I am here.");. But that's your call.

re: templatized logging

John Harrison wrote:
[color=blue]
> "Luther Baker" <lutherbaker@yahoo.com> wrote in message
> news:46d514a2.0405211010.1964715b@posting.google.c om...[/color]
....[color=blue]
>
>
> If you use a template class then you can specialise it rather than using a
> runtime if statement.
>
> template <bool on>
> class Logger
> {
> public:
> static void log()
> {
> cout << "here\n";
> }
> };
>
> template <>
> class Logger<false>
> {
> public:
> void log()
> {
> }
> };
>
> const bool logging = true;
>
> int main()
> {
> X<logging>::f();
> }
>
> More chance of the compiler performing the necessary optimisation if you
> give it a little help.[/color]

Oh yes. I overlooked that completely - so much cleaner than a macro.

Thanks again,

-Luther