Pass string or wstring in a function - c++

Question

I want simplify the code to use the same function for both ANSI and UNICODE string version
tstring formatW(const std::string format, ...);
tstring formatA(const std::wstring format, ...);
in a single parametrized function
tstring format(const tstring format, ...);
However if I use this as, I get an error in line 3
const std::string fmtA = "MouseWheel nFlags %u,zDelta %d, CPoint(%d,%d";
std::string strA = formatA(fmtA, nFlags, zDelta, pt.x, pt.y ); // Ok
std::string strA2 = format (fmtA, nFlags, zDelta, pt.x, pt.y ); // Fail :(
const std::wstring fmtW = L"MouseWheel nFlags %u,zDelta %d, CPoint(%d,%d";
std::wstring strW = formatW(fmtW, nFlags, zDelta, pt.x, pt.y); // Ok
std::wstring strW2 = format (fmtW, nFlags, zDelta, pt.x, pt.y); // Fail
The error I get is this:
error C2664: ~tstring Format(const tstring,..'.)': cannot convert argument 1 from 'const std::string' to 'const tstring'
I am not familiar with parameteized functions.

Answer 1

char and wchar_t (the underyling types of string/wstring) are not compatible (8 and 16 bits) so you cannot combine them inside a runtime-checking environment.
That is why Windows for example has 2 versions for many functions (MessageBoxA, MessageBoxW etc).
Solution: use a class that stores data as UTF-8 (char) then converts them to 16-bit when wchar_t is needed. Or better, vice versa (uses wchar_t internally and converts data to UTF-8 when a char* is needed).

Answer 2

I'm assuming you have good reasons not to just do the Microsoft #ifdef UNICODE thing? It is a bit rubbish, I admit.
You can't check them at runtime, but this is exactly what c++ compile-time overloading was invented for.
So you probably need to do 3 different things:
1) Write 2 function prototypes that give you the behaviour you need
2) Convert them to take a variadic template argument list instead of ...
3) encapsulate it all in a templated class.
1) To declare and implement the two helper functions with the same name, just do that. The compiler will distinguish them based on the first parameter:
tstring format(const std::string& format, ...);
tstring format(const std::wstring& format, ...);
Of course you then end up writing the same boilerplate code twice, something like:
tstring format(const std::string& format, ...) {
va_list format; /// hmm va_list with references - may need a tweak!
va_start(format, __arg);
return vformatA(format, __arg);
}
And it is a pain writing this twice for each method you merge.
2) To use the variadic templates, Declare and implement your functions as:
template <typename... T>
tstring format(const std::string& format, const T& ... t)
{
return formatA(format, t...);
}
Again you need to write this twice. It isn't too complex compared to the c-style variadics, so you might accept that.
3) A third optional step is to write a Helper template class. So the idea of this is that the actual implementation is performed in a helper class, which you only define for string and wide string. To be honest all it does is add bulk and force you to implement both methods.

Answer 3

You could always use templates and limit them to only string and wstring type, so
template <typename T>
T format(const T format, ...);
and later declare two functions that will do what you want according to the type, so
std::string format<std::string>(const std::string format, ...){...}
std::wstring format<std::wstring>(const std::wstring format, ...){...}