Question

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

的指针

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;

标准容器是首选，因为它根据需要管理所有分配和重新分配。

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

3 个答案: