1-8: Como programar en C en muchos pasos

eZine lover (@eZine)

Published in 

0ri0n Team Venezuela

 · 21 May 2023

El_Max_5
maxz-5@cantv.net

Ante todo soy El_Max_5 y quiero agradecer al editor de esta Revista por publicar este curso de programacion; Este curso lo escribi hace tiempo como guia de usuario para estudiantes Universitarios y ha funcionado a las mil maravillas. Si tienes alguna duda o sugerencia puedes escribirme a mi email (a veces trardo un poco para constestar porque me la paso OFF-LINE la mayoria de mi tiempo y muy poco reviso mi correo, Ok).

NOTA: Los Ejemplos que tomaremos son para Borland o Turbo C y puede ser que muchas de las funciones y librerias no sean compatibles con Linux.

Introduccion

C es un lenguaje de programacion de empleo general, caracterizado por ser conciso y poseer un moderno flujo de control y estructuras de datos, asi como un rico conjunto de operadores.

El C es un lenguaje de nivel medio, lo que implica la combinacion de caracteristicas de lenguaje de bajo nivel - ensambladores - con elementos propios de lenguaje de alto nivel como BASIC o PASCAL.

 ------------------------------------------ 
 | Alto Nivel | Medio Nivel | Bajo Nivel  | 
 ------------------------------------------ 
 | ADA        |     C       | EMSAMBLADOR | 
 | BASIC      |   FORTH     |             | 
 | COBOL      |             |             | 
 | FORTRAN    |             |             | 
 | PASCAL     |             |             | 
 ------------------------------------------

Un lenguaje de medio nivel proporciona a los programadores un conjunto minimo de sentencias de control y de manipulacion de datos, que pueden usarse para definir construcciones de alto nivel. Esto significa que el programador debera definir todas las funciones (rutinas), ya que ninguna va previamente incorporada.

Se dise~an, asi, librerias de funciones C que se adaptan a las tareas especificas de un programa.

Entre las ventajas del C se destacan:

• El C posee solamente <b>33 palabras clave</b>;
• El C es <b>portable</b>.

El C se usa para escribir:

• Sistemas Operativos
• Compiladores de lenguajes
• Ensambladores
• Procesadores de palabras
• Integracion E/S
• Controladores de red
• Programas de modem
• Bases de datos
• Interpretes de lenguajes
• Utilidades
• Etc...

El C es un lenguaje estructurado al igual que Pascal y Ada mientras que el BASIC, COBOL, FORTRAN no lo son.

La caracteristica basica de un lenguaje estructurado es el uso de bloques. Un bloque es un conjunto de sentencias que estan relacionadas logicamente.

Un lenguaje estructurado se caracteriza por:

• Soportar el concepto de subrutinas con variables locales y construcciones de bucles.
• No se recomienda el uso de goto (aun cuando no esta prohibido).
• Permitir compilar por separado a las subrutinas.
• Indentar las sentencias.

Para finalizar esta Introduccion, deben introducir las nociones de interpretes y compiladores.

Estos terminos se refieren a la forma en que un programa es ejecutado. Los interpretes y compiladores son programas que operan sobre el codigo fuente de su programa. El codigo fuente es el texto del programa que uno escribe.

Un interprete lee el codigo fuente del programa linea a linea, llevando a cabo cada vez las instrucciones especificas contenidas en la linea.

Un compilador lee el programa entero y lo convierte en codigo objeto (o codigo binario, o codigo maquina) directamente ejecutable por la computadora.

BASIC normalmente es interpretado, el C casi siempre es compilado.

El proceso de compilacion lleva tiempo pero produce un programa directamente ejecutable que se ejecuta mucho mas rapidamente que un programa interpretado.

Con los programas compilados se introducen, entonces, dos conceptos nuevos, a saber "tiempo de compilacion" y "tiempo de ejecucion" que, por desgracia, se encuentran muy a menudo asociado a la palabra error: "compile-time errors" y "run-time errors".

Empecemos....

I.- Manejo de Datos en C

1.- Anatomia de un programa

Sea el programa siguiente:

Ejemplo I.1:

 1:      #include <stdio.h> 
 2: 
 3:      main() 
 4:      { 
 5:         printf("Bienvenidos al C!\n"); 
 6:         return 0; 
 7:      }

La linea 1 es una sentencia include que indica al compilador leer otro archivo fuente. Las llaves "<>" indican al compilador buscar stdio.h en un directorio-subdirectorio preconfigurado en el autoexec.bat. Si se usa las comillas, por ejemplo "otrofichero.h" se indica al compilador buscar en el subdirectorio de trabajo. El archivo stdio.h se denomina cabecera ("header"), razon por la cual su extension es .h, es porque contiene varias declaraciones de entrada-salida que usa el programa. Otros archivos de cabecera contienen otros tipos de declaraciones que veremos en el transcurso de esta revista.

Si el compilador no encuentra el archivo mencionado entre comillas, te tratara como si estuviera delimitado por <> (buscara en los subdirectorios Include).

Los nombres de archivos pueden escribirse en minusculas o mayusculas; la sentencia # include debe escribirse en minusculas. Los nombres de archivos pueden incluir el camino para llegarles, por ejemplo:

 # include "C:\midir\miarchivo.inc"

La linea 2 es una linea vacia. Este tipo de linea es importante para delimitar las diferentes secciones que constituyen el programa.

Las llaves de la linea 4 y 7 abren y cierran un bloque constituido por sentencias y permiten indicar al compilador que queremos que considere a este grupo de sentencias como una entidad. Este tipo de bloque se denomina tambien sentencia compuesta. En el ejemplo tenemos dos sentencias. La primera llama a una funcion de salida formateada printf() que escribe en la pantalla el texto entre comillas. Esta linea termina con \n, lo que provoca un salto de linea al terminarse de escribirse la frase.

La linea 6 es una sentencia return. Termina el programa y regresa al DOS. Usualmente un valor diferente de cero significa que se han producido uno o varios errores.

Hasta el momento no hemos hablado de la linea 3. Esta linea es una de las mas importantes de cualquier programa escrito en C y se explicara en el parrafo siguiente.

a.- La funcion main()

En C los programas se ejecutan de manera lineal. Empiezan en una sentencia, ejecutan las que siguen y, solo si cae un rayo y/o ocurre un corto de energia, terminan con la sentencia y en el tiempo planificados.

Todos los programas empiezan en el mismo sitio: la primera sentencia de una funcion que se ha denominado main() al escribir el programa (si no exista tal funcion el compilador generara un mensaje de error).

Uno de las formas que puede tomar el mas peque~o programa escrito en C es la siguiente:

Ejemplo I.2

 1:      main() 
 2:      { 
 3:              return 0; 
 4:      }

La funcion empieza por su nombre, seguido de un par de parentesis. Si la funcion no tiene parametros estos parentesis no contendran nada.

A continuacion viene el bloque que define la funcion. En este figuran las sentencias (una en este ejemplo), todas terminadas por un ";" (para que el compilador sepa donde terminan).

b.- Mensajes de errores

El compilador da dos tipos de mensajes:

• De errores: en este caso el compilador no puede llevar a cabo su trabajo y Deben corregirse obligatoriamente los errores;
• De advertencias: son llamadas de atencion sobre problemas que podrian eventualmente impedir que el programa se ejecute o que conducirian a resultados imprevisibles. Al recibir tales mensajes, es preferible corregir la causa lo mas rapidamente posible.

El programa siguiente (ejemplo I.3) tiene varios errores de tipeo. Al compilarlo (con CTRL + F9, o con F8 en el modo Trace) se generan varios mensajes.

 1:      include <stdio.h) 
 2: 
 3:      main{} 
 4:      ( 
 5:        printf("Problemas, problemas\n"); 
 6:        printf("Mas problemas!\n); 
 7:        printf("___Errores Voluntarios") 
 8:      )

Al corregir los errores, la compilacion no generara mensajes y se podra ver el resultado en la pantalla de salida (con ALT + F5).

2.- Comentarios

Los comentarios son ignorados por el compilador. Nos permiten aclarar algunos aspectos del programa.

Los comentarios se encierran entre los simbolos /* y */; por ejemplo:

 /* Esto es un comentario */ 

 /* Esto es un comentario 
    que ocupa 
    varias lineas 
 */

3.- Tipos de variables y datos

Una variable es un nombre asociado a un espacio de memoria que se reserva para almacenar un valor.

Antes de usar la variable, esta debe declararse. Esta regla ayuda al compilador a terminar su tarea rapidamente y obliga al programador a planificar cuidadosamente su trabajo. En el listado siguiente (ejemplo I.4) se muestra como declarar, inicializar y utilizar una variable entera. Un entero se simboliza por int.

 1:      #include <stdio.h> 
 2: 
 3:      main() 
 4:      { 
 5:        int cuanto; 
 6: 
 7:        cuanto = 1234; 
 8:        printf("Cuanto = %d\n", cuanto); 
 9:        return 0; 
 10      }

La linea 5 declara la variable llamada cuanto: int es el tipo de dato, cuanto es el identificador.

Por convencion, se separa por una linea blanca la seccion donde se declaran las variables de las otras sentencias del programa.

La linea 7 asigna a la variable cuanto el valor de 1234. Al ejecutar esta sentencia, el programa almacena una representacion binaria de 1234 en el espacio de memoria asignada a la variable cuanto.

La linea 8 muestra cuanto. El argumento %d indica a la funcion printf() donde colocar el valor de la variable cuyo nombre se ha colocado despues de la coma. Al ejecutarse esta linea, printf() convierte el valor binario de cuanto a caracteres, coloca estos caracteres en el sitio donde esta ubicado el argumento %d y manda el resultado al terminal. Ya sabemos que \n provoca una salto de linea en el terminal.

El listado siguiente (ejemplo I.5) declara y muestra un cierto numero de variables de diferentes tipos.

 1:      #include <stdio.h> 
 2: 
 3:      main() 
 4:      { 
 5:         char slash = '/'; 
 6:         short mes = 4; 
 7:         int an = 2001; 
 8:         long poblacion = 308700000L; 
 9:         float pi = 3.14159; 
 10:        double velocidad = 186281.7; 
 11:        long double anioLuz = 5.88e12; 
 12: 
 13:        printf("Fecha = %02d%c%d\n", mes, slash, an); 
 14:        printf("Poblacion = %ld\n", poblacion); 
 15:        printf("Pi = %f\n", pi); 
 16:        printf("Velocidad de la luz =%12.2f miles/sec\n", velocidad); 
 17:        printf("Un a~o luz = %.0Lf miles\n", anioLuz); 
 18:        return 0; 
 19:     }

A continuacion definiremos los diferentes tipos de variables. Para mostrar el valor de estas ultimas en este programa, se usa en printf() varios argumentos (%d, %c, %f, etc..) que se definiran a continuacion.

La linea 7 muestra otra manera de declarar y inicializar una variable.

Todas las variables deben inicializarse. De lo contrario, se obtendrian resultados impredecibles ya que las variables podrian contener valores dejados en la memoria por operaciones previas.

a.- Variables Globales

En el ejemplo anterior, las variables se declaran en el bloque de la funcion main() y son locales. Sin embargo, las variables pueden declararse afuera de main(). En este ultimo caso las variables seran globales.

Contrariamente a las variables locales, las variables globales se preinicializan en cero. El listado siguiente (ejemplo I.6) es identico al del ejemplo I.4 pero declara cuanto como una variable global.

 1       #include <stdio.h> 
 2 
 3       int cuanto; 
 4 
 5       main() 
 6       { 
 7         cuanto = 1234; 
 8         printf("Valor = %d\n", cuanto); 
 9         return 0; 
 10      }

En este caso, el compilador almacena la variable en la misma area de memoria que la del programa.

Al ejecutarse este ultimo, el codigo de arranque coloca cada byte de esta area de memoria en 0.

Si se elimina la linea 7, cuanto tendria un valor de 0.

El ejemplo I.7 ilustra la diferencia entre variables globales y locales.

 1       #include <stdio.h> 
 2 
 3       int global = 100; 
 4       int globalDefault; 
 5 
 6       main() 
 7       { 
 8         int local = 200; 
 9         int localDefault; 
 10 
 11        printf("global = %d\n", global); 
 12        printf("local  = %d\n", local); 
 13 
 14        printf("globalDefault = %d\n", globalDefault); 
 15        printf("localDefault  = %d\n", localDefault); 
 16        return 0; 
 17      }

b.- Palabras Clave

Son simbolos internos del C que cuando se incluyen en su sintaxis formal forman el lenguaje de programacion. Son palabras reservadas que no pueden utilizarse con un objetivo diferente al que se ha destinado. Deben escribirse en minusculas.

 ANSI C 
 ------------------------------------------------------------ 
 | Asm      | default   | for      | short       | union    | 
 | auto     | do        | goto     | signed      | unsigned | 
 | break    | double    | if       | sizeof      | void     | 
 | case     | else      | int      | static      | volatile | 
 | char     | enum      | long     | struct      | while    | 
 | const    | extern    | register | switch      |          | 
 | continue | float     | return   | typedef     |          | 
 ------------------------------------------------------------

Ademas, la Borland amplio este listado agregando 19 palabras clave suplementarias:

 ------------------------------------------------------- 
 | _cdecl | _es     | _fastcall  | _near   | _saveregs | 
 | cdecl  | _export | huge       | near    | _seg      | 
 | _cs    | _far    | interrupt  | _pascal | _ss       | 
 | _ds    | far     | _loadds    | pascal  |           | 
 -------------------------------------------------------

c.- Identificadores

Son palabras que identifican las variables y funciones que dise~amos. Deben empezar por un caracter y pueden contener letras, numeros y el caracter subrayado.

Los identificadores deben tener los 32 primeros caracteres distintos.

Un mismo nombre escrito en mayusculas o en minusculas corresponde a dos variables diferentes:

Mivar, MiVar y MIVAR corresponden a tres variables diferentes.

Generalmente, los identificadores de variables y las funciones de la libreria estandar comienzan por una minuscula. Las palabras clave se escriben siempre en minuscula.

Estos son convenciones y no reglas; pero si todo el mundo las utiliza se obtiene una mejor organizacion de los programas y se entiende mejor el codigo escrito por los demas programadores.

Para mejor claridad se separan las palabras por el caracter de subrayado:

 velocidad_de_la_luz

o se utilizan mayusculas:

 velocidadDelaLuz.

d.- Enteros

Los datos tipo int ocupan 2 bytes y tienen valores entre - 32768 y 32767 (incluyendo el 0). Corresponden a numeros enteros.

Cuando se necesita un rango de valores mas grande se usa el tipo long int que corresponde al rango - 2 147 483 648 a 2 147 483 647.

La declaracion de variable se hace segun:

  long int valorElevado;

que puede abreviarse segun:

  long valorElevado;

Tambien existe el tipo short int:

  short int valorPeque~o;

que se abrevia:

  short valorPeque~o

Sin embargo, en Borland C, un short int es identico al int (el ANSI C no especifica nada y esto depende del compilador usado). Para los enteros muy peque~os se usa el tipo char que tambien puede representar un caracter.

Una variable tipo char ocupa un byte y representa valores entre -128 y +127 (incluyendo el 0).

d.1 Variables signed y unsigned

Todos los enteros char, short, int y long tienen un signo por default. Es decir que pueden ser positivos o negativos. Podria usarse la palabra clave signed para estos valores. Sin embargo, resulta inutil ya que int significa lo mismo que signed int.

Si no se necesita los enteros negativos se puede usar unsigned en la declaracion:

 unsigned char uc; 
 unsigned short si; 
 unsigned int ui; 
 unsigned long li;

Ya que los enteros unsigned no pueden representar numeros negativos, ellos representan el doble del anterior en los numeros positivos (incluyendo el 0) como indicado en la tabla siguiente:

------------------------------------------------------------------------------ 
|    Tipo       | tam. en bytes | tam. en bits | valor minimo | valor maximo | 
------------------------------------------------------------------------------ 
| signed char   |        1      |      8       |     -128     |      127     | 
| unsigned char |        1      |      8       |       0      |      255     | 
| signed short  |        2      |     16       |    -32768    |      32767   | 
| unsigned short|        2      |     16       |       0      |      65535   | 
| signed int    |        2      |     16       |   - 32768    |      32767   | 
| unsigned int  |        2      |     16       |       0      |      65535   | 
| signed long   |        4      |     32       |  -2147483648 |   2147483647 | 
| unsigned long |        4      |     32       |       0      |   4294967295 | 
------------------------------------------------------------------------------

La libreria estandar limits.h indica el rango exacto de los datos de tipos enteros.

En la expresion:

 j = i + 60000;

si i es del tipo unsigned int y es igual a 15000, entonces:

 j = 9464

d.2 Declaracion multiple de variables

Para declarar varias variables del mismo tipo puede usarse:

 int v1; int v2; int v3; int v4;

o

 int v1, v2, v3, v4;

d.3 Valores Verdadero y Falso

En C, falso es equivalente a 0 y verdadero es equivalente a cualquier valor entero diferente de 0.

d.4 Constantes

Son valores fijos que el programa no altera. Generalmente el compilador utiliza el tipo de datos que permiten almacenar el valor en el espacio mas peque~o posible.

Cuando es necesario, se puede obligar al compilador a usar un tipo de datos especifico. Por ejemplo, la constante 1234 normalmente se almacena como int. Sin embargo, si queremos que se almacene como long se usa L despues del ultimo numero:

 long valor = 1234L;

si queremos un valor unsigned, se usa U:

1234U se almacena como unsigned int, 1234UL como unsigned long.

Ademas se puede usar el sistema octal o hexadecimal. Una constante que empieza por 0 se considera como expresada en base 8, una que empieza por 0x como expresada en base 16.

Ejemplo 1.8

 1       #include <stdio.h> 
 2 
 3       main() 
 4       { 
 5         int hexValor = 0xf9ac; 
 6         int octalValor = 0724; 
 7         int decimalValor = 255; 
 8 
 9         printf("Como enteros en base 10:\n"); 
 10        printf(" hexValor = %d\n", hexValor); 
 11        printf(" octalValor = %d\n", octalValor); 
 12        printf(" decimalValor = %d\n", decimalValor); 
 13 
 14        printf("\nComo enteros formateados:\n"); 
 15        printf(" hexValor = %x\n", hexValor); 
 16        printf(" octalValor = %o\n", octalValor); 
 17        printf(" decimalValor = %#x\n", decimalValor); 
 18        return 0; 
 19      }

Formateando los valores hexadecimales con %d en printf() (lineas 10-12) se obtiene sus valores equivalentes en base 10.

Para obtener los valores hexadecimales debe usarse %x (o %X para obtener A.. ...F). Con #x o #X se obtiene los valores hexadecimales de las constantes decimales. Para obtener los valores en el sistema octal se usa %o.

d.5 La palabra clave const

Para almacenar un valor en una variable de tipo int se usa:

 int valor = 1234;

Al escribir:

 valor = 4321;

cambiamos el valor de la variable. Si la variable nuevoValor es tambien del tipo int:

 valor = nuevoValor;

asigna a valor el contenido de nuevoValor.

Para evitarlo se usa la palabra clave const:

 const int calor = 1234;

Al escribir valor = nuevoValor se genera un mensaje de error.

e.- Reales

Existen tres tipos: float, double y long double

---------------------------------------------------------------------------- 
|    Tipo     | tam. en bits | tam. en bytes | valor minimo | valor maximo | 
---------------------------------------------------------------------------- 
| float       |     4        |     32        |  34 10-38    |   34 10+38   | 
| double      |     8        |     64        | 1.7 10-308   | 1.7 10 +308  | 
| long double |    10        |     80        | 3.4 10-4932  | 3.4 10+4932  | 
----------------------------------------------------------------------------

(consultar float.h) or man ... jejeje

Se declaran de la misma manera que las variables int:

 float saldo; 
 double saldo = 525.49;

Por default, las constantes, tal como 525.49 o 99.99 son del tipo double, para que sea del tipo float hay que agregarle f o F:

 3.14159F

o para el tipo long double:

 3.14159L

En el ejemplo I.9 se calcula el impuesto a la venta y el precio de venta de un item a partir del precio de compra y del % de impuesto.

 1       #include <stdlib.h> 
 2       #include <stdio.h> 
 3 
 4       main() 
 5       { 
 6         double precioLista, pagado, porcien, impuesto; 
 7         char s[20]; 
 8         printf("Cuanto pago ? "); 
 9         scanf("%20s", s); 
 10        pagado = atof(s); 
 11        printf("Porcentaje de Impuesto (ej: .06)? "); 
 12        scanf("%20s", s); 
 13        porcien = atof(s); 
 14        precioLista = pagado * (1 + porcien); 
 15        impuesto = precioLista- pagado; 
 16        printf("Precio de venta = Bs.%8.2f\n", precioLista); 
 17        printf("IVA   = Bs.%8.2f\n", impuesto); 
 18        return 0; 
 19      }

La linea 6 declara cuatro variables del tipo float; la linea 7 declara una cadena de caracteres (string); la 9 pregunta por el precio de compra que la linea 10 lea en la cadena s. La sentencia

 scanf("%20s",s);

espera que el usuario tipee hasta 20 caracteres. Esta funcion se declara en stdio.h

char s(20) reserva espacio para 19 caracteres mas un byte para un cero terminal el cual indica la terminacion de la cadena.

La linea 11 llama a la funcion atof(), declarada en stdlib.h para convertir el string a un valor real de tipo double.

f.- Caracteres (char)

Se almacenan en 1 byte. Ya vimos como se usa el tipo char para almacenar enteros entre -128 y + 127, pero una declaracion del tipo:

 char c= 'A';

asigna a la variable c el valor ASCII de la letra A (ojo: comilla sencilla).

El ejemplo 1.10 muestra el valor ASCII de los caracteres en base 10 y 16.

 1       #include <stdio.h> 
 2 
 3       main() 
 4       { 
 5       char c; 
 6 
 7         printf("Tipear el caracter: "); 
 8         c = getchar(); 
 9         printf(" Caracter   = %c\n", c); 
 10        printf(" ASCII (dec) = %d\n", c); 
 11        printf(" ASCII (hex) = %#x\n", c); 
 12        return 0; 
 13      }

En la linea 5 declara la variable, tipo char, c
En la linea 8 llama a la funcion getchar() que lee un caracter introducido por teclado. La funcion espera hasta que se presione Enter.

printf() muestra c, como caracter, decimal y hexadecimal.
Ya que los caracteres se almacenan como enteros, este programa funciona muy bien con int c en la linea 5.

f.1 Cadenas de caracteres como constantes

Estas constantes corresponden a una o mas palabras entre comillas. "Que dia tan bonito" se almacena como una serie de valores tipo char que termina por un byte en cero. Este byte en cero permite a las funciones detectar la terminacion de la cadena.

Generalmente, se escribe estas constantes en una sola linea. Sin embargo, Borland C permite escribir las frases muy largas en varias lineas:

 "Esto parece constituir" 
 "tres cadenas," 
 "pero en realidad es una sola"

Ademas de caracteres, las cadenas pueden contener secuencias de escape que son simbolos especiales que no pueden tipearse directamente.

------------------------------------------------------------------------------ 
| Codigo | Significado          | Valor ASCII Decimal | Hexadecimal | Simbolo| 
------------------------------------------------------------------------------ 
|  '\a'  | alerta               |       7             |    0x07     |   BEL  | 
|  '\b'  | retroceso            |       8             |    0x08     |   BS   | 
|  '\f'  | salto de pagina      |      12             |    0x0C     |   FF   | 
|  '\n'  | salto de linea       |      10             |    0x0a     |   LF   | 
|  '\r'  | retorno de carro     |      13             |    0x0d     |   CR   | 
|  '\t'  | tabulacion horizontal|       9             |    0x09     |   HT   | 
|  '\v'  | tabulacion vertical  |      11             |    0x0b     |   VT   | 
|  '\\'  | slash                |      92             |    0x5c     |   \    | 
|  '\''  | comilla simple       |      39             |    0x27     |   '    | 
|  '\"'  | comilla doble        |      34             |    0x22     |   "    | 
|  '\?'  |                      |      63             |    0x3f     |   ?    | 
------------------------------------------------------------------------------

Para crear una cadena de caracteres se declara:

 char cadena[80];

Se lee la cadena introducida por teclado con:

 scanf("%80s",cadena);

El problema de scanf() es que termina la captacion al primer espacio en blanco o al presionar Enter.

Para leer cadenas con espacio en blanco se usa:

 gets(cadena);

Esta funcion puede aceptar mas caracteres que los previstos en la declaracion de la variable, sobreescribiendose zonas de memorias no asociadas a dicha variables. Para evitarlo, se declara:

 char cadena[128];

ya que el buffer estandar del DOS es de 128 caracteres, los usuarios no pueden entrar cadenas mas largas.

Las cadenas de caracteres son muy utiles para recibir los datos introducidos a traves del teclado. Pero cuando el dato es numerico, el programa debera convertir la cadena a entero o real. Existen para ello tres funciones:

 atof()          (°se obtiene un valor double!) 
 atoi()          (se obtiene un entero int) 
 atol()          (se obtiene un entero long)

Ejemplos 1.11 y 1.12

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

 main() 
 { 
   int valor; 
   char cadena[128]; 

   printf("Tipear el valor: "); 
   gets(cadena); 
   valor = atoi(cadena); 
   printf("Valor en base 10 = %d\n", valor); 
   printf("Valor en hex     = %#x\n", valor); 
   printf("Valor en base 8  = %o\n", valor); 
   return 0; 
 } 

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

 main() 
 { 
   double millas; 
   char cadena[128]; 

   printf("Convierte millas a kilometros\n"); 
   printf("®Cuantas millas? "); 
   gets(cadena); 
   millas = atof(cadena); 
   printf("Kilometros = %f\n", millas * 1.609344); 
   return 0; 
 }

g.- Espacio ocupado por las variables

Los compiladores de ANSI C pueden almacenar los valores de los enteros y reales de manera diferente. En vez de suponer que una cierta variable ocupa un cierto numero de bytes puede usarse el operador sizeof para calcular los requerimientos necesarios para almacenar una variable.

Ejemplo_I_13

 #include <stdio.h> 

 main() 
 { 
   char c; 
   short s; 
   int i; 
   long l; 
   float f; 
   double d; 
   long double ld; 

   printf("Espacio Ocupado por char ...... = %2d byte(s)\n", sizeof(c)); 
   printf("Espacio Ocupado por short ..... = %2d byte(s)\n", sizeof(s)); 
   printf("Espacio Ocupado por int ....... = %2d byte(s)\n", sizeof(i)); 
   printf("Espacio Ocupado por long ...... = %2d byte(s)\n", sizeof(l)); 
   printf("Espacio Ocupado por float ..... = %2d byte(s)\n", sizeof(f)); 
   printf("Espacio Ocupado por double .... = %2d byte(s)\n", sizeof(d)); 
   printf("Espacio Ocupado por long double = %2d byte(s)\n", sizeof(ld)); 
   return 0; 
 }

4- Constantes simbolicas

Son identificadores que se usan para asociar un simbolo a una cadena:

 #define FALSO 0 
 #define CIERTO 1

El compilador sustituye el identificador por la cadena asociada. Al proceso de reemplazamiento se le denomina sustitucion de macro.

(Nota: No termina con ";")

La ventaja de usarlas es que cuando deben cambiarse los valores resulta mas facil hacerlo sobre todo con los programas muy largos.

Tarea para la Casa: Editar math.h para ver las constantes simbolicas alli definidas (jejeje).

5.- Enumeraciones

Podriamos definir los colores con:

 #define ROJO 0 
 #define ANARANJADO 1 
 #define AMARILLO 2 
 #define VERDE 3 
 #define AZUL 4 
 #define INDIGO 5 
 #define MORADO 6

y en el programa usar:

 int color; 
 color = VERDE;

sin embargo, con una lista mas larga esto resultaria bastante tedioso. Para evitarlo, se usa la palabra clave enum:

 enum {ROJO,ANARANJADO,AMARILLO,VERDE,AZUL,INDIGO,MORADO};

lo que da por resultado un simbolo asociado a un valor entero empezando por 0 (0, 1, 2, etc... ).

en el programa se usa entonces:

 int color = AZUL;

Con la palabra clave typedef se crea un nuevo tipo de datos:

 typedef enum 

  { 

    ROJO,ANARANJADO,AMARILLO,VERDE,AZUL,INDIGO,MORADO 

  } Colores;

obteniendose asi un nombre de un nuevo tipo de datos. En este ejemplo, el nombre Colores se asocia a la lista de los nombres de colores. El programa puede entonces declarar una variable de este tipo.

 Colores unColor;

y se asigna una constante simbolica a unColor segun:

 unColor = INDIGO;

Tambien puede usarse un entero:

 unColor = 5;

Si tenemos:

 enum {ENE,FEB,MAR,ABR,MAY,JUN,JUL,AGO,SEP,OCT,NOV,DIC};

como resulta inhabitual asignar el 0 al mes de enero, puede forzarse empezar por 1 con:

 enum { ENE = 1,FEB,MAR,ABR,MAY,JUN,JUL,AGO,SEP,OCT,NOV,DIC};

Tambien podria usarse:

 enum { ENE =10,FEB=20,...,DIC=120};

6- Conversion de Tipos

Para terminar con esta parte de la revista es importante ver lo que pasa al mezclar diferentes tipos de datos en una expresion.

Si tenemos:

 long valor = 12345678; 
 int otroValor;

podemos preguntarnos que pasa al escribir:

 otroValor = valor;

otroValor puede almacenar valores entre -32768 y 32767 pero no puede almacenar la variable valor que es un positivo mas grande. Sin embargo, el compilador permite esta asignacion y almacena 24910 en otroValor (resto de la division de valor por 65536, entero mas grande que puede almacenarse en otroValor).

Se genera asi una perdida de informacion.
Al contrario si otroValor = 4321, la asignacion:

 valor = otroValor;

coloca 4321 en valor. En este caso no existe ningun problema. El compilador promueve la transformacion del dato tipo int a tipo long.

Si fp es del tipo float y db del tipo double, la asignacion:

 db = fp;

promueve fp a double. Sin embargo:

 fp = db;

puede causar problemas.

Otros tipos de promocion tambien se permiten:

 int i; 
 float f =2.8; 
 i =f;

en este caso, i = 2 y se perdieron las cifras decimales.

 Int i= 4; 
 float f; 
 f = i;

promueve i a float y f = 4

 int i= 4; 
 float f =2,8; 
 i = f * i;

i primero se promueve a float y se multiplica obteniendose 11.2. sin embargo, al asignarse el valor del producto a i, se transforma de nuevo i a int y se obtiene 11.

Moldes (Typecasts)

puede controlarse las reglas de promocion que usa el compilador:

 int i = 4; 
 float f = 2.8;

al escribir:

 i = (int) f * i;

se obtiene i = 8

Es decir, se indica al compilador considerar f como int.

 /* 
   Bueno Se~ores, esto fue todo por ahora y nos vemos en la proxima edicion 
   de esta Revista Electronica. 
 */

=< El_Max_5 >=