Function template specialization

>(const std::locale& loc)

I have the following code:
>
template <class T>
struct MyS
{
};
>
template<class T>
inline const T& function(const std::locale& loc)
{
std::cout << "generic" << std::endl;
}
>
template <class CharType, class Traits, class Allocator>
inline const MyS< std::basic_string<CharType, Traits, Allocator&
function< MyS< std::basic_string<CharType, Traits, Allocator{
std::cout << "specialized" << std::endl;
}
>
int main(int argc, char* argv[])
{
function< MyS<std::string(std::locale()); //Should print
"specialized"
function< MyS<std::wstring(std::locale()); //Should print
"specialized"
function< MyS<int(std::locale()); //Should print "generic"
>
return 0;
}
>
Which doesn't compile, I believe it's because you can't partially
specialize function templates.

But I really need to
get the desired behavior(Note the "Should print"s in comments), how
can this be done ?

sheffm...@mail.ru wrote:>>>>>>>
Correct.
>>>
You can invent your own traits class and specialise that (or *on* that).
Full specialisations of function templates *are* allowed.

>
BTW, what's the role of 'MyS' template here? It seems superfluous.
>

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

On Jun 5, 1:05 am, Victor Bazarov <v.Abaza...@comAcast.netwrote:>
Oh, forgot to mention that I need to get this behavior without
changing the signature of generic function:
>
template<class T>
inline const T& function(const std::locale& loc)
>
Is it possible ?

sheffmail@mail.ru wrote:>
So, you have a function template that you want to behave differently if
you give it some special *set of* Ts, right. And that set is unbounded,
right? If it is, the solution is to wrap those in a class template and
specialise that:
>
template<class Tstruct Caller {
static T& call(const std::locale& loc) {
return function<T>(loc);
}
};
>
template<class T, class Ustruct Caller<MyS<T,U {
static MyS<T,U>& call(const std::locale& loc) {
return function<MyS<T,U(loc);
}
};
>
Of course in that case you need to refactor the code that calls the
functions from
>
function<blah>(loc);
>
to
>
Caller<blah>::function(loc);
>
V

Victor Bazarov wrote:>>>>>>>>>>>>>>
Or replace function<blahimplementation to forward to
Caller<blah>::function until you can refactor.
>
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>

That's the problem, I can't modify declaration nor implementation of
"generic" function, because it's actually std::use_facet from STL and
I need to specialize it for my type, which is std::ctype< MyS<...

On Jun 5, 2:15 am, sheffm...@mail.ru wrote:
>>
I don't know if this fit's all your requirements but here is the
closest I could get:
>
=== BEGIN CODE ===
>
template<class T>
inline const T& function(const std::locale& loc)
{
std::cout << "generic" << std::endl;
>
}
>
// this is your implementation of the specialized function; you only
have to
// do it once, at least that's a plus.
template <class T>
inline const MyS<T& function_mys (const std::locale &) {
std::cout << "specialized" << std::endl;
>
}
>
// but you still have to at least have these one-ish liners for each
string
// type; you lose some genericness there.
template <>
inline const MyS<std::string& function<MyS<std::string
(const std::locale &loc) {
return function_mys<std::string>(loc);
>
}
>
template <>
inline const MyS<std::wstring& function<MyS<std::wstring
(const std::locale &loc) {
return function_mys<std::wstring>(loc);
>
}
>
=== END CODE ===
>
The idea there is that you explicitly specialize for every
std::basic_string type you'll be using; but you pass everything off to
function_mys so you still only have to maintain one copy of the
specialized code. Still that means you lose the flexibility of passing
*any* basic_string<A,B,Csince you have to explicitly specialize each
of those short functions.
>
Jason