How to use Templates when working with std::strings and c-style strings?

Question

I was just messing around with templates, when I tried to do this:

template<typename T> void print_error(T msg)
{
#ifdef PLATFORM_WIN32
    ::MessageBox(0, reinterpret_cast< LPCSTR >(msg), "Error", MB_ICONERROR|MB_OK);
#else
    cout << msg << endl;
#endif /* PLATFORM_WIN32 */
}

Of course this obviously will not work if you pass an std::string as T. Because a string can't be cast to a char*, But can this function be coded in a way that it will allow me to pass both a c-style char* array and a c++ std::string as the parameters, and convert them to LPCSTR ?

What is the purpose of `reinterpret_cast` in this code, apart from summoning troubles? — n. m. could be an AI, Jan 25 '12 at 11:30
Please note that `MessageBox` takes a **`LPCTSTR`**, which is a wide string or a narrow string depending on many factors. My guess is that if you want to be generic and safe, you have to copy the string somehow. You should decide for an internal representation (maybe UTF-8, so that you always use `char*` or `std::string`), and convert to the right Windows type at the `MessageBox` call site. Note that Windows will likely require you to use `wcout`, whereas on Linux, you should always go with `cout`. — Alexandre C., Jan 25 '12 at 11:48
You can test if `LPCTSTR` is made of wide characters by testing `#ifdef _UNICODE`. Unicode on Windows means (nowadays) UTF-16. — Alexandre C., Jan 25 '12 at 11:58
almost all suggestions are good and more or less working. I wonder which one should I accept? I'll wait a day or two to see which one gets the most upvotes. -_- — ApprenticeHacker, Jan 26 '12 at 09:24

score 5 · Accepted Answer · answered Jan 25 '12 at 11:22

5

You can use function overloading:

void print_error(char const* msg);
void print_error(std::string const& msg);
...

answered Jan 25 '12 at 11:22

Andriy Tylychko

15,967
6
64
112

2

void print_error(std::string const& msg) { print_error(msg.c_str()); } – Totonga Jan 25 '12 at 11:33
or even: `static inline void print_error(std::string const& msg) { print_error(msg.c_str()); }` to optimize it – Alexander Vassilev Jan 25 '12 at 13:43

score 3 · Answer 2 · answered Jan 25 '12 at 11:23

3

This would work:

#include <sstream>

template<typename T> void print_error(T msg)
{
    std::ostringstream s;
    s << msg;

#ifdef PLATFORM_WIN32
    ::MessageBox(0, s.str().c_str(), "Error", MB_ICONERROR|MB_OK);
#else
    cout << s.str() << endl;
#endif /* PLATFORM_WIN32 */
}

answered Jan 25 '12 at 11:23

hmjd

120,187
20
207
252

No, this wouldn't (but almost). The arguments of `MessageBox` could be wide strings, depending on the platform. – Alexandre C. Jan 25 '12 at 11:37

score 2 · Answer 3 · answered Jan 25 '12 at 13:35

There are several ways to achieve this. One is to combine templated functions with function overloading:

template<typename T>
void print_error(T msg)
{
   ::MessageBox(0, reinterpret_cast< LPCSTR >(msg), "Error", MB_ICONERROR|MB_OK);
   cout << msg << endl;
}

void print_error(const std::string& msg)
{
   ::MessageBox(0, reinterpret_cast< LPCSTR >(msg.c_str()), "Error", MB_ICONERROR|MB_OK);
   cout << msg << endl;
}

int main()
{
string test = "test";
print_error(test);
print_error("test");
return 0;
}

Another way is to partially specialize a class template (function templates cannot be partially specialized) to handle a tagged template argument which tells it that the value is an std::string:

template <typename T>
class StringArgument{};

template <typename T>
struct ErrorPrinter
{
static void print_error(T msg)
{
   ::MessageBox(0, reinterpret_cast< LPCSTR >(msg), "Error", MB_ICONERROR|MB_OK);
}
};

template <typename T>
struct ErrorPrinter<StringArgument<T> >
{
static void print_error(T msg)
{
   ::MessageBox(0, reinterpret_cast< LPCSTR >(msg.c_str()), "Error", MB_ICONERROR|MB_OK);
}
};

int main()
{
string test = "test";   
ErrorPrinter<const char*>::print_error("sdfsdfsdf");
ErrorPrinter<StringArgument<string> >::print_error(test);

return 0;
}

score 1 · Answer 4 · answered Jan 25 '12 at 13:51

1

To elaborate slightly on the solution offered by hmjd this solution should work with any string input, and also integers and the like. It should also work with unicode activated on windows.

#include <sstream>

template<typename T> void print_error(T msg)
{
#ifdef PLATFORM_WIN32
    std::basic_ostringstream< TCHAR > ss;
    ss << msg;
    ::MessageBox(0, ss.str().c_str(), "Error", MB_ICONERROR|MB_OK);
#else
    cout << msg << endl;
#endif /* PLATFORM_WIN32 */
}

answered Jan 25 '12 at 13:51

obmarg

9,369
36
59

True, but at the cost of performance when passing a plain char*, which would cause unnecessary copying of the string at least once, and generally the overhead of a stringstream when it is not always needed. This is a good generic function, but I think it should be specialized for char* and string – Alexander Vassilev Jan 26 '12 at 13:54

score 1 · Answer 5 · answered Jan 26 '12 at 09:31

You can enable print_error if T is char* else it will be compile time error i.e (you need include type_traits and c++11):

template<typename T> 
typename std::enable_if< std::is_same<T, char*>::value, void>::type print_error(T msg)
{
    ::MessageBox(0, reinterpret_cast< LPCSTR >(msg), "Error", MB_ICONERROR|MB_OK);
    cout << msg << endl;
}

How to use Templates when working with std::strings and c-style strings?

5 Answers5