Why int8 works like char (C++) (Visual Studio 2015)

Question

I'm trying to find the smallest int type in C++. I read that there are no types which use less than a byte, because is the minimum addressable size. The smallest one I found is int8_t, or _int8 visual studio type. I tried to use both, but the program stores the values as chars. There are a way to use this types as integers? Or even, if there are a way to use smaller types (2 bits (signed) would be perfect XD, I need to store only -1, 0 and 1), or any other numeric byte type.

Thanks in advance

Answer 1

The standard gives you the following types:

• signed char
• unsigned char

(with char being equivalent to one of these)

And your fixed-width int8_t, uint8_t on an 8-bit system are simply aliases for these.

They are all integers already.

Your statement "but the program stores the values as chars" suggests a misunderstanding of what values with these types fundamentally are. This may be due to the following.

The only "problem" you may encounter is the special-case formatting for these types in the IOStreams sublibrary:

const char c = 40;
std::cout << c << '\n';
// Output: "("

Since int8_t is/may be signed char, this is literally the same:

const int8_t c = 40;
std::cout << c << '\n';
// Output: "("

But this is easily "fixable" with a little integral promotion:

const char c = 40;
std::cout << +c << '\n';
// Output: 40

Now the stream gets an int, and lexically-casts it as part of its formatting routine.

This has to do with the type system and the function overloads provided by the standard library; it has nothing to do with "how the values are stored". They are all integers.

Answer 2

I tried to use both, but the program stores the values as chars.

It doesn't (store the values as chars). In C++, a char value is an integer value. The difference to other integer types, is in two places:

• the compiler converts char literals to integers transparently

• the standard library treats char type separately from other integer types (that is, it considers char to represent letters text characters, not numbers).

As far as the compiler is concerned, the code:

char x = 'A';

is equivalent to:

char x = 65; // set value to 65 (ASCII code for letter "A")

If you look in the debugger at the second definition of x, is probable the debugger/IDE will tell you x is 'A'.

Or even, if there are a way to use smaller types (2 bits (signed) would be perfect XD, I need to store only -1, 0 and 1), or any other numeric byte type.

There is no integer type with a smaller than 8 bits representation.

That said, you can (and probably should) create a custom type for it:

enum class your_type: std::uint8_t
{
    negative = -1,
    neutral = 0,
    positive = 1
};

Choose values that make sense in the context of your program (i.e. not "negative, neutral and positive").

Answer 3

You can use a bit field with two bits.

Answer 4

With MSVC you could use #pragma pack(1) and structs to obtain this.

#pragma pack(1)
struct int2 {
    int value:2;
};
#pragma pack()

int main()
{
    int2 a;
    for (int i = 0; i < 10; i++)
    {
        a.value = i;
        std::cout << a.value << std::endl;
    }

    return 0;
}

Output:

0
1
-2
-1
0
1
-2
-1
0
1

I guess building constructors and operator functions to access the value indirectly shouldn't be a problem.

EDIT: Improved version with operators:

#pragma pack(1)
template <typename INT_TYPE, int BYTE_SIZE>
class int_x {
    INT_TYPE value: BYTE_SIZE;
public:
    int_x() :value(0) {}
    int_x(INT_TYPE v) :value(v) {}
    operator INT_TYPE() const {
        return value;
    }
    int_x& operator=(INT_TYPE v) {
        value = v; return *this;
    }
    int_x& operator+=(INT_TYPE v) {
        value += v; return *this;
    }
    int_x& operator-=(INT_TYPE v) {
        value -= v; return *this;
    }
    int_x& operator/=(INT_TYPE v) {
        value /= v; return *this;
    }
    int_x& operator*=(INT_TYPE v) {
        value *= v; return *this;
    }
};
typedef int_x<int, 1> int1;             //Range [-1;0]
typedef int_x<unsigned int, 1> uint1;   //Range [0;1]

typedef int_x<int, 2> int2;             //Range [-2;1]
typedef int_x<unsigned int, 2> uint2;   //Range [0;3]

typedef int_x<int, 3> int3;             //Range [-4;3]
typedef int_x<unsigned int, 3> uint3;   //Range [0;8]
#pragma pack()