Question

我正在尝试创建一个类：

class CLASS
{
public:
    //stuff
private:
    int x, y;
    char array[x][y];
};

当然，在我将int x, y;更改为

之前，它无效

const static int x = 10, y = 10;

这是不切实际的，因为我试图从文件中读取x和y的值。那么有没有办法初始化一个具有非常量值的数组，或者声明一个数组并在不同的语句中声明它的大小？我知道这可能需要创建一个数组类，但是我不知道从哪里开始，当数组本身不是动态的时候我不想创建一个2D动态列表，只是大小是在编译时不知道。

Answer 1

使用矢量。

#include <vector>
class YourClass
{
public:
    YourClass()
    : x(read_x_from_file()), y(read_y_from_file())
    {
        my_array.resize(x);
        for(int ix = 0; ix < x; ++ix)
            my_array[ix].resize(y);
    }

    //stuff

private:
    int x, y;
    std::vector<std::vector<char> > my_array;
};

Answer 2

编译时，编译器需要具有类的确切大小，您必须使用new运算符来动态分配内存。

切换字符串数组[x] [y];到char **数组;并在构造函数中初始化您的数组，并且不要忘记在析构函数中删除您的数组。

class MyClass
{
public:
    MyClass() {
        x = 10; //read from file
        y = 10; //read from file
        allocate(x, y);
    }

    MyClass( const MyClass& otherClass ) {
        x = otherClass.x;
        y = otherClass.y;
        allocate(x, y);

        // This can be replace by a memcopy
        for( int i=0 ; i<x ; ++i )
            for( int j=0 ; j<x ; ++j )
                array[i][j] = otherClass.array[i][j];
    }

    ~MyClass(){
        deleteMe();
    }

    void allocate( int x, int y){
        array = new char*[x];
        for( int i = 0; i < y; i++ )
            array[i] = new char[y];
    }

    void deleteMe(){
        for (int i = 0; i < y; i++)
           delete[] array[i];
        delete[] array;
    }

    MyClass& operator= (const MyClass& otherClass)
    {
        if( this != &otherClass )
        {
            deleteMe();
            x = otherClass.x;
            y = otherClass.y;
            allocate(x, y);
            for( int i=0 ; i<x ; ++i )
                for( int j=0 ; j<y ; ++j )
                    array[i][j] = otherClass.array[i][j];            
        }
        return *this;
    }
private:
    int x, y;
    char** array;
};

*编辑：我有复制构造函数和赋值运算符

Answer 3

不是那样，就像在c ++中一样，必须在编译时知道c风格的数组大小，某些供应商特定的扩展允许某些运行时大小（以增强与C99的兼容性），但不是在你描述的情况下（如果您有兴趣，here's a description）。最简单的方法是：

std::vector< std::vector<char> > array;

并在构造函数中应用大小：

array.resize(x);
for(std::vector< std::vector<char> >::iterator curr(array.begin()),end(array.end());curr!=end;++curr){
   curr->resize(y);
}

矢量优于c样式数组有许多优点，请参阅here

Answer 4

将所有内存放入一个块中因为它是私有的，所以您可以获取访问方法以检索正确的值。

快速举例：

#include <vector>
#include <iostream>

class Matrix
{
    public:
    class Row
    {
        public:
        Row(Matrix& p,unsigned int x)
            :parent(p)
            ,xAxis(x)
        {}
        char& operator[](int yAxis)
        {
            return parent.data(xAxis,yAxis);
        }
        private:
            Matrix&         parent;
            unsigned int    xAxis;
    };

    Matrix(unsigned int x,unsigned int y)
        :xSize(x)
        ,ySize(y)
        ,dataArray(x*y)
    {}

    Matrix::Row operator[](unsigned int xAxis)
    {
        return Row(*this,xAxis);
    }
    char& data(unsigned int xAxis,unsigned int yAxis)
    {
        return dataArray[yAxis*xSize + xAxis];
    }
    private:
        unsigned int xSize;
        unsigned int ySize;
        std::vector<char>   dataArray;
};


int main()
{
    Matrix      two(2,2);

    two[0][0]   = '1';
    two[0][1]   = '2';
    two[1][0]   = '3';
    two[1][1]   = '4';

    std::cout <<  two[1][0] << "\n";
    std::cout <<  two.data(1,0) << "\n";
}

Answer 5

看看boost::multi_array。

Answer 6

您不能使用非常量值（编译时）以声明方式分配或初始化全局或静态数组。虽然可以使用本地数组（C99可变大小的数组，因为它们的初始化程序基本上在每次执行函数时都在运行时运行）。

根据您的情况，我建议使用指针而不是数组，并在运行时动态创建实际数组（使用new）：

class CLASS
{
public:
    CLASS(int _x, int _y) : x(_x), y(_y) {
       array = new char*[x];
       for(int i = 0; i < x; ++i)
           array[i] = new char[y];
    }
    ~CLASS() {
       for (int i = 0; i < x; ++i)
           delete[] array[i];
       delete[] array;
    }
    //stuff
private:
    int x, y;
    char **array;
};

Answer 7

您可以在构造函数中为您的二维数组分配内存，并在析构函数中释放它。最简单的方法：

array = (char **)malloc(sizeof(char *) * x);
if (array) {
    for (i = 0; i < x; i++) {
        array[i] = (char *)malloc(sizeof(char) * y);
        assert(array[i]);
    }
}

Answer 8

如果在编译时未知大小，则该数组是动态的。保持静止的方法是使它们大于预期的最大尺寸。

Answer 9

如果要将动态大小的数组作为类成员，则需要对其进行数组new并将该值赋给指针。对于静态大小的数组，char array[size]语法仅。

更好的是，你真的应该使用std::vector< std::vector<char> >，现在手动使用动态大小的数组的理由很少。

有没有办法用非常量变量初始化数组？（C ++）

9 个答案:

有没有办法用非常量变量初始化数组？ （C ++）

9 个答案:

有没有办法用非常量变量初始化数组？（C ++）