Mensajes

[¡¡¡¡ Saluditos! ..... !!!!]

Aunque aparentemente sea saí, por lo que tengo entendido el compilador se encargará de eso de  forma automática

Ya he comprobado que en otras ocasiones el definir una función como inline noproduce las mejoras que se esperan de ello ya que al parecer, aunque no la declares como inline, en ocasiones el compilador hace la misma tarea que al declararla inline.

¡¡¡¡ Saluditos! ..... !!!!

Efectivamente, los compiladores de hoy en día hacen maravillas en cuanto a optimizaciones. De hecho muchos compiladores ignoran el uso de inline y lo aplican a discreción según el código que se encuentren (aunque éste esté en el cpp).

En cualquier caso, si un mismo resultado se va a utilizar varias veces en una misma función siempre queda mejor almacenarlo en una variable que volver a insertar la llamada a la función. De esa forma te aseguras que el código sea más óptimo independientemente de que el compilador optimice de una forma o de otra.

En un buscaminas, si abres una mina el programa sabe que ahí hay mina y termina el juego... no te sale un número.

La versión que propones incapacita al juego para detectar las minas y las sustituye por números.

No digo que esté mal... es otro enfoque... pero yo diría que lo suyo es que el programa conociese en todo momento la ubicación de las minas.

O eso o me estoy perdiendo algo.

Se ve que en ciertas casillas salen números, las minas totales de él y los que le rodean, ...

Dudo mucho que en el buscaminas puedas encontrar una casilla con el número 9 ( 8 que le rodean más la mina de la propia casilla )

[¡¡¡¡ Saluditos! ..... !!!!]

Se te fue un gazapo en el código:

Código (cpp) [Seleccionar] Expandir


do{
      cout << "Introduzca columna: ";
      cin >> col;
    }while(col<1 || col>dim);
    col=col-1;
    Matriz[fil][col]='*'; /* <==AQUI */ /*ES ==>  */Matriz[fil][col]='1';

    cout<<Matriz[fil][col]<< "\n\n";


¡¡¡¡ Saluditos! ..... !!!!

Pero ese cambio tiene un problema... que luego cuando vaya a contar... cómo identifica la posición original de la mina??

Pongamos el caso:

Código [Seleccionar] Expandir


1 1 0
0 0 0
0 0 0
0 0 0

Después de calcular las minas se tiene

Código [Seleccionar] Expandir


1 1 1
1 1 1
0 0 0

Eso es incorrecto porque lo lógico es que la salida fuese

Código [Seleccionar] Expandir


1 * 1
1 1 1
0 0 0

Si no marcas dónde están las minas mal vamos.

Código (cpp) [Seleccionar] Expandir


  Matriz[fil][col]='*';

  // ...

  for ( fil = 0 ;fil < dim; fil++)
    for ( col = 0; col < dim; col++)
      Matriz[fil][col]=cont[fil][col]+48;


Ese bucle borra, literalmente, la posición de las minas. Deberías comprobar, antes de machacar el valor de Matriz, que la posición no contiene una mina.

Código (cpp) [Seleccionar] Expandir

cout << "\n\n";

Hay una constante definida en el espacio de nombres std que es endl. Tiene la ventaja de que es portable, ya que la STL en linux implementa su versión de endl y Windows hace lo propio.

Es más portable usar lo siguiente:

Código (cpp) [Seleccionar] Expandir

cout << endl << endl;

Más cosas...

Código (cpp) [Seleccionar] Expandir


for ( fil = 0 ;fil < dim; fil++) {
    for ( col = 0; col < dim; col++){
    contador=0;
      for ( k = -1; k < 2; k++) {
        for ( l = -1; l < 2; l++){
          if (fil+k < 0 || col+l < 0 || fil+k > dim-1 || col+l > dim-1)
            continue;
          else{
            contador+=(Matriz[fil+k][col+l]-'0');
          }
        }
      }
      cont[fil][col]=contador;
    }
  }

contador += ¿¿que??
A ver, si en Matriz las minas se representan con asteriscos... por qué no buscas asteriscos para contarlos?? la transformación que estás haciendo ahí no tiene ningún sentido. Dicho de otra forma:

Código [Seleccionar] Expandir

'*'-'0' == '#'

¿Te suena el caracter '#' si solo pones una mina? Ya sabes de dónde sale.

En C++ las clases mantienen su espacio privado de nombres de métodos, por lo que debemos usar el operador :: para acceder a ellos.

En C++ sólo es necesario ( como norma general ) usar el operador '::' en los siguientes casos:

* Implementar los métodos de una clase. Esto es así porque la implementación puede estar en cualquier parte del código ( no necesariamente en circle.cpp ) y claro, puede existir otra función setX de, perteneciente, por ejemplo, a la clase Rectangle.

Código (cpp) [Seleccionar] Expandir


void Circle::setX( double x )
{
  ...
}

* Llamar a un método del padre que ha sido sobreescrito: Cuando sobreescribes un método virtual, el método del padre deja de estar disponible salvo que el nuevo método así lo requiera. Por tanto, si se requiere ejecutar dicho código hay que llamar a la función indicándole que el ámbito es el del padre.

Código (cpp) [Seleccionar] Expandir


class GeometricObj
{
  public:
    virtual void setX( double x );
};

class Circle : public GeometricObj
{
  public:
    virtual void setX( double x ) override;
};

void  Circle::setX( double x )
{
  GeometricObj::setX( double x );
}

* Para acceder a miembros estáticos. Como en C++ el  mismo nombre puede ser utilizado en diferentes clases, para poder acceder a un miembro estático es necesario indicar el ámbito en el que "existe" dicha función.

Código (cpp) [Seleccionar] Expandir


class POO
{
  public:
    static int Func( );
}

int value = POO::Func( );

* Acceder a enumerados definidos dentro de una clase. Los enumerados se tratan en este caso igual que los miembros estáticos. Están definidos dentro de una clase y no es posible acceder a ellos a través de una instancia de la clase, luego la forma de recuperar esos valores es usando el operador de ámbito:

Código (cpp) [Seleccionar] Expandir



class Animal
{
  public:
    enum Type
    {
      Carnivorous,
      Herbivorous
    };
};

int value = Animal::Carnivorous;

Yo creo que estas son los motivos más comunes en los que es necesario utilizar el operador de ámbito y son casos que están totalmente justificados.

aunque aún es un poco burdo. No se si es lo mejor que se puede hacer a costa de mantenerse puro dentro de C, o se puede mejorar un poquito.

Realmente, si estás programando en C++ no tienes que ser purista C... para eso programas en C directamente... es como intentar ser un purista del latín mientras hablas español... Tendría más sentido intentar ser purista C++ mientras programas C++.

¿Acaso podemos ser creativos e inventar algo con #define para volverlo más amigable?

¿Más amigable?

A mi la forma normal de usar un objeto me parece de lo más amigable:

Código (cpp) [Seleccionar] Expandir


class Circle
{
  public:
    Circle( );

    void SetX( double x );
    void SetY ( double y );
    void SetRadius( double radius );
    void Paint( );

  private:
    double _x;
    double _y;
    double _radius;
    InternalPtr* _ptr; // Para representar una reserva de memoria dinamica
};

Circle circle;
circle.SetX( 12.5 );
circle.SetY( 10.4 );
circle.SetRadius( 200.25 );
circle.Paint( );
;

De hecho, me resulta más amigable que el "equivalente en C":

Código (c) [Seleccionar] Expandir


struct circle_t
{
  double x;
  double y;
  double radius;
  InternalPtr* ptr;
};

typedef circle_t Circle;

Circle circle;
Circle_CreateStruct( &circle ); // inicializacion de la estructura
circle.x = 12.5;
circle.y = 10.4;
circle.radius = 200.25;
Circle_Paint( &circle );
Circle_DeleteStruct( &circle ); // Liberar la memoria reservada previamente.

A ver, ¿cómo hacían los programadores antiguos, cuando no había aparecido C++?

¿Y cómo lo hacían cuando no existía C? Pues tenían que apañarse con ensamblador o, más divertido aún, con tarjetas perforadas... C++ es un lenguaje más moderno y, controlándolo un poco, se puede hacer un trabajo más rápido que con C. Se sacrifica algo de rendimiento pero se gana algo de usabilidad y mantenimiento. Si optas por dar otro paso y usar C#... sacrificas bastante más rendimiento pero el mantenimiento es mucho más sencillo y la programación es muchísimo más rápida.

Obviamente si una herramienta no está disponible no puedes usarla... incluso si no sabes que existe ni te planteas ese supuesto.

Sin embargo si vas a usar un lenguaje que te aporta algo diferente respecto a su antecesor ( caso de C++ y C )... quizás deberías plantearte su uso para poder sacarle más partido al lenguaje. Desde mi punto de vista programar en C++ como si fuese C es una pérdida de tiempo. Puede haber partes del código que en un momento dado haya que programarlas usando la sintaxis de C... pero ya te digo yo que esos casos se pueden contar con los dedos de una mano de los simpsons ( que tienen menos dedos que nosotros ).

Excluyo de este comentario todo código que se realice con objeto de aprender, entender y/o dominar determinadas técnicas... Esos son pasos necesarios para entender el por qué de las cosas y para ello hay que mancharse las manos

Deberías comprarte un manual de C++... si ya lo tienes, deberías leerlo.

Código (cpp) [Seleccionar] Expandir

block_t bit_set::get_block_t( ) const {

y lo mismo en la declaración.

Apuesto a que tu código es más rápido, dado que al no usar clases se optimiza algo mejor... pero tiene la contrapartida de que es bastante más complicado de modificar. Un fallo tonto puede conllevar lagunas de memoria, accesos a memoria no reservada o desbordamientos de buffer.

Además, si estás programando en C++ lo lógico es que uses, al menos, la clase string, ya que la propia STL te lo pide a gritos.

En programación, al menos la parte que afecta a empresas, salvo en casos muy concretos, no se pide ni reinventar la rueda ni recurrir a códigos complicados de mantener... más bien se buscan códigos sencillos y fáciles de mantener (buscando que con ello no se penalice en exceso el rendimiento ). Y teniendo en cuenta que el 99% de los procesos no son críticos en el tiempo... pues como que ganar un poco de velocidad no compensa.

Mi propuesta se basa en aprovechar precisamente esas bazas. Tu propuesta queda genial si la orientas al lenguaje C ( claro que tendrías que sustituir la clase por funciones sueltas )... en C++ sería mucho más recomendable optar por mi opción.

Pero al final es lo que tú has dicho. Son dos puntos de vista diferentes

Código (c) [Seleccionar] Expandir


block_t bit_set::get_block_t() {
return block_;

}

void bit_set::set_union(const bit_set& bs){
   block_ = block_ | bs.get_block_t();
}

Si get_block_t no es const no puede ser llamada desde una instancia declarada como const.

En set_union se está haciendo bs.get_block_t y bs está definida como const.

o le añades const a get_block_t o le quitas el const al parámetro bs.

pero ahora tengo que hacer otro direccionamiento:

3,+SP-> imprime es de PreIncremento
3,SP+-> imprime es de PostIncremento
3,-SP-> imprime es de PreDecremento
3,SP-  -> imprime es de PostDecremento

pero no se bien como hacerle, primero veo que tenga un signo al principio, y despues como le hago para que verifique los que tienen el signo al final?? alguna idea??

Si miras el código que te puesto verás que ya hace eso. Lo único que no discrimina entre incremento y decremento... pero es un cambio que lleva 2 minutos contados