C++ 中的简单存储类和严格的别名

Question

我有以下代码用于存储一个小类。

#include <iostream>

template<typename T>
class storage
{
private:
  struct destroy
  {
    T& m_t;
    destroy(T& t) : m_t(t) { }
    ~destroy() { m_t.~T(); }
  };

  char m_c[sizeof(T)];
  void* address() { return &m_c[0]; }

public:
  void set(const T& t) { new (address()) T(t); }

  T get()
  {
    T& t = *static_cast<T*>(address());
    destroy _d(t);
    return t;
  }

};

template<typename T>
class choosable_storage
{
private:
  union
  {
    T*         m_p;
    storage<T> m_storage;
  };
  bool m_direct;

public:
  choosable_storage() : m_direct(false) { }

  void set_direct(const T& t)
  {
    m_direct = true;
    m_storage.set(t);
  }

  void set_indirect(T* const t) { m_p = t; }

  T get()
  {
    if (m_direct) return m_storage.get();
    return *m_p;
  }

};

int main(void)
{
  storage<int> s; // no problems
  s.set(42);
  std::cout << s.get() << std::endl;

  int i = 10;

  choosable_storage<int> c1; // strict aliasing warnings
  c1.set_indirect(&i);
  std::cout << c1.get() << std::endl;

  choosable_storage<int> c2;
  c2.set_direct(i);
  std::cout << c2.get() << std::endl;

  return 0;
}

当我返回时，gcc 4.4 警告我违反了 storage::get() 中的严格别名规则。

AFAIK，我没有违反任何规则。我实际上违反了严格的别名还是 gcc 在这里变得挑剔？

有没有一种方法可以让它不发出警告而不禁用严格别名？

谢谢

编辑：

另一方面，以下实现不会发出任何警告：

template<typename T>
class storage
{
private:
  struct destroy
  {
    T& m_t;
    destroy(T& t) : m_t(t) { }
    ~destroy() { m_t.~T(); }
    T const& operator()() const { return m_t; }
  };

  char m_c[sizeof(T)];

public:
  void set(const T& t) { new(static_cast<void*>(m_c)) T(t); }

  T get(void) { return destroy(*static_cast<T*>(static_cast<void*>(m_c)))(); }

};

编辑：

gcc 4.5 及更高版本不会发出警告 - 所以显然这只是一个误解严格的别名规则或 gcc 4.4.x 中的错误

Answer 1

我实际上违反了严格别名还是 gcc 在这里变得挑剔？

严格别名规则有两种不同的解释：

• 通常的弱严格别名规则：（char/unsigned char 类型除外）您不能使用强制转换或union 来执行类型双关，您需要 memcpy （或两个 易失性 访问）；这样的代码确实不太合理，并且在C（除了最新的、非常荒谬的C标准）和C++中被明确禁止。
• 不寻常的强严格别名规则：不能重用内存：一旦内存区域具有“动态类型”（什么？），它就不能与其他类型一起使用。因此，您无法编写分配器函数（malloc 替代方案）C，除非它每次只调用 malloc/free。

强规则定义不明确，破坏了许多合理的代码，并且出于某种原因由 GCC 维护者选择（完全基于自我欺骗和循环论证 - 这真的很丑陋）。为了使 C++ 代码能够在强大的严格别名优化下工作，G++ 的维护者为典型的 C++ 代码添加了悲观（基于更多的自我欺骗），以保持优化！

我不知道他们是否/何时意识到自己的错误，如果有疑问，只需禁用严格别名。无论如何，这只是一个非常小的优化。

Answer 2

出于本问题的目的，严格的别名规则本质上规定，除非通过其自身类型的指针/引用或对字符类型（char 或 unsigned char）的指针/引用，否则不应访问对象。

在您的代码中，您有一个 char 类型元素的数组 m_c，并且您尝试通过 T 类型的引用访问它。这是严格的别名违规。在一些更奇特的平台上，这可能会产生影响，例如，如果 m_c 未正确对齐以保存类型 T 的元素。