С++/С++ 11 Эффективный способ создания статического массива/вектора объектов, инициализированных списком инициализаторов, и поддержки диапазона для

Ответ 1

Данные не должны храниться в классе. Фактически, хранение данных в члене static класса приводит к утечке деталей реализации.

Все, что вам нужно, - это доступность данных и глобальные данные для типа класса. Это не связано с раскрытием сведений о хранении: все, что вам нужно предоставить, - это сведения о доступе к хранилищу.

В частности, вы хотите выставить возможность цикла for(:) по данным и работать с ним в стиле С++ 11. Так что выставляйте именно это.

Храните данные в анонимном пространстве имен в файле класса .cpp в массиве C-стиля (или std::array, мне все равно).

Выставить в классе следующее:

namespace details {
  template<
    class R,
    class iterator_traits,
    class iterator_category,
    bool is_random_access=std::is_base_of<
        std::random_access_iterator_tag,
        iterator_category
    >::value
  >
  struct random_access_support {};
  template<class R, class iterator_traits, class iterator_category>
  struct random_access_support<R, iterator_traits, iterator_category, true> {
    R const* self() const { return static_cast<R const*>(this); }
    template<class S>
    typename iterator_traits::reference operator[](S&&s) const {
      return self()->begin()[std::forward<S>(s)];
    }
    std::size_t size() const { return self()->end()-self()->begin(); }
  };
}

template<class It>
struct range:details::random_access_support<
  range<It>,
  std::iterator_traits<It>,
  typename std::iterator_traits<It>::iterator_category
> {
  using value_type = typename std::iterator_traits<It>::value_type;
  using reference = typename std::iterator_traits<It>::reference;
  using iterator = It;
  using iterator_category = typename std::iterator_traits<It>::iterator_category;
  using pointer = typename std::iterator_traits<It>::pointer;

  It begin() const { return b; }
  It end() const { return e; }

  bool empty() const { return b==e; }
  reference front() const { return *b; }
  reference back() const { return *std::prev(e); }

  range( It s, It f ):b(s),e(f) {}

  range()=default;
  range(range const&)=default;
  range& operator=(range const&)=default;
private:
  It b; It e;
};

namespace details {
  template<class T>
  struct array_view_helper:range<T*> {
    using non_const_T = typename std::remove_const<T>::type;
    T* data() const { return this->begin(); }

    array_view_helper( array_view_helper const& ) = default;
    array_view_helper():range<T*>(nullptr, nullptr){}
    array_view_helper& operator=(array_view_helper const&)=default;

    template<class A>
    explicit operator std::vector<non_const_T, A>() const {
      return { this->begin(), this->end() };
    }
    std::vector<non_const_T> as_vector() const {
      return std::vector<non_const_T>(*this);
    }

    template<std::size_t N>
    array_view_helper( T(&arr)[N] ):range<T*>(arr+0, arr+N) {}
    template<std::size_t N>
    array_view_helper( std::array<T,N>&arr ):range<T*>(arr.data(), arr.data()+N) {}
    template<class A>
    array_view_helper( std::vector<T,A>&vec ):range<T*>(vec.data(), vec.data()+vec.size()) {}
    array_view_helper( T*s, T*f ):range<T*>(s,f) {}
  };
}
// non-const
template<class T>
struct array_view:details::array_view_helper<T> {
  using base = details::array_view_helper<T>;

  // using base::base in C++11 compliant compilers:
  template<std::size_t N>
  array_view( T(&arr)[N] ):base(arr) {}
  template<std::size_t N>
  array_view( std::array<T,N>&arr ):base(arr) {}
  template<class A>
  array_view( std::vector<T,A>&vec ):base(vec) {}
  array_view( T*s, T*f ):base(s,f) {}

  // special methods:
  array_view( array_view const& ) = default;
  array_view() = default;
  array_view& operator=(array_view const&)=default;
};
template<class T>
struct array_view<T const>:details::array_view_helper<const T> {
  using base = details::array_view_helper<const T>;

  // using base::base in C++11 compliant compilers:
  template<std::size_t N>
  array_view( std::array<T const,N>&arr ):base(arr) {}
  array_view( T const*s, T const*f ):base(s,f) {}
  template<std::size_t N>
  array_view( T const(&arr)[N] ):base(arr) {}

  // special methods:
  array_view( array_view const& ) = default;
  array_view() = default;
  array_view& operator=(array_view const&)=default;

  // const T only constructors:
  template<std::size_t N>
  array_view( std::array<T,N> const&arr ):base(arr.data(), arr.data()+N) {}
  template<std::size_t N>
  array_view( std::array<T const,N> const&arr ):base(arr.data(), arr.data()+N) {}
  template<class A>
  array_view( std::vector<T,A> const&vec ):base(vec.data(), vec.data()+vec.size()) {}
  array_view( std::initializer_list<T> il):base(il.begin(), il.end()) {}
};

который является, по крайней мере, эскизом некоторых классов представления. живой пример

Затем выведите array_view<MyClass> в качестве члена static вашего класса, который инициализируется массивом, созданным в файле .cpp.

range<It> - это диапазон итераторов, который действует как контейнер, не являющийся владельцем. Выполняется некоторая глупость, чтобы блокировать вызовы, не связанные с постоянным временем, на size или [] на уровне SFINAE. back() отображается и просто не скомпилируется, если вы вызываете его на недействительных итераторах.

A make_range(Container) делает range<It> более полезным.

array_view<T> является range<T*>, который имеет кучу конструкторов из смежных буферных контейнеров, таких как C-массивы, std::array и std::vector s. (фактически исчерпывающий список).

Это полезно, потому что доступ через array_view примерно так же эффективен, как доступ к исходному указателю-первому элементу массива, но мы получаем много хороших методов, которые есть в контейнерах, и он работает с диапазоном для петель. В общем случае, если функция принимает std::vector<T> const& v, вы можете заменить ее на функцию, которая принимает array_view<T> v, и она будет заменой. Большим исключением является operator vector, который является явным, чтобы избежать случайных распределений.

Ответ 2

Мне лично нравится ваш constexpr static int my_array[] = {MyClass{1, 2, 3}, MyClass{1, 2, 3}};. Я не думаю, что вам следует уклониться от этого, если массив C-стиля соответствует вашим потребностям.

Если вы действительно хотите использовать std::vector, хотя вы можете использовать static const std::vector<MyClass*> vec_pre;. Таким образом, ваш файл .cpp будет иметь это вверху:

namespace{
    MyClass A{1, 2, 3}, B{1, 2, 3}, C{1, 2, 3};
}
const std::vector<MyClass*> MyClass::vec_pre{&A, &B, &C};

ИЗМЕНИТЬ после DarkMatter комментариев:

После прочтения ваших комментариев, похоже, что может быть какая-то опасность для обслуживания моего метода. Он все равно может быть выполнен следующим образом: .cpp:

namespace{
    MyClass temp[]{MyClass{1, 2, 3}, MyClass{1, 2, 3}, MyClass{1, 2, 3}};
    const MyClass* pTemp[]{&temp[0], &temp[1], &temp[2]};
}
const std::vector<MyClass*> MyClass::vec_pre{begin(pTemp), end{pTemp}};

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

Ответ 3

Вот способ установки вектора без копирования или перемещения.

Он не использует строчный инициализатор, но ваш вступительный абзац предполагает, что ваша главная задача - избегать копий и движений; а не абсолютное требование использовать фиксированный инициализатор.

 // header
const std::vector<MyClass> &get_vec();

// cpp file
const std::vector<MyClass> &get_vec()
{
    static std::vector<MyClass> x;

    if ( x.empty() )
    {
        x.emplace_back(1,2,3);
        x.emplace_back(4,5,6);
        // etc.
    }

    return x;    
}