Question

我是C ++的新手，我在基于构造函数参数初始化数组时遇到了问题。

我在C＃中尝试做什么：

class Surface
{
    public int[] pixels;

    public Surface(int w, int h)
    {
        pixels = new int[w * h];
    }
}

我现在在C ++中所拥有的：

class Surface
{
    private:
        GLuint pixels[];
    public:
        Surface(int w, int h) {pixels(w * h) } //Initialize pixels based on width and height
        ~Surface();

};

由于

Answer 1

你应该有pixels的简单指针定义：

class Surface {
    private:
        GLuint* pixels; // <<<<<<
    public:
        Surface(int w, int h) : pixels(new GLuint[w * h]) {}
        ~Surface();
};

或者更好std::vector<GLuint>成员：

class Surface {
    private:
        std::vector<GLuint> pixels; // <<<<<<
    public:
        Surface(int w, int h) : pixels(w * h,0) {}
        ~Surface();
};

或至少std::unique_ptr<GLuint[]>：

class Surface {
    private:
        std::unique_ptr<GLuint[]> pixels; // <<<<<<
    public:
        Surface(int w, int h) : pixels(new GLuint[w * h]) {}
        ~Surface();
};

Answer 2

使用std::vector：

#include  <vector>

class Surface
{
    private:
        std::vector<GLuint> pixels;
    public:
        Surface(int w, int h) : pixels(w * h) { }
};

如果您使用new[]，则必须手动管理阵列的分配，复制和释放：

class Surface
{
    private:
        GLuint *pixels;
        int numPixels;
    public:
        Surface(int w, int h) : numPixels(w*h), pixels(new GLuint [numPixels]) { }
        Surface(const Surface &src) : numPixels(src.numPixels), pixels(new GLuint[numPixels]) { std::copy(src.pixels, src.pixels + numPixels, pixels); }
        ~Surface() { delete[] pixels; }
        Surface& operator=(const Surface &lhs) { Surface temp(lhs); std::swap(temp.pixels, pixels); std::swap(temp.numPixels, numPixels); return *this; }
};

Answer 3

在C ++中，静态数组大小必须是编译时常量。

解决方案是使用动态数组，因为它的大小不必是编译时常量。

更好的解决方案是在动态数组上使用一些抽象，例如std::vector。

Answer 4

在C ++中没有可变长度数组这样的东西。所有阵列都有固定长度。由于您需要可变长度数组，因此必须使用std::vector。

std::vector<GLuint> pixels;

构造可以使用resize()来确定向量的大小：

Surface(int w, int h) {
    pixels.resize(w * h);
}

C ++基于构造函数参数初始化数组

4 个答案: