Title is a little ambiguous.

Lets say I have a template defined as:

```
template < typename T >
void foo ( int x ) ;
template <>
void foo<char> ( int x ) ;
template <>
void foo<unsigned char> ( int x ) ;
template <>
void foo<short> ( int x ) ;
...

```

Internally both `foo<signed>()` and `foo<unsigned>()` do exactly the same thing. The only requirement is that `T` be an 8bit type.

I could do this by creating another template to type define a standard type based on size.

```
template < typename T, size_t N = sizeof( T ) > struct remap ;
template < typename T, size_t > struct remap< 1 >
{
    typedef unsigned char value;
}
...

```

Note, function templates cannot have default parameters. This solution only relocates the problem to another template and also introduces a problem if somebody tried passing a struct type as a parameter.

What is the most elegant way to solve this without repeating those function declarations?

This is not a C++11 question.