C++ 如何在C++；上课？

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

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

#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;
    }
}

#包括
#定义ARRSIZE 5
一流的{
私人：
int myarray[ARRSIZE]；
公众：
优雅的（）；
void printary（）；
};
雅致的{
对于（int i=0；istd:：cout要使用模板解决此问题：

#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;
};

#包括
模板
班级优秀决赛
{
公众：
静态常量std:：size\u t size=ArraySize；
/*这里是您的公共界面的其余部分*/
私人：
std：：数组m_数组；
};

然后您可以像这样使用您的类：

#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;
    }
}

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

#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;
    }
}

#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
}

intmain（）
{
优雅的装饰元素；
返回0；
}

你可以很好地选择不使用STD::Advestor，对于C风格的数组。但是我们正在编写C++，所以让我们使用我们拥有的更好的语言设施：
< P>它需要使用动态分配，因为<代码> sieof（高级）

必须是编译时常量。对象的内部大小无法增长。但动态分配不必像链接所建议的那样复杂

您可以这样做：

#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;
    }
}

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

#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;
    }
}

#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
}

#包括
一流的
{
私人：
内部阵列化；
std：：唯一的ptr myarray；
公众：
雅致（国际标准尺寸）；
void printary（）；
};
Classy：：Classy（int parraysize）
：arraysize{parraysize}
，myarray{new int[arraysize]}
{
for（int i=0；istd:：cout您需要使用
new[]
动态分配数组，然后使用
delete[]
将其放在析构函数中。或者，使用
std:：vector
和
reserve
传递给构造函数的量。还有一种方法是将类模板化，使用
size\u t
参数表示希望它具有的元素量，但这完全消除了它的动态方面（此时您还可以使用
std:：array
）

我知道您希望避免动态分配，但这是做您想做的事情的最有效的方法（因为
vector
可能会占用比您预期的更多的空间）。
好吧，我认为在使用经典数组时，如果不使用动态内存分配，您无法做到这一点，但您可以使用std:：vector。您可以这样做：

#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;
    }
}

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

#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;
    }
}

#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
}

#包括
一流的{
私人：
内部阵列化；
std：：向量MyarrayFints；
公众：
雅致（国际标准尺寸）；
void printary（）；
};
Classy：：Classy（int parraysize）{
阵列大小=阵列大小；
for（int i=0；iStd:：CUT使用。一般来说，我不是一个数组的巨大粉丝，对于大多数的目的，除非你真的需要它们来进行一些感知优化， STD:：vector < /Cl> >是你的朋友，而且更容易用你的需求弯曲。但是你可以使用……C++的替代C数组。@变量大小。
std:：unique\u ptr
是在构造时设置大小的数组的标准组件。
std:：vector
用于在其生命周期内大小可能变化的数组。更一般地说，您想了解
新的
（当然还有
删除
）用于动态分配。@BenVoigt是的，我很清楚。但我最近讨论过这个问题。想想看。不要射击messenger。这不会让你“将大小传递给构造函数”正如问题所要求的。
std:：vector
需要一个类型是的，当然，我忘了写它了：D谢谢，我已经更新了。你为什么用
int-arraysize；
跟踪
std:：vector
的大小；
？你不能只使用向量的
大小（）
method？你可以。我已经尽可能少地编辑op的代码。但是最好使用size方法。