Re: Using std::basic_string the extensible way
Stefan Chrobot schrieb:
I'm writing a class that contains a string. But I decided to make it
more extensible and turn it into a class template:
template<typename CharT>
class My
{
std::basic_string<CharT> text;
};
How do I operate on such a string, so that it will work for any valid
instantiation of basic_string? For example, I'd like to append some text
to the end of the string or check if the first letter is lowercase.
Currently I'm doing:
text += "some other text";
For wstring I should probably do:
test += L"some other text";
How do I do it in a generic way?
That depends on the meaning of these literals.
Are these only some selected literals of the
corresponding character type with a special
meaning? If so, than a character-depending
policy/traits class would be reasonable, which
would be explicitely specialized for the corresponding
value, e.g.
template <typename CharT>
class MyTraits;
template <>
struct MyTraits<char> {
static const char* append() {
return "some other text";
}
};
template <>
struct MyTraits<wchar_t> {
static const wchar_t* append() {
return L"some other text";
}
};
template<typename CharT>
class My
{
std::basic_string<CharT> text;
typedef MyTraits<CharT> Traits;
void foo() {
text += Traits::append();
}
};
Otherwise you could only declare the member
functions in the My class template and explicitely
specialize them for the corresponding character
type:
template<typename CharT>
class My
{
std::basic_string<CharT> text;
public:
void foo(); // Only declared, not defined
};
template<>
void My<char>::foo() {
text += "some other text";
}
template<>
void My<wchar_t>::foo() {
text += L"some other text";
}
In both cases some preprocessor magic
can help reducing the redundancies.
Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]