动态分配对象数组

Dynamically allocating array of objects

本文关键字：数组 对象 动态分配      更新时间：2023-10-16

我需要一个DizzyCreature类型的双指针（我的类）来指向一个DizzyCreature指针数组。当我运行它时，我会得到"读取位置0x…的访问冲突"。我可以进行DizzyCreature*并调用其成员函数，但当不能运行数组并对每个对象执行相同的操作时。

我遵循以下指示：http://www.cplusplus.com/forum/beginner/10377/

代码

服务器.h:

class Server
{
 public:
  Server(int x, int y, int count);
  ~Server(void);
  void tick();

 private:
  DizzyCreature** dcArrPtr;
  DizzyCreature* dcPtr;
  int _count;
};

服务器.cpp:

Server::Server(int x, int y, int count)
{
  dcPtr = new DizzyCreature[count];       // this works just fine
  dcArrPtr = new DizzyCreature*[count];   // this doesn't (but gets past this line)
  _count = count;
}
Server::~Server(void)
{
  delete[] *dcArrPtr;
  delete[] dcPtr;
}
void Server::tick()
{
  dcPtr->takeTurn();                // just fine
  for (int i = 0; i < _count; i++) {
    dcArrPtr[i]->takeTurn();        // crash and burn
  }
}

编辑：成员函数takeTurn（）位于DizzyCreature的父类中。程序将其放入函数中，但一旦尝试更改私有成员变量，就会引发异常。如果重要的话，DizzyCreature是GameCreature和WhirlyB类型，因为这是MI上的任务。

您已经为dcArrPtr分配了空间，但没有分配此数组中的每个对象。您必须执行以下操作：

Server::Server(int x, int y, int count)
{
  dcPtr = new DizzyCreature[count];
  dcArrPtr = new DizzyCreature*[count];
  for ( int i = 0; i < count; i++ ) {
    dcArrPtr[ i ] = new DizzyCreature;
  }
  _count = count;
}
Server::~Server(void)
{
  for ( int i = 0; i < count; i++ ) {
    delete dcArrPtr[ i ];
  }
  delete[] *dcArrPtr;
  delete[] dcPtr;
}

这：

dcPtr = new DizzyCreature[count];

"创建"DizzyCreature的数组，而：

dcArrPtr = new DizzyCreature*[count];

"创建"一个指向DizzyCreature的指针数组，但至关重要的是，不为这些指针创建指向的实例。

不过，首选的解决方案是使用标准容器执行类似的任务。如果真的想这样做（并且意识到手动这样做不是最佳实践），那么您需要一个循环来为指针数组中的每个元素调用new。

您分配的是计数指针数组，而不是计数对象数组。

代替

dcArrPtr = new DizzyCreature*[count];

你可能想要

dcArrPtr = new DizzyCreature[count];

您正在分配一个指针数组，但在将它们设置为某个值之前，这些指针是无效的。

double **arr = new double*[10];
for(int i=0;i<10;++i) {
    arr[i] = new double[10];
}

也就是说，当开始使用C++时，您可能应该避免使用原始数组，而是使用std::array和std::vector:

class Server
{
 public:
  Server(int x, int y, int count);
  void tick();

 private:
  std::vector<std::vector<DizzyCreature>> dcArrPtr;
  std::vector<DizzyCreature> dcPtr;

};
Server::Server(int x, int y, int count)
{
  dcPtr.resize(count);
  dcArrPtr.resize(count);
}

void Server::tick()
{
  dcPtr[0].takeTurn();
  for (int i = 0; i < dcArrPtr.size(); i++) {
    dcArrPtr[i][0].takeTurn();
  }
}

使用

std::vector<std::vector<DizzyCreature>>

此外，如果您想使用原始指针（我不建议使用），则必须为数组中的每个指针分配内存。

class A
{
    std::vector<std::vector<int>> v_;
public:
    A()
        : v_(500, std::vector<int>(500))
    {} // 500 x 500
};
class B
{
    int** v_;
public:
    B()
        : v_(new int*[500])
    { // not even exception safe
        for (int i = 500; i--; )
            v_[i] = new int[500];
    }
    ~B()
    {
        for (int i = 500; i--; )
            delete[] v_[i];
        delete[] v_;
    }
};

如果您已经看到二维数组的动态内存分配的实现。这会让你更好地了解在这种情况下如何进行。大多数答案已经回答了你该怎么做。但只要通过任何链接，看看在二维数组的情况下内存是如何分配的。这对你也有帮助。

相关文章：