Существует ли способ инициализировать массив с непостоянными переменными? (C++)

Не таким образом, как в C ++, размеры массивов в стиле c должны быть известны во время компиляции, при этом некоторые специфичные для поставщика расширения допускают определенные размеры времени выполнения (для улучшения совместимости с C99), но не в той ситуации, которую вы описываете (если вам интересно, вот описание ). Проще всего сделать следующее:

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, см. здесь

использовать вектор.

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

Вы не можете выделить или инициализировать глобальный или статический массив, декларативно использующий непостоянные значения (время компиляции). Однако это возможно для локальных массивов (массивы переменного размера 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;
};

Поместите всю память в один блок.
Поскольку он является частным, вы можете использовать методы доступа для получения правильного значения.

Быстрый пример:

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

Если размер неизвестен во время компиляции, массив является динамическим. Что вы можете сделать, чтобы сохранить статичность, так это сделать их больше, чем ваш самый большой ожидаемый размер.

Если вам нужен массив с динамическим размером в качестве члена класса, вам нужно массив new его и присвоить это значение указателю. Синтаксис char array [size] только для массивов статического размера.

Еще лучше, вам действительно следует использовать std :: vector > , в наши дни очень мало веских причин для ручной работы с массивами динамического размера.

Взгляните на boost :: multi_array .

Вы можете выделить память для вашего двумерного массива в конструкторе и освободить ее в деструкторе. Самый простой способ:

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