Mensajes

Sí, pero los defvar pueden cambiar de valory tendría que ir a cada uno y poner el valor actual que correspando (raro caso pero posible), inclusive aunque no cambiaran los valores, tendría que hacer 300 líneas de éso :|

si defvar1 está declarado como

Código (c) [Seleccionar] Expandir

#define defvar1 1

Ya te digo yo que defvar1 no va a cambiar su valor, al menos, hasta que no recompiles la aplicación.

Y tu eliges si crear un vector de 300 líneas... o un switch de 300 líneas. Si tienes 300 casos o buscas formas de optimizar ( por ejemplo agrupando por rangos de valores ) o tienes que poner todos los casos de forma explícita.

Si no es más que hacer una conversión puedes meter todos los valores en un vector y que el índice sean los valores del "define"

Código (c) [Seleccionar] Expandir


int conversor[MAX_DEFVAR];
conversor[defvar1] = -32;
conversor[defvar2] = -32;
// ...

int indice = defvar2;
int valor = conversor[indice];

Si el vector lo dejas estático solo tienes que construirlo una vez.

El problema está en que muchas veces lo único que se busca es eso. Yo estoy estudiando ingeniería informática y una compañera que ha venido de telecomunicaciones me comentó que allí cuando programaban lo único que les pedían era que el programa funcionase, y que la organización y eficiencia del código eran completamente secundarias. Supongo que también dependerá del lugar en el que estudies y de lo que estudies, pero a mi me crujen si les entrego un código con nombres de variables como las de este señor.

En mi universidad pasaba igual... te daban un guión y el resto era cosa tuya... ellos al final solo querían ver que funcionaba y que no había lagunas de memoria... así pasa que luego te encuentras proyectos reales que te dan ganas de arrancarte los ojos.

Sin saber qué uso va a tener ese valor es complicado darte una respuesta.

No dije que se guardase. Lo pondré de otra forma:

Código (cpp) [Seleccionar] Expandir

/* ... */var << 1 == 0b100;

ok. Solo lo puse por si acaso

Yo aportaría algunos comentarios:

* En el destructor no tiene sentido que pongas NRows y NCols a -1... al salir del destructor esas variables pierden todo su sentido.

* Si estás haciendo clases, es decir, C++, por qué no usar al menos la clase string??

* Lo mismo sería aplicable para el tipo booleano. Es más natural usar bool que int.

* Si usas clases de C++ el código queda más limpio y corto:

Código (cpp) [Seleccionar] Expandir


#ifndef STRINGMATRIX_H
#define STRINGMATRIX_H

#include <string>
#include <map>

class StringMatrix
{
  public:
    StringMatrix( ); /* constructor por defecto */
    StringMatrix( const StringMatrix& ); /* constructor de copia */
    ~StringMatrix( ); /* destructor */

    void ReInitialize( );
    std::string getElement( unsigned int row, unsigned int col) const;
    void putElement( unsigned int row, unsigned int col, const std::string& string );
    unsigned int NRows( ) const;
    unsigned int NCols( ) const;
    void addRow( ); /* añadir una fila */
    void addColumn( ); /* añadir una columna */

    StringMatrix& operator=( const StringMatrix& );

  private:

    std::map< std::pair< unsigned int, unsigned int >, std::string > _matrix;
    unsigned int _NRows; /* cantidad de filas */
    unsigned int _NCols; /* cantidad de columnas */
};

#endif // STRINGMATRIX_H

Código (cpp) [Seleccionar] Expandir


#include "StringMatrix.h"

/* Default constructor.
* Constructor por defecto. */
StringMatrix::StringMatrix( )
  : _NRows( 0 ),
    _NCols( 0 )
{
}

/* Copy constructor. Creates a new object as a copy of other object.
* Constructor de copia. Crea un nuevo objeto como una copia de otro objeto. */
StringMatrix::StringMatrix( const StringMatrix &S )
  : _matrix( S._matrix ),
    _NRows( S._NRows ),
    _NCols( S._NCols )
{
}

/* Assignment operator, from other StringMatrix object.
* Operador de asignacióm, a partir de otro objeto StringMatrix. */
StringMatrix& StringMatrix::operator=( const StringMatrix &S )
{
  _matrix = S._matrix;
  _NRows = S._NRows;
  _NCols = S._NCols;

  return *this;
}

/* "Re-initializes" the object. Frees the dinamic allocated memory, and
* it puts the dimensions to zero. This is, returns he object to the original
* state like it was created.
*
* "Re-inicializa" el objeto. Libera la memoria dinámicamente asignada,
* y pone las dimensiones a cero. Es decir, devuelve el objeto al estado
* original como fue creado */
void StringMatrix::ReInitialize( )
{
  _matrix.clear( );
  _NRows = 0;
  _NCols = 0;
}

/* Class destructor /
* Destructor de la clase */
StringMatrix::~StringMatrix( )
{
}

/* Get the number of rows of the matriz /
* Obtener el numero de filas de la matriz */
unsigned int StringMatrix::NRows( ) const
{
  return _NRows;
}

/* Get the number of columns of the matriz /
* Obtener el numero de columnas de la matriz */
unsigned int StringMatrix::NCols( ) const
{
  return _NCols;
}

/* Get an specific element in the matrix. Warning: the indexes start in zero.
* On success is returned a copy of the string stored in such element of
* the matrix. On error, returns NULL.

* Obtener un elemento especifico de la matriz. Cuidado: los índices empiezan
* en cero. En caso exitoso devuelve una copia de la cadena almacenada en
* dicho elemento de la matriz. En caso de error, devuelve NULL. */
std::string StringMatrix::getElement(
          unsigned int row,
          unsigned int col ) const
{
  std::string to_return;

  if ( row < _NRows && col < _NCols )
    to_return = _matrix.at( std::make_pair( row, col ) );

  return to_return;
}

/* Puts an element in a specified position of the matrix. If the position
* exceed the size of matrix, the same is automatically resized.
* On success returns 0, and -1 otherwise.
*
* Pone un elemento en una posicion especificada de la matriz. Si la posicion
* excede el tamano de la matriz, la misma es redimensionada automaticamente.
* Devuelve 0 si tuvo exito, -1 si no tuvo. */
void StringMatrix::putElement(
          unsigned int row,
          unsigned int col,
          const std::string& string )
{
  if ( _NRows <= row )
    _NRows = row + 1;

  if ( _NCols <= col )
    _NCols = col + 1;

  _matrix[ std::make_pair( row, col ) ] = string;
}

/* Add a row to the matrix. On success returs 0, and -1 otherwise.
*
* Anade una fila a la matriz. Devuelve 0 si tuvo éxito, -1 si no tuvo. */
void StringMatrix::addRow( )
{
  _NRows++;
}

/* Add a column to the matrix. On success returs 0, and -1 otherwise.
*
* Anade una columna a la matriz. Devuelve 0 si tuvo éxito, -1 si no tuvo. */
void StringMatrix::addColumn( )
{
  _NCols++;
}

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include "StringMatrix.h"

int main()
{
  StringMatrix S;
  S.putElement(0, 0, "hugo");
  S.putElement(0, 1, "paco");
  S.putElement(1, 0, "maria");
  S.putElement(1, 1, "luisa");

  /* copia contenido de S en M */
  StringMatrix M = S;
 
  /* y lo imprime en pantalla */
  for (unsigned int i = 0; i < M.NRows( ); i++)
  {
    for (unsigned int j = 0; j < M.NCols( ); j++)
      std::cout << M.getElement(i, j) << "\t";
    std::cout << std::endl;
  }

  return EXIT_SUCCESS;
}

haces un delete q... pero qué pasa con el padre que tenía q???

Ese nodo sigue apuntando a una posición de memoria que ahora ya no es válida.

Dicho con otras palabras. Te falta una instrucción tal que

Código (c) [Seleccionar] Expandir

q->Padre->izquierdo = NULL;

obviamente no es algo tan directo porque desde un nodo no tienes acceso al padre...

Venga va, yo también aporto un código con recursividad.

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

void paso( int max_filas, int fila, int col );

int main()
{
 paso( 11, 0, 0 );
 return EXIT_SUCCESS;
}

void paso( int max_filas, int fila, int col )
{
 const char* chars = " *";
 if( fila < max_filas )
 {
   int num_sp = abs( max_filas/2 - fila);
   int end = max_filas - num_sp;
   if ( col == end )
   {
     printf( "\n" );
     col = -1;
     fila++;
   }
   else
     printf( "%c", chars[ col >= num_sp ] );

   paso( max_filas, fila, ++col );
 }
}

En verdad no se muy bien qué tienes que hacer. Pero si te ayuda, te dejo algo:

Código (cpp) [Seleccionar] Expandir

/** 0b significa valor en binario **/
int var = 2; //0b10
var << 1; //0b100   Se ha desplazado 1 posición (izquierda)
var << 3; //0b100000   Se ha desplazado 3 posiciones (izquierda)
var >> 5; //0b1   Se ha desplazado 5 posiciones (derecha)

Esos son los desplazamientos.

Como dije, ni idea de lo que estáis dando, ¿en clase?

Suerte.

Más bien sería...

Código (cpp) [Seleccionar] Expandir

/** 0b significa valor en binario **/
int var = 2; //0b10
int var2 = var << 1; //0b100 Se ha desplazado 1 posición (izquierda)
var2 = var << 3; //0b100000 Se ha desplazado 3 posiciones (izquierda)
var2 = var >> 5; //0b1 Se ha desplazado 5 posiciones (derecha)

Al hacer un desplazamiento el valor no se guarda por defecto en la variable desplazada.

No quiero ni pensar que habrías escrito si hubieras entrado en detalle 

Jajajajaja.

Bueno, lo cierto es que cuando ya has puesto una docena de comentarios con cosas a corregir sobre un programa tan corto no tiene sentido seguir poniendo cosas porque entonces los comentarios se empiezan a solapar. Tampoco es cuestión de echar para atrás a nadie.

desde luego ya te digo yo que si fuese profesor, visto lo visto, me centraría bastante en conseguir que la gente aprendiese a estructurar un programa... me da la sensación que la inmensa mayoría únicamente buscan que el programa funcione y eso me parece un error.