Matrix as an attribute?

When you use formations 1 , the size must be known at compile time or you must use dynamic memory; so your approach is not valid.

A possible solution for using a constructor to determine the size of the board is, as I mentioned, using dynamic memory, for this your Tablero::mat should be a double pointer:

class Tablero
{
    int columnas;
    int filas;
    int **matriz;

public:
    Tablero ();
    Tablero (int pColumnas, int pFilas);
    void mostrarT ();
    void setN (int pA, int pB, int pC, int pD);
    ~Tablero (); 
};

Tablero::Tablero (int pColumnas, int pFilas) :
    columnas{pColumnas},
    filas{pFilas}
{
    matriz = new int*[pFilas];
    for (int indice = 0; indice < pFilas; ++indice)
        matriz[indice] = new int[pColumnas]{};
}

In the previous proposal I made the following changes:

This proposal meets your objectives, but it is not practical; there is no guarantee that the rows are attached to memory, which can give performance problems. You could create the matrix as a one-dimensional array and treat it as two-dimensional:

class Tablero
{
    int columnas;
    int filas;
    int *matriz;

public:
    Tablero ();
    Tablero (int pColumnas, int pFilas);
    void mostrarT ();
    void setN (int pA, int pB, int pC, int pD);
    ~Tablero (); 
};

Tablero::Tablero (int pColumnas, int pFilas) :
    columnas{pColumnas},
    filas{pFilas}
{
    matriz = new int[pColumnas * pFilas]{};
}

With the previous proposal, assigning a value to row y in column x , would be done as follows:

matriz[(y * columnas) + x] = valor;

And to get the value of the row y in the column x would be done as follows:

valor = matriz[(y * filas) + x];

You can forget about memory management and get the same results as the previous proposal if you change Tablero::matriz for std::vector :

class Tablero
{
    int columnas;
    int filas;
    std::vector<int> matriz;

public:
    Tablero ();
    Tablero (int pColumnas, int pFilas);
    void mostrarT ();
    void setN (int pA, int pB, int pC, int pD);
    ~Tablero (); 
};

Tablero::Tablero (int pColumnas, int pFilas) :
    columnas{pColumnas},
    filas{pFilas},
    matriz(pColumnas * pFilas, 0)
{
}

  

Can you tell me if it's okay?

Since you mention that it gives you problems, the answer is obvious, no, it's not right.

  

Do you know where the problem is or am I doing everything wrong?

If you want the board to have a dynamic size (that is, you can change from one execution to another), you need to use dynamic memory ... and you are using an array of fixed size. The problem is not that the array is of fixed size, but also has a 1x1 dimension. That is, any board defined by the user will have a larger size and that causes problems.

I explain. In C ++ there are no checks to verify if you try to access an item that does not belong to your memory. To do those checks, in some cases, the Operating System is in charge and you would not like it to come into action because what you usually do is kill your application so that it does not corrupt the memory.

So what you have to do is use dynamic memory and at this point you have to make a decision about the default constructor:

• You eliminate it, since your thing is to know what size the board is going to have. This option is the simplest
• You prepare the whole class to detect that the board is not initialized.

Imagine that we chose the first option, the code could look like this:

class Tablero
{
private: 
  int c;
  int f;
  int* mat;

public:
  Tablero (int pC, int pF);
  ~Tablero ();

  void mostrarT() const;
  int Get(int pC, int pF) const;
};

Tablero::Tablero(int pC, int pF)
  : c(pC),
    f(pF),
    mat(new int[Pc*Pf](0))
{
  std::fill_n(mat,c*f,0); 
}

Tablero::~Tablero()
{
  delete mat;
}

int Get(int pC, int pF) const
{
  return mat[pF*c+pC];
}

void Tablero::mostrarT() const
{
  cout << "---------------------------" << endl;

  for (int i = 0; i < f; i++)
  {
    for (int j = 0; j < c; j++)
      cout << Get(i,j) << "  ";
    cout << '\n';
  }
}