UNIVERSIDAD TECNICA FEDERICO SANTA MARIA DEPARTAMENTO DE ELECTRONICA Programación Avanzada en C

Transcripción

1 Rutinas de conversión. De enteros a caracteres. Ltoa. Long to Ascii. Pasar de un número en representación interna a una secuencia de caracteres, permite desplegar en la salida los valores de las variables de un programa. La siguiente rutina convierte un entero largo, en representación interna, en una secuencia de dígitos. Se dispone, como argumento de la función, de la base numérica en la que los números se representarán en forma externa. La función ocupa un buffer estático de 65 bits, lo cual permite convertir enteros de 64 bits en secuencias binarias. Se considera en el buffer espacio para el signo y el terminador del string. Para enteros de 16 bits, el rango de representación es: [ ] el cual requiere de 5 char para representar mediante dígitos decimales. Para enteros de 32 bits: [ ] se requieren 10 chars para dígitos. Para enteros de 64 bits: [ ] se requieren 19 char para dígitos decimales. Para imprimir en binario se requieren 63 dígitos binarios. El procedimiento consiste en sacar el módulo base del número, esto genera el último carácter del número; es decir el menos significativo. Luego se divide en forma entera por la base, quedando el resto; del cual se siguen extrayendo uno a uno los dígitos. Por ejemplo para el entero 123 en base decimal, al sacar módulo 10 del número se obtiene el dígito de las unidades, que es 3. Al dividir, en forma entera por la base, se obtiene el número de decenas; es decir, 12. Sacando módulo 10 se obtiene 2; y al dividir por la base se obtiene el número de centenas. Si la base que se pasa como argumento es menor o igual a cero, se asume base decimal. Si la base es mayor que 36, también se asume base decimal. Con base 36 se tienen los 10 dígitos decimales y todas las letras como los dígitos del sistema. La función retorna un puntero al primer carácter de la secuencia. Al inicio de la rutina se apunta al final del buffer, a la posición de las unidades, ya que los dígitos se generan a partir de las unidades. El carácter de fin de string se coloca automáticamente al definir el buffer estático, ya que éste es inicializado con ceros. La función permite desplegar secuencias binarias y hexadecimales. Prof. Leopoldo Silva Bijit

2 Para convertir un número entero a un carácter de un dígito decimal se suma el valor del carácter 0 ; el valor asociado a 0 es 0x30, al 1 está asociado el 0x31. Para números mayores que 9 se suma el valor del carácter 7 (que es 55 decimal); de esta manera para 10, se obtiene: = 65 que es el equivalente a A. #define INT_DIGITOS 63 static char buf[int_digitos + 2]; /* Buffer para INT_DIGITS dígitos, signo - y fin de string '\0' */ char * ltoa(long int i, unsigned int base) char *p = buf + INT_DIGITOS + 1; /* apunta a posición de unidades */ int dig, signo=0; if (i<0) signo=1;i = -i; if(base<=0 base>36) base=10; /*evita división por cero */ do dig=(i%base); if (dig <=9) *--p = '0' + dig; else *--p= '7'+ dig ; i /= base; while (i!= 0); if(signo) *--p = '-'; return p; Para convertir enteros se emplea la misma rutina anterior, invocando con una conversión explícita del entero a largo. char * itoa(int i, unsigned int base) return (ltoa((long)i, base)); La siguiente rutina permite el despliegue del string, mediante putchar. #include <stdio.h> void prtstr(char * p) while(*p) putchar(*p++); El siguiente ejemplo ilustra el uso de las rutinas de conversión. int main(void) int i=-31; Prof. Leopoldo Silva Bijit

3 long int l= L; prtstr( itoa(i,32) ); putchar('\n'); prtstr( ltoa(l,2) ); putchar('\n'); return (0); De secuencias de caracteres a enteros. Si bien esta rutina efectúa el trabajo inverso de la anterior, su diseño es más complejo, ya que debe operar con datos suministrados por un ser humano. La anterior saca algo que está en formato interno y que está bien especificado. En la conversión de un string en un long integer, debe asumirse que el usuario provee una secuencia de caracteres que tiene el siguiente formato: [blancos*] [signo] [0] [x X] [ddd] Los corchetes indican elementos opcionales, el asterisco la repetición de cero o más veces. De esta forma podrían digitarse caracteres espacios o tabuladores antes de la secuencia; podría indicarse el signo +, y también declarar números octales si el primer dígito es cero, o hexadecimales si los primeros dígitos son 0x ó 0X. En el diseño se decide terminar de leer cuando encuentra un carácter que no cumpla el formato. Para permitir seguir analizando la secuencia de entrada se decide pasar a la función, además de un puntero al inicio de la secuencia a analizar, y de la base, la referencia a un puntero a carácter. Al salir de la función se escribe, en la variable pasada por referencia, el valor del puntero que apunta al carácter que detuvo el scan, por no cumplir el formato. Esto debido a que en C, sólo se puede retornar un valor desde la función. Además la función debe resolver que el valor del número ingresado no exceda el mayor representable. Como los números se representan con signo en complemento a la base, se tendrán valores máximos diferentes(en la unidad) para el máximo positivo y el máximo negativo. Por ejemplo para enteros largos de 32 bits, el rango asimétrico de representación en base decimal es [ ]. Entonces debe considerarse que cuando se tenga ingresada la secuencia (corte), si el siguiente dígito(límite) es mayor que 7, para positivos; y mayor que 8, para negativos se tendrá rebalse. Y se debe notificar con el código de error estándar: error de rango. Prof. Leopoldo Silva Bijit

4 Los valores máximos de las representaciones se almacenan en limits.h, mediante estas constantes se pueden calcular la secuencia de corte y el dígito límite, que permiten determinar si se sobrepasa o no el rango de representación. En el código siguiente se incorporan el texto de las funciones, macros y constantes, y se comentan la inclusión de los archivos que las contienen. Los macros de ctype.h se han simplificado, ya que suelen estar implementados mediante una tabla de búsqueda. En la variable local acc se va formando el número. La variable any se coloca en uno si se han consumido caracteres desde la secuencia de entrada; y se le da un valor negativo si se produce rebalse. Como se lee la secuencia de izquierda a derecha, el núcleo del algoritmo consiste en multiplicar el número acumulado en acc, por la base y luego sumarle el valor numérico del dígito. Por ejemplo, la secuencia 123 en decimal, es procesada según: 0* = 1 1* = 12 12* = 123 Nótese que el segundo argumento de la función es un puntero a un puntero a carácter. En caso que a la función se le pase un puntero no nulo, retornará la posición donde se detuvo el scan, o la dirección de inicio de la secuencia si se excede el rango de representación. El código de la rutina pertenece a la Universidad de California. /*#include <limits.h>*/ #define LONG_MAX 0x7FFFFFFFL #define LONG_MIN ((long)0x l) /*#include <ctype.h>*/ #define islower(c) (('a' <= (c) ) && ((c) <= 'z')) #define isupper(c) (('A' <= (c) ) && ((c) <= 'Z')) #define isdigit(c) (('0' <= (c) ) && ((c) <= '9')) #define isspace(c) ((c) == ' ' (c) == '\t' (c)== '\n') #define isalpha(c) ((islower(c)) (isupper(c))) /*#include <errno.h>*/ #define ERANGE 34 /* Resultado demasiado grande. Rebalse de representación. */ extern int errno; /* Copyright (c) 1990 The Regents of the University of California.*/ long strtol(const char *nptr, char **endptr, int base) register const char *s = nptr; Prof. Leopoldo Silva Bijit

5 register unsigned long acc; register int c; register unsigned long cutoff; register int neg = 0, any, cutlim; do c = *s++; while (isspace(c)); /* salta blancos*/ if (c == '-') neg = 1; c = *s++; /* si negativo, registra signo en neg */ else if (c == '+') c = *s++; /* salta signo + */ if ( (base == 0 base == 16) && c == '0' && (*s == 'x' *s == 'X') ) c = s[1];s += 2; base = 16; /*si base es 0 ó 16 consume 0x ó 0X y lee hex*/ if (base == 0) base = c == '0'? 8 : 10; /*si la base es cero, si el primer digito es cero lee octal, sino asume decimal */ /*Calcula el corte y el dígito límite, a partir de los máximos */ cutoff = neg? -(unsigned long) LONG_MIN : LONG_MAX; cutlim = (int)(cutoff % (unsigned long) base); cutoff /= (unsigned long) base; for (acc = 0, any = 0; ; c = *s++) if (isdigit(c)) c -= '0'; else if (isalpha(c)) c -= (isupper(c))? 'A' - 10 : 'a' - 10; else break; if (c >= base) break; if (any < 0 acc > cutoff acc == cutoff && c > cutlim) any = -1; else any = 1; acc *= base; acc += c; if (any < 0) acc = neg? LONG_MIN : LONG_MAX; errno = ERANGE; else if (neg) acc = -acc; if (endptr!= 0) *endptr = any? (char *)(s - 1) : (char *)nptr; return (acc); Las funciones atoi y atol se implementan en base a strtol. En éstas, la base es 10, y no se pasa una referencia a un puntero a carácter. /* Convierte un string en un entero. Ascii to integer. */ int atoi (const char *nptr) return (int) strtol (nptr, (char **) NULL, 10); Prof. Leopoldo Silva Bijit

6 /* Convierte un string en un entero largo. Ascii to long */ long int atol (const char *nptr) return strtol (nptr, (char **) NULL, 10); El siguiente ejemplo ilustra el uso de strtol, y la forma de emplear el segundo argumento. Nótese que al invocar se pasa la dirección de un puntero a carácter; y que al salir, endptr queda apuntando al carácter que no es valido en la secuencia. /* strtol ejemplo */ #include <stdio.h> int main(void) char *string = " guena", *endptr; long lnumber; /* strtol converts string to long integer */ lnumber = strtol(string, &endptr, 10); printf("string = %s long = %ld\n", string, lnumber); printf(" endptr = %s \n", endptr); return 0; Nótese que el segundo argumento actual, en la invocación, es &endptr; es decir, la dirección de un puntero. Entonces en la definición de la función el tipo del segundo argumento debe un puntero a puntero a carácter; es decir: char * * endptr. De dobles a caracteres. Resulta útil una función que convierta un número en punto flotante en una base b1 en otro número punto flotante en base b2. Si b1 es 2 y b2 es 10, se convierte un número real en representación interna en externa. Se dice que en un sistema de base b, la mantisa m está normalizada si: 1/b <= m < 1 El algoritmo consiste en alternar las multiplicaciones (o divisiones) de m por b1, con las divisiones (o multiplicaciones) por b2, de tal forma que m se mantenga en el rango: Prof. Leopoldo Silva Bijit

7 1/b <= m < b con b = b1*b2 El algoritmo es ineficiente, pues el número de operaciones es proporcional a e1; además introduce cierto error, debido a las numerosas operaciones de truncamiento para mantener la mantisa dentro del rango anterior. Debido a que la función entrega dos valores, se decide pasar por referencia el exponente e2. /*Dado un flotante m1*pow(b1, e1) se desea obtener m2*pow(b2, e2) */ double convierta(double m, int e1, int b1, int *e2, int b2) *e2=0; if (e1>=0) while (e1>0) m*=b1;e1--; while(m>=1) m/=b2;(*e2)++; else do m/=b1;e1++; while( m <(1/b2) ) m*=b2;(*e2)--; while (e1!=0); return(m); Un ejemplo de uso se ilustra a continuación: Se definen algunas variables: double number, mantisa, m2; int e1, int e2=0; El siguiente llamado a la rutina frexp, declarada en math.h, retorna la mantisa y el exponente de un número flotante doble, según: mantisa * pow(2, exponente) Con: 0.5 =< mantisa < 1 mantisa = frexp(number, &e1); El llamado a convierta escribe en m2 y e2, el número doble mantisa e1. m2 = convierta(mantisa, e1, 2, &e2, 10); Prof. Leopoldo Silva Bijit

8 printf("m2 = %lf \n", m2); printf("e2 = %d \n", e2); La función prtmantisa imprime la parte fraccionaria o mantisa normalizada de un número u en punto flotante de doble precisión, mediante putchar; empleando como base numérica a base, y sacando un número de dígitos igual a ndig. Sólo acepta bases positivas menores o iguales que 36; en caso de estar fuera de rango asume base decimal. void prtmantisa(double u, int ndig, int base) int i=0; int v; putchar('.'); if(base<=0 base>36) base=10; for(i=0; i<ndig; i++) u*=base; v=(int)u; if (v <=9) putchar(v+'0'); else putchar(v+'7'); u-=v; Multiplica la mantisa por la base, quedando de esta forma un número a la izquierda del punto decimal. Dicho dígito puede obtenerse en v, truncando el doble; esto se logra mediante el cast explícito a entero. Luego se puede enviar hacia la salida el carácter, considerando una conversión a carácter, que toma en cuenta bases mayores a la decimal. Antes de volver a seguir desplegando caracteres, le quita la parte entera al doble; de este modo al inicio del bloque, u siempre es un número fraccionario puro. Los siguientes ejemplos ilustran el uso de la función: prtmantisa(mantissa, 18, 10); putchar('\n'); prtmantisa(mantissa, 52, 2); putchar('\n'); prtmantisa(mantissa, 8, 16); putchar('\n'); Nótese que no tiene sentido invocar la impresión binaria con más de 52 bits, ya que ese es el número de bits de un doble. Tampoco tiene sentido invocar la impresión hexadecimal de la mantisa con más de 7 cifras. Puede verificarse que tampoco tiene sentido solicitar salidas en base decimal con más de 18 dígitos, ya que ésta es la precisión de un doble. La impresión del exponente, mediante putchar, puede lograrse empleando itoa. Prof. Leopoldo Silva Bijit