Question

我发现一些线索严重意味着无法完成，但没有一个使用完全相同的运算符和条件组合，所以我想更具体地问一下。希望这意味着它可以通过某种方式为某人提供快捷方便的答案！

考虑一个示例代理类，用于管理较大存储块中的值 - 如此过于简化但有代表性的示例：

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;
    }
};

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

但是当赋值的左侧和右侧具有相同或继承相关的类型时，默认的复制赋值运算符 - 当然 - 与此目标冲突。它会复制整个storage，从而破坏uint32_t的另一半 - 而不是只复制“暴露的”＃{1}}。价值根据需要。这是正确的！对于大多数情况。但是我想要一种通过转换来分配的方法＆＃39;即使LHS和RHS类型相同。为了避免这种情况，我可以：

重新定义了复制分配运算符以执行代理运算符＆＃39;使用用户定义的operator进行复制 - 这就是我一直在做的事情，但它似乎有点hacky 和，就像任何用户定义的构造函数/赋值运算符一样，打破了 struct的简单可复制状态 - 我需要保留。它memcpy()中仍然g++ ，但我想要定义行为。
或 = delete复制赋值运算符（我们现在可以对TC类型执行此操作）。但是，分配仍然会尝试使用它并抛出编译错误 - 因为delete意味着如果我选择了过载而导致错误中止，而不是将我从过载中排除分辨率＆＃39 ;.为了解决这个问题，我必须明确告诉编译器使用转换运算符并从结果中分配：

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

似乎没有办法告诉编译器＆＃39; 忽略您首选过载产生的任何错误并选择下一个最好的错误＆＃39;。在那儿？更一般地说，在这种情况下，是否有任何方式/ hack / horrifying kludge 强制编译器自动使用/更喜欢某些operator？

换句话说，理想情况下，

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)。

Answer 2

编译时间类型匹配/不匹配可以由std :: enable_if控制。隐式类型转换可以通过显式关键字禁用。可以显式删除所有复制和移动构造函数以避免复制，并且默认构造函数可以显式标记为默认值。编辑：早期回答会考虑问题的第一部分，即用户应该只能传入或离开“暴露”的问题。类型＆＃34;因此，所有转换都必须是显式的，但是为了完成答案，您可以定义一个简单的可复制类并在代理类中使用它可能是你想要的东西：

#include  <cstdint>
#include <type_traits>
struct copyable{
    std::uint32_t number = 0x0;
};
class SomeProxyThing {

public:
    explicit operator  std::uint16_t()  const 
    {
        return storage.number & 0x0000FFFF;
    }
template <typename T, typename std::enable_if<std::is_same<T, std::uint16_t>::value, int>::type=0>
    SomeProxyThing& operator=(T value)
    {
        storage.number &= 0xFFFF0000;
        storage.number |= value;
        return *this;
    }

    SomeProxyThing()=default;
    SomeProxyThing(const SomeProxyThing&)=delete;
    SomeProxyThing(SomeProxyThing&&)=delete;
    SomeProxyThing& operator=(const SomeProxyThing& other) {
        this->storage.number = static_cast<std::uint16_t>(other.storage.number);
    }
    SomeProxyThing& operator=(SomeProxyThing&& other) {
        this->storage.number = static_cast<std::uint16_t>(other.storage.number);
    }

private:
    copyable storage;
};
int main()
{
    SomeProxyThing a, b;
    a = static_cast<std::uint16_t>(43);
    b = a; 
}

是否有可能使`=`更喜欢从转换中分配（删除）副本分配？

2 个答案: