Problem with C ++ Templates

Question

I am trying to create a small library of magazines. I am looking at some problems with C ++ templates. This is what my class structure looks like.

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;

Here I expect stdout_logger_t :: log to come out. but it looks like the derived type is lost and abstract_logger_t :: log ends up being called. Can someone tell me that I am doing something wrong?

Answer 1

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

Here, regardless of loggerwhere you go, the compiler will convert it to abstract_logger_t&. You also need to make the first template of templates.

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

Answer 2

, . , , . . , .

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;

, , std:: endl.

Answer 3

, . , abstract_logger_t . < logger_t = abstract_logger_t. , . - . .

BTW: CamlCase .