C++ C+的问题+；模板

我正试图建立一个小型日志库。 我面临C++模板的一些问题。 下面是我的班级结构

class abstract_logger_t  {
public:
  typedef abstract_logger_t logger_type;
  template<typename data_t>
  abstract_logger_t& log(const data_t& data)  {
    return *this;
  }
};

class stdout_logger_t : public abstract_logger_t  {
public:
  typedef stdout_logger_t logger_type;
  template<typename data_t>
  stdout_logger_t& log(const data_t& data)  {
    cout << data << endl;
    return *this;
  }
};


template<typename logger_t, typename data_t>
void output(logger_t& logger, const data_t& data)  {
  static_cast<typename logger_t::logger_type&>(logger).log(data);
  cout << data;
}


template<typename data_t>
abstract_logger_t& operator<< (abstract_logger_t& logger, const data_t& data)  {
  output(logger, data);
  return logger;
}


stdout_logger_t logger;
logger << "Hi " << 1;

类抽象记录器\u t{
公众：
typedef abstract_logger_t logger_type；
模板
摘要日志记录器日志（常量数据）{
归还*这个；
}
};
类stdout\u logger\u t:public abstract\u logger\u t{
公众：
类型定义标准输出记录器类型；
模板
标准输出记录器和日志（常数数据和数据）{
没有必要把事情弄得过于复杂。
这里的Heritage是无用的，除非您想使用虚拟方法，在这种情况下，您不会太多地使用模板。
这是您的代码的更新版本。当您需要新的记录器类时，只需添加其他记录器类

class stdout_logger_t 
{
public:
  typedef stdout_logger_t logger_type;
  template<typename data_t>
  logger_type& log(const data_t& data)  {
    cout << data << endl;
    return *this;
  }
};
class lazy_logger_t 
{
public:
  typedef lazy_logger_t logger_type;
  template<typename data_t>
  logger_type& log(const data_t& data)  {
    return *this;
  }
};    
template<typename logger_t, typename data_t>
void output(logger_t& logger, const data_t& data)  {
  logger.log(data);
}
template<typename logger_t, typename data_t>
logger_t& operator<< (logger_t& logger, const data_t& data)  {
  output(logger, data);
  return logger;
}

stdout_logger_t logger;
lazy_logger_t lazyLogger;
logger << "Hi " << 1;
lazyLogger << "Hi " << 1;

class标准输出记录器
{
公众：
类型定义标准输出记录器类型；
模板
记录器类型和日志（常数数据和数据）{
cout您似乎将模板与运行时多态性混淆。此外，您的抽象\u logger\t类不是抽象的。您正在调用运算符的输出。为什么要强制转换日志程序？如果没有静态强制转换，模板不工作吗？此外，这将在
中的每个表达式后放置一个
std:：endl
template<typename T, typename data_t>
T& operator<< (T& logger, const data_t& data)  {
  output(logger, data);
  return logger;
}

class stdout_logger_t 
{
public:
  typedef stdout_logger_t logger_type;
  template<typename data_t>
  logger_type& log(const data_t& data)  {
    cout << data << endl;
    return *this;
  }
};
class lazy_logger_t 
{
public:
  typedef lazy_logger_t logger_type;
  template<typename data_t>
  logger_type& log(const data_t& data)  {
    return *this;
  }
};    
template<typename logger_t, typename data_t>
void output(logger_t& logger, const data_t& data)  {
  logger.log(data);
}
template<typename logger_t, typename data_t>
logger_t& operator<< (logger_t& logger, const data_t& data)  {
  output(logger, data);
  return logger;
}

stdout_logger_t logger;
lazy_logger_t lazyLogger;
logger << "Hi " << 1;
lazyLogger << "Hi " << 1;