Array without parameters in c++

C-style array dimensions must be known at compile-time in C++. So there is no variant of Casilla casilla[filas][columnas]; that will work.

Instead you should use a container which can hold the data you want to put in it. Use of C-style arrays in C++ is discouraged because they have some strange behaviour and rules, they are mainly there for backwards compatibility.

The simplest option is a 1-dimensional array with runtime size, that is called vector:

class tablero{

    int filas;
    int columnas;
    std::vector<Casilla> casilla;

public:
    tablero (int filas, int columnas)
        : filas(filas), columnas(columnas), casilla(filas * columnas)
    { }

    Casilla getCasilla(int f, int c) const
    {
        return casilla[f * columnas + c]; 
    }
};

Note the use of the constructor initializer list. You should provide initial values for class members this way, instead of using assignment statements inside the constructor.

In your first example, in your constructor, the line

Casilla casilla[filas][columnas];

declares casilla an array of arrays of Casilla objects local to your constructor. Once your constructor returns, casilla goes out of scope. There is no casilla member variable or local variable in your getCasilla function, so of course it cannot be resolved.

In your second example, your class has a public member casilla declared as 0 by 0 array of Casilla objects. Your getCasilla function would return the item in the nth row and mth column of the 0 by 0 array. In C++, there is no bound checking on array dereferences, so this is returning some out of bounds memory location and is very bad.

You can create dynamic C arrays yourself by using malloc and free, but since you are using C++ it will be easier to just use std::vector.

For example, you could use:

#include <iostream>
#include <vector>

class Casilla
{};

class tablero
{
  int filas_;
  int columnas_;
  std::vector<std::vector<Casilla> > casilla_; // a vector of vectors of Casillas
public:
  tablero(int filas, int columnas) : filas_(filas), columnas_(columnas), 
                                     casilla_(filas, std::vector<Casilla>(columnas))
  // The above is an initialization list
  // We initialize casilla_ as a vector of filas vectors of columnas Casillas
  {}

  std::vector<std::vector<Casilla> > getCasilla() const
  {
    return casilla_;
  }
};


int main(int argc, const char* argv[])
{
  tablero t(3, 3);

  std::cout << "casilla rows: " << t.getCasilla().size() << std::endl;
  std::cout << "casilla cols: " << t.getCasilla()[0].size() << std::endl;

  return 0;
}

First Casilla casilla[filas][columnas]; needs to be a class variable so it's accessible to all methods.
Second the sizes of rows and columns must be a fixed number e.g Casilla casilla[9][9];
If it need to be dynamically allocated you could you Vectors or Vectors of Vectors.
If it's 2d array, you can still create it as 1d array, but depends which is best for your purposes.