Гибкий класс регистратора с помощью стандартных потоков в C++
я хотел бы создать гибкий класс регистратора. Я хочу, чтобы это смогло к выходным данным в файл или в стандартный вывод. Кроме того, я хочу использовать потоки. Класс должен посмотреть что-то как:
class Logger
{
private:
std::ostream m_out; // or ofstream, iostream? i don't know
public:
void useFile( std::string fname);
void useStdOut();
void log( symbol_id si, int val );
void log( symbol_id si, std::string str );
//etc..
};
symbol_id перечисление и определяет форматирование. То, чего я хочу достигнуть, должно смочь легко переключиться от стандартного вывода до файла и наоборот (это - цель use* методы). Предпочтительно, просто используя m_out и просто запись m_out << "something"; без любых проверок, хочу ли я записать в файл или stdout.
Я знаю, что существует много путей, как обойти это (использование if's протестировать, если я хочу записать в файл или stdout, "C путь" (использование FILE* и fprintf)) и так далее, но я уверен, что должен быть путь, как достигнуть этого с потоками C++ хорошим способом. Но я, может казаться, не нахожу путь, как сделать это. Кто-то может помочь мне?
4 ответа
Раньше я пытался решить эту проблему, сделав Logger абстрактным базовым классом и создав отдельные классы FileLogger и OutStreamLogger . Затем создайте объект CompositeLogger , который реализует интерфейс Logger , который просто выводит все регистраторы:
CompositeLogger compLogger;
compLogger.Add(new FileLogger("output.txt"));
compLogger.Add(new StreamLogger(std::cout));
...
compLogger.log(...);
Если вам не нужен такой уровень гибкости и вы хотите сохранить все это в единственный класс, вы можете сделать переменную m_Out указателем на std :: ostream и добавить дополнительный флаг, чтобы отслеживать, нужно ли вам удалять его при очистке:
private:
std::ostream* m_out;
bool m_OwnsStream;
Logger() {
m_Out=&std::cout; // defaults to stdout
m_OwnsStream=false;
}
void useFile(std::string filename) {
m_Out=new std::ofstream(filename);
m_OwnsStream=true;
}
~Logger() {
if (m_OwnStream)
delete m_Out;
}
Очевидно, вам потребуются дополнительные проверки в useFile и useStdOut для предотвращения утечек памяти.
Dr. Доббс опубликовал статью, которую я вдохновил на ведение журнала. Стоит прочитать. http://www.drdobbs.com/cpp/201804215
Похоже, совсем недавно была опубликована еще одна статья, но я ее не читал. http://www.drdobbs.com/cpp/225700666
Вариация решения the_mandrill, для этого я решил, что шаблон Strategy лучше подходит для этой задачи, концептуально.
Мы можем изменить стратегию ведения журнала в любое время, просто вызвав context->SetLogger.
Мы также можем использовать разные файлы для файлового логгера.
class Logger
{
protected:
ostream* m_os;
public:
void Log(const string& _s)
{
(*m_os) << _s;
m_os->flush();
}
};
class FileLogger : public Logger
{
string m_filename;
public:
explicit FileLogger(const string& _s)
: m_filename(_s)
{
m_os = new ofstream(m_filename.c_str());
}
~FileLogger()
{
if (m_os)
{
ofstream* of = static_cast<ofstream*>(m_os);
of->close();
delete m_os;
}
}
};
class StdOutLogger : public Logger
{
public:
StdOutLogger()
{
m_os = &std::cout;
}
};
class Context
{
Logger* m_logger;
public:
explicit Context(Logger* _l) {m_logger = _l;}
void SetLogger(Logger* _l) {m_logger = _l;}
void Log(const string& _s)
{
if (m_logger)
{
m_logger->Log(_s);
}
}
};
int main()
{
string filename("log.txt");
Logger* fileLogger = new FileLogger(filename);
Logger* stdOutLogger = new StdOutLogger();
Context* context = new Context(fileLogger);
context->Log("this log out to file\n");
context->SetLogger(stdOutLogger);
context->Log("this log out to standard output\n");
}
Классы std :: o * stream в C ++ наследуются от std :: ostream. Это означает, что вы должны писать свой интерфейс в зависимости от указателя std :: ofstream или ссылки:
class Logger
{
std::ostream *m_out; // use pointer so you can change it at any point
bool m_owner;
public:
// constructor is trivial (and ommited)
virtual ~Logger()
{
setStream(0, false);
}
void setStream( std::ostream* stream, bool owner )
{
if(m_owner)
delete m_out;
m_out = stream;
m_owner = owner;
}
template<typename T>
Logger& operator << (const T& object)
{
if(!m_out)
throw std::runtime_error("No stream set for Logger class");
(*m_out) << object;
return *this;
}
};
// usage:
Logger logger;
logger.setStream( &std::cout, false ); // do not delete std::cout when finished
logger << "This will be logged to std::cout" << std::endl;
// ...
logger.setStream(
new std::ofstream("myfile.log", std::ios_base::ate|std::ios_base::app),
true ); // delete the file stream when Logger goes out of scope
logger << "This will be appended to myfile.log" << std::endl;