初始化對象數組中的向量大小

Question

我想初始化對象數組中向量的大小。

每個向量都有相同的大小，所以...

庫文件：

#include <vector>

Class NameClass
{
 public:
  explicit NameClass( unsigned size )
  {
    vectorName.resize( size );
  }

  std::vector <type> vectorName;
};

主文件：

#include "lib.hpp"

int main( void )
{
  NameClass object( size ); #1

  NameClass object[ number_objects ]( size ); #2
  NameClass object[ number_objects ] = {NameClass(size), NameClass(size), ... }; #3

  return 0;
}

＃1有效，但不是數組，＃2無效，編譯器說“請求從int轉換為非標量類型'NameClass'”，而＃3有效，但是...荒謬地初始化每個對象。 而且我不能只在類中放入static大小，因為值會改變。

所以...我的研究表明我需要使用std :: generate。 問題是...什么是最好的方法？

對不起，如果很容易問問題，如何使用std :: generate我是新手，很難找到最佳解決方案。

有人建議復雜的解決方案，但我一直在使用我的解決方案

#include "lib.hpp"

int main( void )
{
  unsigned number_objects = something;
  unsigned size = other_thing;
  NameClass object[ number_objects ];

  for( unsigned i = 0; i < number_objects; i++)
    object[i].vectorName.resize( size );

  return 0;
}

我使用Thins是因為它很容易理解並且可以正常工作 。 但是我願意接受其他易於理解和實用的解決方案。

鏈接std :: generate

Answer 1

如果您願意使用std::array和C ++ 14，我們將獲得：

template<std::size_t...Is>
auto index_over( std::index_sequence<Is...> ) {
  return [](auto&&f)->decltype(auto) {
    return decltype(f)(f)(std::integral_constant<std::size_t, Is>{}...);
  };
}
template<std::size_t N>
auto index_upto( std::integral_constant<std::size_t, N> ={} ) {
  return index_over( std::make_index_sequence<N>{} );
}

template<std::size_t N, class F,
  class T = std::decay_t<std::result_of_t< F&( std::integral_constant<std::size_t, 0>& )>>,
  class R = std::array<T, N>
>
R make_array( F&& f ) {
  return index_upto<N>()( [&](auto...Is)->R {
    return {{ f( Is )... }};
  } );
}

我們通過make_array<count>一個lambda。 該lambda接受一個可轉換值（來自編譯時std::size_t其值為I），並返回數組的第I個元素。

其結果是一個std::array大小的count 。

Lambda可以使用auto I來獲取編譯時的多汁性，或者可以使用std::size_t I來獲取值的運行時版本。

上面的大多數內容都可以翻譯成C ++ 11，這很難看。 而且我不喜歡難看的代碼。

現場例子 。

您的代碼如下所示：

int main( void )
{
  unsigned size = 17;
  constexpr std::size_t number_objects = 3;

  auto objects = make_array<number_objects>( [&](std::size_t){ return NameClass(size); } );
}

和objects現在是NameClass的（ std:: NameClass數組，長度為number_objects ，大小均為size 。

Answer 2

為您的類創建一個默認的構造函數：

#include <vector>

class NameClass {
 public:
 NameClass() {} // default constructor

 explicit NameClass( unsigned size ){
    vectorName.resize( size );
 }
 std::vector <type> vectorName;
};

在主要方面：

#include "lib.hpp"

int main( void )
{
  unsigned number_objects = something;
  unsigned size = other_thing;
  NameClass object[ number_objects ];

  for( unsigned i = 0; i < number_objects; i++)
    object[i].vectorName.resize( size );

  return 0;
}

示例2不起作用的原因是因為C ++沒有用於創建未提供默認構造函數的對象數組的語法。

在python中，它看起來像：

[NameClass(size) for _ in range(number_objects)]

我離題了。

要在沒有默認構造函數的情況下仍然創建列表，可以使用此命令（問題是為什么要這樣做）：

#include <iostream>

static constexpr unsigned NUM_OBJECTS = 10;
static constexpr unsigned VEC_SIZE = 30;

int main() {
    NameClass *objects = static_cast<NameClass *>(operator new [](NUM_OBJECTS * sizeof *objects));

    for (unsigned i = 0; i < NUM_OBJECTS; i++) {
        objects[i].vectorName.resize(VEC_SIZE);
    }

    // Required to free memory
    operator delete[](objects);

    return 0;
}

Answer 3

如果使用向量不是問題，那么實際上這是可行的，而且確實很容易。 這是一首詩...

class-test.cpp

#include <stdio.h>
#include <algorithm>

#include "class.hpp"

int main( void )
{
  std::vector <NameClass> object(number_objects, NameClass(size));

  printf("%lu\n", object[0].vectorName.size() );

  return 0;
}

class.hpp

#include <vector>
#include <algorithm>

#include <vector>

class NameClass {
 public:
 NameClass() {} // default constructor

 explicit NameClass( unsigned size ){
    vectorName.resize( size );
 }
 std::vector <double> vectorName;
};

如果要使用數組，則只需使用默認構造函數即可。

clas.hpp

#include <vector>

class NameClass {
 public:
 NameClass(unsigned size) {
 vectorName.resize( size ); 
 } // default constructor

 explicit NameClass( unsigned size ){ // eliminate this
    vectorName.resize( size );
 }
 std::vector <type> vectorName;
};

class-test.cpp

#include <stdio.h>

#include "class.hpp"

int main() {
  NameClass objects[2](4);

  printf("%lu\n", objects[0].vectorName.size());

  return 0;
}

這將打印正確的輸出。

Answer 4

您必須初始化每個向量，只需對其在代碼中的顯示方式進行初始化。 你可以這樣做

std::vector<NameClass> classes(number_of_objects);
std::generate(classes.begin(), classes.end(), []{return NameClass(size);});

std :: generate將為向量的每個元素初始化NameClass的實例。