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

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%（4 字节 33 位）。

例如，您可以使用一些模仿 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_，并让每个容器实例都拥有自己的 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)