C＆＃x2B;＆＃x2B;中的动态数组与Java相比

Question

最近，在学习Java后，我开始学习C ++，并被指示制作一个动态数组，因此我尝试制作一个临时变量，其中包含我需要的内容，然后将其重新分配到我真正想要使用的变量中。

void Pile::grow(Stone s){
    Stone temp[getLength() + 1];
    for (int i = 0; i < sizeof(temp) / sizeof(temp[0]); ++i) {
        if (sizeof(temp) / sizeof(temp[0]) < 28){
            temp[i] = stoneArr[i];
        }
    }
        
    stoneArr = temp;
}

但是，由于某种原因，我无法理解的是，编译器给我一个无法重新分配的错误。

Answer 1

void Pile :: grow（Stone S）

您在任何地方都不会使用 s 。您是否应该将其添加到您要创建的新数组中？

stone temp [getLength（） + 1];

这在标准C ++中是不合法的。固定阵列的大小必须在编译时已知。

一些编译器将“可变长度数组”作为非标准扩展名支持，但是如果您需要编写便携式代码，请不要依靠它们。请参阅为什么不是c ++标准的变量length阵列的一部分？

在运行时动态分配数组，使用 new [] 运算符，例如：

Stone *temp = new Stone[getLength() + 1];
...
delete[] temp;

或者，使用标准 std :: vector 容器，例如：

#include <vector>

std::vector<Stone> temp(getLength() + 1);
...

for（int i = 0; i＆lt; sizeof（temp）/sizeof（temp [0]）; ++ i）

您不能在动态上使用此 size> sizeof trick数组，更不用说VLA了。 sizeof 仅在编译时而不是在运行时评估。

由于您正在从现有数组中复制值，因此请使用该数组的长度：

for (int i = 0; i < getLength(); ++i)

if（sizeof（temp）/sizeof（temp [0]）＆lt; 28）

硬编码 28 这里没有意义。实际上，如果检查需要完全删除。

stonearr = temp;

当 temp 是VLA时，此分配将无法使用。 stonearr 无论如何都不能成为VLA。

stonearr 需要是 Stone*指针 new [] 'D Array（通过遵循 3/5/0 ），或 std :: vector :: vector＆lt; stone＆gt; （首选）。

同样，请尝试尝试：

private:
    Stone *stoneArr;
    int arrLength;

...


Pile::Pile()
    : stoneArr(NULL), arrLength(0) {
}

Pile::Pile(const Pile &src)
    : stoneArr(new Stone[src.arrLength]), arrLength(src.arrLength) {
    for (int i = 0; i < arrLength; ++i) {
        stoneArr[i] = src.stoneArr[i];
    }
}

Pile::~Pile() {
    delete[] StoneArr;
}

Pile& Pile::operator=(const Pile &rhs) {
    if (&rhs != this) {
        Pile temp(rhs);
        std::swap(stoneArr, temp.stoneArr);
        std::swap(arrLength, temp.arrLength);
    }
    return *this;
}

int Pile::getLength() const {
    return arrLength;
}

void Pile::grow(const Stone &s){
    Stone *temp = new Stone[arrLength  + 1];
    for (int i = 0; i < arrLength; ++i) {
        temp[i] = stoneArr[i];
    }
    temp[arrLength] = s;
        
    delete[] stoneArr;
    stoneArr = temp;
    ++arrLength;
}

或：

#include <vector>

private:
    std::vector<Stone> stoneArr;

...

// std::vector follows the rule of 3/5/0, so let the
// compiler handle Pile(), Pile(const Pile &), ~Pile(),
// and operator= for you...

int Pile::getLength() const {
    return stoneArr.size();
}

void Pile::grow(const Stone &s){
    stoneArr.push_back(s);
}