[C con Clase] CRC

Steven Richard Davidson stevenrichard.davidson en gmail.com
Vie Ago 31 05:50:20 CEST 2007


Hola Bernardo,

On 8/30/07, Bernardo Reyes <bernardo5304 en gmail.com> wrote:
> Disculpen , podrian ayudarme a corregir mi programa . Ayer lo compile
> en la escuela y funciono , pero en este momentos estoy en un cybercafe
> y al compilarlo veo que ya no sirve :-s y no se que pueda ser, he
> probado la funcion division con algunos otros numeros  y me funciono
> con uno :-s

Viendo el código fuente, tienes errores lógicos en cuanto a la
manipulación de cadenas de caracteres.

>
> #include "funciones.c"
>

No aconsejo para nada incluir ficheros fuentes. Deberías escribir un
fichero de cabecera e incluirlo en otros ficheros fuentes, o incluso
otros ficheros de cabecera.

>

[CORTE]

> void correr_izq(char *cad){
>     int i;
>     for(i=0;cad[i]!='\0';i++) cad[i]=cad[i+1];

Este algoritmo no es del todo correcto. Tienes que solucionar el
último carácter. Si quieres implementar el mismo comportamiento que el
operador <<, entonces tienes que "agregar" un '0'. Esto sería,

for( i=0; cad[i]!='\0'; i++ )  cad[i] = cad[i+1];
cad[i-1] = '0';  // agregamos un '0' desde la derecha

Por otro lado, es posible que quieras acortar la cadena. Si esto es
así, entonces tendrás que "eliminar" el último carácter. Para hacer
esto, simplemente asignamos el carácter nulo al último lugar. Esto es,

for( i=0; cad[i]!='\0'; i++ )  cad[i] = cad[i+1];
cad[i-1] = 0;  // agregamos el carácter nulo al final de la nueva
cadena recortada

>     }
>
> /*===Quta ceros despues del XOR====*/
> int quitar_ceros_izq(char *cad){
>     int cont=0;
>     while(cad[0]=='0'){

Ten cuidado con este criterio, ya que es posible ir más allá del final
de la cadena: más allá del carácter nulo.

>         correr_izq(cad);
>         cont++;
>         }
>         return cont;
>     }
>
> char* division(char *msj, char *p){
>     int long_msj=strlen(msj);
>     int long_p=strlen(p);
>     int cont=0;
>     int cont2=long_p; //Nos ayuda a saber hasta donde hemos dividido
>     int i;
>     int ceros;
>
>     char *res=(char*)malloc(sizeof(char)*long_msj);
>     char *aux2=(char*)malloc(sizeof(char)*long_p);

[CORTE]

>     return aux2;

Aunque hayas creado memoria correctamente, no la has liberado para
'res'. Esto puede provocar problemas ya que tu programa estará
perdiendo memoria. Por otro lado, como tienes que retornar la cadena
apuntada por 'aux2', no deberías liberar la memoria en esta función.
Por lo tanto, esto significa que el usuario - quien invoque esta
función - tiene la responsabilidad de liberar esta memoria. De lo
contrario, el programa también perderá más memoria.

> /*====Convierte una letra a su representacion en binario====*/
> char* DecimalBinario (unsigned char decimal)
>  {
>    int i=0,j=0,contador=0;
>    unsigned char array[40];
>    char    aux[40];

[CORTE]

>
>      return aux;
>  }

Aquí obtendremos problemas en tiempo de ejecución. El array 'aux' es
local y por tanto es creado al comenzar la función y destruido al
terminar su ejecución. El problema es que estás retornando la
dirección de memoria a una cadena inexistente. Por esta razón, tu
programa aparece funcionar algunas veces y otras no.

Si quieres retornar una cadena, deberías pasarla como un parámetro a
la función. Por ejemplo,

char * DecimalBinario( char *szResultado, unsigned char decimal )
{
  ...
  return szResultado;
}

>
>
> void corrimiento(char*cad, int n){ //Corrimiento a la izquierda de n "bits"
>     int len=strlen(cad);
>     int i;
>     cad[len]='0';
>     for(i=0;i<n;i++) cad[len+i]='0';
>     cad[len+n]='\0';
>     }
>

Teóricamente, esto no es un corrimiento de n bits, sino agregar n
cantidad de 0's al final de la cadena. Si estás implementando un
número binario de cantidad ilimitada de bits, entonces supongo que lo
que estás haciendo es correcto. Recuerda que un número binario suele
estar limitado por una cantidad de bits en particular. Si estamos
antes 16 bits, entonces tu implementación sólo puede tener 16
caracteres para representar cualquier número binario. Por lo tanto, el
corrimiento a la izquierda de n bits implica eliminar y descartar los
primeros n bits. También se agregan n cantidad de 0's al final. El
resultado es un número de 16 bits, al fin y al cabo.


Espero que todo esto te aclare las dudas.

Steven




Más información sobre la lista de distribución Cconclase