Necesito orientacion con el siguiente codigo

[eferion]

Iniciado por acknowledge

yo lo que proponia es hacer un camino totalmente aleatorio y si el camino se cruza empezar de nuevo asì se escribe menos codigo (y es super ineficiente), si llega al final de casualidad calcular el valor.

Hombre, calculando ruta al azar podrías ahorrarte en mi programa digamos... unas 17 líneas (contando comentarios, líneas en blanco y llaves, que las suelo poner en línea independiente)... porque claro tienes que añadir la lógica para generar los aleatorios (20 líneas de código a eliminar - 1 para inicializar random - 1 para generar desplazamiento X - 1 para generar desplazamiento Y).

Creo que el ahorro en líneas tampoco es excesivo aunque en términos estrictos debo darte la razón en todo:

SI son menos líneas
SI es muuuucho más ineficiente jejeje

Iniciado por aguml

Cuando digo que parece usarlo como función me refiero a esto que haces:
variable1(a)
En tu caso variable1 es un int pero esa línea yo la interpreto como:
int variable1 (int a)
A eso me refiero y no lo entiendo. Supongo que será algo que no he dado aun y que tendrá que ver con herencias o cosas de esas pero para mi un nombre con un paréntesis tal y como aparece, hasta donde yo llego es una función.

Echa un vistazo al siguiente ejemplo:

La clase Variable saca por pantalla varios mensajes cuando se llama a sus diferentes funciones.

Después creamos dos clases Clase1 y Clase2. La primera inicializa su instancia de Variable con una asignación, mientras que Clase2 usa los inicializadores en el constructor.

Código C++:

struct Variable
{
   Variable(){ std::cout << "Variable::Variable()" << std::endl; }
 
   Variable(int valor)
   { std::cout << "Variable::Variable(int)" << std::endl; }
 
   void operator=(int valor)
   { std::cout << "Variable::operator=()" << std::endl; }
};
 
class Clase1
{
   Variable v;
  public:
    Clase1()
    {
      v = 5;
    }
};
 
class Clase2
{
   Variable v;
 
  public:
    Clase2()
      : v(5)
    {
    }
};
 
int main()
{
  std::cout << "Clase1 llama a dos funciones" << std::endl;
  Clase1 c1;
 
  std::cout << std::endl;
  std::cout << "Clase2 unicamente llama a una funcion" << std::endl;
  Clase2 c2;
  std::cout << std::endl;
}
 

El resultado es claro. Si se hacen asignaciones se acaban ejecutando dos funciones (constructor por defecto y operador de asignación), mientras que si usamos los inicializadores únicamente se hace una llamada al constructor que corresponda. Esta segunda opción suele ser más eficiente al usar clases ya que aparte de ahorrarnos la llamada a una función nos podemos ahorrar pasos innecesarios (como inicializar una variable a 0 en el constructor por defecto para un instante después asignarle un valor diferente con el operador de asignación).

Espero que te haya quedado este punto más claro con el ejemplo.

Un saludo.