严格的指针别名：针对特定问题的任何解决方案？

Question

我遇到了由于违反严格的指针别名规则而引起的问题。我有一个来自模板的类型 T 和一些相同大小的整数类型 Int（与 sizeof 一样）。我的代码基本上执行以下操作：

T x = some_other_t;
if (*reinterpret_cast <Int*> (&x) == 0)
  ...

因为 T 是可以具有构造函数的任意（大小限制除外）类型，所以我无法将 T 和 结合起来>int。 （这仅在 C++0x 中允许，甚至 GCC 还不支持）。

有什么方法可以重写上面的伪代码以保留功能并避免违反严格的别名规则？请注意，这是一个模板，我无法控制 T 或 some_other_t 的值；赋值和随后的比较确实发生在模板化代码内。

（郑重声明，如果 T 包含任何位字段，则上述代码在 GCC 4.5 上开始损坏。）

Answer 1

static inline int is_T_0(const T *ob)
{
        int p;
        memcpy(&p, ob, sizeof(int));
        return p == 0;
}

void myfunc(void)
{
    T x = some_other_t;
    if (is_T_0(&x))
        ...

在我的系统上，GCC 优化了 is_T_0() 和 memcpy()，从而在 myfunc() 中只生成了一些汇编指令。

Answer 2

您听说过 boost::Optional 吗？

我必须承认我不清楚这里的真正问题......但是 boost::Optional 允许按值存储，但知道实际内存是否已初始化。我还允许就地构建和销毁，所以我想这可能是一个不错的选择。

编辑：

我想我终于抓住了这个问题：你希望能够在内存中的不同点分配很多对象，并且你想知道此时的内存是否已分配是否真的持有一个物体。

不幸的是，您的解决方案有一个巨大的问题：它是不正确的。如果 T 可以以某种方式由 null 位模式表示，那么您会认为它是统一的内存。

您将不得不自己添加至少一点信息。实际上并不算多，毕竟只增长了 3%（33 位对应 4 个字节）。

例如，您可以使用一些模仿 boost::Optional 但以数组方式（以避免填充损失）。

template <class T, size_t N>
class OptionalArray
{
public:


private:
  typedef unsigned char byte;

  byte mIndex[N/8+1];
  byte mData[sizeof(T)*N]; // note: alignment not considered
};

那么就这么简单：

template <class T, size_t N>
bool OptionalArray<T,N>::null(size_t const i) const
{
  return mIndex[i/8] & (1 << (i%8));
}

template <class T, size_t N>
T& OptionalArray<T,N>::operator[](size_t const i)
{
  assert(!this->null(i));
  return *reinterpret_cast<T*>(mData[sizeof(T)*i]);
}

注意：为了简单起见，我没有考虑对齐问题。如果您不了解该主题，请在摆弄记忆之前先阅读它：)

Answer 3

使用 33 位计算机。 ;-P

Answer 4

为什么不简单地：（

const Int zero = 0;
if (memcmp(&some_other_t, &zero, sizeof(zero)) == 0)
  /* some_other_t is 0 */

您可能想尝试将 static 限定符添加到 zero 以查看它是否会在性能方面产生差异）

Answer 5

怎么样：

Int zero = 0;
T x = some_other_t;
if (std::memcmp(&x, &zero, sizeof(zero)) == 0)

它可能没有那么有效，但它应该消除警告。

---

附录 #1：

由于 T 被限制为与 Int 相同的大小，因此将自己设置为 T 类型的虚拟按位零值并直接比较反对它（而不是与 Int(0) 进行转换和比较）。

如果你的程序是单线程的，你可以有这样的东西：

template <typename T>
class Container
{
public:
    void foo(T val)
    {
        if (zero_ == val)
        {
            // Do something
        }
    }

private:
    struct Zero
    {
        Zero() {memset(&val, 0, sizeof(val));}
        bool operator==(const T& rhs) const {return val == rhs;}
        T val;
    };
    static Zero zero_;
};

如果它是多线程的，你会想要避免使用静态成员zero_，并让每个容器实例拥有它自己的< code>zero_ 成员：

template <typename T>
class MTContainer
{
public:
    MTContainer() {memset(zero_, 0, sizeof(zero_));}

    void foo(T val)
    {
        if (val == zero_)
        {
            // Do something
        }
    }

private:
    T zero_;
};

---

附录#2：

让我用另一种更简单的方式来表达上述附录：

// zero is a member variable and is inialized in the container's constructor
T zero;
std::memset(&zero, 0, sizeof(zero));

T x = some_other_t;
if (x == zero)