5

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

考虑一个示例代理类，用于管理更大存储块中的值 - 就像在这个过于简单但具有代表性的示例中一样：

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的 s 工作。在这种情况下，用户应该只能传入或传出“暴露”类型std::uint16_t。我可能正在使用各种代理类类型，并希望这适用于所有这些类型。理想情况下，对于任何类型的组合，我只需键入someProxy = anotherProxy并让编译器完成剩下的工作。

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

  • 重新定义复制赋值运算符以使用用户定义的 s 执行“代理”复制operator- 这是我一直在做的，但它似乎有点 hacky ，并且像任何用户定义的构造函数/赋值运算符一样，打破了微不足道的可复制状态的struct- 我需要保留。无论如何它仍然存在，但我想要定义memcpy()的行为。g++
  • 或= 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() );

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

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

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

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

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

4

2 回答 2

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

于 2016-07-12T19:22:54.577 回答
-1

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

#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; 
}
于 2016-07-12T16:53:00.590 回答