Mensajes

Nota inicial: Por favor, el código ponlo con las etiquetas GeSHi, quedará más claro y legible. Gracias.

"ordenar" strings puede ser una tarea todo lo sencilla o complicada que quieras:

* ¿Quieres que la ordenación sea sensible al uso de mayúsculas?
* ¿Te resulta indiferente que las palabras con letras acentuadas las ponga en posiciones "extrañas"?

Si has respondido "SI" a ambas preguntas, puedes hacer uso de la ordenación básica que viene por defecto en std::string. Es decir, puedes usar los operadores de comparación:

Código (cpp) [Seleccionar] Expandir


std::string cad1 = "bcd";
std::string cad2 = "abc";

if ( cad1 > cad2 )
{
  std::string temp = cad1;
  cad1 = cad2;
  cad2 = temp;
}

std::cout << cad1 << " " << cad2 << std::endl;


Salida:

Código [Seleccionar] Expandir

abc bcd

El mecanismo de ordenación de los operadores de comparación ( '>', '<', '==', '!=', '>=', '<=' ) vendría a ser algo tal que:

Código (cpp) [Seleccionar] Expandir


bool operator<( const std::string& cad1, const std::string& cad2 )
{
  bool to_return = true;

  for ( unsigned int i = 0; i < cad1.size( ); ++i )
  {
    if ( cad1[ i ] > cad2[ i ] )
    {
      to_return = false;
      break;
    }
    else if ( cad1[ i ] < cad2[ i ] )
      break;
  }

  return to_return;
}

Nota que para simplificar estoy asumiendo que ambos strings tienen la misma longitud.

solo linkear las librerias de mysql pero no me funciono.

Y no te funcionó porque...

tambien creado la libreria libmysql.dll  a libmysql.a compila bien todo ...

Es decir, no has podido crear la librería pero sin embargo si has podido crear la DLL???

pero al ejecutar se deiene el programa y analizando con el gdb dice lo siguiente:
->->value-history-value
{<text variable, no debug info>} 0x401690 <mysql_init

Eso te está diciendo que esa parte del código no está compilada en modo debug y, en consecuencia, el gdb no sabe "explorar" su contenido así por las buenas.

Tambien intente otro metodo el cual tambien tengo que convertir libmysq.lib a libmysql.a con reimp pero hacer.
>reimp libmysql.lib
reimp: libmysql.lib: invalid or corrupt import library

Si no te funcionó el primer paso dudo mucho que este te vaya a dar mejores resultados. Si no eres capaz de compilar la librería no hay mucho que puedas hacer.

Instrucciones para distribuir aplicaciones de Qt

Está en inglés, como la inmensa mayoría de la documentación en este mundo, si no sabes inglés te vas a tener que ir acostumbrando.

El codigo_datos no siempre va a ser de tamaño 33, sino que su máximo tamaño es 33(o 16 bytes). Y si por ejemplo declaro char cadena_datos[33], para asignarle una cadena como "2300", le pongo cadena_datos = "2300"????

Código (c) [Seleccionar] Expandir

strcpy( cadena_datos, "2300" );

... y cuando tenga que inicializar el arreglo a 0(o sea que no contenga nada dentro) como le hago si quiero pasar el codigo_datos a la función inicializarVariables??

El ejemplo que has puesto es perfectamente válido.

y con un arreglo cadena_datos[33] también puedo usar el strcat??? para ir concatenando los códigos máquina que se me generen.

No vas a notar diferencias entre crear el buffer en el stack (como te propongo) o en el heap (con malloc). En ambos casos cadena_datos va a ser un puntero. Para el uso que le vas a dar, la única diferencia palpable es que no vas a tener que usar malloc y free.

Código (c) [Seleccionar] Expandir


char* TIPO // ...
char* tipo = "S1";

Realmente es necesario? También puedes aprovechar, ya puestos y hacer combinaciones con números:

Código (c) [Seleccionar] Expandir

char *TIPO, *T1po, *T1p0, *tIpO, *t1po //...

En serio, evita este tipo de prácticas. Además, si tipo (que no TIPO) es constante casi es mejor que lo declares con un define:

Código (c) [Seleccionar] Expandir


#define ETIQUETA_S1 "S1"

// ...

crearRegistroS1( ETIQUETA_S1, Longitud, direccion, codigo_datos, checksum );

También estaría bien que homogeneizases el código... parece que la función ha sido escrita por 20 personas diferentes:

* hay variables en minúsculas, en mayúsculas y mezcladas, con guión bajo y sin el, ... con las funciones pasa lo mismo
* declaras una variable para S1 pero luego en otros sitios utilizas valores puestos a pelo

Es mucho mejor que te propongas un formato para el código y que lo sigas con todas las consecuencias. Un pequeño ejemplo:

* las variables se nombran siempre en minúsculas y usando guiones bajos para separar las palabras: una_variable
* las funciones se nombran con nomenclatura lower Camel Case: funcionCalcularS1
* el tabulado del código será con espacios, no tabuladores, y cada tabulación constará de 3 espacios.
* las llaves de bucles, condicionales y funciones se ponen en una nueva línea.
* Después de una coma que separa argumentos se deja siempre un espacio.
...

Así todo el código presentará una estructura uniforme y será mucho más fácil de leer y de entender. Puedes encontrar diferentes guías ya hechas buscando en google.

También, por otro lado, deberías plantearte el agrupar las variables que están relacionadas entre ellas en estructuras. Es lo que te dije en el primer mensaje, usas 26 variables en esa función... seguro que algunas variables se pueden agrupar. Quedará claro que esas variables están relacionadas de alguna forma y eso mejorará la legibilidad... e incluso puede que consigas reducir el número de argumentos en alguna función.

No hay que tener miedo a declarar estructuras, bien usadas son muy buenos aliados.

Por otro lado, deberías plantearte la posibilidad de sacar cada posibilidad de "esDirectiva" a una función nueva. Lo suyo es intentar programar bajo la premisa: 1 función = 1 responsabilidad. En tu caso, la función leerTemporal se encarga de:

* leer un fichero
* interpretar sus funciones
* en función del tipo de instrucción realizar acciones personalizadas

eso son, al menos, 3 responsabilidades diferentes. Esto te lleva a tener un código monolítico que dificulta su mantenimiento, su expansión y su legibilidad (si, insisto mucho en la legibilidad... tengo mis motivos. Un código que no es legible es costoso de mantener y de interpretar. La legibilidad puede ser un bonus positivo o negativo en tu código y tú eres el que elige)

PD.: codigo_datos crea lagunas de memoria... no se hace el free correspondiente. Además, si siempre va a ser de 33 caracteres yo me plantearía usar memoria estática... C no está pensado para hacer reservas de memoria pequeñas... es muy ineficiente en este aspecto. Además, la memoria dinámica hay que usarla con cabeza y sólo cuando sea necesario, ya que complica la elaboración del código y facilita la aparición de lagunas de memoria.

Si quieres que se ejecute primero B sin importar su posición tienes que implementar algún sistema de cola con prioridades:

Código (c) [Seleccionar] Expandir


// Funciones.
// Podrian usar argumentos sin problemas haciendo un par de cambios
void funcionA( )
{
 // ...
}

void funcionB( )
{
 // ...
}

// Definicion de la estructura
typedef struct
{
 int prioridad;
 void (*funcion)(void);
} tarea;

// Declaracion y llenado de la cola (tambien se puede hacer dinamicamente )
tarea tareas[2];
tareas[0].prioridad = 1;
tareas[0].funcion = &funcionA;
tareas[1].prioridad = 2;
tareas[2].funcion = &funcionB;

// Ordenar las tareas
// Los bucles en este caso concreto son ridiculos, estan puestos para generalizar
for ( i = 0; i < 1; i++ )
{
 for ( j = 1; j < 2; j++ )
 {
   if ( tareas[ i ].prioridad < tareas[ j ].prioridad )
   {
     tarea temp = tareas[ i ];
     tareas[ i ] = tareas[ j ];
     tareas[ j ] = tareas[ i ];
   }
}

// Ejecucion por orden
Boton
{
 for ( i = 0; i < 2; i++ )
   tareas[ i ].funcion( );
}

Con lo vago de tu código es complicado hacer una aproximación mayor.

Un saludo.

Ese código tienes que dividirlo para hacerlo más manejable.

176 líneas y 26 variables suponen bastante densidad para una sola función.

Dicho con código:

Código (c) [Seleccionar] Expandir


Boton
{
   tipo arreglo1 [] = {A1, A2, A3}
   tipo arreglo2 [] = {B1, B2, B3}

    if(DatoObtenido2 == arreglo2)
    {
       //Haga las siquientes instrucciones
       return; //Salir del metodo
    }
    else if(Dato obtinedo1 == arreglo1)  //Es decir si el dato obtenido es igual al del arreglo
    {
       //Haga las siquientes instrucciones
       return; //salir del metodo
    }
}

Si tu idea es ejecutar una serie de tareas aleatorias según un orden de importancia aleatorio, puedes optar por poner cada tarea en una función o clase (según estés en C o C++). Entonces cargas las tareas a ejecutar en un vector en el que se indique también la prioridad de cada tarea.

Al ejecutar el método que controla la pulsación del botón ordenas las tareas por prioridad y las vas ejecutando una a una.

Si haces:

Código (c) [Seleccionar] Expandir


codigo_datos = (char*)malloc(33*sizeof(char));
codigo_datos = 0;

Estás haciendo que el puntero apunte a otra dirección de memoria, por lo que pierdes la dirección de la memoria reservada y eso resulta en una laguna de memoria.

En cambio, si haces:

Código (c) [Seleccionar] Expandir


codigo_datos = (char*)malloc(33*sizeof(char));
*codigo_datos = 0;

Entonces haces que la primera posición de la memoria reservada valga 0, es decir, contiene una cadena de longitud 0.

Aún así, si lo que quieres es que tener la memoria inicializada al reservarla, puedes usar calloc en vez de malloc. calloc inicializa la memoria, poniendo todos los bytes a 0:

Código (c) [Seleccionar] Expandir

codigo_datos = (char*)calloc(33, sizeof(char));