Question

在下面的代码中，我希望在调用Class构造函数时将数组定义为size x的数组。我怎么能这样做？

class Class
{
public:
  int array[];
  Class(int x) : ??? { }
}

Answer 1

你这些人过于复杂了。当然你可以用C ++做到这一点。他可以使用普通数组来提高效率。如果向量不提前知道数组的最终大小，即它需要随着时间的推移而增长，那么它才有意义。

如果您可以知道链中的数组大小高一级，则模板化类最简单，因为没有动态分配且没有内存泄漏的可能性：

template < int ARRAY_LEN > // you can even set to a default value here of C++'11

class MyClass
  {   
  int array[ARRAY_LEN]; // Don't need to alloc or dealloc in structure!  Works like you imagine!   
  }

// Then you set the length of each object where you declare the object, e.g.

MyClass<1024> instance; // But only works for constant values, i.e. known to compiler

如果您无法知道声明对象的位置的长度，或者您想要重用不同长度的同一对象，或者您必须接受未知长度，那么您需要在构造函数中分配它，在你的析构函数中释放它...（理论上总是检查以确保它有效...）

class MyClass
  {
  int *array;

  MyClass(int len) { array = calloc(sizeof(int), len); assert(array); }   
  ~MyClass() { free(array); array = NULL; } // DON'T FORGET TO FREE UP SPACE!
  }

Answer 2

您无法使用在编译时无法计算的非const维度初始化数组的大小（至少在当前C ++标准，AFAIK中不是这样）。

我建议使用std::vector<int>而不是数组。它为大多数操作提供类似数组的语法。

Answer 3

使用new运算符：

class Class
{
   int* array;
   Class(int x) : array(new int[x]) {};
};

Answer 4

我不认为可以做到。至少不是你想要的方式。当大小来自动态信息（x）时，您无法创建静态大小的数组（array []）。

您需要存储指向int的指针和大小，并重载复制构造函数，赋值运算符和析构函数来处理它，或者使用std :: vector。

class Class
{
  ::std::vector<int> array;
  Class(int x) : array(x) { }
};

Answer 5

难道你不明白不需要使用矢量，如果想要使用数组，那就是效率问题，例如：更少的空间，没有复制时间（在这种情况下，如果处理得当，甚至不需要在析构函数中删除数组）等等，无论出于何种原因。

正确答案是:(引用）

class Class
{
   int* array;
   Class(int x) : array(new int[x]) {};
};

不要试图强迫一个人使用非最佳替代品，否则你会让没有经验的程序员感到困惑

Answer 6

对不起这个老线程。实际上有一种方法可以找出数组编译时的大小。它是这样的：

#include <cstdlib>

template<typename T>
    class Class
    {
        T* _Buffer;

        public:
        template<size_t SIZE>
            Class(T (&static_array)[SIZE])
            {
                _Buffer = (T*)malloc(sizeof(T) * SIZE);

                memcpy(_Buffer, static_array, sizeof(T) * SIZE);
            }

            ~Class()
            {
                if(_Buffer)
                {
                    free(_Buffer);
                    _Buffer = NULL;
                }
            }
    };

int main()
{
    int int_array[32];
    Class<int> c = Class<int>(int_array);

    return 0;
}

或者，如果您讨厌malloc / new，那么您可以创建一个大小模板化的类。虽然，我不会真的推荐它，语法也很难看。

#include <cstdio>

template<typename T, size_t SIZE>
    class Class
    {
        private:
            T _Array[sz];
        public:
            Class(T (&static_array)[SIZE])
            {
                memcpy(_Array, static_array, sizeof(T) * SIZE);
            }
    };

int main()
{
    char int_array[32];
    Class<char, sizeof(int_array)> c = Class<char, sizeof(int_array)>(int_array);
    return 0;
}

无论如何，我希望这有用：）

Answer 7

为什么不使用向量代替使用原始数组。

class SomeType {
  vector<int> v;
  SomeType(size_t x): v(x) {}
};

使用矢量将在异常情况下为您提供自动泄漏保护，并在原始阵列上提供许多其他好处。

Answer 8

你不能用C ++做 - 改为使用std :: vector：

#include <vector>

struct A {
   std::vector <int> vec; 
   A( int size ) : vec( size ) {
   }
};

Answer 9

将数组声明为指针。您可以稍后在初始化列表中通过new。

初始化它

最好使用未知大小的矢量。

您可能还希望在可变长度数组上查看this question。

Answer 10

两个选项：

使用std :: vector。这样可以轻松地重新调整阵列的尺寸使用std :: tr1 :: array。这具有静态大小。

两者都可以在构造函数初始化列表中正确初始化。

Answer 11

我遇到了同样的问题，并且以这种方式解决了

class example
{
  int *array;

  example (int size)
  {
    array = new int[size];
  }
}

Answer 12

就像已经建议的那样，在大多数情况下，向量是一个不错的选择。

或者，如果要避免动态内存分配，并且在编译时知道最大大小，则可以将自定义分配器与std :: vector一起使用，或者可以使用嵌入式模板库之类的库。

查看此处：https://www.etlcpp.com/home.html

示例类：


#include <etl/vector.h>

class TestDummyClass {
public:
    TestDummyClass(size_t vectorSize) {
        if(vectorSize < MAX_SIZE) {
            testVector.resize(vectorSize);
        }
    }

private:
    static constexpr uint8_t MAX_SIZE = 20;
    etl::vector<int, MAX_SIZE> testVector;
    uint8_t dummyMember = 0;
};

确定构造函数初始值设定项中的数组大小

12 个答案: