Verwendung von boost::array mit unbekannter Größe als Objektvariable

Ich würde gerne boost::array als Klassenmitglied verwenden, aber ich kenne die Größe zur Kompilierzeit nicht.
Ich habe an so etwas gedacht, aber es funktioniert nicht:

int main() {
     boost::array<int, 4> array = {{1,2,3,4}};
     MyClass obj(array);
 }
 class MyClass {
     private:
         boost::array<int, std::size_t> array;
     public:
         template<std::size_t N> MyClass(boost::array<int, N> array)
         : array(array) {};
 };
 

Der Compiler gcc sagt:

error: type/value mismatch at argument 2 in template parameter list for
   ‘template<class _Tp, long unsigned int _Nm> struct boost::array’
 error:   expected a constant of type ‘long unsigned int’, got ‘size_t’
 

Was natürlich bedeutet, dass man keine Arrays mit variabler Größe als Klassenmitglieder verwenden kann. In diesem Fall würde dies alle Vorteile von boost::array gegenüber Vektoren oder Standard-Arrays zunichte machen.

Können Sie mir zeigen, was ich falsch gemacht habe?

Antworten:

Das Array von Boost hat eine feste Größe basierend auf dem zweiten Vorlagenparameter und boost::array<int,4> ist ein anderer Typ ab boost::array<int,2> . Sie können keine Instanzen derselben Klasse (MyClass in Ihrem Beispiel) haben, die unterschiedliche Typen für ihre Mitglieder haben.

std::vectors können jedoch unterschiedliche Größen haben, ohne unterschiedliche Typen zu sein:

struct MyClass {
   template<std::size_t N>
   explicit
   MyClass(boost::array<int, N> const& array)
   : data(array.begin(), array.end())
   {}
 private:
   std::vector<int> data;
 };
 int main() {
   boost::array<int, 4> a = {{1,2,3,4}};
   MyClass obj(a);
   boost::array<int, 2> a2 = {{42,3}};
   MyClass obj2(a2);
   // notice obj.data.size() != obj2.data.size()
   return 0;
 }
 

Trotzdem ist boost::array immer noch nützlich (es ist sogar in diesem Beispielcode nützlich), nur nicht genau so, wie Sie es verwenden möchten.

Einige Code-Antworten

int main() {
boost::array<int, 4>
array = {{1,2,3,4}};
MyClass obj(array);
}  class MyClass {
private:
  boost::array<int, std::size_t>
array;
public:
  template<std::size_t N>
MyClass(boost::array<int, N>
array)
  : array(array) {};
};

error: type/value mismatch at argument 2 in template parameter list for   ‘template<class _Tp, long unsigned int _Nm>
struct boost::array’ error:   expected a constant of type ‘long unsigned int’, got ‘size_t’ 

struct MyClass {   template<std::size_t N>
  explicit   MyClass(boost::array<int, N>
const&
array)   : data(array.begin(), array.end())   {}  private:   std::vector<int>
data;
};
 int main() {   boost::array<int, 4>
a = {{1,2,3,4}};
  MyClass obj(a);
   boost::array<int, 2>
a2 = {{42,3}};
  MyClass obj2(a2);
   // notice obj.data.size() != obj2.data.size()    return 0;
} 

template <
size_t N >
class MyClass { private:
boost::array<
int, N >
array;
public:    MyClass(boost::array<
int, N >
array) : array(array) {};
};
 // ...  boost::array<int, 4>
array = {{1,2,3,4}};
MyClass<4>
obj(array);

class MyClass { private:
std::vector<
int >
array;
public:    MyClass(const std::vector<
int >&
array) : array(array) {};
};

template<int Size>
class MyClass { private:
boost::array<int, Size>
m_array;
public:
// .... };

    template<unsigned long N>
MyClass(boost::array<int, N>
array) : array(array) {};

int main() {
int* array = new int[4];
for( int i=0;
i<4;
++i ) array[i] = i+1;
MyClass obj(array);
}  class MyClass {
private:
  int* array;
public:
  MyClass( int* array )
  : array(array) {}
  ~MyClass() { delete[] array;
} };

class MyClass {
private:
  boost::scoped_array<int>
array;
public:
  MyClass( int* array )
  : array(array) {} };

MyFunction (int* array,int size);
// function prototype 

boost::array<int,4>
testArray;
boost::array<int,5>
testArray2;
 // Calling the function: MyFunction(testArray.data(),4);
MyFunction(testArray2.data(),5);