Как инициализировать последовательность неподвижных, не копируемых объектов?

Скажем, у меня есть тип, который нельзя ни перемещать, ни копировать:

struct foo
{
  explicit foo( size_t ){}
  ~foo(){}

  foo( foo const & ) = delete;
  foo( foo && ) = delete;
  foo& operator=( foo const & ) = delete;
  foo& operator=( foo & ) = delete;
};

Теперь, учитывая число, известное во время компиляции (назовем его N), есть ли способ создать «последовательность» из них в стеке, причем каждый из них инициализируется числами от 0 до N-1? Я бы удовлетворился массивом в стиле C foo[N], std::array< foo, N > или, возможно, даже каким-нибудь std::tuple.

Чего я пытаюсь избежать, так это написать:

foo f0( 0 ), f1( 1 ), ... fNminus1( N-1 );

когда мне кажется, что это то, что компилятор должен сделать за меня. Лучшее, что я смог придумать, это использовать boost::optional.

boost::optional< foo > f[N];

for( size_t i = 0U; i < N; ++i )
  f[i] = boost::in_place( i );

Но это зависит от логики времени выполнения, хотя вся необходимая информация доступна во время компиляции. Кроме того, у меня осталось что-то, что ведет себя как массив указателей.


c++ constructor compile-time
person Andrew Durward    schedule 12.04.2013    source источник

Ответы (3)


arrow_upward
3
arrow_downward 

// create a type with the proper alignment
typedef std::aligned_storage<sizeof(foo), std::alignment_of<foo>::value>::type buffer_type;

const int N = 10;
// create an array of uninitialized raw data
buffer_type storage_buffer[N];

// initialize each foo object with placement new
for (size_t i=0; i<N; ++i)
    new (storage_buffer + i) foo(i);

foo * fp = (foo*)(&storage_buffer);
// access your foo objects via fp


// you must manually call the destructor of each object
for (size_t i=0; i<N; ++i)
    fp[i].~foo();

Если это кажется большим хлопот, это так. Но вы можете легко инкапсулировать эту функциональность в классе.

person Benjamin Lindley    schedule 12.04.2013

arrow_upward
1
arrow_downward

Хотя это и не строго массив, вы можете сделать это с помощью рекурсии шаблона.

template< typename T, size_t N >
struct type_array : public type_array< T, N-1 > {
    // this is the Nth element
    T elem;
    // it is constructed with N
    type_array() : elem( N ) {}

    // member function to return the Nth element
    T & get( size_t n ) {
        if ( n == N ) {
            return elem;
        } else {
            return type_array< T, N-1 >::get( n );
        }
    }
};

// base case when N == 0
template< typename T >
struct type_array<T, 0> {
    T elem;
    type_array() : elem( 0 ) {}
    T & get( size_t n ) {
      return elem;
    }
};

Использование:

type_array< foo, 100 > foo_array;   // construct 100 foos
foo_array.get(1);                   // foo with n == 1
foo_array.get(2);                   // foo with n == 2
person yngccc    schedule 12.04.2013

arrow_upward
1
arrow_downward

Как и ответ Бенджамина Линдли, но упакованный в класс:

#include <type_traits>
#include <utility>
#include <new>

template<typename T>
class uninitialized {
public:
  constexpr uninitialized() { }

  ~uninitialized() {
    get().~T();
  }

  explicit uninitialized(const uninitialized& other) {
    construct(other);
  }

  explicit uninitialized(uninitialized&& other) {
    construct(std::move(other));
  }

  template<class... Args>
  explicit uninitialized(Args&&... args) { 
    construct(std::forward<Args>(args)...);
  }

  template<class... Args>
  void construct(Args&&... args) noexcept {
    static_assert(std::is_nothrow_constructible<T, Args...>::value, "constructor should not throw!");
    ::new(getPointer()) T (std::forward<Args>(args)...);
  }

  uninitialized& operator = (const T& t) { 
    get() = t;
    return *this;
  }

  uninitialized& operator = (T&& t) {
    get() = std::move(t);
    return *this;
  }

  T* operator -> () { return getPointer(); }    
  T& operator * () { return get(); }    
  T* operator & () { return getPointer(); }    
  T* getPointer() { return reinterpret_cast<T*>(&data); }    
  T& get() { return *reinterpret_cast<T*>(&data); }

  const T* operator -> () const { return getPointer(); }    
  const T& operator * () const { return get(); }    
  const T* operator & () const { return getPointer(); }    
  const T* getPointer() const { return reinterpret_cast<const T*>(&data); }    
  const T& get() const { return *reinterpret_cast<const T*>(&data); }

private:
  std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type data;
};

Теперь все немного проще:

uninitialized<foo> f[N];

for (size_t i = 0; i < N; ++i)
  f[i].construct(i);

for (const auto& fooref : f)
  fooref->bar();

// foo::~foo is called for you
person R1tschY    schedule 05.06.2015
comment
Боюсь, я должен проголосовать за это. Проблема здесь в том, что если construct выдает исключение, вы вызовете деструктор объекта, который никогда не создавался. - person David Stone; 05.12.2015
comment
@DavidStone Да, это проблема. Конструктор не должен бросать. Я добавил static_assert. В ответе Бенджамина Линдли при сбое конструктора деструктор не вызывается. - person R1tschY; 06.12.2015