Question

我想在头文件中声明一个数组，但我希望在构造类时声明数组的大小。这可能吗？我在这个网站上发现了很多数组声明，但没有特别说明。当我尝试下面的代码时，我得到错误“数组绑定不是一个整数常量'''令牌”

foo.h中

class foo{
   private:
      uint16_t _size;
      uint16_t array[_size];
   public:
      foo(uint16_t size);
      virtual ~foo();
}

Foo.cpp中

#include "foo.h"
foo::foo(uint16_t size)
:_size(size)  
{ 
}

Answer 1

这样做的一个特殊方法是

class foo
{
public:
   foo(uint16_t size);
private:
   uint16_t _size;
   uint16_t* array;
};

foo::foo(uint16_t size) :_size(size)
{
    array = new int[_size];
}

这将允许你在运行时动态创建一个数组，我建议你使用std :: vector，因为通常它们比C ++（IMO）中的数组好很多但是如果你有特殊的理由使用它数组就像我做的那样。使用静态意味着如果你想在别处使用那个类，那么_size会在实例之间共享相同的值，我也不认为会编译，因为只有静态函数可以访问静态成员。

EDT：急于回答我忘了说你应该在类中添加一个析构函数来破坏数组，当类超出这个范围时

foo:~foo()
{
    delete[] array;
}

得到了投票，因为我从未添加过对三级规则的引用。理想情况下，你不应该使用动态初始化数组，只需使用向量，这里是三个规则的链接C++ rule of three

Answer 2

理想情况下，您应该使用std::vector<uint16_t>：它可以让您动态决定大小，如下所示：

vector<uint16_t> array;
...
foo(size_t size) : array(size) {}
...

或者，您可以使用指针代替数组，在构造函数中分配它，并在析构函数中删除：

uint16_t *array;
...
foo(size_t size) : array(new uint16_t[size]) {}
...
~foo() {delete[] array;}

这不太好，因为一旦定义了析构函数，就需要处理rule of three。

Answer 3

如果你真的必须使用数组，你可以使用template参数来定义数组大小：

template<size_t N>
class foo{
private:
    uint16_t array[N];

public:
    foo()
    {
    }
};

foo<3> f;

std::vector是C ++中的动态数组，它为操作数组提供了丰富的接口，没有理由不使用std::vector。

class foo{
private:
    std::vector<uint16_t> array;
   
public:
    foo(uint16_t size) : array(size)
    {
    }
};

Answer 4

你不能这样做。数组的大小必须是编译时常量。在您的情况下，类foo实例的大小取决于数组的大小。如果您在每次使用类foo时都知道编译时包含数组的大小，那么您可以使用模板：

template <size_t N>
class foo {
    uint16_t array[N];
public:
    foo() {}
};

否则你应该使用C ++提供的可调整大小的数组：std::vector：

class foo {
    std::size_t size;
    std::vector<uint16_t> array;
public:
    foo(std::size_t size_) 
    : size(size_)
    , array(size_)
    {}
};

Answer 5

这不是初始化静态变量的方式。这是如何（通常在CPP文件中）：

uint16_t foo::_size = /* something */;

但我认为你不想要一个静态变量。我建议你改用动态分配的数组：

class foo{
   private:
      uint16_t _size;
      uint16_t* array;
      static uint16_t* copy(uint16_t* a, uint16_t s) {
          if (!a) return 0;
          uint16_t* ret = new uint16_t[s];
          for (int i = 0; i < s; i++) ret[i] = a[i];
          return ret;
      }
   public:
      foo(const foo& f) : _size(f._size), array(0) { array = copy(f.array, f._size); }
      foo(uint16_t size = 0) : _size(size), array(0) {
          if (size == 0) return;
          array = new uint16_t[_size];
      }
      ~foo() { delete[] array; }
}

更好的解决方案是使用其中一个标准库容器，例如std::vector。

Answer 6

使用矢量。

class foo{
   private:
      std::vector<uint16_t> array;
   public:
      foo(uint16_t size)
};

foo::foo(uint16_t size) : array(size)  
{ 
}

是否可以使用在构造函数中初始化的成员初始化头文件中的私有数组？ C ++

6 个答案: