Dar mas sencillez a este codigo

[aguml]

Hola amigos, he conseguido esta funcion la cual hace una especie de crc muy particular de un texto y quiero dejarlo lo mas simple posible sin tantos castings ya que otras similares lo he conseguido y se que esta se puede pero no lo consigo. Aqui la funcion:

Código C++:

AnsiString CalcularValorLIC(char *cadena,int sizebuffer)
{
    signed char caracter;
    unsigned long valor1, valor2, valor3, valor4;
    unsigned long contador;
    unsigned long sizefilelic;
    unsigned long retval = 0;
 
    if (cadena) {
        caracter = *cadena;
        sizefilelic = 0;
        if (caracter) {
            do {
                if (caracter == 0x1A)
                    break;
                caracter = *reinterpret_cast<signed char*>(sizefilelic + cadena + 1);
                ++sizefilelic;
            } while (caracter);
        }
        contador = 0;
        valor2 = 0;
        valor3 = sizefilelic;
        retval = valor3;
        if (valor3) {
            valor4 = valor3 + 1;
            do {
                valor1 = static_cast<unsigned long>(*reinterpret_cast<unsigned char*>(contador + reinterpret_cast<unsigned long>(cadena)));
                valor2 = valor2 ^ valor1 + contador;
                ++contador;
                valor3 = (*reinterpret_cast<unsigned char*>(valor2 % valor4 + reinterpret_cast<unsigned long>(cadena) + 1) + valor2 + (valor1 + valor2) * 2 + retval) * valor2;
                retval = valor3;
            } while (contador < sizefilelic);
        }
    }
 
    return AnsiString().sprintf("%09lu", retval);
}
 

Lo que hace es recorrer un buffer y con una serie de operaciones obtiene la posicion de un byte con el que realizar mas operaciones e ir sumando y creando el crc.
He intentado quitarle los castings pero no doy con el modo y creo que lo hago mal y por eso da valores diferentes, porque no respeto correctamente el tema de los parentesis o algo asi.
¿podrian ayudarme a dejarlo lo mas claro posible para alguien como yo que no entiendo mucho de castings y cosas asi?
Por ejemplo esa parte si que se:

Código C++:

do {
                if (caracter == 0x1A)
                    break;
                caracter = *reinterpret_cast<signed char*>(sizefilelic + cadena + 1);
                ++sizefilelic;
            } while (caracter);
 

La dejo asi:

Código C++:

do {
                if (caracter == 0x1A)
                    break;
                ++sizefilelic;
                caracter = cadena[sizefilelic];
            } while (caracter);
 

Eso quiero hacer con todo el codigo para que sea lo mas sencillo para yo entenderlo.
Lo que me falta por modificar creo que tiene que quedar algo tal que asi:

Código C++:

*********** do {
* * * * * * * * valor1 =cadena [contador];
* * * * * * * * valor2 = valor2 ^ valor1 + contador;
* * * * * * * * ++contador;
* * * * * * * * valor3 = (cadena [(valor2 % valor4) + 1] + valor2 + (valor1 + valor2) * 2 + retval) * valor2;
* * * * * * * * retval = valor3;
* * * * * * } while (contador < sizefilelic);
 

Pero creo que hago algo mal.

[eferion]

Cambios que yo haría:

1. Reducir el ámbito de todas las variables

Así pasa que valor1...valor4 únicamente se usan en la segunda parte del algoritmo, no tiene sentido que estén declaradas al inicio de la función. Al inicio de la función únicamente deberían estar declaradas 1 variables: retval

2. Simplicar el tipo de las variables

caracter no gana nada siendo signed char. Lo cambio a char. Con este cambio tonto consigo que esto:

se convierta en esto:

Código C++:

caracter = cadena[sizefilelic + 1];
 

Con esto queda más claro que el bucle:

Código C++:

if (caracter) {
  do {
    if (caracter == 0x1A)
      break;
    caracter = cadena[sizefilelic + 1];
    ++sizefilelic;
  } while (caracter);
}
 

3. Traducir el codigo a cristiano

Se puede simplificar bastante, ya que lo único que hace es contar caracteres hasta llegar al caracter 0x1A o al final del string. La versión simplificada podría quedar tal que:

Código C++:

char* ptr;
for( *ptr = cadena ; *ptr && *ptr != 0x1A; ++ptr);
unsigned long sizefilelic = ptr - cadena;
 

Y con C++11 y lambdas:

Código C++:

unsigned long sizefilelic = [cadena]()
{
  char* ptr;
  for( *ptr = cadena ; *ptr && *ptr != 0x1A; ++ptr);
  return ptr - cadena;
}();
 

La segunda parte del algoritmo únicamente se ejecutará si valor3 es distinto de 0... puesto que valor3 coge su valor de sizefilelic podemos hacer que esa parte se ejecute únicamente si el valor de esta última variable es distinto de 0... quedará un código un poco más legible:

Código C++:

if( sizefilelic )
{
  unsigned long contador = 0;
  unsigned long valor2 = 0;
  unsigned long valor3 = sizefilelic;
  retval = valor3;
 
  unsigned long valor4 = valor3 + 1;
  do {
    unsigned long valor1 = static_cast<unsigned long>(*reinterpret_cast<unsigned char*>(contador + reinterpret_cast<unsigned long>(cadena)));
    valor2 = valor2 ^ valor1 + contador;
    ++contador;
    valor3 = (*reinterpret_cast<unsigned char*>(valor2 % valor4 + reinterpret_cast<unsigned long>(cadena) + 1) + valor2 + (valor1 + valor2) * 2 + retval) * valor2;
    retval = valor3;
  } while (contador < sizefilelic);
}
 

Como el bucle do..while se va a ejecutar al menos una vez, la instrucción retval=valor3 se puede eliminar con todo el cariño del mundo.

Código C++:

valor1 = static_cast<unsigned long>(*reinterpret_cast<unsigned char*>(contador + reinterpret_cast<unsigned long>(cadena)));
 

Esta línea lo único que hace es desplazarse un offset dado por contador sobre el buffer cadena... lo único que almacena valor1 es el caracter existente en dicha posición convertido a unsigned long.

Un homólogo sencillo:

Código C++:

valor1 = static_cast<unsigned long>(cadena[contador]);
 

Esto:

Código C++:

*reinterpret_cast<unsigned char*>(valor2 % valor4 + reinterpret_cast<unsigned long>(cadena) + 1)
 

En cristiano significa esto:

Código C++:

cadena[(valor2%valor4) + 1];
 

Y para rematar la jugada, la variable contador la podemos meter en un for para sustituir el do-while, con lo que nos queda la segunda parte del algoritmo tal que:

Código C++:

if( sizefilelic )
{
  unsigned long valor2 = 0;
  unsigned long valor3 = sizefilelic;
 
  const unsigned long valor4 = valor3 + 1;
  for( unsigned long contador=0; contador<sizefilelic; ++contador)
  {
    unsigned long valor1 = static_cast<unsigned long>(cadena[contador]);
    valor2 = valor2 ^ valor1 + contador;
    valor3 = (cadena[(valor2%valor4) + 1] + valor2 + (valor1 + valor2) * 2 + retval) * valor2;
    retval = valor3;
  }
}
 

No puedo probar el algoritmo primero porque no tengo ansistring y segundo porque no tengo cadenas de prueba... pero a grandes rasgos el código debería ser el mismo.

PD.: espero que si empiezas a sacar dinero de todo esto te acuerdes de mí jejejeje

Un saludo.

[aguml]

Jajaja dinero nada. Estas cosas las hago porque me gusta trastear y me divierte además de mantener la mente fresca. No soy universitario ni nada, simplemente me gusta y me divierte y me parece algo apasionante aunque me sobrepasa pero bueno.
Con respecto al ámbito de las variables, ciertamente es que primero aprendí C jejeje.
Ayer en el móvil estuve trasteando y llegue a algo parecido aunque los bucles siguen siendo do while y tampoco lo he probado:

Código C++:

AnsiString CalcularValorLIC(char *cadena,int sizebuffer)
{
    unsigned long valor1, valor2 = 0, valor3;
    unsigned long contador = 0;
    unsigned long sizefilelic = 0;
    unsigned long retval = 0;
 
    do {
        if (cadena[sizefilelic] == 0x1A)
            break;
        ++sizefilelic;
    }while(cadena[sizefilelic]);
 
    valor3 = sizefilelic;
    do {
        valor1 = cadena [contador];
        valor2 = valor2 ^ valor1 + contador;
        retval = (cadena [(valor2 % (sizefilelic + 1)) + 1] + valor2 + (valor1 + valor2) * 2 + valor3) * valor2;
        ++contador;
    } while (contador < sizefilelic);
    return AnsiString().sprintf("%09lu", retval);
}
 

Yo directamente me cargue todos los castings ¿son realmente necesarios? El C++Builder no se queja nada.

[eferion]

Iniciado por aguml

Con respecto al ámbito de las variables, ciertamente es que primero aprendí C jejeje.

Que conste que lo siguiente compila en C perfectamente:

Código C:

for( int i=0; i<10; i++)
  printf("%d\n",i);
 

Iniciado por aguml

Yo directamente me cargue todos los castings ¿son realmente necesarios? El C++Builder no se queja nada.

Habría que mirar cada caso individual ya que depende de cómo se gestionen los datos los cast pueden ser importantes.

Un ejemplo:

Código C++:

float a = 5;
float b = 2;
float res = static_cast<float>(static_cast<int>(a)/static_cast<int>(b)) + 1.0;
 

¿Se pueden quitar los cast?

Pues depende... el cast a float se puede eliminar, ya que el compilador realizará el cast automáticamente al sumar un entero con un float... pero si eliminas alguno de los cast a int entonces la división retornará decimales y el resultado no será el mismo.

[aguml]

Bueno, tirando de tu codigo lo he dejado lo mas pequeño posible y haciendo pruebas da los mismos resultados que la original asi que asi la dejo:

Código C++:

AnsiString CalcularValorLIC(char *cadena,int sizebuffer)
{
    unsigned long resto = 0;
    unsigned long retval = 0;
 
    for(int contador = 0; contador < sizebuffer; ++contador)
    {
        resto = resto ^ cadena[contador] + contador;
        retval = (cadena[(resto % (sizebuffer + 1)) + 1] + resto + (cadena[contador] + resto) * 2 + retval) * resto;
    }
    return AnsiString().sprintf("%09lu", retval);
}
 

Los cast aquí no son necesarios ya que funciona perfecto sin ellos.
El bucle que obtiene el tamaño del buffer no era necesario ya que ya introduzco el tamaño como parametro y la comprobación de cada caracter con 0x1A tampoco la necesito en mi caso porque todos serán caracteres imprimibles.
He quitado variables que no son necesarias para nada.
Un detalle, lo que tu dices que en C compila perfectamente a mi no me compila. Que yo sepa eso esta prohibido en C, se puede declarar variables al principio del ambito del for pero no en la estructura de creación de éste. No se si es porque eso cambio con alguna versión y yo tengo alguna anticuada pero ese es mi caso jejeje.

[eferion]

No tengo compiladores de C disponibles... pero hasta donde recuerdo el estándar C99 (que data de 1999) copió de C++ la posibilidad de declarar variables en cualquier parte del código... incluídos los bucles.

Lo mismo deberías actualizar tu compilador.

[aguml]

La verdad es que no se que compilador tengo y no se como verlo pero es el que trae C++Builder 6.

[eferion]

En el diálogo "acerca de" del IDE te podrás hacer una idea de la fecha del compilador... que imagino que por tu versión rondará el año 2000.

En cualquier caso, C++ Builder está pensado sobretodo para el desarrollo de programas en C++...

[aguml]

Ok gracias.