1

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

#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 中的错误

4

2 回答 2

3

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

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

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

强规则定义不明确，破坏了许多合理的代码，并且出于某种原因被 GCC 维护者选择（完全基于自欺欺人和循环论证——这真的很难看）。为了使 C++ 代码与强严格的别名优化一起工作，G++ 的维护者为典型的 C++ 代码添加了悲观化（基于更多的自欺欺人），以保持优化！

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

于 2012-07-21T02:33:33.150 回答
0

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

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

于 2010-11-13T04:58:43.860 回答