Segmentation fault trying to overload << operator - c++

Question

Beginning with C++, I've written that simple piece of code, which is designed to serve as a (very basic) logger. This is mainly to try overloading operators.
class Logger {
public:
Logger() : _has_logged_something(false) { };
template <typename T>
friend Logger& operator <<(Logger& logger, T const & value) {
logger._has_logged_something = true;
std::cerr << value;
return logger;
};
private:
bool _has_logged_something;
};
I need to remember when something has been loaded already, in the _has_logged_something instance variable. But this line is causing a very helpful Segmentation fault (core dumped) at runtime. Must be an obvious mistake, but I can't get it.
--
Edit
As this doesn't seem to be a problem with this piece of code, here is how it is used to avoid using singletons (probably not the best code ever, but anyway).
#ifndef _BORDERS_COMMON_LOGGER_LOGGER_HH_INCLUDED
#define _BORDERS_COMMON_LOGGER_LOGGER_HH_INCLUDED
#include "common/log/logger.hh"
#include "common/log/event.hh"
namespace {
static borders::common::log::Logger* _global_logger = NULL;
}
namespace borders {
namespace common {
namespace log {
inline bool is_global_instance_initialized() {
return _global_logger != NULL;
};
inline Logger& get_global_instance() {
if (_global_logger == NULL) _global_logger = new Logger;
return *_global_logger;
};
} // namespace log
} // namespace common
} // namespace borders
#define LOG_INFO() (borders::common::log::get_global_instance())
#define LOG_START()
#define LOG_STOP() \
if (borders::common::log::is_global_instance_initialized()) \
delete &borders::common::log::get_global_instance(); \
else \
(void) 0;
#endif // _BORDERS_COMMON_LOGGER_LOGGER_HH_INCLUDED
Given I try to run this with:
LOG_INFO() << "Foo" << "Bar"
Once again, the text gets written on console when I comment out the line I pointed out before.

Answer 1

OK, I got it!
I think. At least I have a guess
See, that line logger._has_logged_something = true is the only line that used the data of the class logger. So my guess is that the class is invalid
I mean that you didn't really create that class. For some reason it wasn't really allocated.
For example if you did:
Logger *log; // see - I didn't put any value to it!
(*log)<<value; // this will do a segmentation fault or something
// ONLY if you have the line logger._has_logged_something = true
This is just an example. There are other options like:
struct blah{
blah(Logger &log):logger(log);
Logger &logger;
};
blah func(){
Logger log;
return blah(log);
}
...
blah b=func(); // b has an invalid logger in it, because it was destroyed after func
blah.logger << value ; // will do a segmentation fault too
Edit
Just saw your edit. So it seems to be my first example. Specifically, I believe you did LOG_STOP() before you logged.
Edit 2
You have an intrinsic problem in your code. LOG_STOP deletes the logger, but doesn't reset it to NULL. So if you want to restart logging after that, the logger won't be recreated (as get_global_instance checks if the logger is NULL before deciding to create it).
Try changing LOG_STOP to set _global_logger to NULL and see if that fixes it.