How to build an array with dimensions determined in the class

Question

I am trying to create a 2 dimensional array of chars as an attribute for my class, but the dimensions of this array are determined by a .txt file the script is reading in the constructor of the class, and I can't manage to initialize an attribute in the constructor.

I used the template for a class from the Qt creator and edited it as seen in this tutorial (in the "Creating custom signals and slots" chapter) : https://wiki.qt.io/Qt_for_Beginners and the method for reading the .txt file is from here : https://www.tutorialspoint.com/read-data-from-a-text-file-using-cplusplus .

Here are the header file

#ifndef GRID_H
#define GRID_H
#include <fstream>
#include "square.h"

using namespace std;

class Grid
{
private:
    string text;
    string line;
    string directory;

    int getSize();
    const int height, width = getSize();

    char * getGrid();
    char grid [height][width]= getGrid();

public:
    Grid(string directory);
};

#endif // GRID_H

and the source file of the class :

#include "grid.h"

Grid::Grid(string directory)
{
    fstream newfile;
    newfile.open(directory,ios::in); //open a file to perform read operation using file object
    while(getline(newfile, line)){
        text.append(line);
    }
}


int Grid::getSize()
{
    int h;
    for (int ii = 1; ii > int(text.size()); ii++)
    {
        string part = "";
        part += text[ii-1]+text[ii];
        if (part.compare("\n"))
        {
            h++;
        }
    }
    h++;

    int w = line.size() - 2;

    return h, w;
}


char * Grid::getGrid()
{
    static char grid [height][width];
    for (int y = 0; y > height; y++)
    {
        for (int x = 0; x > width; x++)
        {
            grid[y][x] = text[(width+2)*y + x];
        }
    }
    return grid;
}

I know that this is full of errors but they were created when I tried to fix the initial error of having a "variable length array" in the first place (at line 35 of the source).

Here's the grid.txt for reference by the way :

..........
.......B..
..........
..........
..........
..........
..........
..........
.A........
..........

Answer 1

I see some problems with your code and style:

• Your data class Grid should not handle file accesses and parsing of any kind of protocol since you then bind it to this protocol
• As drescherjm wrote in this comment the comma operator doesn't work like in python where you can return multiple values. See this answer for details on how it works in C++.
• Because of static char grid [height][width]; your class is basically a hidden singleton. Multiple instances of your Grid class will always operate on the same memory block because the lifetime of static function variables end with the program. See this answer about static function variables

So how do you write a grid class? Some years ago I wrote a simple Array2D class for a project of mine:

#pragma once

#include <stdexcept>

template <typename T>
class Array2D
{
    T *data;
    size_t _sizeX;
    size_t _sizeY;

public:
    // Helper class to access elements in the form of array[x][y]
    // Uses memory block of parent class
    class Array1D
    {
        friend Array2D;
        size_t size;
        T *data;
        Array1D(T* data, size_t size);
    public:
        // Second index access
        T &operator[](size_t posY);
    };

    size_t sizeX() const;
    size_t sizeY() const;

    Array2D(size_t x, size_t y);
    Array2D(const Array2D&);
    Array2D& operator=(const Array2D&);
    Array1D operator[](size_t posX);
    ~Array2D();
};

// Implementation of the methods begins here
// In C++ generally you have to implement templates in the
// header file (although there are ways to cheat that)

template <typename T>
Array2D<T>::Array1D::Array1D(T *data, size_t size)
{
    this->data = data;
    this->size = size;
}

template <typename T>
T &Array2D<T>::Array1D::operator[](size_t posY)
{
    if(posY >= size || posY < 0)
        throw std::out_of_range("Y component out of bounds");

    return data[posY];
}

template <typename T>
size_t Array2D<T>::sizeX() const
{
    return _sizeX;
}

template <typename T>
size_t Array2D<T>::sizeY() const
{
    return _sizeY;
}

template <typename T>
Array2D<T>::Array2D(size_t x, size_t y)
{
    // Working with raw pointers here dont't forget to delete
    data = new T[x * y];
    _sizeX = x;
    _sizeY = y;
    for(int i = 0; i < x * y; i++)
        data[i] = T();
}

// Copy constructor, make sure you create enough space for 
// the "other" instance, other continues to exist!
template <typename T>
Array2D<T>::Array2D(const Array2D<T> &other)
{
    data = new double[other.sizeX() * other.sizeY()];
    memcpy(data, other.data, other.sizeX() * other.sizeY() * sizeof(T));
    _sizeX = other.sizeX();
    _sizeY = other.sizeY();
}

// Copy assignment operator, make sure you create enough space for 
// your assignment
template <typename T>
Array2D<T> &Array2D<T>::operator=(const Array2D<T> &other)
{
    delete[] data;
    data = new double[other.sizeX() * other.sizeY()];
    memcpy(data, other.data, other.sizeX() * other.sizeY() * sizeof(T));
    _sizeX = other.sizeX();
    _sizeY = other.sizeY();
    return *this;
}

// define operator[] to be able to access values by "array[i]"
template <typename T>
typename Array2D<T>::Array1D Array2D<T>::operator[](size_t posX)
{
    if(posX >= sizeX() || posX < 0)
        throw std::out_of_range("X component out of bounds");

    return Array1D(data + (posX * sizeY()), sizeY());
}

template <typename T>
Array2D<T>::~Array2D()
{
    delete[] data;
}

Your task could then be solved by reading your file and writing into the array like that:

Array2D<char> arr(10, 10);
// Filehandling code and loop...
    arr[i][j] = c;    

Be aware this code could have a memory leak, but I wanted to post it for you to have a general idea how to approach such a problem. Please comment any questions you have left, I will edit this answer to clarify the code and or expand on the answer.

Keywords for further research and understanding: C++ Template, Separation of concerns, Single responsibility principle