Partial Method Specialization - c++

Question

I have a C++ class with a template method in Logger.hpp and I want to add specializationis to it to support other classes, such as an specialization in Player.hpp. I suppose what I'm going to achieve is called "partial method specialization", please correct me if I'm wrong.
I tried the following (simplified) code:
Logger.hpp
class Logger {
public:
template<typename T, typename... ArgTypes> void log(T message, ArgTypes... args) {
std::cout << message << std::endl;
// do more with args...
}
};
Player.hpp
#include "Logger.hpp"
class Player {
public:
Player(const std::string &name) : name(name) {}
std::string getName() const { return name; }
private:
std::string name;
};
// add support for logger->log(myPlayer, 19, 11)
// (19 and 11 are arbitrary arguments and can be of any number and types)
// unfortunately this line does not compile
// (declaration is incompatible with function template "void Logger::log(T message, ArgTypes ...args)")
template<typename... ArgTypes> void Logger::log<Player>(Player message, ArgTypes... args) {
std::cout << "Player(name=" << message.getName() << ")" << std::endl;
// do more with args...
}
How should I add the functionality to my Logger class to allow me to log my Player class (and other classes later)?
I do NOT want to add the specialication in Logger.hpp. It should be possible to handle Logger.hpp like a library and anyone is free to add support for their types in their code.
Also note that I pass a variadic argument (typename... ArgTypes) following the typed first argument.
Also note that overloading the << operator on the C++ output class is also NOT an option since the cout lines will be replaced by a different code later.

Answer 1

I found some workaround that will work in my specific case and it might also be the solution for others, having this kind of issue.
Instead of the first log parameter T being a template parameter, I choose the specific type std::string. As for other classes, I simply add a std::string conversion operator, which will produce any string I want.
This works fine for me since I'm dealing with strings in the end and I want to do the same with the args every time. The new code looks like this:
Logger.hpp
class Logger {
public:
template<typename... ArgTypes> void log(std::string message, ArgTypes... args) {
std::cout << message << std::endl;
// do more with args...
}
};
Player.hpp
#include "Logger.hpp"
class Player {
public:
Player(const std::string &name) : name(name) {}
std::string getName() const { return name; }
operator std::string() const {
return std::string("Player(name=") + name + ")";
}
private:
std::string name;
};
If I don't want to use the string conversion or if I want to pass some of the args to my function, another solution would be using base and sub class. Something like this could work (not tested):
Logger.hpp
class Loggable {
public:
virtual void logMe() = 0;
};
class Logger {
public:
template<typename T, typename... ArgTypes> void log(T message, ArgTypes... args) {
std::cout << message << std::endl;
// do more with args...
}
template<typename... ArgTypes> void log(Loggable *loggable, ArgTypes... args) {
loggable->logMe();
}
};
Player.hpp
#include "Logger.hpp"
class Player : public Loggable {
public:
Player(const std::string &name) : name(name) {}
std::string getName() const { return name; }
void logMe() override {
std::cout << "Player(name=" << message.getName() << ")" << std::endl;
}
private:
std::string name;
};