Thread: char counts as a separate type from signed char and unsigned char??

I've just stumbled across something weird. Now first off, I'm aware that when you say just "char" it is implementation specific whether you'll get a signed or an unsigned char. But what I find surprising is that regardless of whether default char is signed or unsigned, the compiler seems to treat signed char, unsigned char and char as 3 distinct types.

Code:

#include <iostream>

template < typename VarType >
struct Test
{
    inline static void test()
    {
        std::cout << "unspecified type\n";
    }
};

template <>
struct Test< signed char >
{
    inline static void test()
    {
        std::cout << "signed char\n";
    }
};

template <>
struct Test< unsigned char >
{
    inline static void test()
    {
        std::cout << "unsigned char\n";
    }
};

/*
template <>
struct Test< char >
{
    inline static void test()
    {
        std::cout << "char\n";
    }
};
*/

int main()
{
    Test< char >::test();
}

This example prints "unspecified type". Only if you uncomment the specialization for char and compile / run again do you get the expected (to me at least) result: "char".

Does anyone else find that surprising?

Originally Posted by antred

char counts as a separate type from signed char and unsigned char?

Yes. This is stated in the standard.

Originally Posted by antred

Does anyone else find that surprising?

No, otherwise they should have just gone with char is signed char to be consistent with the other signed integer types.

It's written into the standard.

Originally Posted by c++ 98

3.9.1 Fundamental types
1 Objects declared as characters (char) shall be large enough to store any member of the implementation’s
basic character set. If a character from this set is stored in a character object, the integral value of that char-
acter object is equal to the value of the single character literal form of that character. It is implementation-
defined whether a char object can hold negative values. Characters can be explicitly declared unsigned
or signed. Plain char, signed char, and unsigned char are three distinct types.

That seems reasonable to me. If it didn't act that way then the following program would call different functions on different machines for the f(c_char) call.

Code:

#include <iostream>
using namespace std;
void f(char c) { cout << "char\n"; }

void f(signed char c) { cout << "signed char\n"; }

void f(unsigned char c) { cout << "unsigned char\n"; }

int main()
{
    char c_char = 'a';
    signed char c_signed_char = 'a';
    unsigned char c_unsigned_char = 'a';

    f(c_char);
    f(c_signed_char);
    f(c_unsigned_char);
}