为类调整动态分配的指针数组的大小

Resizing dynamically allocated pointer array to class

本文关键字：数组 指针 调整 动态分配      更新时间：2023-10-16

如何在不使用向量的情况下调整数组的大小?我要调整大小的数组是一个指向类

的指针
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++;
}

假设我重载了=操作符

你不能调整数组的大小，你只能分配一个新的(更大的大小)和复制旧数组的内容。如果你不想使用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;
}

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

相反，您需要为新内存使用临时变量，并从旧的b复制(或移动)到新内存。然后删除旧内存并重新分配指针，

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

无论如何，假设你有一个指向动态分配的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;

标准容器更可取，因为它可以根据需要管理所有的分配和重新分配。

相关文章：