0

我想在头文件中声明一个数组，但我想在构造类时声明数组的大小。这可能吗？我在这个网站上发现了很多数组声明，但不是这个。当我尝试下面的代码时，我收到错误“数组绑定不是']'标记之前的整数常量”

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)  
{ 
}
4

6 回答 6

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++ 三规则的链接

于 2013-03-17T22:48:37.513 回答
1

理想情况下，您应该使用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;}

这不太好，因为一旦定义了析构函数，就需要处理三的规则。

于 2013-03-17T22:48:52.710 回答
1

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

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)
    {
    }
};
于 2013-03-17T23:01:49.397 回答
1

你不能那样做。数组的大小必须是编译时间常数。在您的情况下，类 foo 实例的大小取决于数组的大小。如果您在编译时知道每次使用 class 时包含的数组的大小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_)
    {}
};
于 2013-03-17T23:02:43.320 回答
0

这不是初始化静态变量的方式。方法如下（通常在 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.

于 2013-03-17T22:49:15.670 回答
0

使用向量。

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

foo::foo(uint16_t size) : array(size)  
{ 
}
于 2013-03-17T22:50:47.610 回答