Question

我有一个类需要存储一个可变大小的数组。理想情况下，此大小将被定义为给予类的构造函数的参数。

我可以定义一个常量，然后使用它，如下所示：

#include <iostream>
#define ARRSIZE 5

class Classy{
    private:
        int myarray[ARRSIZE];

    public:
        Classy();
        void printarray();
};

Classy::Classy(){
    for(int i = 0; i < ARRSIZE; i++){
        myarray[i] = i * i * 2;
    }
}

void Classy::printarray(){
    for(int i = 0; i < ARRSIZE; i++){
        std::cout << myarray[i] << std::endl;
    }
}

但是，我想这样做：

#include <iostream>
class Classy{
    private:
        int arraysize;
        int myarray[arraysize];

    public:
        Classy(int parraysize);
        void printarray();
};

Classy::Classy(int parraysize){
    arraysize = parraysize;
    for(int i = 0; i < arraysize; i++){
        myarray[i] = i * i * 2;
    }
}

void Classy::printarray(){
    for(int i = 0; i < arraysize; i++){
        std::cout << myarray[i] << std::endl;
    }
}

编译器真的不喜欢我的方法，所以我正在寻找另一种做事方式。

我做了一些关于这个主题的谷歌搜索，但我的搜索并没有取得丰硕成果。我找到了使用动态内存分配的this方法。这是我想避免的，所以我正在寻找一种不依赖于此的解决方案。它可能（我开始思考）它是我问题的唯一优雅解决方案（如果是这种情况，那么问题当然应该被视为重复）。

Answer 1

需要使用动态分配，因为sizeof (Classy)必须是编译时常量。对象的内部大小无法增长。但动态分配不必像链接所暗示的那样复杂。

你可以这样做：

#include <memory>
class Classy
{
    private:
        int arraysize;
        std::unique_ptr<int[]> myarray;

    public:
        Classy(int parraysize);
        void printarray();
};

Classy::Classy(int parraysize)
    : arraysize{parraysize}
    , myarray{new int[arraysize]}
{
    for(int i = 0; i < arraysize; i++){
        myarray[i] = i * i * 2;
    }
}

#include <iostream>
void Classy::printarray()
{
    for(int i = 0; i < arraysize; i++){
        std::cout << myarray[i] << std::endl;
    }
}

这将允许大小在创建时变化，并在此后修复。当您的对象死亡时，std::unique_ptr会自动销毁阵列内容。

Answer 2

您想使用模板来解决此问题：

#include <array>

template<std::size_t ArraySize>
class Classy final
{
public:
    static const std::size_t size = ArraySize;

    /* The rest of your public interface here */
private:
    std::array<int, ArraySize> m_array;
};

然后你可以像这样使用你的课程：

int main()
{
    Classy<5> hasArrayOfFiveElements;
    return 0;
}

你可以选择不使用std :: array，而不是使用c风格的数组。但是我们正在编写C ++，所以让我们使用我们可以使用的更好的语言设施：）

Answer 3

您需要使用new[]动态分配数组，然后在析构函数中delete[]。或者，使用std::vector<int>和reserve传递给构造函数的金额。还有一种方法是让你的类模板化，为你希望它拥有的元素数量采用size_t参数，但这完全消除了它的动态方面（你也可能使用{{1那时候。

我知道你想避免动态分配，但这是做你想要的最有效的方法（因为std::array可能会占用比你预期更多的空间）。

Answer 4

嗯，我认为在使用经典数组时不使用动态内存分配就可以做到，但是你可以使用std :: vector。你可以这样做：

#include <iostream>
class Classy{
    private:
        int arraysize;
        std::vector<int> myArrayOfInts;

    public:
        Classy(int parraysize);
        void printarray();
};

Classy::Classy(int parraysize){
    arraysize = parraysize;
    for(int i = 0; i < arraysize; i++){
        myArrayOfInts.push_back(i * i * 2);
    }
}

void Classy::printarray(){
    for(int i = 0; i < myArrayOfInts.size(); i++){ //you could also use arraysize, but then you
        std::cout << myArrayOfInts[i] << std::endl;//must update it when you add or remove any
    }                                              // element from vector
}

如何在C ++类中初始化可变大小的数组？

4 个答案: