如何拥有类似于 unsigned char 但不允许别名的类型？

Question

我想要一个类型，比如unsigned char:

• sizeof 为 1
• 可以为其分配整数值（无需任何强制转换）
• 允许位操作
• 算术是允许的，但不是必须的
• 未签名
• 可轻松复制

但是，与unsigned char 不同的是，它不允许别名。我的意思是，一个类型，它没有异常[basic.lval/11.8]：

如果程序尝试通过以下类型之一以外的左值访问对象的存储值，则行为未定义：

[...]

• char、unsigned char 或 std​::​byte 类型。

有可能有这样的类型吗？

原因：我几乎从不使用unsigned char 的别名属性。所以，我想改用一个类型，它不会阻止某些类型的优化（注意，我问这个问题是因为我实际上有一些函数，由于 @ 的别名允许属性，这些函数没有得到很好的优化987654327@)。所以，我想有一个这样的类型：“不要为你不使用的东西买单”。

---

这是一个示例，其中unsigned char 阻止优化：Using this pointer causes strange deoptimization in hot loop

Answer 1

您可以定义自己的类型：

#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));

Answer 2

标准的该部分调用char、unsigned char 和std::byte。但是，您可以创建自己的类型，例如 std::byte，并且不允许使用别名：

enum class my_byte : unsigned char {};

使用它不是很好，因为您必须转换为 unsigned char 才能使用它做任何有意义的事情。但是，您可以重载按位和算术运算符以使其更易于使用。

---

我们可以通过以下简单函数来验证这一点：

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

如果允许 A 使用 B 别名，编译器将必须生成两个负载：一个用于 lhs，另一个用于 rhs。如果不允许 A 与 B 别名，编译器可以生成单个加载并将值添加到自身。 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;
}

这会导致以下结果：

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

因此my_byte 不继承与char 和std::byte 相同的别名属性