Good point.

I hope the answer is:

- short circuited;

- type need not to be streamable.

The experiment shows that this's not the answer. There's no specialization for this case, so lexical_cast goes through all its regular machinery.

This is not a common usecase and I see only one practical use of it.

A user might want to write a template that uses lexical_cast without having to pay the performance cost when the cast isn't necessary. Specializing lexical_cast for this case would save the user from having to specialize his own template. I'm guessing template<typename Target> Target lexical_cast(const Target& arg) { return arg; } doesn't work because the compiler can't decide between lexical_cast<Foo> and lexical_cast for lexical_cast<Foo>(some_foo). Could something like template<typename T> T lexical_cast(const Target& arg) work? (My syntax might not be perfect; it's been a while since I've done partial specialization.) --Jeffrey Bosboom

I recall that function templates cannot be partially specialised, so we (or the user in question) would have to do complete specialisation instead, so the given type would have to be known.

Okay, so function templates can't be partially specialized like that, but class templates can, and classes can have static member functions. So how about template Target lexical_cast(const Source& arg) { return lexical_cast_impl::cast(arg); } template class lexical_cast_impl { inline static cast(const Source& arg) { /* ... */ } }; //partial specialization for Target = Source template<class Target> class lexical_cast_impl { inline static cast(const Source& arg) {return arg;} }; --Jeffrey Bosboom