c++ - 是否有可能使 `=` 比(删除的)复制分配更喜欢从转换分配？

Question

我发现了一些严重暗示这无法完成的线程，但没有一个线程使用完全相同的运算符和条件组合，所以我想问得更具体一些。希望这意味着它对某人来说是一个快速而简单的答案......不管怎样!

考虑一个示例代理类，用于管理更大存储 block 中的值 - 如这个过于简单但具有代表性的示例所示:

class SomeProxyThing {
    std::uint32_t storage;

public:
    operator std::uint16_t() const
    {
        return storage & 0x0000FFFF;
    }

    SomeProxyThing &operator=(std::uint16_t const value)
    {
        storage &= 0xFFFF0000;
        storage |= value;
    }
};

我希望所有 分配通过用户定义的运算符 工作。用户应该只能传入或传出“公开”类型，在本例中为 std::uint16_t。我可能正在使用各种代理类类型，并希望它适用于所有这些类型。理想情况下，对于任何类型的组合，我可以只键入 someProxy = anotherProxy 并让编译器完成其余的工作。

但是当赋值的左侧和右侧具有相同或与继承相关的类型时，默认的复制赋值运算符 - 当然 - 与此目标冲突。它复制了整个 storage，从而破坏了 uint32_t 的另一半——而不是只复制所需的“暴露”值。没错!对于大多数情况。但我想要一种“通过转换分配”的方法，即使 LHS 和 RHS 类型相同。为了避免这种情况，我可以:

• 重新定义复制赋值运算符以使用用户定义的运算符执行“代理”复制 - 这就是我一直在做的，但它看起来有点像任何用户定义的构造函数/赋值运算符一样，hacky and 打破了 struct 的trivially copyable 状态 - 我需要这样做保持。在 g++ 中它仍然是 memcpy()anyway，但我想要定义的行为。
• 或= delete复制赋值运算符(我们现在可以对 TC 类型执行此操作)。但是赋值仍然会尝试使用它并抛出一个编译错误——因为 delete 意味着“如果我是选择的重载则错误中止”，而不是“将我排除在重载决议之外”。为了解决这个问题，我必须明确告诉编译器使用转换运算符并从其结果赋值:

SomeProxyThing a, b;
a = 42;
b = static_cast<std::uint16_t>(a);
// a.k.a.
b.operator=( a.operator std::uint16_t() );

似乎没有办法告诉编译器“忽略您首选的重载产生的任何错误并选择下一个最佳的”。在那儿？更一般地说，在这种情况下，是否有任何方法/破解/可怕的组合来强制编译器自动使用/首选某些运算符？

换句话说，理想情况下，在

SomeProxyThing a, b;
a = 42;
b = a;

那 b = a; 真的会这样做:

b = static_cast<std::uint16_t>(a);
// a.k.a.
b.operator=( a.operator std::uint16_t() );

无需我手动输入，使用 static_cast，或实现命名的 get/set 方法。理想情况下，我希望对任何此类代理的读/写看起来完全像对书面代码中基本类型的读/写，所有这些都使用 =。

我强烈怀疑这是不可能的......但确认会很好!

Answer 1

你可以这样做:

#include <stdint.h>
#include <iostream>
#include <type_traits>

using namespace std;

class Proxy_state
{
protected:
    uint32_t storage;
public:
    // Access to the bytes
};

static_assert( is_trivially_copyable<Proxy_state>::value, "!" );

class Some_proxy_thing
    : public Proxy_state
{
private:

public:
    operator std::uint16_t() const
    {
        return storage & 0x0000FFFF;
    }

    auto operator=( uint16_t const value )
        -> Some_proxy_thing&
    {
        clog << "=(uint16_t)" << endl;
        storage &= 0xFFFF0000;
        storage |= value;
        return *this;
    }

    auto operator=( Some_proxy_thing const& value )
        -> Some_proxy_thing&
    { return operator=( static_cast<uint16_t>( value ) ); }
};

static_assert( not is_trivially_copyable<Some_proxy_thing>::value, "!" );

auto main()
    -> int
{
    Some_proxy_thing    a{};
    Some_proxy_thing    b{};
    const Some_proxy_thing c = b;

    a = c;

    a = 123;
    a = b;
}

这里所有三个赋值输出(到标准错误流)=(uint16t)。