将动态分配的指针数组调整为 class

Question

如何在不使用向量的情况下调整数组的大小？我要调整大小的数组是指向 class

的指针

class A
{
    private:
    B * b;
    int numOfItems;
    int maxNumOfItems;

    public:
    A();
    ~A();
    resizeMX();
};


A::A()
{
     numOfItems = 0;
     maxNumOfItems = 20;
     b = new B[maxNumOfItems];
     for(int i=0;i<maxNumOfItems ;i++)
     {
         b[i] = 0;
     }
}

A::~A()
{
    for(int i=0;i<numOfItems;i++)
     {
         delete [] b;
     }
}

void A::resizeMX(const B & obj)
{
     bool value=false;
     if(numOfItems<=maxNumOfItems && value == false)
     {
        //assign values to *b in for loop
     }
     else
     {
       //resize index of *b

我知道我们应该动态分配新内存。是这样的吗？

       ++maxNumOfItems; 
        b=new B[maxNumOfItems];
        //keep previous assigned values and add new values at the end
        for(int j=numOfItems;j<maxNumOfItems;j++)
        {
            //assign values to b[j]
        }
     }  
        numOfItems++;
}

假设我确实重载了 = 运算符

Answer 1

您不能调整数组大小，只能分配新的（更大的）数组并复制旧数组的内容。如果您不想使用 std::vector（出于某种原因），这里是它的代码：

int size = 10;
int* arr = new int[size];

void resize() {
    size_t newSize = size * 2;
    int* newArr = new int[newSize];

    memcpy( newArr, arr, size * sizeof(int) );

    size = newSize;
    delete [] arr;
    arr = newArr;
}

Answer 2

当您进行重新分配时 b = new B[...] 您会丢失原始指针，因此会丢失所有以前的对象。

相反，您需要为新内存使用一个临时变量，并将 copy（或移动）从旧 b 到新内存。然后你删除旧内存并重新分配指针，

Answer 3

首先，数组不是指针。指针可以包含数组第一个元素的地址，它可以动态分配也可以不动态分配。

无论如何，假设您有一个指向 B

的动态分配数组的指针

pointer = new B[size];   //  assume size > 0

  //  optionally do something with the elements of pointer other than resizing

那么，要调整大小就需要动态分配一个新数组

B *new_pointer = new B[newsize];    // assume size < newsize

然后将元素复制到新数组

for (i = 0; i < size; ++i)
      new_pointer[i] = pointer[i];     // relies on B's assignment operator

然后释放旧的动态分配数组

delete [] pointer;

最后，重新分配 pointer 以指向新分配的数组。

pointer = new_pointer;

最好使用标准容器，因为它根据需要管理所有分配和重新分配。

将动态分配的指针数组调整为 class

Resizing dynamically allocated pointer array to class

c++

class

dynamic-memory-allocation