是否有可能在头文件中初始化带有在构造函数中初始化的成员的私有数组?c++

Is it possible to initialize a private array in a header file with a member which is initialized in the constructor? c++

本文关键字：初始化 成员 数组 c++ 有可能 文件 是否 构造函数      更新时间：2023-10-16

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

foo。

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

一种特殊的方法是

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将在实例之间共享相同的值，我也不认为这会编译，因为只有静态函数可以访问静态成员。

在我匆忙回答的时候，我忘了说你应该在你的类中添加一个析构函数，以便在类超出作用域时销毁数组，就像这样 
foo:~foo()
{
    delete[] array;
}

被否决了，因为我从来没有提到过三原则。理想情况下你不应该使用动态初始化的数组而应该使用向量这是c++三规则的链接三规则

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

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

你可以使用模板参数来定义数组的大小，如果你真的需要使用array:

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

你不能那样做。数组的大小必须是编译时常数。在您的示例中，类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_)
    {}
};

使用vector 

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

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

相关文章：