我正在编写一个类似于 std::function 的类型删除函数包装器。 (是的，我见过类似的实现，甚至是 p0288r0 提案，但我的用例非常狭窄而且有些专业。)。下面高度简化的代码说明了我当前的实现:

class Func{
    alignas(sizeof(void*)) char c[64]; //align to word boundary

    struct base{
        virtual void operator()() = 0;
        virtual ~base(){}
    };

    template<typename T> struct derived : public base{
        derived(T&& t) : callable(std::move(t)) {} 
        void operator()() override{ callable(); }
        T callable;
    };

public:
    Func() = delete;
    Func(const Func&) = delete;

    template<typename F> //SFINAE constraints skipped for brevity
    Func(F&& f){
        static_assert(sizeof(derived<F>) <= sizeof(c), "");
        new(c) derived<F>(std::forward<F>(f));
    }

    void operator () (){
        return reinterpret_cast<base*>(c)->operator()(); //Warning
    }

    ~Func(){
        reinterpret_cast<base*>(c)->~base();  //Warning
    }
};

Compiled , GCC 6.1 警告 strict-aliasing :

warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
         return reinterpret_cast<T*>(c)->operator()();

我也知道strict-aliasing rule .另一方面，我目前不知道利用小对象堆栈优化的更好方法。尽管有警告，但我所有的测试都通过了 GCC 和 Clang，(并且额外的间接级别阻止了 GCC 的警告)。我的问题是:

• 我最终会因为这个案例的警告而被烧死吗？
• 有没有更好的就地对象创建方法？

查看完整示例:Live on Coliru

最佳答案

首先，使用 std::aligned_storage_t。这就是它的意义所在。

其次，virtual 类型及其后代的确切大小和布局由编译器确定。在内存块中分配派生类，然后将该 block 的地址转换为基类型可能有效，但标准中不能保证它会有效。

特别是，如果我们有 struct A {}; struct B:A{}; 不能保证除非你是标准布局指向B的指针可以是reintepreted 作为指向A 的指针(尤其是通过void*)。并且其中带有 virtual 的类不是标准布局。

所以重新解释是未定义的行为。

我们可以解决这个问题。

struct func_vtable {
  void(*invoke)(void*) = nullptr;
  void(*destroy)(void*) = nullptr;
};
template<class T>
func_vtable make_func_vtable() {
  return {
    [](void* ptr){ (*static_cast<T*>(ptr))();}, // invoke
    [](void* ptr){ static_cast<T*>(ptr)->~T();} // destroy
  };
}
template<class T>
func_vtable const* get_func_vtable() {
  static const auto vtable = make_func_vtable<T>();
  return &vtable;
}

class Func{
  func_vtable const* vtable = nullptr;
  std::aligned_storage_t< 64 - sizeof(func_vtable const*), sizeof(void*) > data;

public:
  Func() = delete;
  Func(const Func&) = delete;

  template<class F, class dF=std::decay_t<F>>
  Func(F&& f){
    static_assert(sizeof(dF) <= sizeof(data), "");
    new(static_cast<void*>(&data)) dF(std::forward<F>(f));
    vtable = get_func_vtable<dF>();
  }

  void operator () (){
    return vtable->invoke(&data);
  }

  ~Func(){
    if(vtable) vtable->destroy(&data);
  }
};

这不再依赖于指针转换保证。它只需要 void_ptr == new( void_ptr ) T(blah)。

如果您真的担心严格的别名，请将 new 表达式的返回值存储为 void*，并将其传递给 invoke 和 destroy 而不是 &data。这是无可非议的:从 new 返回的指针 是 指向新构造对象的指针。生命周期结束的data的访问可能是无效的，但之前也是无效的。

对象何时开始存在以及何时结束在标准中相对模糊。我看到的解决此问题的最新尝试是 P0137-R1 , 其中引入了 T* std::launder(T*) 以非常清晰地消除别名问题。

new 返回的指针的存储是我清楚明确地知道在 P0137 之前不会遇到任何对象别名问题的唯一方法。

标准确实规定:

If an object of type T is located at an address A, a pointer of type cv T* whose value is the address A is said to point to that object, regardless of how the value was obtained

问题是“新表达式是否真的保证对象是在相关位置创建的”。我无法说服自己它如此明确地陈述。但是，在我自己的类型删除实现中，我不存储该指针。

实际上，在这种简单的情况下，上面的内容与许多 C++ 实现对虚函数表所做的大致相同，只是没有创建 RTTI。

关于c++ - 小对象堆栈存储、严格别名规则和未定义行为，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39477443/