How to have a type which is like unsigned char, but not allowed to alias?

Question

I'd like to have a type, which is like unsigned char:

• sizeof is 1
• integer values can be assigned to it (without any casts)
• bit manipulations are allowed
• arithmetic is allowed, but not a must
• unsigned
• trivially copyable

But, unlike unsigned char, it is not allowed to alias. I mean, a type, which doesn't have the exception [basic.lval/11.8]:

If a program attempts to access the stored value of an object through a glvalue of other than one of the following types the behavior is undefined:

[...]

• a char, unsigned char, or std​::​byte type.

Is it possible to have a type like this?

The reason: I almost never use unsigned char's aliasing property. So, I'd like to use a type instead, which doesn't prevent certain kind of optimizations (note, I asked this question because I actually have functions, which aren't optimized well, because of the aliasing-allowing property of unsigned char). So, I'd like to have a type for which this is true: "don't pay for what you don't use".

---

Here's an example, where unsigned char prevents optimization: Using this pointer causes strange deoptimization in hot loop

Answer 1

That section of the standard calls out char, unsigned char, and std::byte. However, you can make your own type which is like std::byte and it wouldn't be allowed to alias:

enum class my_byte : unsigned char {};

Using it isn't so nice, as you have to cast to unsigned char to do anything meaningful with it. However, you can overload the bitwise and arithmetic operators to make it nicer to work with.

---

We can verify this with the following simple function:

auto foo(A& a, B& b) {
    auto lhs = b;
    a = 42;
    auto rhs = b;
    return lhs + rhs;
}

If A was allowed to alias with B, the compiler would have to generate two loads: one for lhs and one for rhs. If A was not allowed to alias with B, the compiler can generate a single load and just add the value to itself. Let's test it:

// int& cannot alias with long&
auto foo(int& a, long& b) {
    auto lhs = b;
    a = 42;
    auto rhs = b;
    return lhs + rhs;
}

// std::byte& can alias with long&    
auto bar(std::byte& a, long& b) {
   auto lhs = b;
    a = (std::byte)42;
    auto rhs = b;
    return lhs + rhs;
}

// if my_byte& can alias with long&, there would have to be two loads
auto baz(my_byte& a, long& b) {
    auto lhs = b;
    a = (my_byte)42;
    auto rhs = b;
    return lhs + rhs;
}

This results in the following:

foo(int&, long&):
        mov     rax, QWORD PTR [rsi]
        mov     DWORD PTR [rdi], 42
        add     rax, rax
        ret
bar(std::byte&, long&):
        mov     rax, QWORD PTR [rsi]
        mov     BYTE PTR [rdi], 42
        add     rax, QWORD PTR [rsi]
        ret
baz(my_byte&, long&):
        mov     rax, QWORD PTR [rsi]
        mov     BYTE PTR [rdi], 42
        add     rax, rax
        ret

Thus my_byte does not inherit the same aliasing properties as char and std::byte

Answer 2

You can define your own type:

#include <type_traits>

class uchar {
    unsigned char value = {};

public:
    template <typename T,
        std::enable_if_t<
            std::is_convertible_v<T, unsigned char>,
            int
        > = 0>
    constexpr uchar(T value)
        : value{static_cast<unsigned char>(value)}
    {}

    constexpr uchar()
    {}

    template <typename T,
        std::enable_if_t<
            std::is_convertible_v<T, unsigned char>,
            int
        > = 0>
    constexpr uchar& operator=(T value)
    {
        this->value = static_cast<unsigned char>(value);
        return *this;
    }

    explicit constexpr operator unsigned char() const
    {
        return value;
    }

    friend constexpr uchar operator+(uchar lhs, uchar rhs) {
        return lhs.value + rhs.value;
    }

    friend constexpr uchar operator-(uchar lhs, uchar rhs) {
        return lhs.value - rhs.value;
    }

    // And so on...
};

// The compiler could technically add padding after the `value` member of
// `uchar`, so we `static_assert` to verify that it didn't. I can't imagine
// any sane implementation would do so for a single-member type like `uchar`
static_assert(sizeof(uchar) == sizeof(unsigned char));
static_assert(alignof(uchar) == alignof(unsigned char));