Question

我正在尝试将数组作为类的一部分。数组应该是可变大小。在我的代码中，数组应该由某个函数赋予可变大小的内容，然后将其视为类的成员。我的代码没有运行，我能够将我的问题归结为几行代码。

在这个例子中，我将数组保存在一个指针“dptr”中，这样它就可以被函数初始化为可变大小，然后作为类成员访问。

在我给空指针内容之后，我可以只调用它一次，之后我在访问它时得到的只是某种奇怪的，几乎是随机的数字。

class x 
{
public:
   double* dptr;

void void_()
   {
       double d[] = { 2., 3., 4. };
       dptr = d;
   }
};


int main() 

{
   x x_;
   x_.void_();

   int index = 0;
   std::cout << x_.dptr[index] << std::endl; // works perfectly fine for any index ( outputs 2 )

   std::cout << x_.dptr[index] << std::endl; // outputs something random ( outputs 6.95241e-310 )
}

我猜在 void 结束后，双 "d" 的析构函数被调用，指针指向的内容被删除。

有没有办法解决这个问题，例如，不允许调用析构函数？

Answer 1

干净的方法是使用 std::vector 并在调用构造函数时初始化成员：

struct x {
    std::vector<double> d;
    x() : d{2.,3.,4.} {}
};

避免调用解析器的方法是动态创建数组。但是，在这种情况下，x 应该跟在 rule of 5 之后。

Answer 2

不，您一直在使用动态分配的指针并向类添加析构函数：

class x 
{
public:
   double* dptr;

x()
  {
    dptr = nullptr;
  }
x(const &x) = delete;
operator=(const &x) = delete;

void void_()
   {
       double d[] = new double[3]
       d[0] = 2.;
       d[1] = 3.;
       d[2] = 4.; 
       dptr = d;
   }
 ~x() 
   {
       if(dptr != nullptr) {
          delete[] dptr;
       }
   }
};

但如果您尝试以这种方式分配数组以完成任何实际工作，请考虑改用 std::vector。然后为您处理所有内部结构，您不必弄乱指针。

析构函数删除指针

2 个答案: