Creating a new primitive type

Is there a way to create a new type that is like one of the basic types (eg char), and can be implcitly converted between, but will resolve diffrently in templates, such that for example, the following code works?

typedef char utf8;
template<typename T>void f(T c);
template<> void f<char>(char c)
{
    std::cout << "ascii " << c << std::endl;
}
template<> void f<utf8>(utf8 c)//error C2766: explicit specialization; 'void f<char>(char)' has already been defined
{
    std::cout << "utf8 " << c << std::endl;
}
int main()
{
    char c1 = 'x';
    utf8 c2 = 'g';
    f(c1);
    f(c2);
}

I'm thinking that it may be possible with a class containing a single data member, if so what is the cleanest way to do it, and will compilers be able to optimise it as if it was a primitive.

EDIT: I tried BOOST_STRONG_TYPEDEF, and that seems to work for basic things, but how can I then go onto create a std::basic_string from the new type?

BOOST_STRONG_TYPEDEF(char,utf8);
//first try
BOOST_STRONG_TYPEDEF(std::string,utf8_string);
//second try
typedef std::basic_string<utf8, std::char_traits<utf8>,std::allocator<utf8> > uft8_string;

The first one doesn't really work because the resulting type still expects char for all its methods, and the second one doesn't seem to like the presence of constructors and assignment operators :(

I haven't tried the other way to create the new char type yet, will it be able to get around this if I can开发者_C百科t with BOOST_STRONG_TYPEDEF?

C++ author Matthew Wilson calls what you're describing "true typedefs." They're implemented as a class containing a single data member (just like you said). He describes them and provides a template implementation in chapter 18 of Imperfect C++ (good book, by the way) and in this article in Dr. Dobb's Journal.

Regarding optimization, any good compiler should be able to optimize this as a primitive (since large parts of the STL, for example, rely on good quality optimizations like this), but I don't have any specifics.

I heard a rumour that C++0x will bring strong typedefs which will allow for the utf8 class in your case to be distinguishable from the char, but that doesn't exist currently. Maybe Boost's strong typedef would help, but I don't know.

The problem here is that typedef doesn't really define new types (like say Ada, where you can define mutually incompatable integer types), just aliases for existing ones.

I believe one of the proposals for the next version of C++ will include proper types.