Debugging crash in small object optimization for type erasure

Question

I'm implementing a class that performs type erasure for small objects and have encountered a segmentation fault which I do not understand.

The following program:

#include <iostream>
#include <type_traits>

struct small_object
{
  public:
    template<class T>
    small_object(const T& value)
    {
      new(&storage_) concrete<T>(value);
    }

    ~small_object()
    {
      get_abstract().~abstract();
    }

    void print() const
    {
      // XXX crash here
      get_abstract().print();
    }

  private:
    struct abstract
    {
      virtual ~abstract(){}

      virtual void print() const = 0;
    };

    template<class T>
    struct concrete
    {
      concrete(const T& value) : value_(value) {}

      void print() const
      {
        std::cout << value_ << std::endl;
      }

      T value_;
    };

    abstract& get_abstract()
    {
      return *reinterpret_cast<abstract*>(&storage_);
    }

    const abstract& get_abstract() const
    {
      return *reinterpret_cast<const abstract*>(&storage_);
    }

    typename std::aligned_storage<4 * sizeof(void*)> storage_;
};

int main()
{
  small_object object(13);

  // XXX i expect this line to print '13' to the terminal but it crashes
  object.print();

  return 0;
}

Crashes at the lines indicated by XXX.

I believe the issue is that the virtual call to .print() is not being dynamically dispatched correctly, but I don't understand why.

Can anyone tell what am I missing?

Answer 1

You didn't derive concrete<T> from abstract, so no vtable is being created when you construct the object using placement new. Therefore, when you try to invoke the virtual function, it will fail; concrete<T> and abstract are actually completely unrelated types in this example.

I would recommend using the override keyword if you're using C++11 or newer to allow the compiler to generate an error in cases like this.

Answer 2

std::aligned_storage<4 * sizeof(void*)> storage_;

This creates storage of one byte.

The template argument does not set the size of the declared object, but rather the size of an object that can be allocated in a suitably-sized array of this type. Hence, you need

std::aligned_storage<4 * sizeof(void*)> storage_[4 * sizeof(void*)];

GCC 6.2.0 warns you about this:

warning: placement new constructing an object of type ‘small_object::concrete<int>’ and size ‘16’ in a region of type ‘std::aligned_storage<32ul>’ and size ‘1’ [-Wplacement-new=]

(You still need to derive concrete from abstract).