LENGUAJE C

CAPITULO 1: INTRODUCCION

1.- INTRODUCCION
El lenguaje de programacin C est caracterizado por ser de uso general, con una sintaxis sumamente compacta y de
alta portabilidad.
Es comn leer que se lo caracteriza como un lenguaje de "bajo nivel". No debe confundirse el trmino "bajo" con
"poco", ya que el significado del mismo es en realidad "profundo", en el sentido que C maneja los elementos bsicos
presentes en todas las computadoras: caracteres, nmeros y direcciones .
Esta particularidad, junto con el hecho de no poseer operaciones de entrada-salida, manejo de arreglo de caracteres,
de asignacin de memoria, etc , puede al principio parecer un grave defecto; sin embargo el hecho de que estas
operaciones se realicen por medio de llamadas a Funciones contenidas en Libreras externas al lenguaje en s, es el
que confiere al mismo su alto grado de portabilidad, independizandolo del "Hardware" sobre el cual corren los
programas, como se ir viendo a lo largo de los siguientes captulos.
La descripcin del lenguaje se realiza siguiendo las normas del ANSI C, por lo tanto, todo lo expresado ser
utilizable con cualquier compilador que se adopte; sin embargo en algunos casos particulares se utilizaron funciones
Compilador Sistema Operativo-dependientes, explicitndose en estos casos la singularidad de las mismas.

2.- ANATOMIA DE UN PROGRAMA C

Siguiendo la tradicin, la mejor forma de aprender a programar en cualquier lenguaje es editar, compilar, corregir y
ejecutar pequeos programas descriptivos. Analicemos por lo tanto el primer ejemplo :
EJEMPLO 1
#include <stdio.h>
main()
{
printf("Bienvenido a la Programacion
en lenguaje C \n");
return 0;
}
FUNCION main()
Dejemos de lado por el momento el anlisis de la primer linea del programa, y pasemos a la segunda.
La funcin main() indica donde empieza el programa, cuyo cuerpo principal es un conjunto de sentencias
delimitadas por dos llaves, una inmediatamente despus de la declaracin main() " { ", y otra que finaliza el listado
"} ". Todos los programas C arrancan del mismo punto: la primer sentencia dentro de dicha funcin, en este caso
printf ("......").

UTN - Informtica I

Capitulo I

-1 -

LENGUAJE C

En el EJEMPLO 1 el programa principal est compuesto por slo dos sentencias: la primera es un llamado a una
funcin denominada printf(), y la segunda, return, que finaliza el programa retornando al Sistema Operativo.
Recurdese que el lenguaje C no tiene operadores de entrada-salida por lo que para escribir en video es necesario
llamar a una funcin externa. En este caso se invoca a la funcin printf(argumento) existente en la Librera y a la
cual se le enva como argumento aquellos caracteres que se desean escribir en la pantalla. Los mismos deben estar
delimitados por comillas. La secuencia \n que aparece al final del mensaje es la notacin que emplea C para el
caracter "nueva linea" que hace avanzar al cursor a la posicin extrema izquierda de la lnea siguiente. Ms adelante
analizaremos otras secuencias de escape habituales.

La segunda sentencia (return 0) termina el programa y devuelve un valor al Sistema operativo, por lo general cero si
la ejecucin fu correcta y valores distintos de cero para indicar diversos errores que pudieron ocurrir. Si bien no es
obligatorio terminar el programa con un return, es conveniente indicarle a quien lo haya invocado, sea el Sistema
Operativo o algn otro programa, si la finalizacin ha sido exitosa, o no. De cualquier manera en este caso, si
sacamos esa sentencia el programa correr exactamente igual, pero al ser compilado, el compilador nos advertir de
la falta de retorno.

Cada sentencia de programa queda finalizada por el terminador "; ", el que indica al compilador el fin de la misma.
Esto es necesario ya que, sentencias complejas pueden llegar a tener ms de un rengln, y habr que avisarle al
compilador donde terminan.
Es perfectamente lcito escribir cualquier sentencia abarcando los renglones que la misma necesite, por ejemplo
podra ser:
printf("Bienvenido a la Programacion en lenguaje C \n");

3.- ENCABEZAMIENTO
Las lneas anteriores a la funcin main() se denominan ENCABEZAMIENTO (HEADER) y son informaciones que
se le suministran al Compilador.
La primera lnea del programa est compuesta por una directiva: " #include " que implica la orden de leer un archivo
de texto especificado en el nombre que sigue a la misma ( <stdio.h> ) y reemplazar esta lnea por el contenido de
dicho archivo.
En este archivo estn incluidas declaraciones de las funciones luego llamadas por el programa (por ejemplo printf() )
necesarias para que el compilador las procese. Por ahora no nos preocupemos por el contenido del archivo ya que
ms adelante, en el captulo de funciones, analizaremos exhaustivamente dichas declaraciones.
Hay dos formas distintas de invocar al archivo, a saber, si el archivo invocado est delimitado por comillas (por
ejemplo "stdio.h") el compilador lo buscar en el directorio activo en el momento de compilar y si en cambio se lo
delimita con los signos <.......> lo buscar en algun otro directorio, cuyo nombre habitualmente se le suministra en el
momento de la instalacin del compilador en el disco ( por ejemplo C:\TC\INCLUDE). Por lo general estos archivos
son guardados en un directorio llamado INCLUDE y el nombre de los mismos est terminado con la extensin .h.

UTN - Informtica I

Capitulo I

-2 -

LENGUAJE C

La razn de la existencia de estos archivos es la de evitar la repeticin de la escritura de largas definiciones en cada
programa.
Ntese que la directiva "#include" no es una sentencia de programa sino una orden de que se copie literalmente un
archivo de texto en el lugar en que ella est ubicada ,por lo que no es necesario terminarla con "; ".

4.- COMENTARIOS
La inclusin de comentarios en un programa es una saludable prctica, como lo reconocer cualquiera que haya
tratado de leer un listado hecho por otro programador por s mismo, varios meses atrs. Para el compilador, los
comentarios son inexistentes, por lo que no generan lineas de cdigo, permitiendo abundar en ellos tanto como se
desee.
En el lenguaje C se toma como comentario todo caracter interno a los simbolos: /* */ . Los comentarios pueden
ocupar uno o ms renglones. Tambin podemos tener comentarios sobre una misma lneas mediante la inclusin de
doble barras //
COMENTARIOS
suma = suma + k // comentario sobre la lnea
/* este es un comentario corto */
/* ..........
............ */

UTN - Informtica I

Capitulo I

-3 -

LENGUAJE C

CAPITULO 2: VARIABLES Y CONSTANTES

1.- DEFINICION DE VARIABLES

Si yo deseara imprimir los resultados de multiplicar un nmero fijo por otro que adopta valores entre 0 y 9 , la forma
normal de programar esto sera crear una CONSTANTE para el primer nmero y un par de VARIABLES para el
segundo y para el resultado del producto. Una variable , en realidad , no es ms que un nombre para identificar una
(o varias) posiciones de memoria donde el programa guarda los distintos valores de una misma entidad . Un
programa debe DEFINIR a todas las variables que utilizar , antes de comenzar a usarlas , a fin de indicarle al
compilador de que tipo sern , y por lo tanto cuanta memoria debe destinar para albergar a cada una de ellas.
EJEMPLO 2
#include <stdio.h>
main()
{
int multiplicador;
int multiplicando;
int resultado;
multiplicador = 1000 ;
multiplicando = 2 ;

/* defino multiplicador como un entero */

/* defino multiplicando como un entero */
/* defino resultado como un entero */
/* les asigno valores */

resultado = multiplicando * multiplicador ;

printf("Resultado = %d\n", resultado);
/* muestro el resultado */
return 0;
}
En las primeras lneas de texto dentro de main() defino mis variables como nmeros enteros , es decir del tipo "int"
seguido de un identificador (nombre) de la misma . Este identificador puede tener la cantidad de caracteres que se
desee , sin embargo de acuerdo al Compilador que se use , este tomar como significantes slo los primeros n de
ellos ; siendo por lo general n igual a 32 . Es conveniente darle a los identificadores de las variables , nombres que
tengan un significado que luego permita una fcil lectura del programa. Los identificadores deben comenzar con una
letra con el smbolo de subrayado "_" , pudiendo continuar con cualquier otro caractr alfanumrico el smbolo
"_" . El nico smbolo no alfanumrico aceptado en un nombre es el "_" . El lenguaje C es sensible al tipo de letra
usado ; as tomar como variables distintas a una llamada "variable" , de otra escrita como "VARIABLE". Es una
convencin entre los programadores de C escribir los nombres de las variables y las funciones con minsculas,
reservando las maysculas para las constantes.
El compilador dar como error de "Definicin incorrecta" a la definicin de variables con nombres del tipo de :
4pesos $variable primer-variable !variable etc.etc
NOTA: Los compiladores reservan determinados trminos palabras claves (Keywords) para el uso sintctico del
lenguaje, tales como: asm, auto, break, case, char, do, for, etc. Si bien estas palabras estn definidas para el ANSI C,
los distintos compiladores extienden esta definicin a OTROS trminos, por lo que es aconsejable leer la tabla
completa de palabras reservadas del compilador que se vaya a usar, para no utilizarlas en nombres de variables.

UTN - Informtica I

Capitulo II

LENGUAJE C

Vemos en las dos lineas subsiguientes a la definicin de las variables, que puedo ya asignarles valores (1000 y 2) y
luego efectuar el clculo de la variable "resultado". Si prestamos ahora atencin a la funcin printf(), sta nos
mostrar la forma de visualizar el valor de una variable. Insertada en el texto a mostrar, aparece una secuencia de
control de impresin "%d" que indica, que en el lugar que ella ocupa, deber ponerse el contenido de la variable
( que aparece luego de cerradas las comillas que marcan la finalizacin del texto , y separada del mismo por una
coma) expresado como un un nmero entero decimal. As, si compilamos y corremos el programa , obtendremos
una salida :
SALIDA DEL EJEMPLO 2
Resultado = 2000

2.- INICIALIZACION DE VARIABLES

Las variables del mismo tipo pueden definirse mediante una definicin mltiple separandolas mediante " , " a saber :
int multiplicador, multiplicando, resultado;
Esta sentencia es equivalente a las tres definiciones separadas en el ejemplo anterior. Las variables pueden tambin
ser inicializadas en el momento de definirse .
int multiplicador = 1000, multiplicando = 2, resultado;
De esta manera el EJEMPLO 2 podra escribirse:
EJEMPLO 2 BIS
#include <stdio.h>
main()
{
int multiplicador=1000 , multiplicando=2 ;
printf("Resultado = %d\n", multiplicando * multiplicador);
return 0;
}

Obsrvese que en la primer sentencia se definen e inicializan simultaneamente ambas variables.La variable
"resultado" la hemos hecho desaparecer ya que es innecesaria. Si analizamos la funcin printf() vemos que se ha
reemplazado "resultado" por la operacin entre las otras dos variables. Esta es una de las particularidades del
lenguaje C : en los parmetros pasados a las funciones pueden ponerse operaciones (incluso llamadas a otras
funciones) , las que se realizan ANTES de ejecutarse la funcin , pasando finalmente a esta el valor resultante de las
mismas. El EJEMPLO 2 funciona exactamente igual que antes pero su cdigo ahora es mucho ms compacto y
claro.

UTN - Informtica I

Capitulo II

LENGUAJE C

3.- TIPOS DE VARIABLES

Variables del tipo entero

En el ejemplo anterior definimos a las variables como enteros (int).
De acuerdo a la cantidad de bytes que reserve el compilador para este tipo de variable, queda determinado el
"alcance" mximo valor que puede adoptar la misma.
Debido a que el tipo int ocupa dos bytes su alcance queda restringido al rango entre -32.768 y +32.767
(incluyendo 0 ).
En caso de necesitar un rango ms amplio, puede definirse la variable como "long int nombre_de_variable" en
forma ms abreviada "long nombre_de_variable"
Declarada de esta manera, nombre_de_variable puede alcanzar valores entre - 2.347.483.648 y +2.347.483.647.
A la inversa, si se quisiera un alcance menor al de int, podra definirse "short int " simplemente "short", aunque
por lo general, los compiladores modernos asignan a este tipo el mismo alcance que "int".
Debido a que la norma ANSI C no establece taxativamente la cantidad de bytes que ocupa cada tipo de variable,
sino tan slo que un "long" no ocupe menos memoria que un "int" y este no ocupe menos que un "short",los
alcances de los mismos pueden variar de compilador en compilador , por lo que sugerimos que confirme los valores
dados en este pargrafo (correspondientes al compilador de Borland C++) con los otorgados por su compilador
favorito.
Para variables de muy pequeo valor puede usarse el tipo "char" cuyo alcance est restringido a -128, +127 y por lo
general ocupa un nico byte.
Todos los tipos citados hasta ahora pueden alojar valores positivos negativos y, aunque es redundante, esto puede
explicitarse agregando el calificador "signed" delante; por ejemplo:
signed int
signed long
signed long int
signed short
signed short int
signed char

UTN - Informtica I

Capitulo II

LENGUAJE C

Si en cambio, tenemos una variable que slo puede adoptar valores positivos (como por ejemplo la edad de una
persona ) podemos aumentar el alcance de cualquiera de los tipos , restringindolos a que slo representen valores
sin signo por medio del calificador "unsigned" . En la TABLA 1 se resume los alcances de distintos tipos de
variables enteras
TABLA 1 VARIABLES DEL TIPO NUMERO ENTERO
TIPO
signed char
Unsigned char
Signed short
Unsigned short
Signed int
Unsigned int
Signed long
Unsigned long

BYTES
1
1
2
2
2
2
4
4

VALOR MINIMO
-128
0
-32.768
0
-32.768
0
-2.147.483.648
0

VALOR MAXIMO
127
255
+32.767
+65.535
+32.767
+65.535
+2.147.483.647
+4.294.967.295

NOTA: Si se omite el calificador delante del tipo de la variable entera, ste se adopta por omisin (default) como
"signed".

Variables de numero real o punto flotante

Un nmero real de punto flotante es aquel que adems de una parte entera, posee fracciones de la unidad. En
nuestra convencin numrica solemos escribirlos de la siguiente manera : 2,3456, lamentablemente los compiladores
usan la convencin del PUNTO decimal (en vez de la coma) . As el numero Pi se escribir : 3.14159 Otro formato
de escritura, normalmente aceptado, es la notacin cientfica. Por ejemplo podr escribirse 2.345E+02, equivalente a
2.345 * 100 234.5

De acuerdo a su alcance hay tres tipos de variables de punto flotante , las mismas estn descriptas en la TABLA 2
TABLA 2 TIPOS DE VARIABLES DE PUNTO FLOTANTE
TIPO
Float
Double
Long double

BYTES
4
8
10

VALOR MINIMO
3.4E-38
1.7E-308
3.4E-4932

VALOR MAXIMO
3.4E+38
1.7E+308
3.4E+4932

Las variables de punto flotante son SIEMPRE con signo, y en el caso que el exponente sea positivo puede obviarse
el signo del mismo.

UTN - Informtica I

Capitulo II

LENGUAJE C
4.- CONVERSION AUTOMATICA DE TIPOS
Cuando dos mas tipos de variables distintas se encuentran DENTRO de una misma operacin expresin
matemtica , ocurre una conversin automtica del tipo de las variables. En todo momento de realizarse una
operacin se aplica la siguiente secuencia de reglas de conversin (previamente a la realizacin de dicha operacin):
1) Las variables del tipo char short se convierten en int
2) Las variables del tipo float se convierten en double
3) Si alguno de los operandos es de mayor precisin que los dems , estos se convierten al tipo de aquel y
el resultado es del mismo tipo.
4) Si no se aplica la regla anterior y un operando es del tipo unsigned el otro se convierte en unsigned y el
resultado es de este tipo.
Las reglas 1 a 3 no presentan problemas, slo nos dicen que previamente a realizar alguna operacin las variables
son promovidas a su instancia superior. Esto no implica que se haya cambiado la cantidad de memoria que las aloja
en forma permanente
Otro tipo de regla se aplica para la conversin en las asignaciones.
Si definimos los trminos de una asignacin como,"lvalue" a la variable a la izquierda del signo igual y "rvalue" a la
expresin a la derecha del mismo, es decir:
"lvalue" = "rvalue" ;
Posteriormente al clculo del resultado de "rvalue" (de acuerdo con las reglas antes descriptas), el tipo de este se
iguala al del "lvalue". El resultado no se ver afectado si el tipo de "lvalue" es igual superior al del "rvalue", en
caso contrario se efectuar un truncamiento redondeo, segun sea el caso.
Por ejemplo, el pasaje de float a int provoca el truncamiento de la parte fraccionaria, en cambio de double a float se
hace por redondeo.

5.- ENCLAVAMIENTO DE CONVERSIONES (casting)

Las conversiones automticas pueden ser controladas a gusto por el programador, imponiendo el tipo de variable al
resultado de una operacin. Supongamos por ejemplo tener:
double d , e , f = 2.33 ;
int i = 6 ;
e=f*i;
d = (int) ( f * i ) ;
En la primer sentencia calculamos el valor del producto (f * i) , que segn lo visto anteriormente nos dar un double
de valor 13.98 , el que se ha asignado a e. Si en la variable d quisiramos reservar slo el valor entero de dicha
operacin bastar con anteponer, encerrado entre parntesis, el tipo deseado. As en d se almacenar el nmero
13.00.
Tambin es factible aplicar la fijacin de tipo a una variable, por ejemplo obtendremos el mismo resultado, si
hacemos:
d = (int) f * i ;
En este caso hemos convertido a f en un entero (truncando sus decimales )

UTN - Informtica I

Capitulo II

LENGUAJE C

6.- VARIABLES DE TIPO CARACTER

El lenguaje C guarda los caracteres como nmeros de 8 bits de acuerdo a la norma ASCII extendida , que asigna a
cada caracter un nmero comprendido entre 0 y 255 ( un byte de 8 bits) Es comn entonces que las variables que
vayan a alojar caracteres sean definidas como: char c ;
Sin embargo, tambin funciona de manera correcta definirla como
int c ;
Esta ltima opcin desperdicia un poco ms de memoria que la anterior ,pero en algunos casos particulares presenta
ciertas ventajas . Pongamos por caso una funcin que lee un archivo de texto ubicado en un disco. Dicho archivo
puede tener cualquier caracter ASCII de valor comprendido entre 0 y 255.
Para que la funcin pueda avisarme que el archivo ha finalizado deber enviar un nmero NO comprendido entre 0 y
255 ( por lo general se usa el -1 , denominado EOF, fin de archivo End Of File), en este caso dicho nmero no
puede ser mantenido en una variable del tipo char, ya que esta slo puede guardar entre 0 y 255 si se la define
unsigned no podria mantener los caracteres comprendidos entre 128 y 255 si se la define signed (ver TABLA 1).
El problema se obvia facilmente definindola como int.
Las variables del tipo caractr tambin pueden ser inicializadas en su definicin, por ejemplo es vlido escribir:
char c = 97 ; para que c contenga el valor ASCII de la letra "a", sin embargo esto resulta algo engorroso , ya que
obliga a recordar dichos cdigos .
Existe una manera ms directa de asignar un caractr a una variable ; la siguiente inicializacin es idntica a la
anterior :
char c = 'a' ;
Es decir que si delimitamos un caracter con comilla simple , el compilador entender que debe suplantarlo por su
correspondiente cdigo numrico .
Lamentablemente existen una serie de caracteres que no son imprimibles , en otras palabras que cuando editemos
nuestro programa fuente (archivo de texto) nos resultar difcil de asignarlas a una variable ya que el editor las toma
como un COMANDO y no como un caracter . Un caso tpico sera el de "nueva linea" ENTER .
Con el fin de tener acceso a los mismos es que aparecen ciertas secuencias de escape convencionales . Las mismas
estan listadas en la TABLA 3 y su uso es idntico al de los caracteres normales , asi para resolver el caso de una
asignacin de "nueva linea " se escribir:

char c = '\n' ;

UTN - Informtica I

/* secuencia de escape */

Capitulo II

LENGUAJE C

TABLA 3 SECUENCIAS DE ESCAPE

CODIGO
'\n'
'\r'
'\f'
'\t'
'\b'
'\''
'\"'
'\\ '
'\? '
'\nnn'
'\xnn'

SIGNIFICADO

VALOR ASCII
VALOR ASCII
(decimal)
(hexadecimal)
nueva lnea
10
0x0A
retorno de carro
13
0x0D
nueva pgina
2
x0C
tabulador horizontal
9
0x09
retroceso (backspace)
8
0x08
comilla simple
39
0x27
comillas
4
0x22
barra
92
0x5C
interrogacin
63
0x3F
cualquier caracter (donde nnn es el cdigo ASCII expresado en octal)
cualquier caracter (donde nn es el cdigo ASCII expresado en hexadecimal)

7.- TAMAO DE LAS VARIABLES (sizeof)

En muchos programas es necesario conocer el tamao (cantidad de bytes) que ocupa una variable, por ejemplo en el
caso de querer reservar memoria para un conjunto de ellas. Lamentablemente, como vimos anteriormente este
tamao es dependiente del compilador que se use, lo que producir, si definimos rigidamente (con un nmero dado
de bytes) el espacio requerido para almacenarlas, un problema serio si luego se quiere compilar el programa con un
compilador distinto del original
Para salvar este problema y mantener la portabilidad, es conveniente que cada vez que haya que referirse al
TAMAO en bytes de las variables, se lo haga mediante un operador llamado "sizeof" que calcula sus
requerimientos de almacenaje
Est tambin permitido el uso de sizeof con un tipo de variable, es decir:
sizeof(int)
sizeof(char)
sizeof(long double) , etc.

8.- DEFINICION DE NUEVOS TIPOS ( typedef )

A veces resulta conveniente crear otros tipos de variables , redefinir con otro nombre las existentes , esto se puede
realizar mediante la palabra clave "typedef" , por ejemplo:
typedef unsigned long double enorme ;
A partir de este momento ,las definiciones siguientes tienen idntico significado:
unsigned long double nombre_de_variable ;
enorme nombre_de_variable ;
UTN - Informtica I

Capitulo II

10

LENGUAJE C

9.- CONSTANTES
Aquellos valores que , una vez compilado el programa no pueden ser cambiados , como por ejemplo los valores
literales que hemos usado hasta ahora en las inicializaciones de las variables (1000 , 2 , 'a' , '\n' , etc), suelen
denominarse CONSTANTES .
Como dichas constantes son guardadas en memoria de la manera que al compilador le resulta ms eficiente suelen
aparecer ciertos efectos secundarios , a veces desconcertantes , ya que las mismas son afectadas por las reglas de
RECONVERSION AUTOMATICA DE TIPO vista previamente.
A fin de tener control sobre el tipo de las constantes, se aplican la siguientes reglas :

Una variable expresada como entera (sin parte decimal) es tomada como tal salvo que se la siga de las
letras F L (maysculas minsculas) ejemplos :
1 : tomada como ENTERA
1F : tomada como FLOAT
1L : tomada como LONG DOUBLE

Una variable con parte decimal es tomada siempre como DOUBLE, salvo que se la siga de la letra F L
1.0 : tomada como DOUBLE
1.0F : tomada como FLOAT
1.0L : tomada como LONG FLOAT

Si en cualquiera de los casos anteriores agregamos la letra U u la constante queda calificada como
UNSIGNED (consiguiendo mayor alcance) :
1u : tomada como UNSIGNED INT
1.0UL : tomada como UNSIGNED LONG DOUBLE

Una variable numrica que comienza con "0" es tomado como OCTAL asi : 012 equivale a 10 unidades
decimales

Una variable numrica que comienza con "0x" "0X" es tomada como hexadecimal : 0x16 equivale a 22
unidades decimales y 0x1A a 26 unidades decimales.

10.- CONSTANTES SIMBOLICAS

Por lo general es una mala prctica de programacin colocar en un programa constantes en forma literal (sobre todo
si se usan varias veces en el mismo) ya que el texto se hace dificil de comprender y an ms de corregir, si se debe
cambiar el valor de dichas constantes.
Se puede en cambio asignar un smbolo a cada constante, y reemplazarla a lo largo del programa por el mismo, de
forma que este sea ms legible y adems, en caso de querer modificar el valor, bastar con cambiarlo en la
asignacin.

UTN - Informtica I

Capitulo II

11

LENGUAJE C
El compilador, en el momento de crear el ejecutable, reemplazar el smbolo por el valor asignado.
Para dar un smbolo a una constante bastar, en cualquier lugar del programa (previo a su uso) poner la directiva:
por ejemplo :
#define VALOR_CONSTANTE 342

#define PI 3.1416

UTN - Informtica I

Capitulo II

12

LENGUAJE C

CAPITULO 3: OPERADORES
1.- INTRODUCCION
Si analizamos la sentencia siguiente:
var1 = var2 + var3;
estamos dicindole al programa, por medio del operador +, que compute la suma del valor de dos variables , y una
vez realizado sto asigne el resultado a otra variable var1. Esta ltima operacin (asignacin) se indica mediante
otro operador, el signo =.
El lenguaje C tiene una amplia variedad de operadores, y todos ellos caen dentro de 6 categorias , a saber :
aritmticos , relacionales, lgicos, incremento y decremento, manejo de bits y asignacion. Todos ellos se irn
describiendo en los prrafos subsiguientes.

2.- OPERADORES ARITMETICOS

Tal como era de esperarse los operadores aritmticos ,mostrados en la TABLA 4 , comprenden las cuatro
operaciones basicas , suma , resta , multiplicacin y divisin , con un agregado , el operador mdulo .
TABLA 4 OPERADORES ARITMETICOS
SIMBOLO
+
*
/
%
-

DESCRIPCION
SUMA
RESTA
MULTIPLICACION
DIVISION
MODULO
SIGNO

EJEMPLO
a+b
a-b
a*b
a/b
a%b
-a

ORDEN DE EVALUACION
3
3
2
2
2
2

El operador mdulo ( % ) se utiliza para calcular el resto del cociente entre dos ENTEROS , y NO puede ser
aplicado a variables del tipo float double .
Si bien la precedencia (orden en el que son ejecutados los operadores) se analizar ms adelante, en este captulo,
podemos adelantar algo sobre el orden que se realizan las operaciones aritmticas.
En la TABLA 4, ltima columna, se da el orden de evaluacin de un operador dado. Cuanto ms bajo sea dicho
nmero mayor ser su prioridad de ejecucin. Si en una operacin existen varios operadores, primero se evaluarn
los de multiplicacin , divisin y mdulo y luego los de suma y resta . La precedencia de los tres primeros es la
misma , por lo que si hay varios de ellos, se comenzar a evaluar a aquel que quede ms a la izquierda . Lo mismo
ocurre con la suma y la resta .

UTN - Informtica I

Capituli III

13

LENGUAJE C

Para evitar errores en los clculos se pueden usar parntesis , sin limitacin de anidamiento, los que fuerzan a
realizar primero las operaciones incluidas en ellos . Los parntesis no disminuyen la velocidad a la que se ejecuta el
programa sino que tan slo obligan al compilador a realizar las operaciones en un orden dado, por lo que es una
buena costumbre utilizarlos ampliamente .
Los parntesis tienen un orden de precedencia 0, es decir que antes que nada se evala lo que ellos encierran .
Se puede observar que no existen operadores de potenciacin, radicacin, logaritmacin, etc, ya que en el lenguaje C
todas estas operaciones ( y muchas otras ) se realizan por medio de llamadas a Funciones.
El ltimo de los operadores aritmticos es el de SIGNO . No debe confundirselo con el de resta, ya que este es un
operador unitario que opera sobre una nica variable cambiando el signo de su contenido nmerico. Obviamente no
existe el operador + unitario, ya que su operacin sera DEJAR el signo de la variable, lo que se consigue
simplemente por omisin del signo.

3.- OPERADORES RELACIONALES

Todas las operaciones relacionales dan slo dos posibles resultados : VERDADERO FALSO . En el lenguaje C,
Falso queda representado por un valor entero nulo (cero) y Verdadero por cualquier nmero distinto de cero En la
TABLA 5 se encuentra la descripcin de los mismos .

TABLA 5 OPERADORES RELACIONALES

SIMBOLO
<
>
<=
>=
==
!=

DESCRIPCION
menor que
mayor que
menor o igual que
mayor o igual que
igual que
distinto que

EJEMPLO
(a < b)
(a >b)
(a < = b)
( a >>= b )
( a = = b)
( a != b)

ORDEN DE EVALUACION
5
5
5
5
6
6

Uno de los errores ms comunes es confundir el operador relacional IGUAL QUE (= =) con el de asignacion
IGUAL A (=). La expresin a=b copia el valor de b en a, mientras que a = = b retorna un cero , si a es distinto de b
un nmero distinto de cero si son iguales.
Los operadores relacionales tiene menor precedencia que los aritmticos , de forma que a < b + c se interpreta como
a < ( b + c ), pero aunque sea superfluo recomendamos el uso de parntesis a fin de aumentar la legilibilidad del
texto.
Cuando se comparan dos variables tipo char el resultado de la operacin depender de la comparacin de los valores
ASCII de los caracteres contenidos en ellas. Asi el caracter a ( ASCII 97 ) ser mayor que el A (ASCII 65 ) que el
9 (ASCII 57).

UTN - Informtica I

Capituli III

14

LENGUAJE C
4.- OPERADORES LOGICOS
Hay tres operadores que realizan las conectividades lgicas Y (AND) , O (OR) y NEGACION (NOT) y estn
descriptos en la TABLA 6 .
TABLA 6 OPERADORES LOGICOS
SIMBOLO
&&
||
!

DESCRIPCION
Y (AND)
O (OR)
NEGACION (NOT)

EJEMPLO
(a>b) && (c < d)
(a>b) || (c < d)
!(a>b)

ORDEN DE EVALUACION
10
11
1

Los resultados de la operaciones lgicas siempre adoptan los valores CIERTO FALSO. La evaluacin de las
operaciones lgicas se realiza de izquierda a derecha y se interrumpe cuando se ha asegurado el resultado .
El operador NEGACION invierte el sentido lgico de las operaciones , as ser
!( a >> b )
!( a == b )
etc.

equivale a ( a < b )
" " ( a != b )

En algunas operaciones suele usrselo de una manera que se presta a confusin , por ejemplo : ( !i ) donde i es un
entero. Esto dar un resultado CIERTO si i tiene un valor 0 y un resultado FALSO si i es distinto de cero .

5.- OPERADORES DE INCREMENTO Y DECREMENTO

Los operadores de incremento y decremento son slo dos y estn descriptos en la TABLA 7

TABLA 7 OPERADORES DE INCREMENTO Y DECREMENTO

SIMBOLO
++
--

DESCRIPCION
Incremento
Decremento

EJEMPLO
++i i++
--i i--

ORDEN DE EVALUACION
1
1

Para visualizar rapidamente la funcin de los operadores antedichos , digamos que las sentencias :
a=a+1;
a++ ;
tienen una accin idntica , de la misma forma que
a=a-1;
a-- ;
es decir incrementa y decrementa a la variable en una unidad
Si bien estos operadores se suelen emplear con variables int , pueden ser usados sin problemas con cualquier otro
tipo de variable . As si a es un float de valor 1.05 , luego de hacer a++ adoptar el valor de 2.05 y de la misma
manera si b es una variable del tipo char que contiene el caracter 'C' , luego de hacer b-- su valor ser 'B' .

UTN - Informtica I

Capituli III

15

LENGUAJE C

Si bien las sentencias

i++ ;
++i ;
son absolutamente equivalentes, en la mayoria de los casos la ubicacin de los operadores incremento decremento
indica CUANDO se realiza ste .
Veamos el siguiente ejemplo :
int i = 1 , j , k ;
j = i++ ;
k = ++i ;
ac j es igualado al valor de i y POSTERIORMENTE a la asignacin i es incrementado por lo que j ser igual a 1 e i
igual a 2 , luego de ejecutada la sentencia . En la siguiente instruccin i se incrementa ANTES de efectuarse la
asignacion tomando el valor de 3 , l que luego es copiado en k .

6.- OPERADORES DE ASIGNACION

En principio puede resultar algo futil gastar papel en describir al operador IGUAL A ( = ) , sin embargo es necesario
remarcar ciertas caractersticas del mismo .
Anteriormente definimos a una asignacin como la copia del resultado de una expresin ( rvalue ) sobre otra
(lvalue) , esto implica que dicho lvalue debe tener LUGAR (es decir poseer una posicin de memoria ) para alojar
dicho valor .
Es por lo tanto vlido escribir
a = 17 ;
pero no es aceptado , en cambio
17 = a ; /* incorrecto */
ya que la constante numrica 17 no posee una ubicacin de memoria donde alojar al valor de a .
Aunque parezca un poco extrao al principio las asignaciones , al igual que las otras operaciones , dan un resultado
que puede asignarse a su vez a otra expresin .
De la misma forma que (a + b) es evaluada y su resultado puedo copiarlo en otra variable : c = (a + b) ; una
asignacin (a = b) da como resultado el valor de b , por lo que es lcito escribir
c=(a=b);
Debido a que las asignaciones se evalan de derecha a izquierda , los parntesis son superfluos , y podr escribirse
entonces :
c = a = b = 17 ;
con lo que las tres variables resultarn iguales al valor de la contante .

UTN - Informtica I

Capituli III

16

LENGUAJE C

El hecho de que estas operaciones se realicen de derecha a izquierda tambin permite realizar instrucciones del tipo :
a = a + 17 ;
significando esto que al valor que TENIA anteriormente a , se le suma la constante y LUEGO se copia el resultado
en la variable .
Como este ltimo tipo de operaciones es por dems comn , existe en C un pseudocdigo , con el fn de abreviarlas .
Asi una operacin artmetica o de bit cualquiera (simbolizada por OP )
a = (a) OP (b) ;
puede escribirse en forma abreviada como :
a OP= b ;
Por ejemplo
a += b ;
a -= b ;
a *= b ;
a /= b ;
a %= b ;

/* equivale : a = a + b */
/* equivale : a = a - b */
/* equivale : a = a * b */
/* equivale : a = a / b */
/* equivale : a = a % b */

Ntese que el pseudooperador debe escribirse con los dos smbolos seguidos , por ejemplo += , y no ser aceptado
+(espacio) = .
Los operadores de asignacin estan resumidos en la TABLA 8 .
TABLA 8 OPERADORES DE ASIGNACION
SIMBOLO
=
op=
=?:

DESCRIPCION
igual a
Pseudocodigo
asig.condicional

EJEMPLO
a=b
a += b
a = (c>b)?d:e

ORDEN DE EVALUACION
13
13
12

Vemos de la tabla anterior que aparece otro operador denominado ASIGNACION CONDICIONAL . El significado
del mismo es el siguiente :
lvalue = ( operacin relacional logica ) ? (rvalue 1) : (rvalue 2) ;
de acuerdo al resultado de la operacin condicional se asignar a lvalue el valor de rvalue 1 2 . Si aquella es
CIERTA ser lvalue = rvalue 1 y si diera FALSO , lvalue = rvalue 2 .
Por ejemplo, si quisiramos asignar a c el menor de los valores a b , bastar con escribir :
c=(a<b)?a:b;

UTN - Informtica I

Capituli III

17

LENGUAJE C
7.- OPERADORES DE MANEJO DE BITS
Estos operadores muestran una de las armas ms potentes del lenguaje C , la de poder manipulear
INTERNAMENTE , es decir bit a bit , las variables .
Debemos anticipar que estos operadores slo se aplican a variables del tipo char , short , int y long y NO pueden ser
usados con float double ,
Sabemos que las computadoras guardan los datos organizados en forma digital , en bytes , formado por nmeros
binarios de 8 bits y como se vi anteriormente cuando se analiz el tamao de las variables , un char ocupar un byte
de 8 bits , mientras que los short e int se forman con dos bytes ( 16 bits ) y los long por cuatro bytes ( 32 bits ).
Para el manejo de dichos bits , contamos con los operadores descriptos en la TABLA 9 .

TABLA 9 OPERADORES DE MANEJO DE BITS

SIMBOLO
&
|
^
<<
>>
~

DESCRIPCION
Y AND (bit a bit)
O OR INCLUSIVA
O OR EXCLUSIVA
ROTACION A LA IZQUIER
ROTACION A LA DERECHA
COMPLEMENTO A UNO

EJEMPLO
a&b
a|b
a^b
a << b
a >> b
~a

ORDEN DE EVAL.
7
9
8
4
4
1

Describiremos mediante unos pocos ejemplos la operatoria de manejo de bits.

Analicemos primero como funciona el operador Y, tambin llamado BITWISE AND , las reglas para la operacin
son las dadas en la TABLA 10 .

TABLA 10 REGLAS PARA LA OPERACION Y (BITWISE AND)

bit a
0
0
1
1

UTN - Informtica I

&
&
&
&
&

Bit b
0
1
0
1

Capituli III

=
=
=
=
=

bit c
0
0
0
1

18

LENGUAJE C

Si suponemos tener dos variables del tipo char, una de ella de valor 85 (hex. 55 ), otra de valor 71 (hex. 47) y
realizamos el AND a nivel bits de ellas, obtendremos :
bits
0 1 0 1 0 1 0 1

decimal
85

hexadecimal
55

0 1 0 0 0 1 1 1

71

47

0 1 0 0 0 1 0 1

69

45

Ntese que la operacin es del tipo lgico entre bits, por lo que los resultados numricos tienen poco ningn
significado y slo se han puesto con el fin de ejemplificar .
De la misma manera para la operacion O INCLUSIVA, cuyas reglas se dan en la TABLA 11, ser:
TABLA 11 REGLAS PARA LA OPERACION O INCLUSIVA (BITWISE OR )
bit a

0
0
1
1

|
|
|
|

bit
b
0
1
0
1

bit c

=
=
=
=

0
1
1
1

Para las mismas variables anteriores obtendremos :

0 1 0 1 0 1 1 1 87 57
Analizando ahora la O EXCLUSIVA ( EXOR ) tendremos :

TABLA 12 REGLAS PARA LA OPERACION O EXCLUSIVA ( EXOR )

bit a
0
0
1
1

^
^
^
^
^

bit b
0
1
0
1

=
=
=
=
=

bit c
0
1
1
0

Para las mismas variables anteriores obtendremos :

0 0 0 1 0 0 1 0

UTN - Informtica I

18

12

Capituli III

19

LENGUAJE C

Veamos ahora las operaciones de desplazamiento , la sentencia

c = a << b
implica asignarle a c, el valor de a con sus bits corridos a la izquierda en b lugares , los bits que van "saliendo" por la
izquierda , se desechan ; y los bits que van quedando libres a la derecha se completan con cero .
Se procede de la misma manera para el corrimiento a la derecha >>.
El operador COMPLEMENTO A UNO es del tipo unitario , es decir que realiza una operacin sobre una nica
variable , y su efecto es dar a la variable un valor igual a restar de ( -1 ) el valor que traa . Quizs es ms visible
decir que este operador cambia los bits en 1 de la variable en 0 y viceversa.

TABLA 13 PRECEDENCIA DE LOS OPERADORES

PRECEDENCIA
0
1
2
3
4
5
6
7
8
9
10
11
12
13

OPERADORES
()[] -> .
sizeof (tipo) ! ~ ++ -- signo* &
*/%
+>
>=
== !=
&
^
|
&&
||
?:
= += -= *= etc

ASOCIATIVIDAD
izq. a derecha
derecha a izq.
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
izq. a derecha
derecha a izq.
derecha a izq.

NOTA: en el rengln de los operadores de precedencia cero hemos agregado ubicndolos a la derecha del mismo
para diferenciarlos, tres operadores , [] ->> y . que sern analizados ms adelante, de la misma manera en el rengln
siguiente hemos colocado al final a dos operadores: * y & ya que aunque coinciden en smbolo con los de
PRODUCTO y AND A NIVEL BITS, son OTRO tipo de operadores que se describirn en captulos sucesivos. En
ese mismo rengln se ha consignado como SIGNO al unitario -

UTN - Informtica I

Capituli III

20

LENGUAJE C

CAPITULO 4: PROPOSICIONES PARA EL CONTROL DE FLUJO DE

PROGRAMA

1.- INTRODUCCION
En lo que sigue de este captulo, denominaremos BLOQUE DE SENTENCIAS al conjunto de sentencias
individuales includas dentro un par de llaves. Por ejemplo :
{
sentencia 1 ;
sentencia 2 ;
.............
sentencia n ;
}
Este conjunto se comportar sintacticamente como una sentencia simple y la llave de cierre del bloque NO debe ir
seguida de punto y coma .
Un ejemplo de bloque ya visto , es el cuerpo del programa principal de la funcin main() .
main()
{
bloque de sentencias
}
En las proposiciones de control de flujo de programa , trabajaremos alternativamente con sentencias simples y
bloques de ellas .

2.- PROPOSICION IF - ELSE

Esta proposicin sirve para ejecutar ciertas sentencias de programa , si una expresin resulta CIERTA otro grupo
de sentencias, si aquella resulta FALSA. Su interpretacin literal sera : SI es CIERTA tal cosa , haga tal otra , si no
lo es saltela .
El caso ms sencillo sera :
if(expresin)
sentencia ;

if(expresin) sentencia ;
UTN - Informtica I

Capitulo IV

21

LENGUAJE C

Cuando la sentencia que sigue al IF es nica, las dos formas de escritura expresadas arriba son equivalentes . La
sentencia slo se ejecutar si el resultado de "expresin" es distinto de cero (CIERTO) , en caso contrario el
programa saltear dicha sentencia , realizando la siguiente en su flujo.
Veamos unos ejemplos de las distintas formas que puede adoptar la "expresin" dentro de un IF :

if( a > b )

if( (a > b) != 0 )

if(a)

if(a != 0)

if(!a)

if(a == 0 )

las dos expresiones son idnticas, aunque a veces

resulta ms claro expresarla de la segunda manera,
sobre todo en los primeros contactos con el lenguaje.
Las dos superiores son idnticas entre s , al igual que
las dos inferiores Obsrvese que (!a) dar un valor
CIERTO slo cuando a sea FALSO. (ver operador
NEGACION en el captulo anterior )

if( a == b )

if( a = b )

La primera es una expresin correcta , el IF se realizar

slo si a es igual a b. En cambio la segunda es un
error,ya que no se est comparando a con b , sino
ASIGNANDO el valor de esta a aquella .

/* Error */

En casos ms complejos que los anteriores , la proposicin IF puede estar seguida por un bloque de sentencias :

if(expresin)

if(expresin)

{
sentencia 1 ;
sentencia 2 ;
.............
}

sentencia 1 ;
sentencia 2 ;
...............

Las dos maneras son equivalentes , por lo que la posicin de la llave de apertura del bloque queda librada al gusto
del programador . El indentado de las sentencias (sangra) es tambin optativo , pero sumamente recomendable,
sobre todo para permitir la lectura de proposiciones muy complejas anidadas , como se ver luego.
El bloque se ejecutar en su conjunto si la expresion resulta CIERTA. El uso del ELSE es optativo , y su aplicacin
resulta en la ejecucin de una , una serie de sentencias en el caso de que la expresin del IF resulta FALSA.

UTN - Informtica I

Capitulo IV

22

LENGUAJE C

Su aplicacin puede verse en el ejemplo siguiente :

if(expresin)
{
sentencia 1 ;
sentencia 2 ;
}
sentencia 3 ;
sentencia 4 ;
sentencia 5 ;

if(expresin)
{
sentencia 1 ;
sentencia 2 ;
}
else
{
sentencia 3 ;
sentencia 4 ;
}
sentencia 5 ;

En el ejemplo de la izquierda no se usa el ELSE y por lo tanto las sentencias 3 , 4 y 5 se ejecutan siempre . En el
segundo caso , las sentencias 1 y 2 se ejecutan solo si la expresin es CIERTA , en ese caso las 3 y 4 NO se
ejecutarn para saltarse directamente a la 5 , en el caso de que la expresin resulte FALSA se realizarn las 3 y 4 en
lugar de las dos primeras y finalmente la 5 .
La proposicin ELSE queda siempre asociada al IF ms cercano , arriba de l .
Es comn tambin , en caso de decisiones mltiples , el uso de anidamientos ELSE-IF de la forma indicada abajo:

if(exp.1)

if(exp.1)

sentencia1 ;

sentencia1 ;

else if(exp.2)
sentencia2 ;

else if(exp.2)
sentencia2 ;

else if(exp.3)
sentencia3 ;
else
sentencia5 ;

else if(exp.3)
sentencia3 ;
else
sentencia5 ;

Si bin se suele escribir segn la modalidad de la izquierda , a la derecha hemos expresado las asociaciones entre los
distintos ELSE IF por medio del indentado del texto.

UTN - Informtica I

Capitulo IV

23

LENGUAJE C

3.- PROPOSICION SWITCH

El SWITCH es una forma sencilla de evitar largos , tediosos y confusos anidamientos de ELSE-IF .
Supongamos que estamos implementando un Menu , con varias elecciones posibles . El esqueleto de una posible
solucin al problema usando if-else podra ser el siguiente :

#include <<stdio.h>>
main()
{
int c ;
printf("\nMENU :") ;
printf("\n
A = ADICIONAR A LA LISTA ") ;
printf("\n
B = BORRAR DE LA LISTA ") ;
printf("\n
O = ORDENAR LA LISTA ") ;
printf("\n
I = IMPRIMIR LA LISTA ") ;
printf("\n\nESCRIBA SU SELECCION , Y LUEGO <<ENTER>> : ") ;
if( (c = getchar()) != '\n' )
{
if( c == 'A')
printf("\nUD. SELECCIONO AGREGAR") ;
else
if( c == 'B')
printf("\nUD. SELECCIONO BORRAR") ;
else
if( c == 'O' )
printf("\nUD. SELECCIONO ORDENAR") ;
else
if( c == 'I' )
printf("\nUD. SELECCIONO IMPRIMIR") ;
else
printf("\n\a\aUD. APRETO UN CARACTER ILEGAL" ) ;
}
else
printf("\n UD. NO HA SELECCIONADO NADA !" ) ;
}

Como es fcil de ver , cuando las opciones son muchas, el texto comienza a hacerse difcil de entender y engorroso
de escribir.
El mismo programa, utilizando un SWITCH , quedara mucho ms claro de leer, y sencillo de escribir, como se
aprecia en el EJEMPLO siguiente.

UTN - Informtica I

Capitulo IV

24

LENGUAJE C

#include <stdio.h>
#include <conio.h>
main()
{
int c ;
printf("\nMENU :") ;
printf("\n
A = ADICIONAR A LA LISTA ") ;
printf("\n
B = BORRAR DE LA LISTA ") ;
printf("\n
O = ORDENAR LA LISTA ") ;
printf("\n
I = IMPRIMIR LA LISTA ") ;
printf("\n\nESCRIBA SU SELECCION , Y LUEGO <<ENTER>> : ") ;
c = getchar() ;
switch (c)
{
case 'A' :
printf("\nUD. SELECCIONO AGREGAR") ;
break ;
case 'B' :
printf("\nUD. SELECCIONO BORRAR") ;
break ;
case 'O' :
printf("\nUD. SELECCIONO ORDENAR") ;
break ;
case 'I' :
printf("\nUD. SELECCIONO IMPRIMIR") ;
break ;
case '\n':
printf("\n UD. NO HA SELECCIONADO NADA !" ) ;
break ;
default :
printf("\n\a\aUD. APRETO UN CARACTER ILEGAL" ) ;
break ;
}
}
El SWITCH empieza con la sentencia : switch (expresin) . La expresin contenida por los parntesis debe ser
ENTERA , en nuestro caso un caracter ; luego mediante una llave abre el bloque de las sentencias de comparacin .
Cada una de ellas se representa por la palabra clave "case" seguida por el valor de comparacin y terminada por dos
puntos . Seguidamente se ubican las sentencias que se quieren ejecutar , en el caso que la comparacin resulte
CIERTA . En el caso de resultar FALSA , se realizar la siguiente comparacin , y as sucesivamente .
Prestemos atencin tambien a la sentencia BREAK con la que se termina cada CASE. Una caracterstica poco obvia
del SWITCH , es que si se eliminan los BREAK del programa anterior , al resultar CIERTA una sentencia de
comparacin, se ejecutarn las sentencias de ese CASE particular pero TAMBIEN la de todos los CASE por debajo
del que ha resultado verdadero.

UTN - Informtica I

Capitulo IV

25

LENGUAJE C
Quizs se aclare esto diciendo que , las sentencias propias de un CASE se ejecutarn si su comparacin otra
comparacin ANTERIOR resulta CIERTA . La razn para este poco "juicioso" comportamiento del SWITCH es
que as se permite que varias comparaciones compartan las mismas sentencias de programa , por ejemplo :
.................
case 'X' :
case 'Y' :
case 'Z' :
printf(" UD. ESCRIBIO X , Y , Z ") ;
break ;
..................
La forma de interrumpir la ejecucin luego de haber encontrado un CASE cierto es por medio del BREAK , el que
d por terminado el SWITCH .
Al final del bloque de sentencias del SWITCH , aparece una optativa llamada DEFAULT , que implica : si no se ha
cumplido ningun CASE , ejecute lo que sigue. Es algo superfluo poner el BREAK en este caso , ya que no hay ms
sentencias despues del DEFAULT , sin embargo , como el orden en que aparecen las comparaciones no tiene
importancia para la ejecucin de la instruccin, puede suceder que en futuras correcciones del programa se agregue
algn nuevo CASE luego del DEFAULT , por lo que es conveniente preveerlo , agregando el BREAK , para evitar
errores de laboriosa ubicacin .
Ms adelante volveremos sobre otros usos del BREAK.

4.- LA ITERACION WHILE

El WHILE es una de las tres iteraciones posibles en C . Su sintaxis podra expresarse de la siguiente forma :
while(expresion)
proposicin 1 ;

while(expresin) {
proposicin 1 ;
proposicin 2 ;
...............
proposicin n ;
}
Esta sintaxis expresada en palabras significaria: mientras (expresin) d un resultado CIERTO ejectese la
proposicin 1 , en el caso de la izquierda ejectese el bloque de sentencias , en el caso de la derecha.
Por lo general , dentro de la proposicin del bloque de ellas , se modifican trminos de la expresin condicional ,
para controlar la duracin de la iteracin .

5.- LA ITERACION DO - WHILE

Su sintaxis ser :
do {
proposicin 1 ;
proposicin 2 ;
...............
} while (expresin) ;
Expresado en palabras , esto significa : ejecute las proposiciones , luego repita la ejecucin mientras la expresin d
un resultado CIERTO . La diferencia fundamental entre esta iteracin y la anterior es que el DO-WHILE se ejecuta
siempre AL MENOS una vez , sea cual sea el resultado de expresin.
UTN - Informtica I

Capitulo IV

26

LENGUAJE C

6.- ITERACION FOR

El FOR es simplemente una manera abreviada de expresar un WHILE , veamos su sintaxis :
for ( expresin1 ; expresin2 ; expresion3 ) {
proposicin1 ;
proposicin2 ;
..............}
Esto es equivalente a :
expresin1 ;
while ( expresin2 ) {
proposicin1 ;
proposicin2 ;
..............
expresion3 ;
}
La expresin1 es una asignacin de una ms variables , (equivale a una inicializacin de las mismas ) , la
expresin2 es una relacin de algun tipo que , mientras d un valor CIERTO , permite la iteracin de la ejecucin y
expresin3 es otra asignacin , que comunmente vara alguna de las variables contenida en expresin2 .
Todas estas expresiones , contenidas en el parntesis del FOR deben estar separadas por PUNTO Y COMA y NO
por comas simples .
No es imprescindible que existan TODAS las expresiones dentro del parntesis del FOR , pudiendose dejar en
blanco algunas de ellas , por ejemplo :
for ( ; exp2 ; exp3)
for (exp1 ; ; )

for ( ; ; )
Estas dos ltimas expresines son interesantes desde el punto de vista de su falta de trmino relacional , lo que
implica que el programador deber haber previsto alguna manera alternativa de salir del lazo ( probablemente
mediante BREAK RETURN como veremos ms adelante ) ya que sin , la ejecucin del mismo es infinita ( tan
larga como se mantenga encendida la computadora ) .

UTN - Informtica I

Capitulo IV

27

LENGUAJE C
7.- LA SENTENCIA BREAK
El BREAK , ya brevemente descripto con el SWITCH , sirve tambin para terminar loops producidos por WHILE ,
DO-WHILE y FOR antes que se cumpla la condicin normal de terminacin . En el EJEMPLO siguiente vemos su
uso para terminar un WHILE indeterminado.
#include <stdio.h>
#include <conio.h>
main()
{
char c ;
printf("ESTE ES UN LOOP INDEFINIDO ") ;
while(1) {
printf( "DENTRO DEL LOOP INDEFINIDO (apriete una tecla):" ) ;
if( (c = getch()) == 'Q' )
break ;
printf( "\nNO FUE LA TECLA CORRECTA PARA ABANDONAR EL LOOP ") ;
}
printf("\nTECLA CORRECTA : FIN DEL WHILE ") ;
}

Obsrvese que la expresin while(1) SIEMPRE es cierta , por lo que el programa correr imparable hasta que el
operador oprima la tecla "secreta" Q . Esto se consigue en el IF , ya que cuando c es igual al ASCII Q se ejecuta la
instruccin BREAK ,dando por finalizado el WHILE .
El mismo criterio podra aplicarse con el DO-WHILE con FOR , por ejemplo haciendo
for (;;) {
............
if( expresin )
break ;
}

/* loop indefinido */
/* ruptura del loop cuando expresin sea verdadera */

8.- LA SENTENCIA CONTINUE

La sentencia CONTINUE es similar al BREAK con la diferencia que en vez de terminar violentamente un loop ,
termina con la realizacin de una iteracin particular y permitiendo al programa continuar con la siguiente.

9.- LA FUNCION EXIT()

La funcin EXIT() tiene una operatoria mucho ms drastica que las anteriores , en vez de saltear una iteracin
abandonar un lazo de programa , esta abandona directamente al programa mismo dndolo por terminado . Realiza
tambin una serie de operaciones tiles como ser , el cerrado de cualquier archivo que el programa hubiera abierto ,
el vaciado de los buffers de salida , etc.

UTN - Informtica I

Capitulo IV

28

LENGUAJE C
Normalmente se la utiliza para abortar los programas en caso de que se est por cometer un error fatal inevitable .
Mediante el valor que se le ponga en su argumento se le puede informar a quien haya llamado al programa ( Sistema
Operativo , archivo .bat , u otro programa ) el tipo de error que se cometi.

10.- SENTENCIA GOTO

Si Ud. se ha admirado de que C tenga la operacin GOTO , recuerde que el hecho de existir NO lo obliga a usarla ,
en el mismo sentido que por tener puertas los aviones no est obligado a saltar por ellas en pleno vuelo.
El uso del GOTO implica un salto incondicional de un lugar a otro del programa . Esta prctica hace que los
programas sean muy dificiles de corregir mantener.
Si no quedara ms remedio que usarlo, (y en programacin estructurada SIEMPRE hay remedio) debe marcarse el
destino del salto mediante un nombre seguido por dos puntos .
if( c == 0 ) goto OTRO_LADO ;
.............................
OTRO_LADO:
printf(........
En este caso si c es cero se saltean todas las sentencias entre el if y el destino , continuandose con la ejecucin del
printf() . El destino puede ser tanto posterior como anterior al GOTO invocante .

UTN - Informtica I

Capitulo IV

29

LENGUAJE C

CAPITULO 5: FUNCIONES
1.- INTRODUCCION
La forma ms razonable de encarar el desarrollo de un programa complicado es aplicar lo que se ha dado en llamar
"Programacin Top - Down" .
Esto implica que, luego de conocer cual es la meta a alcanzar, se subdivide esta en otras varias tareas concurrentes,
por ejemplo :
Leer un teclado, procesar datos, mostrar los resultados .
Luego a estas se las vuelve a dividir en otras menores :
Y as se contina hasta llegar a tener un gran conjunto de pequeas y simples tareas, del tipo de "leer una tecla"
"imprimir un caracter".
Luego slo resta abocarse a resolver cada una de ellas por separado.
De esta forma el programador, slo se las tendr que ver con diminutas piezas de programa, de pocas lineas, cuya
escritura y correccin posterior es una tarea simple.
Tal es el criterio con que est estructurado el lenguaje C, donde una de sus herramientas fundamentales sn las
funciones. Todo compilador comercial trae una gran cantidad de Librerias de toda ndole, matematicas, de entrada salida, de manejo de textos, de manejo de grficos, etc, que solucionan la mayor parte de los problemas bsicos de
programacin .
Sin embargo ser inevitable que en algn momento tenga que crear mis propias funciones, las reglas para ello son
las que desarrollaremos en este captulo .
Comencemos con algunos conceptos bsicos: para hacer que las instrucciones contenidas en una funcin, se
ejecuten en determinado momento, no es necesario ms que escribir su nombre como una linea de sentencia en mi
programa. Convencionalmente en C los nombres de las funciones se escriben en minscula y siguen las reglas dadas
anteriormente para los de las variables, pero deben ser seguidos, para diferenciarlas de aquellas por un par de
parntesis .
Dentro de estos parntesis estarn ubicados los datos que se les pasan a las funciones. Est permitido pasarles uno,
ninguno una lista de ellos separados por comas, por ejemplo: pow10( a ), getch(), strcmp( s1, s2 ) .
Un concepto sumamente importante es que los argumentos que se les envan a las funciones son los VALORES de
las variables y NO las variables mismas. En otras palabras, cuando se invoca una funcin de la forma pow10( a ) en
realidad se est copiando en el "stack" de la memoria el valor que tiene en ese momento la variable a, la funcin
podr usar este valor para sus clculos, pero est garantizado que los mismos no afectan en absoluto a la variable en
s misma.
Como veremos ms adelante, es posible que una funcin modifique a una variable, pero para ello, ser necesario
comunicarle la DIRECCION EN MEMORIA de dicha variable .
Las funciones pueden no devolver valores al programa invocante. Hay funciones que tan slo realizan acciones,
como por ejemplo clrscr(), que borra la pantalla de video, y por lo tanto no retornan ningun dato de inters; en
cambio otras efectuan clculos, devolviendo los resultados de los mismos.
La invocacin a estos dos tipos de funciones difiere algo, por ejemplo escribiremos :
clrscr() ;
c = getch() ;
donde en el segundo caso el valor retornado por la funcin se asigna a la variable c. Obviamente sta deber tener el
tipo correcto para alojarla .
UTN - Informtica I

Capitulo V

- 30 -

LENGUAJE C

2.- DECLARACION DE FUNCIONES

Antes de escribir una funcin es necesario informarle al Compilador los tamaos de los valores que se le enviarn en
el stack y el tamao de los valores que ella retornar al programa invocante .
Estas informaciones estn contenidas en la DECLARACION del PROTOTIPO DE LA FUNCION.
Formalmente dicha declaracin queda dada por :
tipo del valor de retorno nombre_de_la_funcin(lista de tipos de parmetros)
Pongamos algunos ejemplos :
float mi_funcion(int i, double j ) ;
double otra_funcion(void) ;
void la_ultima(long double z, char y, int x, unsigned long w) ;
El primer trmino del prototipo da, como hemos visto el tipo del dato retornado por la funcin; en caso de obviarse
el mismo se toma, por omisin, el tipo int. Sin embargo, aunque la funcin devuelva este tipo de dato, para evitar
malas interpretaciones es conveniente explicitarlo .
Ya que el "default" del tipo de retorno es el int, debemos indicar cuando la funcin NO retorna nada, esto se realiza
por medio de la palabra VOID ( sin valor).
De la misma manera se acta, cuando no se le enviarn argumentos.
Ms adelante se profundizar sobre el tema de los argumentos y sus caractersticas.
La declaracin debe anteceder en el programa a la definicin de la funcin. Es normal, por razones de legibilidad de
la documentacin, encontrar todas las declaraciones de las funciones usadas en el programa, en el HEADER del
mismo, junto con los include de los archivos *.h que tienen los prototipos de las funciones de Librera.
Si una ms de nuestras funciones es usada habitualmente, podemos disponer su prototipo en un archivo de texto, e
incluirlo las veces que necesitemos, segn se vio en captulos previos.

3.- DEFINICION DE LAS FUNCIONES

La definicin de una funcin puede ubicarse en cualquier lugar del programa, con slo dos restricciones: debe
hallarse luego de dar su prototipo, y no puede estar dentro de la definicin de otra funcin ( incluida main() ). Es
decir que a diferencia de Pascal, en C las definiciones no pueden anidarse.
NOTA: no confundir definicin con llamada; una funcin puede llamar a tantas otras como desee .

UTN - Informtica I

Capitulo V

- 31 -

LENGUAJE C
La definicin debe comenzar con un encabezamiento, que debe coincidir totalmente con el prototipo declarado para
la misma, y a continuacin del mismo, encerradas por llaves se escribirn las sentencias que la componen; por
ejemplo:
#include <stdio.h>
float mi_funcion(int i, double j ); /* DECLARACION observe que termina en ";" */
main()
{
float k ;
int p ;
double z ;
...........
k = mi_funcion( p, z );
/* LLAMADA a la funcin */
...........
}
/* fin de la funcin main() */
float mi_funcion(int i, double j ) /* DEFINICION observe que NO lleva ";" */
{
float n
...................
printf("%d", i );
/* LLAMADA a otra funcin */
...................
return ( 2 * n );
/* RETORNO devolviendo un valor float */
}
Pasemos ahora a describir ms puntualmente las distintas modalidades que adoptan las funciones .

4.- FUNCIONES QUE NO RETORNAN VALOR NI RECIBEN PARAMETROS

Veamos como ejemplo la implementacion de una funcion "pausa"
#include <stdio.h>
void pausa(void) ;
main()
{
int contador = 1;
printf("VALOR DEL CONTADOR DENTRO DEL while \n");
while (contador <= 10) {
if(contador == 5 ) pausa();
printf("%d\n", contador++);
}
pausa() ;
printf("VALOR DEL CONTADOR LUEGO DE SALIR DEL while: %d", contador) ;
return 0;
}
void pausa(void)
{
char c ;
printf("\nAPRIETE ENTER PARA CONTINUAR ") ;
while( (c = getchar()) != '\n') ;
}

UTN - Informtica I

Capitulo V

- 32 -

LENGUAJE C
Analicemos lo hecho, en la segunda linea hemos declarado la funcin pausa, sin valor de retorno ni parmetros.
Luego esta es llamada dos veces por el programa principal, una cuando contador adquiere el valor de 5 (antes de
imprimirlo) y otra luego de finalizar el loop.
Posteriormente la funcin es definida. El bloque de sentencias de la misma est compuesto, en este caso particular,
por la definicin de una variable c, la impresin de un mensaje de aviso y finalmente un while que no hace nada,
solo espera recibir un caracter igual a <ENTER>.
En cada llamada, el programa principal transfiere el comando a la funcin, ejecutandose, hasta que sta finalice, su
propia secuencia de instrucciones. Al finalizar la funcin esta retorna el comando al programa principal,
continuandose la ejecucin por la instruccin que sucede al llamado .
Si bien las funciones aceptan cualquier nombre, es una buena tcnica de programacin nombrarlas con trminos que
representen, aunque sea vagamente, su operatoria .
Se puede salir prematuramente de una funcin void mediante el uso de RETURN, sin que este sea seguido de
ningun parmetro valor .

5.- FUNCIONES QUE RETORNAN VALOR

Analicemos por medio de un ejemplo dichas funciones :
#include <stdio.h>
#include <conio.h>
#define FALSO 0
#define CIERTO 1
int finalizar(void);
int lea_char(void) ;
main()
{
int i = 0;
int fin = FALSO;
printf("Ejemplo de Funciones que retornan valor\n");
while (fin == FALSO) {
i++;
printf("i == %d\n", i);
fin = finalizar();
}
printf("\n\nFIN DEL PROGRAMA........");
return 0;
}
int finalizar(void)
{
int c;
printf("Otro nmero ? (s/n) ");
do {
c = lea_char() ;
} while ((c != 'n') && (c != 's'));
return (c == 'n');
}
int lea_char(void)
{
int j ;
if( (j = getch()) >>= 'A' && j <<= 'Z' )
return( j + ( 'a' - 'A') ) ;
else
return j ;}
UTN - Informtica I

Capitulo V

- 33 -

LENGUAJE C

Analicemos paso a paso el programa anterior; las dos primeras lineas incluiran, en el programa los prototipos de las
funciones de librera usadas, ( en este caso printf() y getch() ). En las dos siguientes damos nombres simblicos a
dos constantes que usaremos en las condiciones lgicas y posteriormente damos los prototipos de dos funciones que
hemos creado.
Podran haberse obviado, en este caso particular, estas dos ltimas declaraciones, ya que ambas retornan un int
(default), sin embargo el hecho de incluirlas har que el programa sea ms facilmente comprensible en el futuro.
Comienza luego la funcin main(), inicializando dos variables, i y fin, donde la primera nos servir de contador y la
segunda de indicador lgico. Luego de imprimir el rtulo del programa, entramos en un loop en el que
permaneceremos todo el tiempo en que fin sea FALSO.
Dentro de este loop, incrementamos el contador, lo imprimimos, y asignamos a fin un valor que es el retorno de la
funcin finalizar() .
Esta asignacin realiza la llamada a la funcin, la que toma el control del flujo del programa, ejecutando sus propias
instrucciones.
Saltemos entonces a analizar a finalizar(). Esta define su variable propia, c, (de cuyas propiedades nos ocuparemos
ms adelante) y luego entra en un do-while, que efecta una llamada a otra funcin, lea_char(), y asigna su retorno a
c iterando esta operativa si c no es 'n' 's', note que: c != 'n' && c != 's' es equivalente a: !( c == 'n' || c == 's' ) .
La funcin lea_char() tiene como misin leer un caracter enviado por el teclado, ( lo realiza dentro de la expresin
relacional del IF ) y salvar la ambigedad del uso de maysculas minsculas en las respuestas, convirtiendo las
primeras en las segundas. Es facil de ver que, si un caracter esta comprendido entre A y Z, se le suma la diferencia
entre los ASCII de las minsculas y las maysculas ( 97 - 65 = 32 ) para convertirlo, y luego retornarlo al invocante.
Esta conversin fu incluida a modo de ejemplo solamente, ya que existe una de Librera, tolower() declarada en
ctype.h, que realiza la misma tarea.
Cuando lea_char() devuelva un caracter n s, se saldr del do-while en la funcin finalizar() y se retornar al
programa principal, el valor de la comparacin lgica entre el contenido de c y el ASCII del caracter n. Si ambos son
iguales, el valor retornado ser 1 (CIERTO) y en caso contrario 0 ( FALSO ) .
Mientras el valor retornado al programa principal sea FALSO, este permanecer dentro de su while imprimiendo
valores sucesivos del contador, y llamadas a las funciones, hasta que finalmente un retorno de CIERTO ( el operador
presion la tecla n) hace terminar el loop e imprimir el mensaje de despedida.
Nota: preste atencin a que en la funcin finalizar() se ha usado un do-while .Cmo modificara el programa para
usar un while ?. En la funcin lea_char se han usado dos returns, de tal forma que ella sale por uno u otro. De esta
manera si luego de finalizado el else se hubiera agregado otra sentencia, esta jams sera ejecutada.
En el siguiente ejemplo veremos funciones que retornan datos de tipo distinto al int.
Debemos presentar antes, otra funcin muy comn de entrada de datos: scanf(), que nos permitir leer datos
completos (no solo caracteres) enviados desde el teclado, su expresin formal es algo similar a la del printf() ,
scanf("secuencia de control", direccin de la variable ) ;

UTN - Informtica I

Capitulo V

- 34 -

LENGUAJE C

Donde en la secuencia de control se indicar que tipo de variable se espera leer, por ejemplo :
%d si se desea leer un entero decimal (int)
%o " " " " " " octal
"
%x " " " " " " hexadecimal "
%c " " " " " caracter
%f leer un flot
%ld leer un long int
%lf leer un double
%Lf leer un long double
Por "direccin de la variable" deber entenderse que se debe indicar, en vez del nombre de la variable en la que se
cargar el valor leido, la direccin de su ubicacin en la memoria de la mquina. Esto suena sumamente apabullante,
pero por ahora solo diremos, (ms adelante abundaremos en detalles ) que para ello es necesario simplemente
anteponer el signo & al nombre de la misma .
As, si deseo leer un entero y guardarlo en la variable "valor_leido" escribir: scanf("%d",&valor_leido); en cambio
si deseara leer un entero y un valor de punto flotante ser: scanf("%d %f", &valor_entero, &valor_punto_flotante) ;
El tipo de las variables deber coincidir EXACTAMENTE con los expresados en la secuencia de control, ya que de
no ser as, los resultados son impredecibles.
Por supuesto esta funcin tiene muchsimas ms opciones, ( consulte el Manual de Librerias de su Compilador, si
tiene curiosidad ) sin embargo, por simplicidad, por ahora nos conformaremos con las antedichas.
El prototipo de scanf() esta declarado en stdio.h .
Usaremos tambin otra funcin, ya citada, clrscr(). Recordemos que esta es solo vlida para mquinas tipo PC
compatibles y no corre bajo Windows.
Encaremos ahora un programa que nos presente primero, un men para seleccionar la conversin de C a Fahrenheit
de centmetros a pulgadas, hecha nuestra eleccin, nos pregunte el valor a convertir y posteriormente nos de el
resultado .
Si suponemos que las funciones que usaremos en el programa sern frecuentemente usadas, podemos poner las
declaraciones de las mismas, as como todas las contantes que usen, en un archivo texto, por ejemplo convers.h. Este
podr ser guardado en el subdirectorio donde estn todos los dems (INCLUDE) dejado en el directorio activo, en
el cual se compila el programa fuente de nuestro problema. Para variar, supongamos que esto ltimo es nuestro caso
CONVERS.H

#include <conio.h>
#define FALSO 0
#define CIERTO 1
#define CENT_POR_INCH 25.4
void pausa(void)
;
void mostrar_menu(void)
;
int seleccion(void)
;
void cm_a_pulgadas(void)
;
void grados_a_fahrenheit(void) ;
double leer_valor(void)
;

UTN - Informtica I

Capitulo V

- 35 -

LENGUAJE C

Vemos que un Header puede incluir llamadas a otros (en este caso conio.h). Hemos puesto tambien la definicin de
todas las constantes que usaran las funciones abajo declaradas. De dichas declaraciones vemos que usaremos
funciones que no retornan nada, otra que retorna un entero y otra que devuelve un double .
Veamos ahora el desarrollo del programa en s. Observe que la invocacin a conversin.h se hace con comillas, por
haber decidido dejarlo en el directorio activo .

#include <stdio.h>
#include "convers.h"
main()
{
int fin = FALSO;
while (!fin) {
mostrar_menu();
switch(seleccion()) {
case 1:
cm_a_pulgadas();
break;
case 2:
grados_a_fahrenheit();
break;
case 3:
fin = CIERTO;
break;
default:
printf("\nError en la Seleccion!\a\a\n");
pausa() ;
}
}
return 0;}
/* Funciones */
void pausa(void)
{
char c = 0;
printf("\n\n\nAPRIETE ENTER PARA CONTINUAR ") ;
while( (c = getch()) != '\r') ;
}
void mostrar_menu(void)
{
clrscr();
printf("\n
Menu\n");
printf("---------------------------\n");
printf("1: Centimetros a pulgadas\n");
printf("2: Celsius a Fahrenheit\n");
printf("3: Terminar\n");
}
UTN - Informtica I

Capitulo V

- 36 -

LENGUAJE C

int seleccion(void)
{
printf("\nEscriba el nmero de su Seleccin: ");
return (getche() - '0');
}

void cm_a_pulgadas(void)
{
double centimetros; /* Guardar el valor pasado por leer_valor() */
double pulgadas ; /* Guardar el valor calculado */
printf("\nEscriba los Centimetros a convertir: ");
centimetros = leer_valor();
pulgadas = centimetros * CENT_POR_INCH;
printf("%.3f Centimetros = %.3f Pulgadas\n", centimetros, pulgadas);
pausa() ;
}
void grados_a_fahrenheit(void)
{
double grados; /* Guardar el valor pasado por leer_valor() */
double fahrenheit ; /* Guardar el valor calculado */
printf("\nEscriba los Grados a convertir: ");
grados = leer_valor();
fahrenheit = (((grados * 9.0)/5.0) + 32.0) ;
printf("%.3f Grados = %.3f Fahrenheit", grados, fahrenheit);
pausa();
}
double leer_valor(void)
{
double valor; /* Variable para guardar lo leido del teclado */
scanf("%lf", &valor);
return valor;
}

Veamos que hemos hecho: primero incluimos todas las definiciones presentes en el archivo convers.h que habiamos
previamente creado. Luego main() entra en un loop, que finalizar cuando la variable fin tome un valor CIERTO, y
dentro del cual lo primero que se hace es llamar a mostrar_men(), que pone los rtulos de opciones .
Luego se entra en un SWITCH que tiene como variable ,el retorno de la funcin seleccin() (recuerde que tiene que
ser un entero), segn sea ste se saldr por alguno de los tres CASE. Observe que seleccin() lee el teclado mediante
un getche(), (similar a getch() antes descripta, pero con la diferencia que aquella hace eco del caracter en la pantalla)
y finalmente devuelve la diferencia entre el ASCII del nmero escrito menos el ASCII del nmero cero, es decir, un
entero igual numericamente al valor que el operador quizo introducir .
Si este fue 1, el SWITCH invoca a la funcin cm_a_pulgadas() y en caso de ser 2 a grados_a_fahrenheit() .
Estas dos ltimas proceden de igual manera: indican que se escriba el dato y pasan el control a leer_valor(), la que
mediante scanf() lo hace, retornando en la variable valor, un double, que luego es procesado por aquellas
UTN - Informtica I

Capitulo V

- 37 -

LENGUAJE C
convenientemente. Como hasta ahora la variable fin del programa principal no ha sido tocada, y por lo tanto
continua con FALSO ,la iteracin del while sigue realizandose, luego que se ejecuta el BREAK de finalizacin del
CASE en cuestin. En cambio, si la seleccin() hubiera dado un resultado de tres, el tercer case, la convierte en
CIERTO, con lo que se finaliza el WHILE y el programa termina.
Vemos en este ejemplo, la posibilidad de mltiples llamados a funciones, una llama a otra, que a su vez llama a otra,
la cual llama a otra, etc ,etc, dando un esquema de flujo de programa de la forma :

6.- AMBITO DE LAS VARIABLES (SCOPE)

VARIABLES GLOBALES

Hasta ahora hemos diferenciado a las variable segun su "tipo" (int, char double, etc), el cual se refera, en ltima
instancia, a la cantidad de bytes que la conformaban. Veremos ahora que hay otra diferenciacin de las mismas, de
acuerdo a la clase de memoria en la que residen .
Si definimos una variable AFUERA de cualquier funcin (incluyendo esto a main() ), estaremos frente a lo
denominado VARIABLE GLOBAL. Este tipo de variable ser ubicada en el segmento de datos de la memoria
utilizada por el programa, y existir todo el tiempo que est ejecutandose este .
Este tipo de variables son automaticamente inicializadas a CERO cuando el programa comienza a ejecutarse .
Son accesibles a todas las funciones que esten declaradas en el mismo, por lo que cualquiera de ellas podr actuar
sobre el valor de las mismas.
Por ejemplo :
#include <stdio.h>
double una_funcion(void);
double variable_global ;
main()
{
double i ;
printf("%f", variable_global );
/* se imprimir 0 */
i = una_funcion() ;
printf("%f", i );
/* se imprimir 1 */
printf("%f", variable_global );
/* se imprimir 1 */
variable_global += 1 ;
printf("%f", variable_global );
/* se imprimir 2 */
return 0 ;
}
double una_funcion(void)
{
return( variable_global += 1) ;
}

Observemos que la variable_global est definida afuera de las funciones del programa, incluyendo al main(), por lo
que le pertenece a TODAS ellas. En el primer printf() del programa principal se la imprime, demostrandose que est
automaticamente inicializada a cero .

UTN - Informtica I

Capitulo V

- 38 -

LENGUAJE C
Luego es incrementada por una_funcion() que devuelve ademas una copia de su valor, el cual es asignado a i ,la que,
si es impresa mostrar un valor de uno, pero tambien la variable_global ha quedado modificada, como lo demuestra
la ejecucin de la sentencia siguiente. Luego main() tambien modifica su valor , lo cual es demostrado por el printf()
siguiente.
Esto nos permite deducir que dicha variable es de uso pblico, sin que haga falta que ninguna funcin la declare,
para actuar sobre ella.

Las globales son a los dems tipos de variables, lo que el GOTO es a los otros tipos de sentencias .
Puede resultar muy difcil evaluar su estado en programas algo complejos, con mltiples llamados condicionales a
funciones que las afectan, dando comunmente orgen a errores muy engorrosos de corregir .

VARIABLES LOCALES

A diferencia de las anteriores, las variables definidas DENTRO de una funcin, son denominadas VARIABLES
LOCALES a la misma, a veces se las denomina tambin como AUTOMATICAS, ya que son creadas y destrudas
automaticamente por la llamada y el retorno de una funcin, respectivamente .
Estas variables se ubican en la pila dinmica (stack) de memoria ,destinandosele un espacio en la misma cuando se
las define dentro de una funcin, y borrndose cuando la misma devuelve el control del programa, a quien la haya
invocado.
Este mtodo permite que, aunque se haya definido un gran nmero de variables en un programa, estas no ocupen
memoria simultaneamente en el tiempo, y solo vayan incrementando el stack cuando se las necesita, para luego, una
vez usadas desaparecer, dejando al stack en su estado original .
El identificador nombre que se la haya dado a una variable es slo relevante entonces, para la funcin que la haya
definido, pudiendo existir entonces variables que tengan el mismo nombre, pero definidas en funciones distintas, sin
que haya peligro alguno de confusin .
La ubicacin de estas variables locales, se crea en el momento de correr el programa, por lo que no poseen una
direccin prefijada, esto impide que el compilador las pueda inicializar previamente. Recuerdese entonces que, si no
se las inicializa expresamente en el momento de su definicin, su valor ser indeterminado (basura) .
VARIABLES LOCALES ESTATICAS

Las variables locales vistas hasta ahora, nacen y mueren con cada llamada y finalizacin de una funcin, sin
embargo muchas veces sera util que mantuvieran su valor, entre una y otra llamada a la funcin sin por ello perder
su mbito de existencia, es decir seguir siendo locales slo a la funcin que las defina. En el siguiente ejemplo
veremos que esto se consigue definiendo a la variable con el prefacio static.
VARIABLES DE REGISTRO

Otra posibilidad de almacenamiento de las variables locales es, que en vez de ser mantenidas en posiciones de la
memoria de la computadora, se las guarde en registros internos del Microprocesador que conforma la CPU de la
misma .

UTN - Informtica I

Capitulo V

- 39 -

LENGUAJE C
De esta manera el acceso a ellas es mucho ms directo y rpido, aumentando la velocidad de ejecucin del
programa. Se suelen usar registros para almacenar a los contadores de los FOR, WHILE, etc.
Lamentablemente, en este caso no se puede imponer al compilador, este tipo de variable, ya que no tenemos control
sobre los registros libres en un momento dado del programa, por lo tanto se SUGIERE, que de ser posible, ubique la
variable del modo descripto. El prefacio en ste caso ser :
register int var_reg ;
Hay que recalcar que esto es slo vlido para variables LOCALES, siendo imposible definir en un registro a una
global. Por otra parte las variables de registro no son accesibles por direccin, como se ver ms adelante .
VARIABLES EXTERNAS

Al DEFINIR una variable, como lo hemos estado haciendo hasta ahora, indicamos al compilador que reserve para la
misma una determinada cantidad de memoria, (sea en el segmento de memoria de datos, si es global en el stack, si
es local), pero debido a que en C es normal la compilacin por separado de pequeos mdulos, que componen el
programa completo, puede darse el caso que una funcin escrita en un archivo dado, deba usar una variable global
definida en otro archivo. Bastar para poder hacerlo, que se la DECLARE especificando que es EXTERNA a dicho
mdulo, lo que implica que est definida en otro lado .
Supongamos que nuestro programa est compuesto por slo dos mdulos: mod_prin.c y mod_sec.c los cuales se
compilarn y enlazarn juntos, por medio del compilador y el linker, por ejemplo corriendo: bcc mod_prin.c
mod_sec.c si usaramos el compilador de Borland .
Si en el primer mdulo (mod_prin.c) aparece una variable global, definida como
double var1 = 5 ;
El segundo mdulo, ubicado en un archivo distinto de aquel, podr referenciarla mediante la declaracin de la
misma :
extern double var1 ;
Notes que la inializacin de la variable slo puede realizarse en su DEFINICION y no en la declaracin. Esta
ltima, no reserva memoria para la variable sino que slo hace mencin que la misma ha sido definida en otro lado .
Ser finalmente el Linker el que resuelva los problemas de direccionamiento de la variable al encadenar los dos
mdulos compilados .

7.- ARGUMENTOS Y PARAMETROS DE LAS FUNCIONES

Supongamos que en un determinado programa debemos calcular repetidamente el valor medio de dos variables, una
solucin razonable sera crear una funcin que realice dicho clculo, y llamarla cada vez que se necesite. Para ello
ser necesario, en cada llamada, pasarle los valores de las variables para que calcule su valor medio. Esto se define
en la declaracin de la funcion especificando, no solo su valor de retorno sino tambin el tipo de argumentos que
recibe :
double valor_medio(double x, double y) ;
de esta declaracin vemos que la funcin valor_medio recibe dos argumentos ( x e y ) del tipo double y devuelve un
resultado de ese mismo tipo .

UTN - Informtica I

Capitulo V

- 40 -

LENGUAJE C
Cuando definamos a la funcin en s, deberemos incluir parmetros para que alberguen los valores recibidos, as
escribiremos:
double valor_medio(double x, double y )
{
return ( (x + y) / 2.0 )
}
NOTA: No es necesario que los NOMBRES de los prametros coincidan con los declarados previamente, es decir
que hubiera sido equivalente escribir: double valor_medio(double a, double b) etc, sin embargo es una buena
costumbre mantenerlos igual. En realidad en la declaracin de la funcin, no es necesario incluir el nombre de los
parmetros, bastara con poner solo el tipo, sin embargo es prctica generalizada, explicitarlos a fin de hacer ms
legible al programa .
Aqu estamos utilizando la sntaxis moderna del lenguaje C, pudiendose encontrar en versiones arcaicas,
definiciones equivalentes como :
double valor_medio() double valor_medio(double, double)
double x;
double x ;
double y;
double y ;
{
{
............
..............
Sin embargo es preferible utilizar la nomenclatura moderna, ya que esta facilita la rpida comprensin del programa.
Veamos un ejemplo, para determinar el comportamiento de los parmetros, Supongamos desear un programa que
calcule el valor medio de dos variables incrementadas en un valor fijo, es decir:
( ( x + incremento ) + ( y + incremento ) ) / 2.0
Lo podramos resolver de la siguiente forma :
#include <stdio.h>
/* Declaracin de la funcin y el tipo de sus parmetros */
double valor_medio(double p_valor, double s_valor, double inc) ;
main()
{
double x, y, z, resultado ;
printf("Ingrese el primer valor: ") ;
scanf("%lf", &x ) ;
printf("\nIngrese el segundo valor: ");
scanf("%lf", &y ) ;
printf("\nIngrese el incremento : ");
scanf("%lf", &z) ;
resultado = valor_medio( x, y, z ); /* llamada a la funcin y
pasaje de argumentos */
printf("\n\nResultado de la operacin: %lf", resultado) ;
printf("\n\nValor con que quedaron las variables: ") ;
printf("\n Primer valor : %lf ", x ) ;
printf("\n Segundo valor: %lf ", y ) ;
printf("\n Incremento : %lf ", z ) ;
}
UTN - Informtica I

Capitulo V

- 41 -

LENGUAJE C

/* Definicin de la funcin y sus parmetros */

double valor_medio( double p_valor, double s_valor, double inc )
{
p_valor += inc ;
s_valor += inc ;
return ( (p_valor + s_valor ) / 2.0 ) ;
}

Veamos primero cual seria la salida de pantalla de este programa :

SALIDA DEL EJEMPLO

Ingrese el primer valor:
[SUPONGAMOS ESCRIBIR: 10.0]
Ingrese el segundo valor:
[
"
"
: 8.0]
Ingrese el incremento :
[
"
"
: 2.0]
Resultado de la operacin: 11.000000
Valor con que quedaron las variables:
Primer valor : 10.000000
Segundo valor: 8.000000
Incremento : 2.000000

Vemos que luego de obtenidos, mediante scanf(), los tres datos x, y, z, los mismos son pasados a la funcin de
calculo en la sentencia de asignacin de la variable resultado. La funcin inicializa sus parmetros ( p_valor, s_valor
e inc ) con los valores de los argumentos enviados ( x, y, z ) y luego los procesa. La unica diferencia entre un
argumento y una variable local, es que sta no es inicializada automaticamente, mientras que aquellos lo sn, a los
valores de los argumentos colocados en la expresin de llamada.
Ac debemos remarcar un importante concepto: ste pasaje de datos a las funciones, se realiza COPIANDO el valor
de las variables en el stack y No pasandoles las variables en s. Esto se denomina: PASAJE POR VALOR y
garantiza que dichas variables no sean afectadas de ninguna manera por la funcin invocada. Una clara prueba de
ello es que, en la funcin valor_medio() se incrementa p_valor y s_valor, sumandoseles el contenido del parmetro
inc. Sin embargo cuando, luego de retornar al programa principal, imprimimos las variables cuyos valores fueron
enviados como parametros, vemos que conservan sus valores iniciales. Veremos ms adelante que otras estructuras
de datos pueden ser pasadas a las funciones por direcciones en vez de por valor, pudiendo aquellas modificarlas a
gusto .
Debe aclararse que, el pasaje de argumentos, es tambin una OPERACION, por lo que las variables pasadas quedan
afectadas por las reglas de Conversin Automtica de Tipo, vistas en el Captulo 2. Como ejemplo, si x hubiera sido
definida en la funcin main() como int, al ser pasada como argumento a valor_medio() sera promovida a double.

Especial cuidado debe tenerse entonces con los errores que pueden producirse por redondeo truncamiento, siendo
una buena tcnica de programacin hacer coincidir los tipos de los argumentos con los de los parmetros.

UTN - Informtica I

Capitulo V

- 42 -

LENGUAJE C

CAPITULO 6: ESTRUCTURAS DE AGRUPAMIENTO DE VARIABLES

1.- CONJUNTO ORDENADO DE VARIABLES (ARRAYS)
Los arreglos conjuntos de datos ordenados (arrays) recolectan variables del MISMO tipo , guardandolas en forma
secuencial en la memoria . La cantidad mxima de variables que pueden albergar est slo limitada por la cantidad
de memoria disponible . El tipo de las variables involucradas puede ser cualquiera de los ya vistos , con la nica
restriccin de que todos los componentes de un array deben ser del mismo tipo .
La declaracin de un array se realiza segn la siguiente sintaxis :
tipo de las variables nombre[ cantidad de elementos] ;
Por ejemplo :
int var1[10] ;
char nombre[50] ;
float numeros[200] ;
long double cantidades[25] ;
Si tomamos el primer caso , estamos declarando un array de 10 variables enteras , cada una de ellas quedar
individualizada por el subndice que sigue al nombre del mismo es decir :
var1[0] , var1[1] , etc , hasta var1[9] .
Ntese que la CANTIDAD de elementos es 10 , pero su numeracin v de 0 a 9 , y n de 1 a 10 . En resumen un
array de N elementos tiene subndices vlidos entre 0 y N - 1 . Cualquier otro nmero usado como subndice , traer
datos de otras zonas de memoria , cuyo contenido es impredictible .
Se puede referenciar a cada elemento , en forma individual , tal como se ha hecho con las variables anteriormente ,
por ejemplo :
var1[5] = 40 ;
contador = var1[3] + 7 ;
if( var1[0] >>= 37 )
..................
Tambien es posible utilizar como subndice expresiones aritmticas , valores enteros retornados por funciones , etc .
As podramos escribir :
printf(" %d " , var1[ ++i] ) ;
var1[8] = var1[ i + j ] ;
...............................
int una_funcion(void) ;
var1[0] = var1[ una_funcion() ] * 15 ;
Por supuesto los subndices resultantes de las operaciones tienen que estar acotados a aquellos para los que el array
fu declarado y ser enteros .

UTN - Informtica I

Capitulo VI

- 43 -

LENGUAJE C
La inicializacin de los arrays sigue las mismas reglas que vimos para los otros tipos de variables , es decir : Si se
declaran como globales ( afuera del cuerpo de todas las funciones ) cada uno de sus elementos ser
automaticamente inicializado a cero . Si en cambio , su declaracion es local a una funcin , no se realiza ninguna
inicializacin, quedando a cargo del programa cargar los valores de inicio.
La inicializacin de un array local , puede realizarse en su declaracin , dando una lista de valores iniciales:
int numero[8] = { 4 , 7 , 0 , 0 , 0 , 9 , 8 , 7 } ;
Obsrvese que la lista est delimitada por llaves . Otra posibilidad , slo vlida cuando se inicializan todos los
elementos del array , es escribir :
int numero[] = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 } ;
donde se obvia la declaracin de la cantidad de elementos , ya que est implcita en la lista de valores constantes .
Tambin se puede inicializar parcialmente un array , por ejemplo :
int numero[10] = { 1 , 1 , 1 } ;
en ste caso los tres primeros elementos del mismo valdran 1 , y los restantes cero en el caso que la declaracin sea
global , cualquier valor impredecible en el caso de que sea local .

2.- CONJUNTO ORDENADO DE CARACTERES (STRINGS)

Los strings son simplementes arrays de caracteres , tal como los vimos hasta ahora , con el agregado de un ltimo
elemento constante : el caracter NULL ( ASCII == 0 , simbolizado por la secuencia de escape \0 ) . Este agregado
permite a las funciones que procesan a los mismos , determinar facilmente la finalizacin de los datos .
Podemos generar un string , declarando :
char car_str[] = { 'A' , 'B' , 'C' , 'D' , 0 } ;
char car_str[] = { 'A' , 'B' , 'C' , 'D' , '\0' } ;
Ambas maneras son equivalentes. Sin embargo hay , en el lenguaje C , una forma ms compacta de declararlos :
char car_str[] = "ABCD" ;
char car_str[5] = "ABCD" ;
int texto[] = "renglon 1 \n renglon 2 \n " ; /* ERROR */
unsigned char texto[] = "renglon 1 \n renglon 2 \n " ;
Simplemente en la declaracin del mismo se encierran los caracteres que lo componen entre comillas . Obsrvese
que en la segunda declaracin , se ha explicitado ( no es necesario ) , la cantidad de elementos que tiene el string , y
s uno ms que la cantidad de caracteres con que se lo inicializa , para dejar lugar al NULL . Todas stas
declaraciones agregan automticamente el NULL como ltimo elemento del array .
Un caso interesante es l de la tercer lnea ( comentada como ERROR ) , con el fn de poder albergar al caracter
"\n"20( ASCII 179 ) se intent asignar el string a un array de enteros , Esto no es permitido por el compilador , que
lo rechaza como una asignacin invlida . La razn de ello se ver ms adelante cuando analicemos punteros , ya
que el string constante usado como rvalue es un puntero a char , y no a int . La solucin mas comn para este caso
es, declarar el array como unsigned char , con lo que llevamos el alcance de sus elementos a 255 .

UTN - Informtica I

Capitulo VI

- 44 -

LENGUAJE C
Si tuvieramos el caso de tener que albergar en un string el caracter EOF ( -1 ) y al mismo tiempo caracteres con
ASCII mayor que 127 ,se podra definir el array como int , pero su inicializacin se tendr que hacer bligatoriamente
usando llaves, como vimos anteriormente.
Se deduce entonces , de lo antedicho que un string sigue siendo un array de caracteres , con la salvedad del agregado
de un terminador , por lo que las propiedades que veremos a continuacion , se aplicaran indistintamente a ambos .

3.- ARRAYS Y STRINGS COMO ARGUMENTOS DE FUNCIONES

Los arrays , como todos los otros tipos de variables , pueden ser pasados como argumentos a las funciones . Veamos
esquematicamente como sera la sintaxis :
double funcion_1( float numeros[10] , char palabra[] ) ;
/*linea 1*/
.......................................................
main()
/*linea 2*/
{
float numeros[10] = { 1.1 , 2.2 , 3.0 } ;
/*linea 3*/
char palabra[] = " Lenguaje C " ;
/*linea 4*/
double c ;
/*linea 5*/
........................................................
c = funcion_1( numeros , palabra )
/*linea 6*/
........................................................
}
double funcion_1( float numeros[10] , char palabra[] )
{
........................................................
}

/*linea 7*/

Es necesario analizar con mucho detenimiento , este ltimo ejemplo . En la primer lnea declaramos el prototipo de
funcion_1() que recibe como argumentos dos arrays , uno de 10 elementos del tipo float , y otro de caracteres de
longitud indeterminada . En el primer caso la funcin necesitar saber de alguna manera cual es la longitud del array
numrico recibido, mientras que en el segundo , no hace falta , ya que la funcin puede ser construda para que , por
s misma , detecte la finalizacin del string por la presencia del caracter NULL . Se podra generalizar ms el
programa declarando :
double funcion_1( double numeros[] , int longitud_array , char palabra[] ) ;
en donde , en la variable longitud_array se enviara la cantidad de elementos de numeros[] .
En la tercer lnea se declara el array numrico , inicializandose slo los tres primeros elementos , y en la cuarta lnea
se declara el string .
En la sptima lnea se d la definicin de la funcin , de acuerdo al prototipo escrito anteriormente .
Si miramos con detenimiento la sexta lnea , el llamado a la funcin , vemos que los argumentos pasados slo tienen
el NOMBRE de ambos arrays . Esta es la diferencia ms importante entre este tipo de estructura de datos y las
variables simples vistas anteriormente , ya que los arrays son pasados a las funciones por DIRECCION y n por
valor .

UTN - Informtica I

Capitulo VI

- 45 -

LENGUAJE C

En el lenguaje C se prefiere , para evitar el uso abusivo del stack , cuando hay que enviar a una funcin una larga
estructura de datos , en lugar de copiar a todos ellos , cargar el stack slo con la direccin de la posicin de memoria
donde est ubicado el primero de los mismos.
El nombre de un array equivale sintcticamente a la direccion del elemento cero as ser :
numero == direccin de numero[0]
palabra == direccion de palabra[0]

Esto habilita a las funciones a que puedan acceder a los arrays directamente , all donde el programa los ha ubicado
en la memoria , por lo que pueden MODIFICARLOS EN FORMA PERMANENTE aunque no hayan sido
declarados como locales a la funcin misma n globales al programa .
Es muy importante recordar este ltimo concepto , a fn de evitar errores muy comunes , en los primeros intentos de
programacin en C .
Otra caracterstica importante de los arrays es que , su nombre ( direccin del primer elemento ) es una
CONSTANTE y n una variable . El nombre de los arrays implican para el compilador el lugar de memoria donde
empieza la estructura de datos por lo que , intentar cambiar su valor es tomado como un error , as si escribieramos
por ejemplo :

char titulo[] = "Primer titulo" ;

....................................
titulo = "subtitulo" ;

La primer sentencia es correcta , ya que estamos incializando al string , pero la segunda producira un error del tipo
"LVALUE REQUERIDO " , es decir que el compilador espera ver , del lado izquierdo de una expresin , a una
variable y en cambio se ha encontrado con una constante titulo ( sea la direccin de memoria donde est
almacenada la P de "Primer ttulo") . Esto al compilador le suena similar a una expresin de la clase : 124 = j y se
niega rotundamente a compilarla .

4.- ARRAYS MULTIDIMENSIONALES.

Las estructuras de datos del tipo array pueden tener ms de una dimensin , es bastante comn el uso de arrays
"planos" matriciales de dos dimensiones , por ejemplo :
int matriz[ nmero total de filas ] [ nmero total de columnas ] ;
Si declaramos :
int matriz[3][4] ;

UTN - Informtica I

Capitulo VI

- 46 -

LENGUAJE C

esquematicamente la disposicion "espacial" de los elementos seria:

columnas:
filas

[0][0]

[0][1]

[0][2]

[0][3]

matriz[0][]

[1][0]

[1][1]

[1][2]

[1][3]

matriz[1][]

[2][0]

[2][1]

[2][2]

[2][3]

matriz[2][]

Por supuesto , aunque menos usados , se pueden generar arrays de cualquier nmero de dimensiones .
Para inicializar arrays multidimensionales , se aplica una tcnica muy similar a la ya vista , por ejemplo para dar
valores iniciales a un array de caracteres de dos dimensiones , se escribir :
char dia_de_la_semana[7][8] = {
"lunes" , "martes" , " miercoles" ,
"jueves" , "viernes" , "sbado" ,
"domingo"
};
Ac el elemento [0][0] ser la "l" de lunes , el [2][3] la "r" de miercoles , el [5][2] la "b" de sabado, etc. Ntese que
los elementos [0][5] , [1][6] ,etc estan inicializados con el caracter NULL y demas [0][6] y [0][7], etc no han sido
inicializados. Si le parece que en este prrafo se nos escap un error , est equivocado , lo que ocurre es que se
olvid de contar los ndices desde 0.
Este ltimo ejemplo tambin podra verse como un array unidimensional de strings.

5.- ESTRUCTURAS
DECLARACION DE ESTRUCTURAS

As como los arrays son organizaciones secuenciales de variables simples , de un mismo tipo cualquiera dado ,
resulta necesario en multiples aplicaciones , agrupar variables de distintos tipos , en una sola entidad . Este sera el
caso , si quisieramos generar la variable " legajo personal " , en ella tendriamos que incluir variables del tipo :
strings , para el nombre , apellido , nombre de la calle en donde vive , etc , enteros , para la edad , nmero de codigo
postal , float ( double , si tiene la suerte de ganar mucho ) para el sueldo , y as siguiendo .
Existe en C en tipo de variable compuesta , para manejar sta situacin tpica de las Bases de Datos , llamada
ESTRUCTURA . No hay limitaciones en el tipo ni cantidad de variables que pueda contener una estructura ,
mientras su mquina posea memoria suficiente como para alojarla , con una sla salvedad : una estructura no puede
contenerse a s misma como miembro .

UTN - Informtica I

Capitulo VI

- 47 -

LENGUAJE C
Para usarlas , se deben seguir dos pasos . Hay que , primero declarar la estructura en s , sto es , darle un nombre y
describir a sus miembros , para finalmente declarar a una ms variables , del tipo de la estructura antedicha ,
veamos un ejemplo :
struct legajo {
int edad ;
char nombre[50] ;
float sueldo ;
};
struct legajo legajos_vendedores , legajos_profesionales ;
En la primer sentencia se crea un tipo de estructura , mediante el declarador "struct",luego se le d un nombre "
legajo " y finalmente , entre llaves se declaran cada uno de sus miembros , pudiendo estos ser de cualquier tipo de
variable , incluyendo a los arrays an otra estructura . La nica restriccin es que no haya dos miembros con el
mismo nombre , aunque s pueden coincidir con el nombre de otra variable simple , ( o de un miembro de otra
estructura ) , declaradas en otro lugar del programa. Esta sentencia es slo una declaracin , es decir que no asigna
lugar en la memoria para la estructura , slo le avisa al compilador como tendr que manejar a dicha memoria para
alojar variables del tipo struct legajo .
En la segunda sentencia , se definen dos variables del tipo de la estructura anterior ,(sta definicin debe colocarse
luego de la declaracin ) , y se reserva memoria para ambas .
Las dos sentencias pueden combinarse en una sola , dando la definicin a continuacin de la declaracion :
struct legajo {
int edad ;
char nombre[50] ;
float sueldo ;
} legajo_vendedor , legajo_programador ;

Y si n fueran a realizarse ms declaraciones de variables de ste tipo , podra obviarse el nombre de la estructura
(legajo ).
Las variables del tipo de una estructura , pueden ser inicializadas en su definicin , as por ejemplo se podra
escribir:
struct legajo {
int edad ;
char nombre[50] ;
float sueldo ;
char observaciones[500] ;
} legajo_vendedor = { 40 , "Juan Eneene" , 1200.50 ,
"Asignado a zona A"
};
struct legajo legajo_programador = { 23 , "Jose Peres" , 2000.0 ,
"Asignado a zona B" } ;
Ac se utilizaron las dos modalidades de definicin de variables , inicializandolas a ambas .

UTN - Informtica I

Capitulo VI

- 48 -

LENGUAJE C
REGLAS PARA EL USO DE ESTRUCTURAS

Lo primero que debemos estudiar es el mtodo para dirigirnos a un miembro particular de una estructura .Para ello
existe un operador que relaciona al nombre de ella con el de un miembro , este operador se representa con el punto
(.) , as se podr referenciar a cada uno de los miembros como variables individuales , con las particularidades que
les otorgan sus propias declaraciones , internas a la estructura.
La sintaxis para realizar sta referencia es : nombre_de_la_estructura.nombre_del_miembro , as podremos escribir
por ejemplo , las siguientes sentencias
strut posicion_de {
float eje_x ;
float eje_y ;
float eje_z ;
} fin_recta , inicio_recta = { 1.0 , 2.0 , 3.0 ) ;

fin_recta.eje_x = 10.0 ;
fin_recta.eje_y = 50.0 ;
fin_recta.eje_z = 90.0 ;
if( fin_recta.eje_x == inicio_recta.eje_x )
..........................................

Es muy importante recalcar que , dos estructuras , aunque sean del mismo tipo , no pueden ser asignadas
comparadas la una con la otra , en forma directa , sino asignando comparandolas miembro a miembro. Esto se
v claramente explicitado en las lneas siguientes , basadas en las declaraciones anteriores:

fin_recta = inicio_recta ;
if( fin_recta >>= inicio_recta );

/* ERROR */
/* ERROR */

fin_recta.eje_x = inicio_recta.eje_x ;

/* FORMA CORRECTA DE ASIGNAR */

fin_recta.eje_y = inicio_recta.eje_y ;

/* UNA ESTRUCTURA A OTRA

*/

fin_recta.eje_z = inicio_recta.eje_z ;
if( (fin_recta.eje_x >>= inicio_recta.eje_x) &&
(fin_recta.eje_y >>= inicio_recta.eje_y) &&
(fin_recta.eje_z >>= inicio_recta.eje_z) )

/* FORMA CORRECTA DE */
/* COMPARAR UNA

*/

/* ESTRUCTURA CON OTRA */

Las estructuras pueden anidarse , es decir que una mas de ellas pueden ser miembro de otra . Las estructuras
tambin pueden ser pasadas a las funciones como parmetros , y ser retornadas por stas , como resultados .

UTN - Informtica I

Capitulo VI

- 49 -

LENGUAJE C

6.- ARRAYS DE ESTRUCTURAS

Cuando hablamos de arrays dijimos que se podan agrupar , para formarlos , cualquier tipo de variables , esto es
extensible a las estructuras y podemos entonces agruparlas ordenadamente , como elementos de un array . Veamos
un ejemplo :
typedef struct {
char material[50] ;
int
existencia ;
double costo_unitario ;
} Item ;
Item stock[100] ;
Hemos definido aqu un array de 100 elementos , donde cada uno de ellos es una estructura del tipo Item compuesta
por tres variables , un int , un double y un string array de 50 caracteres.
Los arrays de estructuras pueden inicializarse de la manera habitual , as en una definicin de stock, podramos
haber escrito:
Item stock1[100] = {
"tornillos" , 120 , .15 ,
"tuercas" , 200 , .09 ,
"arandelas" , 90 , .01
};

Item stock2[] = {
{ 'i','t','e','m','1','\0' } , 10 , 1.5 ,
{ 'i','t','e','m','2','\0' } , 20 , 1.0 ,
{ 'i','t','e','m','3','\0' } , 60 , 2.5 ,
{ 'i','t','e','m','4','\0' } , 40 , 4.6 ,
{ 'i','t','e','m','5','\0' } , 10 , 1.2 ,
};
Analicemos un poco las diferencias entre la dos inicializaciones dadas , en la primera , el array material[] es
inicializado como un string , por medio de las comillas y luego en forma ordenada , se van inicializando cada uno de
los miembros de los elementos del array stock1[] , en la segunda se ha preferido dar valores individuales a cada uno
de los elementos del array material , por lo que es necesario encerrarlos entre llaves .
Sin embargo hay una diferencia mucho mayor entre las dos sentencias , en la primera explicitamos el tamao del
array , [100] , y slo inicializamos los tres primeros elementos , los restantes quedarn cargados de basura si la
definicin es local a alguna funcin , de cero si es global , pero de cualquier manera estn alojados en la memoria ,
en cambio en la segunda dejamos implcito el nmero de elementos , por lo que ser el compilador el que calcule la
cantidad de ellos , basandose en cuantos se han inicializado , por lo tanto este array slo tendr ubicados en memoria
cuatro elementos , sin posibilidad de agregar nuevos datos posteriomente .

UTN - Informtica I

Capitulo VI

- 50 -

LENGUAJE C

Veremos ms adelante que en muchos casos es usual realizar un alojamiento dinmico de las estructuras en la
memoria , en razn de ello , y para evitar ademas el saturacin de stack por el pasaje retorno desde funciones , es
necesario conocer el tamao , espacio en bytes ocupados por ella .
Podemos aplicar el operador sizeof , de la siguiente manera :
longitud_base_de_datos = sizeof( stock1 ) ;
longitud_de_dato
= sizeof( Item ) ;
cantidad_de_datos
= sizeof( stock1 ) / sizeof( Item ) ;
Con la primera calculamos el tamao necesario de memoria para albergar a todos datos, en la segunda la longitud de
un slo elemento ( record ) y por supuesto dividiendo ambas , se obtiene la cantidad de records.

7.- UNIONES
Las uniones son a primera vista, entidades muy similares a las estructuras, estn formadas por un nmero cualquiera
de miembros, al igual que aquellas, pero en ste caso no existen simultaneamente todos los miembros, y slo uno de
ellos tendr un valor vlido.
Supongamos por caso, que queremos guardar datos para un stock de materiales , pero los mismos pueden ser
identificados , en un caso con el nmero de articulo (un entero ) y en otro por su nombre ( un string de 10 letras
como mximo ). No tendra sentido definir dos variables , un int y un string , para cada artculo , ya que voy a usar
una modalidad la otra, pero n las dos simultaneamente. Las uniones resuelven este caso , ya que si declaro una
que contenga dos miembros, un entero y un string , slo se reservar lugar para el mayor de ellos , en este caso, el
string , de tal forma que si asigno un valor a ste se llenar ese lugar de la memoria con los caracteres
correspondientes, pero si en cambio asigno un valor al miembro declarado como int ste se guardar en los dos
primeros bytes del MISMO lugar de memoria. Por supuesto, en una unin, slo uno de los miembros tendr
entonces un valor correcto .

UTN - Informtica I

Capitulo VI

- 51 -

LENGUAJE C

CAPITULO 7: PUNTEROS (POINTERS)

1.- INTRODUCCION A LOS PUNTEROS

Los punteros en el Lenguaje C , son variables que " apuntan " , es decir que poseen la direccin de las ubicaciones
en memoria de otras variables, y por medio de ellos tendremos un poderoso mtodo de acceso a todas ellas .
Quizs este punto es el ms conflictivo del lenguaje , ya que muchos programadores en otros idiomas , y novatos en
C , lo ven como un mtodo extrao al menos desacostrumbrado , lo que les produce un cierto rechazo . Sin
embargo , y en la medida que uno se va familiarizando con ellos , se convierten en la herramienta ms cmoda y
directa para el manejo de variables complejas , argumentos , parmetros , etc , y se empieza a preguntar como es que
hizo para programar hasta aqu , sin ellos . La respuesta es que no lo ha hecho , ya que los hemos usado en forma
encubierta, , sin decir lo que eran . ( Perdn por el pequeo engao )
Veamos primero , como se declara un puntero :
tipo de variable apuntada *nombre_del_puntero ;
int *pint ;
double *pfloat ;
char *letra , *codigo , *caracter ;
En estas declaraciones slo decimos al compilador que reserve una posicin de memoria para albergar la direccin
de una variable , del tipo indicado , la cual ser referenciada con el nombre que hayamos dado al puntero .
Obviamente , un puntero debe ser inicializado antes de usarse , y una de las eventuales formas de hacerlo es la
siguiente:

int var1 ;
int *pint ;

/* declaro ( y creo en memoria ) una variable entera ) */

/* " " " " " un puntero que contendr la direccin de una variable entera */

pint = &var1 ;

/* escribo en la direccin de memoria donde est el

puntero la direccin de la variable entera */

Como habiamos anticipado en captulos anteriores " &nombre_de_una_variable " implica la direccin de la
misma . Si se pregunta porque no se usaron otros smbolos en vez de & y * , que se confunden con la Y lgica de
bits y el producto , ..... consuelese pensando que yo tambin me hice siempre esa pregunta . De cualquier manera es
siempre obvio , en el contexto del programa el uso de los mismos .

UTN - Informtica I

Capitulo VII

- 52 -

LENGUAJE C

Esquematicamente , lo que hemos hecho se puede simbolizar de la siguiente manera : donde dentro del recuadro est
el contenido de cada variable .
Pint

xxxxxx
Direccin de var1
yyyyyy (posicin de memoria
ocupada por el puntero )

valor contenido por var1

xxxxxx (posicin de memoria
ocupada por la variable)

En realidad , como veremos ms adelante , en la declaracin del puntero , est implicita otra informacin : cual es el
tamao (en bytes) de la variable apuntada.
El smbolo & , direccin , puede aplicarse a variables , funciones , etc , pero n a constantes expresiones , ya que
stas no tienen una posicin de memoria asignada.
La operacin inversa a la asignacin de un puntero , de referenciacin del mismo , se puede utilizar para hallar el
valor contenido por la variable apuntada . As por ejemplo sern expresiones equivalentes :

y = var1 ;
y = *pint ;
printf("%d" , var1 ) ;
printf("%d" , *pint) ;

En estos casos , la expresin " *nombre_del_puntero " , implica " contenido de la variable apuntada por el mismo " .
Veamos un corto ejemplo de ello :
#include <stdio.h>
main()
{
char var1 ;
char *pchar;
pc = &var1 ;

/*una variable del tipo caracter */

/* un puntero a una variable del tipo caracter */
/*asignamos al puntero la direccion de la variable */

for (var1 = 'a'; var1 <<= 'z'; var1++)

printf("%c", *pchar) ; /* imprimimos el valor de la variable apuntada */
return 0 ;
}

UTN - Informtica I

Capitulo VII

- 53 -

LENGUAJE C
Vemos ac , que en el FOR se incrementa el valor de la variable , y luego para imprimirla usamos la
dereferenciacin de su puntero.
El programa imprimir las letras del abecedario de la misma manera que lo habra hecho si la sentencia del printf()
huiera sido, printf("%c" , var1 ) .
Hay un error , que se comete con bastante frecuencia , y es cargar en la direccin apuntada por un puntero a un tipo
dado de variable , el contenido de otro tipo de las mismas , por ejemplo :

double d = 10.0 ;
int i = 7 , *pint ;
pint = &i ;
*pint = 10 ;
*pint = d ;
pint = &d ;

/* correcto,equivale a asignar a i el valor 10 */ ;

/* ERROR se pretende cargar en una variable entera un valor double */
/* INCORRECTO se pretende apuntar a una variable double con un
puntero declarado como apuntador a int */

pint = 4358 ;

/* ?????? */

El primer error , la asignacin de un double , produce la prdida de informacin dada por la conversin automtica
de tipo de variable , ya vista anteriormente , el segundo produce un llamado de atencin rotulado como " asignacin
sospechosa de un pointer " . Resumiendo , las variables constantes cargadas por dereferenciacin de un puntero ,
deben coincidir en tipo con la declaracin de aquel .
La asignacin de una constante a un pointer , y no a la variable apuntada por l , es un serio error , ya que debe ser el
compilador , el encargado de poner en l el valor de la direccin , aquel as lo declara dando un mensaje de "
conversin de puntero no transportable " . Si bien lo compila , ejecutar un programa que ha tenido esta advertencia
es similar a jugar a la ruleta rusa , puede "colgarse" la mquina lo que es peor destruirse involuntariamente
informacin contenida en un disco , etc.
Hay un slo caso en el que esta asignacin de una constante a un puntero es permitida , muchas funciones para
indicar que no pueden realizar una accin que se ha producido un error de algun tipo , devuelven un puntero
llamado "Null Pointer" , lo que significa que no apunta a ningun lado vlido , dicho puntero ha sido cargado con la
direccin NULL ( por lo general en valor 0 ) , as la asignacin : pint = NULL ; es vlida y permite luego
operaciones relacionales del tipo if( pint ) ..... if( print != NULL ) para convalidar la validez del resultado devuelto
por una funcin .
Una advertencia : si bien volveremos ms adelante sobre este tema , debemos desde ahora tener en cuenta que los
punteros no son enteros , como parecera a primera vista , ya que el nmero que representa a una posicin de
memoria , s lo es . Debido al corto alcance de este tipo de variable , algunos compiladores pueden , para apuntar a
una variable muy lejana , usar cualquier otro tipo , con mayor alcance que el antedicho .

UTN - Informtica I

Capitulo VII

- 54 -

LENGUAJE C

2.- PUNTEROS Y ARRAYS

Hay una relacin muy cercana entre los punteros y los arrays . Y vimos previamente que el designador ( nombre
de un array ) era equivalente a la direccin del elemento [0] del mismo . La explicacin de sto es ahora sencilla : el
nombre de un array , para el compilador C , es un PUNTERO inicializado con la direccin del primer elemento del
array . Sin embargo hay una importante diferencia entre ambos , que haremos notar ms abajo.

Veamos algunas operaciones permitidas entre punteros :

ASIGNACION

float var1 , conjunto[] = { 9.0 , 8.0 , 7.0 , 6.0 , 5.0 );

float *punt ;
punt = conjunto ; /* equivalente a hacer : punt = &conjunto [0] */
var1 = *punt ;
*punt = 25.1 ;

Es perfectamente vlido asignar a un puntero el valor de otro , el resultado de sta operacin es cargar en el puntero
punt la direccin del elemento [0] del array conjunto , y posteriormente en la variable var1 el valor del mismo (9.0)
y para luego cambiar el valor de dicho primer elemento a 25.1 .
Veamos cual es la diferencia entre un puntero y el denominador de un array : el primero es una VARIABLE , es
decir que puedo asignarlo , incrementarlo etc , en cambio el segundo es una CONSTANTE , que apunta siempre al
primer elemento del array con que fu declarado , por lo que su contenido NO PUEDE SER VARIADO . Si lo
piensa un poco , es lgico , ya que "conjunto" implica la direccin del elemento conjunto [0] , por lo que , si yo
cambiara su valor , apuntara a otro lado dejando de ser , "conjunto" . Desde este punto de vista , el siguiente
ejemplo nos muestra un tipo de error bastante frecuente:
ASIGNACION ERRONEA

int conjunto[5] , lista[] = { 5 , 6 , 7 , 8 , 0 ) ;

int *apuntador ;
apuntador = lista ;
/* correcto */
conjunto = apuntador;
/* ERROR ( se quiere asignar a una constante ) */
lista = conjunto ;
/* ERROR ( idem ) */
apuntador = &conjunto
/* ERROR no se puede aplicar el operador & (direccin) a una constante */

UTN - Informtica I

Capitulo VII

- 55 -

LENGUAJE C

Veamos ahora las distintas modalidades del incremento de un puntero :

INCREMENTO O DECREMENTO DE UN PUNTERO
int *pint , arreglo_int[5] ;
double *pdou , arreglo_dou[6] ;
pint = arreglo_int ;
pdou = arreglo_dou ;
pint += 1 ;

/* pint apunta a arreglo_int[0] */

/* pdou apunta a arreglo_dou[0] */
/* pint apunta a arreglo_int[1] */

pdou += 1 ;
pint++ ;

/* pdou apunta a arreglo_dou[1] */

/* pint apunta a arreglo_int[2] */

pdou++ ;

/* pdou apunta a arreglo_dou[2] */

Hemos declarado y asignado dos punteros , uno a int y otro a double , con las direcciones de dos arrays de esas
caracteristicas . Ambos estarn ahora apuntando a los elementos [0] de los arrays . En las dos instrucciones
siguientes incrementamos en uno dichos punteros . adonde apuntaran ahora ?.
Para el compilador , stas sentencias se leen como : incremente el contenido del puntero ( direccin del primer
elemento del array ) en un nmero igual a la cantidad de bytes que tiene la variable con que fu declarado . Es decir
que el contenido de pint es incrementado en dos bytes (un int tiene 2 bytes ) mientras que pdou es incrementado 8
bytes ( por ser un puntero a double ) , el resultado entonces es el mismo para ambos , ya que luego de la operacin
quedan apuntando al elemento SIGUIENTE del array , arreglo_int[1] y arreglo_dou[1] .
Vemos que de sta manera ser muy facil "barrer" arrays , independientemente del tamao de variables que lo
compongan , permitiendo por otro lado que el programa sea transportable a distintos hardwares sin preocuparnos de
la diferente cantidad de bytes que pueden asignar los mismos , a un dado tipo de variable .
De manera similar las dos instrucciones siguientes , vuelven a a incrementarse los punteros , apuntando ahora a los
elementos siguientes de los arrays.
Todo lo dicho es aplicable , en identica manera , al operador de decremento -- .
ARITMETICA DE DEREFERENCIA

Debido a que los operadores * y ++ -- tienen la misma precedencia y se evaluan de derecha a izquierda , y los
parntesis tienen mayor precedencia que ambos , muchas operaciones que los utilizan en conjunto a todos estos
operadores , pueden parecer poco claras y dar origen a un sinnmero de errores , (revise un poco la TABLA 13 del
captulo 3 ) analicmoslas detalladamente , partiendo de :
int *p , a[] = { 0 , 10 , 20 , 30 , 40 , 50 , 60 , 70 , 80 , 90 } ;
int var ;
p=a;

UTN - Informtica I

Capitulo VII

- 56 -

LENGUAJE C

A partir de aqu , el puntero est apuntando a a[0] . Veamos las distintas variantes que puede tener la siguiente
instruccin:
*p = 27 ;
La ms sencilla de las opciones , simplemente asignamos al elemento apuntado por p ( a[0] ) un valor constante .
Veamos la inversa de ella:
var = *p ;
var sera asignada al valor 0 (contenido de a[0]) , y p seguira apuntando al mismo elemento. Que hubiera pasado, si
en vez de ello se hubiera escrito:
var = *( p + 1 ) ;
ac podramos traducir el sentido de la operacin como : cargue var con el contenido del elemento siguiente al
apuntado por p ( a[1] ) . Lo interesante de remarcar ac es que p , en s mismo , NO VARIA Y LUEGO DE ESTA
SENTENCIA SEGUIRA APUNTANDO A a[0] . De la misma forma : var = *( p + 3 ) asignar 30 a var , sin
modificar el contenido de p .
En cambio la expresin :
var = *( p++ ) ;
podemos leerla como : asigne a var el valor de lo apuntado por p y LUEGO incremente ste para que apunte al
proximo elemento . As en var quedara 0 ( valor de a[0] ) y p apuntara finalmente a a[1] . Si en vez de sto
hubieramos preincrementado a p tendramos :
var = *( ++p ) ;
la que puede leerse como : apunte con p al prximo elemento y asigne a var con el valor de ste . En este caso var
sera igualada a 10 ( a[1] ) y p quedara apuntando al mismo .
En las dos operaciones anteriores los parntesis son superfluos ya que al analizarse los operadores de derecha a
izquierda , dara lo mismo escribir :
var = *p++ ;
var = *++p ;

/* sintcticamente igual a var = *(p++) */

/*
"
" " var = *(++p) */

3.- ARITMETICA DE PUNTEROS

La aritmtica ms frecuentemente usada con punteros son las sencillas operaciones de asignacin , incremento
decremento y dereferenciacin . Todo otro tipo de aritmtica con ellos est prohibida es de uso peligroso poco
transportable . Por ejemplo no est permitido , sumar , restar , dividir , multiplicar , etc , dos apuntadores entre s .
Lo cual si lo pensamos un poco es bastante lgico , ya que de nada me servira sumar dos direcciones de memoria ,
por ejemplo .
Otras operaciones estan permitidas , como la comparacin de dos punteros , por ejemplo ( punt1 == punt2 ) ( unt1
< punt2 ) sin embargo este tipo de operaciones son potencialmente peligrosas , ya que con algunos modelos de
pointers pueden funcionar correctamente y con otros no .

UTN - Informtica I

Capitulo VII

- 57 -

LENGUAJE C
4.- PUNTEROS Y VARIABLES DINAMICAS
Recordemos lo expresado en captulo 5 , sobre el mbito existencia de las variables , la menos duradera de ellas
era la del tipo local a una funcin , ya que naca y mora con sta . Sin embargo , esto es algo relativo , en cuanto a la
funcin main() , ya que sus variables locales ocuparn memoria durante toda la ejecucin del programa.
Supongamos un caso tpico , debemos recibir una serie de datos de entrada , digamos del tipo double , y debemos
procesar segn un determinado algoritmo a aquellos que aparecen una ms veces con el mismo valor .
Si no estamos seguros de cuantos datos van a ingresar a nuestro programa , pondremos alguna limitacin ,
suficientemente grande a los efectos de la precisin requerida por el problema , digamos 5000 valores como
mximo, debemos definir entonces un array de doubles capaz de albergar a cinco mil de ellos , por lo que el mismo
ocupar del orden de los 40 k de memoria .
Si definimos este array en main() , ese espacio de memoria permanecer ocupado hasta el fn del programa , aunque
luego de aplicarle el algoritmo de clculo ya no lo necesitemos ms , comprometiendo seriamente nuestra
disponibilidad de memoria para albergar a otras variables . Una solucin posible sera definirlo en una funcin
llamada por main() que se ocupara de llenar el array con los datos , procesarlos y finalmente devolviera algn tipo
de resultado , borrando con su retorno a la masiva variable de la memoria .
Sin embargo en C existe una forma ms racional de utilizar nuestros recursos de memoria de manera conservadora .
Los programas ejecutables creados con estos compiladores dividen la memoria disponible en varios segmentos , uno
para el cdigo ( en lenguaje mquina ) , otro para albergar las variables globales , otro para el stack ( a travez del
cual se pasan argumentos y donde residen las variables locales ) y finalmente un ltimo segmento llamado memoria
de apilamiento amontonamiento ( Heap ) .
El Heap es la zona destinada a albergar a las variables dinmicas , es decir aquellas que crecen ( en el sentido de
ocupacin de memoria ) y decrecen a lo largo del programa , pudiendose crear y desaparecer (desalojando la
memoria que ocupaban) en cualquier momento de la ejecucin .
Veamos cual sera la metodologa para crearlas ; supongamos primero que queremos ubicar un nico dato en el
Heap , definimos primero un puntero al tipo de la variable deseada :
double *p ;
notemos que sta declaracin no crea lugar para la variable , sino que asigna un lugar en la memoria para que
posteriormente se guarde ah la direccin de aquella Para reservar una cantidad dada de bytes en el Heap , se efectua
una llamada a alguna de las funciones de Librera , dedicadas al manejo del mismo . La ms tradicional es malloc() (
su nombre deriva de memory allocation ) , a esta funcin se le d como argumento la cantidad de bytes que se quiere
reservar , y nos devuelve un pointer apuntando a la primer posicin de la "pila" reservada . En caso que la funcin
falle en su cometido ( el Heap est lleno ) devolvera un puntero inicializado con NULL .
p = malloc(8) ;
ac hemos pedido 8 bytes ( los necesarios para albergar un double ) y hemos asignado a p el retorno de la funcin ,
es decir la direccin en el Heap de la memoria reservada.
Como es algo engorroso recordar el tamao de cada tipo variable , agravado por el hecho de que , si reservamos
memoria de esta forma , el programa no se ejecutar correctamente , si es compilado con otro compilador que asigne
una cantidad distinta de bytes a dicha variable , es ms usual utilizar sizeof , para indicar la cantidad de bytes
requerida :
p = malloc( sizeof(double) ) ;

UTN - Informtica I

Capitulo VII

- 58 -

LENGUAJE C
En caso de haber hecho previamente un uso intensivo del Heap , se debera averiguar si la reserva de lugar fu
exitosa:
if( p == NULL )
rutina_de_error() ;
si no lo fu estas sentencias me derivan a la ejecucin de una rutina de error que tomar cuenta de este caso . Por
supuesto podra combinar ambas operaciones en una sola ,
if( ( p = malloc( sizeof(double) ) ) == NULL ) {
printf("no hay mas lugar en el Heap ..... Socorro !!" ) ;
exit(1) ;
}
se ha reemplazado aqu la rutina de error , por un mensaje y la terminacin del programa , por medio de exit()
retornando un cdigo de error .
Si ahora quisiera guardar en el Heap el resultado de alguna operacin , sera tan directo como,
*p = a * ( b + 37 ) ;
y para recuperarlo , y asignarselo a otra variable bastara con escribir :
var = *p ;

5.- PUNTEROS A STRINGS

No hay gran diferencia entre el trato de punteros a arrays , y a strings , ya que estos dos ltimos son entidades de la
misma clase . Sin embargo analicemos algunas particularidades . As como inicializamos un string con un grupo de
caracteres terminados en '\0' , podemos asignar al mismo un puntero :
p = "Esto es un string constante " ;
esta operacin no implica haber copiado el texto , sino slo que a p se le ha asignado la direccin de memoria donde
reside la "E" del texto . A partir de ello podemos manejar a p como lo hemos hecho hasta ahora . Veamos un
ejemplo

#include <stdio.h>
#define TEXTO1 " Hola , como "
#define TEXTO2 "le va a Ud. ? "
main()
{
char palabra[20] , *p ;
int i ;
p = TEXTO1 ;
for( i = 0 ; ( palabra[i] = *p++ ) != '\0' ; i++ ) ;
p = TEXTO2 ;
printf("%s" , palabra ) ;
printf("%s" , p ) ;
return 0 ;
}

Definimos primero dos strings constantes TEXTO1 y TEXTO2 , luego asignamos al puntero p la direccin del
primero , y seguidamente en el FOR copiamos el contenido de ste en el array palabra , observe que dicha operacin
termina cuando el contenido de lo apuntado por p es el terminador del string , luego asignamos a p la direccin de
TEXTO2 y finalmente imprimimos ambos strings , obteniendo una salida del tipo : " Hola , como le va a UD. ? " (
espero que bien ) .

UTN - Informtica I

Capitulo VII

- 59 -

LENGUAJE C
Reconozcamos que esto se podra haber escrito ms compacto, si hubieramos recordado que palabra tambien es un
puntero y NULL es cero , as podemos poner en vez del FOR
while( *palabra++ = *p++ ) ;
Vemos que aqu se ha agregado muy poco a lo ya sabido , sin embargo hay un tipo de error muy frecuente , que
podemos analizar , fjese en el EJEMPLO siguiente , ve algun problema ? .
( CON ERRORES )

#include <stdio.h>
main()
{
char *p , palabra[20] ;
printf("Escriba su nombre : ") ;
scanf("%s" , p ) ;
palabra = " Como le va " ;
printf("%s%s" , palabra , p ) ;
}

Pues hay dos errores , a falta de uno , el primero ya fue analizado antes , la expresin scanf("%s" , p ) es correcta
pero , el error implcito es no haber inicializado al puntero p , el cual slo fu definido , pero aun no apunta a ningun
lado vlido . El segundo error est dado por la expresin : palabra = " Como le va " ; (tambin visto anteriormente)
ya que el nombre del array es una constante y no puede ser asignado a otro valor .
Como lo escribiramos para que funcione correctamente ?
(CORRECTO)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
char *p , palabra[20] ;
p = (char *)malloc(sizeof(char)128) ;
printf("Escriba su nombre : ") ;
scanf("%s" , p ) ;
strcpy(palabra , " Como le va " ) ;
printf("%s%s" , palabra , p ) ;
}

Observe que antes de scanf() se ha inicializado a p, mediante el retorno de malloc() y a al array palabra se le copiado
el string mediante la funcin vista anteriormente strcpy().
Debemos aclarar tambin que, la secuencia de control %s en el printf() impone enviar a la pantalla un string, estando
ste apuntado por el argumento siguiente al control, ste puede ser tanto el nombre de un array, como un puntero, ya
que ambos explicitan direcciones.

UTN - Informtica I

Capitulo VII

- 60 -

LENGUAJE C

Una forma alternativa de resolverlo , sera:

( CORRECTO )
#include <stdio.h>
main()
{
char p[20] , *palabra ;
printf("Escriba su nombre : ") ;
scanf("%s" , p ) ;
palabra = " Como le va " ;
printf("%s%s" , palabra , p ) ;
}
Obsrvese , que es idntico al primero , con la salvedad que se ha invertido las declaraciones de las variables , ahora
el puntero es palabra y el array es p . Ambas soluciones son equivalentes y depender del resto del programa , cual
es la mejor eleccin .

6. - ARRAYS DE PUNTEROS
Es una prctica muy habitual , sobre todo cuando se tiene que tratar con strings de distinta longitud , generar array
cuyos elementos son punteros , que albergarn las direcciones de dichos strings.
Si imaginamos a un puntero como una flecha , un array de ellos equivaldra a un carcaj indio lleno de aquellas .
Asi como:
char *flecha;
defina a un puntero a un caracter , la definicin
char *carcaj[5];
implica un array de 5 punteros a caracteres .

INICIALIZACION DE ARRAYS DE PUNTEROS

Los arrays de punteros pueden ser inicializados de la misma forma que un array comn , es decir dando los valores
de sus elementos , durante su definicin , por ejemplo si quisieramos tener un array donde el subndice de los
elementos coincidiera con el nombre de los das de la semana , podramos escribir :
char *dias[] = {
"nmero de da no vlido" ,
"lunes"
,
"martes"
,
"miercoles"
,
"jueves"
,
"viernes"
,
"sabado"
,
"por fn es domingo"
}

UTN - Informtica I

Capitulo VII

- 61 -

LENGUAJE C
Igual que antes, no es necesario en este caso indicar la cantidad de elementos , ya que el compilador los calcula por
la cantidad de trminos dados en la inicializacin. Asi el elemento dias[0] ser un puntero con la direccin del
primer string, dias[1], la del segundo, etc.

7. - PUNTEROS A ESTRUCTURAS
Los punteros pueden tambin servir para el manejo de estructuras , y su alojamiento dinmico , pero tienen adems
la propiedad de poder direccionar a los miembros de las mismas utilizando un operador particular , el -> , (escrito
con los smbolos "menos" seguido por "mayor" ) .
Supongamos crear una estructura y luego asignar valores a sus miembros , por los mtodos ya descriptos
anteriormente :
struct conjunto {
int a ;
double b ;
char c[5] ;
} stconj ;
stconj.a = 10 ;
stconj.b = 1.15 ;
stconj.c[0] = 'A' ;
La forma de realizar lo mismo , mediante el uso de un puntero, sera la siguiente :
struct conjunto {
int a ;
double b ;
char c[5] ;
} *ptrconj ;
ptrconj = (struct conjunto *)malloc( sizeof( struct conjunto )) ;
ptrconj->a = 10 ;
ptrconj->b = 1.15 ;
ptrconj->c[0] = 'A' ;
En este caso vemos que antes de inicializar un elemento de la estructura es necesario alojarla en la memoria
mediante malloc(), observe atentamente la instruccin: primero se indica que el puntero que devuelve la funcin sea
del tipo de apuntador a conjunto (sto es slo formal), y luego con sizeof se le da como argumento las dimensiones
en bytes de la estructura.
Ac se puede notar la ventaja del uso del typedef , para ahorrar tediosas repeticiones de texto, y mejorar la
legilibilidad de los listados; podramos escribir:
typedef struct {
int a ;
double b ;
char c[5] ;
} conj ;
conj *ptrconj ;
ptrconj = ( conj *)malloc( sizeof( conj )) ;

UTN - Informtica I

Capitulo VII

- 62 -

LENGUAJE C
Es muy importante ac , repasar la TABLA 13 del final del captulo 3 , donde se indican las precedencias de los
operadores , a fn de evitar comportamientos no deseados , cuando se usan simultaneamente varios de ellos .
Ya que c es un array podemos escribir :
x = *ptrconj -> c ;
la duda ac es, si nos referimos al contenido apuntado por ptrconj por c.
Vemos en la tabla que, el operador -> es de mayor precedencia que la de * (dereferenciacin), por lo que, el
resultado de la expresin es asignar el valor apuntado por c, es decir el contenido de c[0] .
De la misma forma:
*ptrconj -> c++ ; incrementa el puntero c , haciendolo tener la direccion
de c[1] y luego extrae el valor de ste .
++ptrconj -> c ; incrementa el valor de c[0] .
En caso de duda , es conveniente el uso a discrecin de parntesis , para saltar por sobre las , a veces complicadas ,
reglas que impone la precedencia as , si queremos por ejemplo el valor de c[3] , la forma ms clara de escribir es:
*( ptrconj -> ( c + 4 ) ) ;
(Recuerde que c[3] es el CUARTO elemento del array ).

8.- PUNTEROS Y FUNCIONES

La relacin entre los punteros y las funciones , puede verse en tres casos distintos , podemos pasarle a una funcin
un puntero como argumento (por supuesto si su parmetro es un puntero del mismo tipo ) , pueden devolver un
puntero de cualquier tipo , como ya hemos visto con malloc() y calloc() , y es posible tambin apuntar a la direccin
de la funcin , en otras palabras , al cdigo en vez de a un dato.

PUNTEROS COMO PARAMETROS DE FUNCIONES .

Supongamos que hemos declarado una estructura , se puede pasar a una funcin como argumento , de la manera que
ya vimos anteriormente:

struct conjunto {
int a ;
double b ;
char c[5] ;
} datos ;
void una_funcion( struct conjunto datos );

Hicimos notar, en su momento, que en este caso la estructura se copiaba en el stack y as era pasada a la funcin,
con el peligro que esto implicaba, si ella era muy masiva, de agotarlo.

UTN - Informtica I

Capitulo VII

- 63 -

LENGUAJE C

Otra forma equivalente es utilizar un puntero a la estructura :

struct conjunto {
int a ;
double b ;
char c[5] ;
} *pdatos ;
void una_funcion( struct conjunto *pdatos ) ;
Con lo que slo ocupo lugar en el stack para pasarle la direccin de la misma. Luego en la funcin, como todos los
miembros de la estructuras son accesibles por medio del puntero, tengo pleno control de la misma.
Un ejemplo de funciones ya usadas que poseen como parmetros a punteros son:
scanf(puntero_a_string_de_control , punteros_a_variables) printf(puntero_a_string_de_control , variables )
En ambas vemos que los strings de control son , como no podra ser de otro modo , punteros , es decir que los
podramos definir fuera de la funcin y luego pasarselos a ellas :
p_control = "valor : %d " ;
printf( p_control , var ) ;
PUNTEROS COMO RESULTADO DE UNA FUNCION

Las funciones que retornan punteros son por lo general aquellas que modifican un argumento , que les ha sido
pasado por direccin ( por medio de un puntero ) , devolviendo un puntero a dicho argumento modificado , las que
reservan lugar en el Heap para las variables dinmicas , retornando un puntero a dicho bloque de memoria .
As podremos declarar funcines del tipo de:
char *funcion1( char * var1 ) ;
double *funcion2(int i , double j , char *k ) ;
struct item *funcion3( struct stock *puntst ) ;
El retorno de las mismas puede inicializar punteros del mismo tipo al devuelto , distinto , por medio del uso del
casting . Algunas funciones , tales como malloc() y calloc() definen su retorno como punteros a void :
void *malloc( int tamano ) ;
de esta forma al invocarlas , debemos indicar el tipo de puntero de deseamos
p = (double *)malloc( 64 ) ;

UTN - Informtica I

Capitulo VII

- 64 -

LENGUAJE C

CAPITULO 8: FUNCIONES DE MANEJO DE STRINGS

1.- INTRODUCCION
Si bien ya hemos realizado variadas operaciones de manejo de string , dada su importancia, pues son cuando menos
el medio de comunicacin de los programas con el operador, trataremos ac de sintetizar los conceptos relativos a
los mismos, y resumir aquellas funciones ya vistas, con el agregado de otras nuevas.
La mayora de las que veremos a continuacin, responden a la norma ANSI C, por lo que sern independientes del
compilador que usemos. Estas tienen sus prototipos definidos en los archivos de encabezamiento stdio.h, stdlib.h,
string.h y ctype.h.
Agregaremos tambien algunas que caen fuera de la norma, por lo que su portabilidad a otros compiladores distintos
al que fueron extraidas, no es segura. Seran aquellas declaradas en Headers no citados arriba. Sin embargo, hoy en
da practicamente todos los compiladores las traen tienen otras similares, con nombres parecidos. De cualquier
forma, antes de compilar los ejemplos aqu suministrados, en caso de encontrarse alguna de estas, verifique con su
manual de Libreria la existencia y compatibilidad de la misma.
Refresquemos, antes de comenzar, algunas de las caractersticas bsicas de los strings. Estos pueden aparecer en un
programa como una constante simblica, de la forma siguiente:
#define TITULO "Capitulo 9"
en este caso, en cada lugar donde aparece TITULO se reemplazar esta constante simblica por la DIRECCION de
la C del texto con que fu definida .
As, ser correcto escribir:
char *p = TITULO ;
Recordemos tambien que en la memoria, el string se guardar de la siguiente forma:

67 97 112 105 116 117 108 111 20 57 0

Donde los nmeros son el cdigo ASCII que representa a cada caracter del string , en particular , note que 20
corresponde al espacio , terminandose con un NULL (cdigo 0 ) .
A los efecttos prcticos, para las funciones de manejo de los mismos, es como si en realidad hubieramos
memorizados directamente los caracteres:

C a p i t u l o

9 /0

El cdigo ASCII de los caracteres imprimibles v entre el 31 y el 127 , reservndose los cdigos entre el 0 y 30 ,
para los caracteres de control (retorno de carro, avance de linea, tabulador, etc).
Si en cambio , hubieramos escrito el string de una manera ortogrficamente ms correcta :
#define TITULO "Captulo 9"
(con la i acentuada) estaramos introduciendo un caracter del conjunto ASCII Extendido , ya que su cdigo supera a
127 y est representado por 173 .
UTN - Informtica I

Capitulo VIII

- 65 -

LENGUAJE C
Lo correcto en este caso sera definir , aunque muchos compiladores ya lo presuponen por omisin, para asegurar la
portabilidad :
unsigned char *p = TITULO ;
de esta forma se garantiza que el alcance de la variable sea de 255 , en su defecto :
int *p = TITULO ;
Es correcto tambien declarar el puntero , y asignarlo posteriormente
char *p ;
p = TITULO ;
Esta asignacin solo d , al contenido del puntero la direccin del string global predefinido .
Sin embargo , si en lugar de un puntero deseamos usar un array , en este caso es correcta la inicializacin del mismo,
pero no as su asignacin posterior:
char nombre[] = TITULO ;
.................
char nombre[11] ;
nombre = TITULO ;

/* Correcto */

/* Incorrecto */

Ya que si bien, el nombre de un array es un puntero , es de ndole constante , negndose el compilador a cambiar su
direccin.
Si estuvieramos en el caso de ingresar un string variable , por ejemplo leyendolo desde el teclado , podramos
utilizar un array, de la siguiente forma :
char nombre[128] ;
scanf("%s" , nombre ) ;
en este caso la nica precaucin es que , el array tenga suficiente longitud para albergar a cualquier string escrito .
En el caso de trabajar bajo DOS, basta con darle 128 caracteres, ya que el buffer de lectura de ese sistema operativo
no supera dicha cantidad .
Hay que hacer notar que la longitud de un string puede ser mayor que la del texto vlido contenido , ya que este
termina donde se encuentra el NULL , quedando los bytes sobrantes desaprovechados .
Seria incorrecto leer este string mediante un puntero declarado , pero al que no se le ha reservado memoria:
char *p ;
scanf("%s" , p ) /* Incorrecto */
ya que la direccin contenida por p no ha sido inicializada an con ningun valor vlido . Lo correcto en ste caso es:
char *p ;
p = (char *)malloc(128 * sizeof(char)) ;
scanf("%s" , p )
/* Correcto */
reservando memoria previamente a cargar el string.
Otro punto sobre el que quiero volver, a fn de evitar confusiones, es el sentido de la constante NULL , y el de
variables nulas.

UTN - Informtica I

Capitulo VIII

- 66 -

LENGUAJE C

Segun ste se aplique a caracteres, strings punteros, su significado varia:

Un caracter nulo tiene el valor ASCII cero. Un string siempre estar terminado por un caracter NULL .
Un string nulo vacio, no tiene longitud cero, sino que su primer caracter es un NULL .
Un puntero nulo, no corresponde a un string vacio, sin que su contenido ha sido asignado a la direccin 0
NULL, es decir que no apunta a ningun string an.

Hay que recalcar que, practicamente todas las funciones que describiremos a continuacin , basan su operatoria en la
suposicin que los strings que se le pasan como argumento , terminan en el caracter NULL , si por error esto no
fuera as , los resultados son catastrficos , produciendose generalmente la destruccin de los datos y el aborto del
programa .

2. - FUNCIONES DE IMPRESION DE STRINGS

Daremos un anlisis de las funciones que permiten la impresin en pantalla de strings , muchas de ellas pueden
obviamente , utilizarse para imprimir otro tipo de variable , pero aqu slo describiremos su aplicacin particular
sobre el tema de nuestro interes.
PRINTF()

Header : <stdio.h>
Prototipo : int printf( const char *formato , argumento , ......... )
Portabilidad : Definida en ANSI C. No es compatible con Windows
Comentario : Retorna un entero igual a la cantidad de caracteres que ha impresso , un EOF (End Of File ,
por lo general -1 ) en caso de error operacin fallida . Tiene un uso ms generalizado que el que aqu
describimos , ya que por el momento veremos slo su aplicacin a strings . El string de formato puede ser
construido directamente en la funcin , delimitndolo con comillas , definido antes en el listado , y
pasado como argumento por medio de un puntero . Puede contener , directamente el texto a imprimir , si
ste es una constante , en cuyo caso no se pasarn ms argumentos , una mezcla de texto constante con
secuencias de control de formato para la impresin del resto de los parmetros pasados. La secuencia de
control comienza con el caracter % . En caso de impresin de strings , el comando debe terminarse con la
letra s. Entre el comienzo (%) y el fn (s) de la secuencia de control , pueden introducirse opcionalmente
modificadores cuyo sentido , en el caso de los strings , es el siguiente : % [justificacin] [longitud]
[.presicion] s La (longitud) d la cantidad MINIMA de caracteres a imprimir , independientemente de
cuantos caracteres tenga el string . Si este valor es mayor que la cantidad de caracteres del string , se
rellenar con blancos el sobrante , colocandose los mismos a la derecha izquierda , segun sea la
justificacin . Si la (longitud) es menor que la del string , este quedar truncado . La precisin es un nmero
, que debe estar precedido por un punto , e indica el mximo nmero de caracteres del string , que se
imprimirn . La justificacin "default" es hacia la derecha , un signo menos en este campo impone una
justificacion a la izquierda . Dentro de la secuencia de comando pueden ubicarse secuencias de escape
como las vistas en captulos anteriores . Un caso especial se d , cuando en el lugar de la longitud se coloca
un asterisco (*) , ste implica que la longitud vendr expresada por el argumento que sigue al string en la
lista de los mismos (un entero) .

UTN - Informtica I

Capitulo VIII

- 67 -

LENGUAJE C

Ejemplos : En los ejemplos siguientes se ha colocado el caracter | adelante y atras de la secuencia de

comando , para mostrar donde empieza y donde termina la impresin del string .
...........
p = "Lenguaje C" ; /* 10 caracteres */
...........
printf("|%15s|" , p ) ; /* imprime : | Lenguaje C| */
printf("|%15.8s|" , p ) ; /* " : |
Lenguaje| */
printf("|%-15s|" , p ) ; /* " : |Lenguaje C | */
printf("|%-15.8s|" , p ) ; /* " : |Lenguaje
| */
printf("|%.6s|" , p ) ; /* " : |Lengua|
*/
ancho = printf("|%15s|" , p ); /* imprime : | Lenguaje C| */
printf("|%*.8s|" , p , ancho); /* " : |
Lenguaje| */

Existe otra funcin ms especfica que la anterior , aunque ms restrigida , puts() .

PUTS()

Header : <stdio.h>
Prototipo : int puts( const char *s )
Portabilidad : Definida en ANSI C. No es compatible con Windows
Comentario : Copia un string terminado con un NULL y apuntado por s en la salida estandar , normalmente
stdout video . Si la salida fu exitosa retorna un valor positivo , caso contrario EOF . Luego de impreso el
string agrega automaticamente un \n avance de lnea . Es ms rpida que la anterior , ya que escribe
directamente el buffer de video . Solo es aplicable a variables del tipo strings
Ejemplo :
#include <stdio.h>
main()
{
char p[] = "Uno" , s[] = "Dos" ;
puts(p) ;
puts(s) ;
}
/* imprime : Uno
Dos
*/

3. - FUNCIONES DE ADQUISICION DE STRING

Cuando se necesita leer un string enviado desde el teclado , se utilizar alguna de las funciones abajo citadas ,
debiendose tener los recaudos descriptos antes , ya que la longitud del mismo es desconocida.
SCANF()

Header : <stdio.h>
Prototipo : int scanf( const char *formato , direccion , ......... )
Portabilidad : Definida en ANSI C. No es compatible con Windows

UTN - Informtica I

Capitulo VIII

- 68 -

LENGUAJE C

Comentario : Esta funcin es la inversa del printf() y valen para ella los mismos comentarios respecto a su
generalidad. La analizaremos desde el punto de vista exclusivo de los strings . Las secuencias de control
dentro del string de formato , comenzarn con % y terminarn con s , siendo optativo colocar entre ambas
los siguientes modificadores: % [*] [longitud] [N F] s El * en ste caso suprime el asignamiento del valor
ingresado a la variable. Longitud es un entero que indica el mximo de caracteres a cargar en la direccin
dada por el puntero . N F intruyen a la funcin a forzar al puntero entregado como parmetro a ser Near
Far . Se pueden poner varios especificadores de formato seguidos, en ese caso , la cantidad de argumentos
debe coincidir co la de aquellos , por lo menos no ser menor, ya que si as fuera los resultados son
impredecibles y por lo general desastrosos . En cambio , si la cantidad es mayor, el excedente sera
simplemente no tomado en cuenta . Si se separan los especificadores con caracteres de distanciameinto no
imprimibles como , espacio , \t , \n , etc , la funcin esperar a que el correspondiente sea ingresado por el
teclado , una vez ubicado el proximo caracterer imprimible ser enviado a la direccin apuntada por el
prximo parmetro , descartando los separadores anteriores . Si en cambio se usan para separar dos
especificadores de formato , caracteres imprimibles , como dos puntos , coma , etc , estos sern leidos y
descartados. Una condicin particular puede darse en el caso de los strings : se puede especificar los
caracteres grupos de caracteres que se desea leer , si luego del % y encerrado entre corchetes [] se coloca
un grupo de ellos , solo sern enviados a la direccin del parmetro , aquellos que coincidan con los
mismos . Por ejemplo %[0123456789]s solo leer los caracteres numricos . Esto se puede expresar , en
forma ms compacta como %[0-9]s Si en cambio se desea EXCLUIR dichos caracteres debr escribirse :
%[^0-9]s , indicandose la exclusin mediante el simbolo ^ . El uso anterior al de esta funcin , de alguna
otra que lea el teclado pude dejar el buffer del mismo cargado con caracteres que luego afectan a scanf
como si nuevamente hubieran sido escritos , en estos casos se impone el uso previo a la llamada a sta
funcin de fflush() . Retorna un entero de igual valor al de campos leidos exitosamente.

Ejemplo : scanf("%20s" \n "%[0-9A-F]s" , p , q) ; En ste caso se leer un primer string de n ms de 20

caracteres, y se enviar a la direccin contenida por el puntero p , luego se esperar un ENTER y se
enviarn a la direccin de q todos aquellos caracteres leidos que correspondan a los nmeros a letras
comprendidas entre la A y F.

De la misma manera que para printf(), hay funciones menos generales, dedicadas expresamente a la lectura de
strings, como gets(), que veremos a continuacin .
GETS()

Header : <stdio.h>

Prototipo : char *gets( char *s )

Portabilidad : Definida en ANSI C. No es compatible con Windows

Comentario : Lee caracteres desde la entrada estandar , incluyendo los espacios hasta que encuentra un
avance de linea (ENTER), este es reemplazado por un NULL, y el string resultante en cargado en la
direccion indicada por s. Retorna s, un NULL en caso de error. Es responsabilidad del programador, que s
tenga suficiente longitud como para albergar lo ledo.

UTN - Informtica I

Capitulo VIII

- 69 -

LENGUAJE C

4. - FUNCIONES DE CONVERSION ENTRE STRING Y VARIABLES NUMERICAS

Puede darse el caso que la informacin a ingresarse a un programa ejecutable , por el operador pueda ser en algunos
caso un valor numrico y en otros un string de caracteres . Un problema tpico enfrentamos en el ejemplo en que
ingresabamos a nuestra base de datos un articulo , ya sea por su nombre por su nmero de cdigo .
Ms cmodo que escribir dos instancias del programa , una para cada una de las opciones , es dejar que el operador
escriba lo que se le venga en ganas , leyendolo como un string , luego verificar si ste est compuesto
exclusivamente por nmeros posee algun caracter n numrico , y actuar en consecuencia .
Para evaluar si un string cae dentro de una categora dada , es decir si est compuesto exclusivamente por nmeros ,
letras, maysculas , minsculas , caracteres alfanumricos , etc existen una serie de funciones , algunas de las cuales
ya hemos usado, que describimos a continuacin .

Estas deben ser usadas con los strings , analizando caracter a caracter de los mismos, dentro de un FOR un
WHILE:

for(i=0 ; palabra[i] != NULL ; i++)

{ if( isalnum(palabra[i] )
.........................
}
IS.....()

Header : <ctype.h>

Prototipo :
int isalnum( int c )
int isalpha( int c )
int isascii( int c )
int iscntrl( int c )
int isdigit( int c )
int islower( int c )
int isupper( int c )
int ispunct( int c )
int isspace( int c )
int isxdigit( int c )

Portabilidad : Definida en ANSI C

UTN - Informtica I

Capitulo VIII

- 70 -

LENGUAJE C

Comentario : Retornarn un valor CIERTO (distinto de cero) si el caracter enviado como argumento cae
dentro de la catewgora fijada para la comparacin y FALSO cero en caso contrario . Las categorias para
cada funcin son las siguientes :

La Funcin Retorna CIERTO si c es :

Isalnum(c)
Isalpha(c)
Isascii(c)
Iscntrl(c)
Islower(c)
Isupper(c)
Isdigit(c)
Ispunct(c)
Isspace(c)
Isxdigit(c)

Alfanumrico ( letras nmeros )

Alfabetico , mayscula minscula
Si su valor est entre 0 y 126
Si es un caracter de control cuyo ASCII est comprendido entre 0 y 31 si es el cdigo de "delete", 127
Si es un caracter alfabtico minuscula.
Si es un caracter alfabtico mayscula
Si es un nmero comprendido entre 0 y 9
Si es un caracter de puntuacin
Si es el caracter espacio, tabulador, avance de lnea, retorno de carro, etc.
Si es cdigo correspondiente a un nmero hexadecimal, es decir entre 0 - 9 A - F a - f .

Una vez que sabemos que un string est compuesto por nmeros , podemos convertirlo en una variable numrica ,
de cualquier tipo , para poder realizar con ella los clculos que correspondan .
ATOI() , ATOL() , ATOF()

Header : <stdlib.h>
Prototipo :
int atoi( const char *s )
long atol( const char *s )
double atof( const char *s )
Portabilidad : Definida en ANSI C
Comentario : Convierten el string apuntado por s a un nmero . atoi() retorna un entero , atol() un long y
atof() un double . ( Algunos compiladores traen una funcin adicional , _atold() que retorna un long double
) . El string puede tener la siguiente configuracin :
[espacios , blancos , tabulador , etc] [signo] xxx
donde xxx son caracteres entre 0 y 9 , para atoi() y atol() . Para atof() en cambio , se aceptan :
[espacios , etc] [signo] xxx [.] [ xxx]
[espacios , etc] [signo] xxx [.] [ xxx] [ e E [signo] xxx ]
segn se desee usar la convencin de punto flotante cientifica.

Es posible tambien , aunque menos frecuente , realizar la operacin inversa, es decir, convertir un nmero en un
string.
ITOA() , ULTOA()

UTN - Informtica I

Capitulo VIII

- 71 -

LENGUAJE C

Header : <stdlib.h>
Prototipo:
char *itoa( int numero , char *s , int base )
char *ultoa( unsigned long numero , char *s , int base )
Portabilidad : Definida en ANSI C
Comentario : Retornan un puntero a un string formado por caracteres que representan los dgitos del
nmero enviado como argumento . Por base se entiende la de la numeracin en la que se quiere expresar el
string , 10 para decimal , 8 para octal , 16 para hexadecimal , etc . itoa() convertir un entero , mientras
ultoa() lo har con un unsigned long.

5.- DETERMINACION DE LA LONGITUD DE UN STRING

Hemos aplicado anteriormente esta funcin, damos aqu entonces , slo una ampliacin de sus caracteristicas.
STRLEN() , _FSTRLEN

Header : <string.h>
Prototipo :
size_t strlen( const char *s )
size_t far _fstrlen( const char far *s )
Portabilidad : Definidas en ANSI C
Comentario : Retornan un entero con la cantidad de caracteres del string . No toma en cuenta al terminador
NULL . Por lo que la memoria real necesaria para albergar al string es 1+strlen(s) . _fstrlen() d idntico
resultado , pero acepta como argumento un puntero " far " .
Ejemplo :
..............
char s[128] ;
gets(s) ;
p = (char *)malloc( sizeof( strlen(s) + 1 ) ;

6.- COPIA Y DUPLICACION DE STRINGS

Vimos que el operador de asignacin no est definido para strings , es decir que hacer p = q , donde p y q son dos
arrays , no produce la copia de q en p y directamente la expresin no es compilada . Si en cambio p y q son dos
punteros a caracteres , la expresin es compilada , pero no produce el efecto de copia , simplemente , cambia el valor
de p , haciendo que apunte al MISMO string que q . Es decir que no se genera uno nuevo , por lo que todo lo
operado sobre p afectar al original , apuntado por q .
Para generar entonces , una copia de un string en otro lugar de la memoria , se deben utilizar alguna de las funciones
abajo descriptas . Hay que diferenciar la copia de la duplicacion : la primera copia un string sobre un lugar
PREVIAMENTE reservado de memoria ( mediante malloc() , calloc() alguna otra funcin funcin de alocacin ) ,
en cambio la duplicacin GENERA el espacio para guardar al nuevo string as creado.

UTN - Informtica I

Capitulo VIII

- 72 -

LENGUAJE C

STRCPY()

Header : <string.h>
Prototipo : char *strcpy( char *destino , const char *origen )
Portabilidad : Definidas en ANSI C
Comentario : Copia los caracteres del string "origen" , incluyendo el NULL , a partir de la direccin
apuntada por "destino" . No verifica que haya suficiente memoria reservada para tal efecto , por lo que es
responsabilidad del programador ubicar previamente suficiente memoria como para albergar a una copia de
"origen" . Aunque es superfluo , su retorno es el puntero "destino" .

Existe tambien una funcin para realizar la copia PARCIAL . Por lo general las funciones que realizan acciones
sobre una parte solamente , de los strings , llevan el mismo nombre de las que los afectan totalmente , pero con la
adicin de la letra "n".
STRNCPY()
Header : <string.h>
Prototipo : char *strncpy( char *destino , const char *origen , size_t n_char )
Portabilidad : Definidas en ANSI C
Comentario : Copia n_char caracteres del string "origen" , NO incluyendo el NULL , si la cantidad de
caracteres copiada es menor que strlen(origen) + 1 , en la direccin apuntada por "destino" . n_char es un
nmero entero y deber ser menor que la memoria reservada apuntada por destino .
Ejemplo:
#include <string.h>
main()
{
char strvacio[11] ;
char strorigen[] = "0123456789" ;
char strdestino[] = "ABCDEFGHIJ" ;
..................
strncpy( strdestino , strorigen , 5 ) ;
strncpy( strvacio , strorigen , 5 ) ;
strvacio[5] = '\0' ;
.........................
}
Los strings quedaran , luego de la copia :
strdestino[] == 0 , 1 , 2 , 3 , 4 , F , G , H , I , J , \0
strvacio[] == 0 , 1 , 2 , 3 , 4 , \0 , indefinidos
Note que en el caso de strdestino no hizo falta agregar el NULL , ya que ste se gener en la incializacin del
mismo, en cambio strvacio no fu inicializado , por lo que para terminar el string , luego de la copia , se deber
forzosamente agregar al final del mismo.

UTN - Informtica I

Capitulo VIII

- 73 -

LENGUAJE C

La funcin siguiente permite la duplicacin de strings :

STRDUP()

Header : <string.h>
Prototipo : char *strdup( const char *origen )
Portabilidad : Definida en ANSI C
Comentario : Duplica el contenido de "origen" en una zona de memoria por ella reservada y retorna un
puntero a dicha zona .
Ejemplo :
#include <string.h>
main()
{
char *p ;
char q[] = "Duplicacin de strings" ;
p = strdup( q ) ;
..................
}
Note que el retorno de la funcin debe ser siempre asignado a un dado puntero .

7. - CONCATENACION DE STRINGS
Se puede, mediante la concatenacin de dos ms strings , crear otro , cuyo contenido es el agregado del de todos
los anteriores .
La concatenacin de varios strings puede anidarse , de la siguiente manera :
strcat( strcat(x , w) , z ) ;
en la cual al x se le agrega a continuacin el w , y luego el z . Por supuesto x tiene que tener suficiente longitud
como para albergarlos .
STRCAT()

Header : <string.h>
Prototipo : char *strcat( char *destino , const char *origen )
Portabilidad : Definida en ANSI C
Comentario : Agrega el contenido de "origen" al final del string inicializado "destino" , retornando un
puntero a este .
Ejemplo :
#include <string.h>
char z[20] ;
main()
{
char p[20] ;
char q[] = "123456789" ;
char w[] = "AB" ;

UTN - Informtica I

Capitulo VIII

- 74 -

LENGUAJE C
char y[20] = "AB" ;
strcat( y , q ) ; /* Correcto , el contenido de y[] ser:
y[] == A,B,1,2,3,4,5,6,7,8,9,\0 */
strcat( z , q ) ; /* Correcto , por ser global z[] qued
inicializado con 20 NULLS por lo que
luego de la operacin quedar:
z[] == 1,2,3,4,5,6,7,8,9,\0
strcat( p , q ) ; /* Error ! p no ha sido inicializado por
lo que la funcin no encuentra el NULL
para empezar a agregar , por lo que
barre la memoria hasta encontrar
alguno, y ah escribe con resultados,
generalmente catastrficos.
strcat( w , q ) ; /* Error ! w solo tiene 3 caracteres,
por lo el resultado final ser:
w[] == A,B,1 sin la terminacin
del NULL por lo que cualquier
prxima operacin que se haga
utilizando este array, como string,
fallar rotundamente .
{
STRNCAT()

Header : <string.h>
Prototipo : char *strncat( char *destino , const char *origen , size_t cant)
Portabilidad : Definida en ANSI C
Comentario : Similar en un todo a la anterior , pero solo concatena cant caracteres del string "origen" en
"destino" .

8. - COMPARACION DE STRINGS
No debe confundirse la comparacin de strings , con la de punteros , es decir
if(p == q) {
............
slo dar CIERTO cuando ambos apunten al MISMO string , siempre y cuando dichos punteros sean " near " "
huge " . El caso que ac nos ocupa es ms general , ya que involucra a dos ms strings ubicados en distintos puntos
de la memoria ( abarca el caso anterior , como situacin particular).
STRCMP()

Header : <string.h>
Prototipo : int strcmp( const char *s1 , const char *s2 )
Portabilidad : Definida en ANSI C
Comentario : Retorna un entero , cuyo valor depende del resultado de la comparacin
< 0 si s1 es menor que s2
== 0 si s1 es igual a s2

UTN - Informtica I

Capitulo VIII

- 75 -

LENGUAJE C
> 0 si s1 es mayor que s2
La comparacin se realiza caracter a caracter , y devuelve el resultado de la realizada entre los primeros dos que
sean distintos.
La misma se efectua tomando en cuenta el cdigo ASCII de los caracteres as ser por ejemplo '9' < 'A' , 'A' < 'Z y
'Z' < 'a' .

STRCMPI()

Header : <string.h>
Prototipo : int strcmpi( const char *s1 , const char *s2 )
Portabilidad : Solamente vlida para el DOS
Comentario : Retorna un entero , de una manera similar a la anterior pero no es sensible a la diferencia
entre maysculas y minsculas , es decir que en este caso 'a' == 'A' y 'Z' > 'a' .

STRNCMP() , STRNCMPI()

Header : <string.h>
Prototipo : int strcmpi( const char *s1 , const char *s2 , size_t cant)
Portabilidad : strncmpi() es solamente vlida para el DOS strncmp() est definida en ANSI C
Comentario : Retornan un entero , con caracteristicas similares a las de las funciones hermanas , descriptas
arriba , pero solo comparan los primeros "cant" caracteres .

9.- BUSQUEDA DENTRO DE UN STRING

Muchas veces dentro de un programa , se necesita ubicar dentro de un string , a un determinado caracter conjunto
ordenado de ellos . Para simplificarnos la tarea existen una serie de funciones de Librera , que toman por su cuenta
la resolucin de este problema :
STRCHR() Y STRRCHR()

Header : <string.h>
Prototipo :
char *strchr( const char *s1 , int c )
char *strrchr( const char *s1 , int c )
Portabilidad : Definidas en ANSI C
Comentario : Retornan un puntero , a la posicin del caracter dentro del string , si es que lo encuentran ,
en su defecto NULL . strchr() barre el string desde el comienzo , por lo que marcar la primer aparicin del
caracter en l , en cambio strrchr() lo barre desde el final , es decir que buscar la ltima aparicin del
mismo . El terminador NULL es considerado como parte del string .

UTN - Informtica I

Capitulo VIII

- 76 -

LENGUAJE C

STRBRK()

Header : <string.h>
Prototipo : char *strbrk( const char *s1 , const char *s2 )
Portabilidad : Definidas en ANSI C
Comentario : Similar a las anteriores , pero ubicando la primer aparicin de cualquier caracter contenido en
s2 , dentro de s1 .

STRSTR()

Header : <string.h>
Prototipo : char *strstr( const char *s1 , const char *s2 )
Portabilidad : Definidas en ANSI C
Comentario : Busca dentro de s1 un substring igual a s2 , devolviendo un puntero al primer caracter del
substring . cualquier caracter contenido en s2 , dentro de s1 .

STRTOK()

Header : <string.h>
Prototipo : char *strtok( const char *s1 , const char *s2 )
Portabilidad : Definidas en ANSI C
Comentario : Busca dentro de s1 un substring igual a s2 , si lo encuentra MODIFICA a s1 reemplazando el
substring por NULL, devolviendo la direccin de s1. Si se lo vuelve a invocar con NULL en lugar en el
lugar del parmetro s1, continua buscando en el string original una nueva aparicin de s2 . Cuando no
encuentra el substring , retorna NULL. Sirve para descomponer un string en "palabras de una frase" cuando
stas estan separadas por un mismo caracter/es .
Ejemplo :
puts("escriba una frase , separando las palabras con espacios") ;
gets(s) ;
p = strtok(s , " ") ;
while(p) {
puts(p) ;
p = strtok( NULL , " ") ;
}

10.- FUNCIONES DE MODIFICACION DE STRING

Resulta conveniente a veces uniformizar los string leidos de teclado, antes de usarlos, un caso tpico es tratar de
independizarse de la posibilidad de que el operador escriba, algunas veces con mayscula y otras con minscula.
UTN - Informtica I

Capitulo VIII

- 77 -

LENGUAJE C

STRLWR() Y STRUPR()

Header : <string.h>
Prototipo :
char *strlwr( char *s1 )
char *strupr( char *s1 )
Portabilidad : Definidas en ANSI C
Comentario : Convierten respectivamente los caracteres comprendidos entre a y z a minsculas
maysculas , los restantes quedan como estaban .

UTN - Informtica I

Capitulo VIII

- 78 -

LENGUAJE C

CAPITULO 9: SENTECIAS DE ENTRADA Y SALIDA

SALIDA : print()
La rutina printf permite la representacin de valores numricos, caracteres y cadenas de texto por pantalla.

El prototipo de la sentencia printf es el siguiente:

printf(control,arg1,arg2...);

En la cadena de control indicamos la forma en que se mostrarn los argumentos posteriores. Tambin podemos
introducir una cadena de texto ( sin necesidad de argumentos ), o combinar ambas posibilidades, as como sentencias
de escape
En el caso de que utilicemos argumentos deberemos indicar en la cadena de control tanto los modificadores como
argumentos vayamos a representar.
El modificador est compuesto por el caracter % seguido por un caracter de conversin, que indica de que tipo se
trata.

/* Uso de la sentencia printf() 1. */

#include <stdio.h>
main() /* Saca por pantalla una suma */
{
int a=20,b=10;
printf("El valor de a es %d\n",a);
printf("El valor de b es %d\n",b);
printf("Por tanto %d+%d=%d",a,b,a+b);
}

Los modificadores ms utilizados son:

%c
%d
%u
%o
%x
%e
%f
%s
%p

UTN - Informtica I

Un nico caracter
Un entero con signo, en base decimal
Un entero sin signo, en base decimal
Un entero en base octal
Un entero en base hexadecimal
Un nmero real en coma flotante, con exponente
Un nmero real en coma flotante, sin exponente
Una cadena de caracteres
Un puntero o direccin de memoria

Capitulo IX

- 79 -

LENGUAJE C

/* Uso de la sentencia printf() 2. */

#include <stdio.h>
main()
{
char cad[]="El valor de";
int a=-15;
unsigned int b=3;
float c=932.5;
printf("%s a es %d\n",cad,a);
printf("%s b es %u\n",cad,b);
printf("%s c es %e o %f",cad,c,c);
}

El formato completo de los modificadores es el siguiente:

% [signo] [longitud] [.precisin] [l/L] conversin
Signo: indicamos si el valor se ajustar a la izquierda, en cuyo caso utilizaremos el signo menos, o a la derecha ( por
defecto ).
Longitud: especifica la longitud mxima del valor que aparece por pantalla. Si la longitud es menor que el nmero
de dgitos del valor, ste aparecer ajustado a la izquierda.
Precisin: indicamos el nmero mximo de decimales que tendr el valor.
l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double.

/* Uso de la sentencia printf() 3. */

#include <stdio.h> main() /* Modificadores 2 */
main()
{
char cad[ ]="El valor de";
int a=25986;
long int b=1976524;
float c=9.57645;
printf("%s a es %9d\n",cad,a);
printf("%s b es %ld\n",cad,b);

UTN - Informtica I

Capitulo IX

- 80 -

LENGUAJE C
printf("%s c es %.3f",cad,c); }
}

UTN - Informtica I

Capitulo IX

- 81 -

LENGUAJE C
ENTRADA : scanf( )
La funcin scanf permite entrar datos en la memoria del ordenador a travs del teclado.
El prototipo de la sentencia scanf es el siguiente:
scanf(control,arg1,arg2...);

En la cadena de control indicaremos, por regla general, los modificadores que harn referencia al tipo de dato de los
argumentos. Al igual que en la sentencia printf los modificadores estarn formados por el caracter % seguido de un
caracter de conversin. Los argumentos indicados sern, nuevamente, las variables.
La principal caracterstica de la sentencia scanf es que necesita saber la posicin de la memoria del ordenador en que
se encuentra la variable para poder almacenar la informacin obtenida. Para indicarle esta posicin utilizaremos el
smbolo ampersand ( & ), que colocaremos delante del nombre de cada variable. ( Esto no ser necesario en los
arrays ).

/* Uso de la sentencia scanf(). */

#include <stdio.h> main() /* Solicita dos datos */
main()
{
char nombre[10];
int edad;
printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tu edad: ");
scanf("%d",&edad); }
}

UTN - Informtica I

Capitulo IX

- 82 -

LENGUAJE C

CAPITULO 10 : FICHEROS
10.1 - Manejo de ficheros bsico con stdio.h
La biblioteca STDIO contiene funciones para trabajar con ficheros: bsicamente leer y escribir datos de diferentes
formas.
Antes de trabajar con un fichero, hay que abrirlo. Cuando se abre un fichero, se devuelve un puntero a una
estructura de tipo FILE (definido en STDIO). Esta estructura, llamada descriptor de fichero , servir para
manipular posteriormente el fichero.
Tras su uso, hay que cerrar el fichero.
Modelo de uso:
FILE* fd;
/* variable para apuntar al descriptor de fichero */
...
/* abre el fichero en modo lectura */
fd = fopen ( "pepe.txt", "rt" );
... trabaja con el fichero ...
fclose (fd);

/* cierra el fichero */

Muchas de las funciones de STDIO para trabajar con ficheros comienzan por la letra "f" (fopen, fclose, fprintf,
fwrite, etc.)

10.2 Abrir y cerrar un fichero

Abrir un fichero
fd = fopen ( nombre, modo );
Devuelve NULL si no se pudo abrir correctamente el fichero.
nombre es el nombre del fichero.
modo es una cadena donde se define el modo de apertura:
r slo lectura
w escritura
a apndice (escribir desde el final)
+ (combinado con r,w a) lectura/escritura
t fichero de texto

UTN - Informtica I

Capitulo X

- 82 -

LENGUAJE C
b fichero binario
Ejemplo :
fd = fopen ( "c:\\ejemplos\\fichero.txt", "r+t" );
abre el fichero c:\ejemplos\fichero.txt en modo lectura/escritura y en modo texto. Obsrvese que las barras en el
nombre del fichero tienen que escribirse duplicadas.
Un fichero abierto en modo texto convierte la combinacin CR+LF en un carcter de salto de lnea. Si es binario,
CR+LF se consideran dos caracteres independientes.
Cerrar un fichero
fclose ( fd );
donde fd es un descriptor de fichero ya abierto.

10.3 Leer una cadena desde un fichero

fgets ( cadena, N, fd );
Lee una lnea de texto.
cadena es el vector de caracteres donde se depositar la lnea.
N es el mximo nmero de caracteres para leer. Si la lnea ocupa ms de N caracteres, slo se lee esa cantidad.
fd es el descriptor del fichero.
Cuando se abre un fichero, se comienza a leer desde la primera lnea. Llamadas consecutivas a fgets van leyendo
lnea por lnea. Si se cierra el fichero y se vuelve a abrir, se lee otra vez desde el principio.
Internamente existe un puntero del fichero que apunta a la posicin relativa al fichero donde se va a leer el
siguiente dato.

10.4 Escribir una cadena en un fichero

fputs ( cadena, fd );
cadena es el texto que se escribe. fputs incluye adems un salto de lnea.
fd es el descriptor del fichero.
Las lneas escritas se van aadiendo una detrs de otra. Se comienza por el principio del fichero ( w) o por el final
(a). Tambin existe internamente un puntero de fichero para escritura.
fprintf ( fd, formato, arg1, arg2, ... );
Escribe un texto con formato en un fichero. La sintaxis es idntica a printf, salvo que el primer argumento es un
descriptor de fichero.
10.5 Detectar el final de fichero
x = feof ( fd );
Devuelve un 1 si se ha llegado al final del fichero. Un cero en caso contrario.
til para saber cundo dejar de leer informacin, por ejemplo
UTN - Informtica I

Capitulo X

- 83 -

LENGUAJE C

10.6 Reposicionar el puntero del fichero

rewind ( fd );
Mueve el puntero de lectura/escritura del fichero al comienzo del mismo (rebobina).
fseek ( fd, posicin, de_dnde );
Mueve el puntero del fichero a la posicin indicada, relativa a un punto especificado en de_dnde.
posicin es de tipo long .
de_dnde puede tener los siguientes valores:
SEEK_SET desde el origen del fichero
SEEK_CUR desde la posicin actual del puntero
SEEK_END desde el final del fichero
Ejemplo :
FILE* fich;
char cadena [16];
/* lee los ltimos 15 caracteres del fichero */
fich = fopen ( "fichero.txt", "rt" );
fseek ( fd, -15L, SEEK_END);
fgets ( texto, 15, fich );
fclose (fich);
10.7 Flujos (streams) estndares
Los ficheros de donde se lee o escribe informacin con las rutinas de STDIO se llaman flujos o streams. Un flujo
puede ser un fichero, pero tambin el teclado (se puede leer de l) o la pantalla (se puede escribir en ella).
Los llamados flujos estndares son estos:

stdin

entrada estndar (normalmente el teclado)

stdout

salida estndar (normalmente la pantalla)

stderr

error estndar (normalmente la pantalla)

Se pueden utilizar con las funciones de STDIO:

fgets ( cadena, 80, stdin );
fprintf (stderr,"Se ha producido un error" );

UTN - Informtica I

Capitulo X

- 84 -

LENGUAJE C
Los flujos estndares se pueden redirigir desde el MS-DOS.

10.8 Gestin de errores: errno

Muchas funciones de biblioteca devuelven un -1 o un NULL si ocurre un error. Esto es habitual en las funciones de
tratamiento de ficheros.
La variable errno contiene un cdigo de error relativo al ltimo error producido. Para trabajar con errno hay que
incluir el fichero errno.h
En errno.h estn definidos todos los cdigos de error posibles.
Aparte, existe la funcin perror(), que da un mensaje (en ingls) sobre el error producido.

UTN - Informtica I

Capitulo X

- 85 -

LENGUAJE C
CAPITULO 11 : Algoritmos de Ordenamiento

Qu es ordenamiento?
Es la operacin de arreglar los registros de una tabla en algn orden secuencial de acuerdo a un criterio
de ordenamiento.
El ordenamiento se efecta con base en el valor de algn campo en un registro.
El propsito principal de un ordenamiento es el de facilitar las bsquedas de los miembros del conjunto
ordenado.
Ej. de ordenamientos:
Dir. telefnico, tablas de contenido, bibliotecas y diccionarios, etc.
El ordenar un grupo de datos significa mover los datos o sus referencias para que queden en una
secuencia tal que represente un orden, el cual puede ser numrico, alfabtico o incluso alfanumrico,
ascendente o descendente.
Cundo conviene usar un mtodo de ordenamiento?
Cuando se requiere hacer una cantidad considerable de bsquedas y es importante el factor tiempo.
Tipos de ordenamientos:
Los 2 tipos de ordenamientos que se pueden realizar son: los internos y los externos.
Los internos:
Son aquellos en los que los valores a ordenar estn en memoria principal, por lo que se asume que el
tiempo que se requiere para acceder cualquier elemento sea el mismo (a[1], a[500], etc).
Los externos:
Son aquellos en los que los valores a ordenar estn en memoria secundaria (disco, cinta, cilindro
magntico, etc), por lo que se asume que el tiempo que se requiere para acceder a cualquier elemento
depende de la ltima posicin accesada (posicin 1, posicin 500, etc).
Eficiencia en tiempo de ejecucin:
Una medida de eficiencia es:
Contar el # de comparaciones (C)
Contar el # de movimientos de items (M)
Estos estn en funcin de el #(n) de items a ser ordenados.
Un "buen algoritmo" de ordenamiento requiere de un orden nlogn comparaciones.
La eficiencia de los algoritmos se mide por el nmero de comparaciones e intercambios que tienen que
hacer, es decir, se toma n como el nmero de elementos que tiene el arreglo o vector a ordenar y se dice
que un algoritmo realiza O(n2) comparaciones cuando compara n veces los n elementos, n x n = n2
Algoritmos de ordenamiento:
Internos:
1. Insercin directa.
1. Insercin directa.
2. Insercin binaria.
2. Seleccin directa.
1. Seleccin directa.
3. Intercambio directo.
UTN - Informtica I

Capitulo XI

- 86 -

LENGUAJE C

4.
5.
6.
7.
8.
9.

1. Burbuja.
2. Shake.
Insercin disminucin incremental.
1. Shell.
Ordenamiento de rbol.
1. Heap.
2. Tournament.
Sort particionado.
1. Quick sort.
Merge sort.
Radix sort.
Clculo de direccin.

Externos:
1. Straight merging.
2. Natural merging.
3. Balanced multiway merging.
4. Polyphase sort.
5. Distribution of initial runs.
Clasificacin de los algoritmos de ordenamiento de informacin:
El hecho de que la informacin est ordenada, nos sirve para poder encontrarla y accesarla de manera
ms eficiente ya que de lo contrario se tendra que hacer de manera secuencial.
A continuacin se describirn 4 grupos de algoritmos para ordenar informacin:
Algoritmos de insercin:
En este tipo de algoritmo los elementos que van a ser ordenados son considerados uno a la vez. Cada
elemento es INSERTADO en la posicin apropiada con respecto al resto de los elementos ya ordenados.
Entre estos algoritmos se encuentran el de INSERCION DIRECTA, SHELL SORT, INSERCION BINARIA
y HASHING.
Algoritmos de intercambio:
En este tipo de algoritmos se toman los elementos de dos en dos, se comparan y se INTERCAMBIAN si
no estn en el orden adecuado. Este proceso se repite hasta que se ha analizado todo el conjunto de
elementos y ya no hay intercambios.
Entre estos algoritmos se encuentran el BURBUJA y QUICK SORT.
Algoritmos de seleccin:
En este tipo de algoritmos se SELECCIONA o se busca el elemento ms pequeo (o ms grande) de
todo el conjunto de elementos y se coloca en su posicin adecuada. Este proceso se repite para el resto
de los elementos hasta que todos son analizados.
Entre estos algoritmos se encuentra el de SELECCION DIRECTA.
Algoritmos de enumeracin:
En este tipo de algoritmos cada elemento es comparado contra los dems. En la comparacin se cuenta
cuntos elementos son ms pequeos que el elemento que se est analizando, generando as una
ENUMERACION. El nmero generado para cada elemento indicar su posicin.

UTN - Informtica I

Capitulo XI

- 87 -

LENGUAJE C
Los mtodos simples son: Insercin (o por insercin directa), seleccin, burbuja y shell, en dnde el
ltimo es una extensin al mtodo de insercin, siendo ms rpido. Los mtodos ms complejos son el
quick-sort (ordenacin rpida) y el heap sort.
A continuacin se mostrarn los mtodos de ordenamiento ms simples.
METODO DE INSERCIN.
Este mtodo toma cada elemento del arreglo para ser ordenado y lo compara con los que se encuentran
en posiciones anteriores a la de l dentro del arreglo. Si resulta que el elemento con el que se est
comparando es mayor que el elemento a ordenar, se recorre hacia la siguiente posicin superior. Si por
el contrario, resulta que el elemento con el que se est comparando es menor que el elemento a
ordenar, se detiene el proceso de comparacin pues se encontr que el elemento ya est ordenado y se
coloca en su posicin (que es la siguiente a la del ltimo nmero con el que se compar).
Procedimiento Insertion Sort
Este procedimiento recibe el arreglo de datos a ordenar a[] y altera las posiciones de sus elementos
hasta dejarlos ordenados de menor a mayor. N representa el nmero de elementos que contiene a[].
paso 1: [Para cada pos. del arreglo] For i <- 2 to N do
paso 2: [Inicializa v y j] v <- a[i]
j <- i.
paso 3: [Compara v con los anteriores] While a[j-1] > v AND j>1 do
paso 4: [Recorre los datos mayores] Set a[j] <- a[j-1],
paso 5: [Decrementa j] set j <- j-1.
paso 5: [Inserta v en su posicin] Set a[j] <- v.
paso 6: [Fin] End.

Ejemplo:
Si el arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'], el algoritmo va a recorrer el
arreglo de izquierda a derecha. Primero toma el segundo dato 's' y lo asigna a v y i toma el valor de la
posicin actual de v.
Luego compara esta 's' con lo que hay en la posicin j-1, es decir, con 'a'. Debido a que 's' no es menor
que 'a' no sucede nada y avanza i.
Ahora v toma el valor 'o' y lo compara con 's', como es menor recorre a la 's' a la posicin de la 'o';
decrementa j, la cual ahora tiene la posicin en dnde estaba la 's'; compara a 'o' con a[j-1] , es decir,
con 'a'. Como no es menor que la 'a' sale del for y pone la 'o' en la posicin a[j]. El resultado hasta este
punto es el arreglo siguiente: a = ['a','o','s','r',....]
As se contina y el resultado final es el arreglo ordenado :
a = ['a','a','e','e','g','i','l','m','n','o','p','r','s','t','x']
MTODO DE SELECCIN.
El mtodo de ordenamiento por seleccin consiste en encontrar el menor de todos los elementos del
arreglo e intercambiarlo con el que est en la primera posicin. Luego el segundo mas pequeo, y as
sucesivamente hasta ordenar todo el arreglo.
Procedimiento Selection Sort
paso 1: [Para cada pos. del arreglo] For i <- 1 to N do
paso 2: [Inicializa la pos. del menor] menor <- i
paso 3: [Recorre todo el arreglo] For j <- i+1 to N do
paso 4: [Si a[j] es menor] If a[j] < a[menor] then
paso 5: [Reasigna el apuntador al menor] min = j
paso 6: [Intercambia los datos de la pos.
min y posicin i] Swap(a, min, j).
paso 7: [Fin] End.

Ejemplo:
UTN - Informtica I

Capitulo XI

- 88 -

LENGUAJE C
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento
es la primera 'a'. De manera que no ocurre ningn cambio. Luego se procede a buscar el siguiente
elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que est en la segunda posicin, la 's', quedando el arreglo as despus
de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo
que est en la tercera posicin, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posicin hasta ordenar todo el
arreglo.
El nmero de comparaciones que realiza este algoritmo es :
Para el primer elemento se comparan n-1 datos, en general para el elemento i-simo se hacen n-i
comparaciones, por lo tanto, el total de comparaciones es:
la sumatoria para i de 1 a n-1 (n-i) = 1/2 n (n-1).
MTODO BURBUJA.
El bubble sort, tambin conocido como ordenamiento burbuja, funciona de la siguiente manera: Se
recorre el arreglo intercambiando los elementos adyacentes que estn desordenados. Se recorre el
arreglo tantas veces hasta que ya no haya cambios. Prcticamente lo que hace es tomar el elemento
mayor y lo va recorriendo de posicin en posicin hasta ponerlo en su lugar.
Procedimiento Bubble Sort
paso 1: [Inicializa i al final de arreglo] For i <- N down to 1 do
paso 2: [Inicia desde la segunda pos.] For j <- 2 to i do
paso 4: [Si a[j-1] es mayor que el que le sigue] If a[j-1] < a[j] then
paso 5: [Los intercambia] Swap(a, j-1, j).
paso 7: [Fin] End.

Tiempo de ejecucin del algoritmo burbuja:

1. Para el mejor caso (un paso) O(n)
2. Peor caso n(n-1)/2
3. Promedio O(n2)
MTODO DE SHELL.
Ordenamiento de disminucin incremental.
Nombrado as debido a su inventor Donald Shell.
Ordena subgrupos de elementos separados K unidades (respecto de su posicin en el arreglo) del
arreglo original. El valor K es llamado incremento.
Despus de que los primeros K subgrupos han sido ordenados (generalmente utilizando INSERCION
DIRECTA), se escoge un nuevo valor de K ms pequeo, y el arreglo es de nuevo partido entre el nuevo
conjunto de subgrupos. Cada uno de los subgrupos mayores es ordenado y el proceso se repite de
nuevo con un valor ms pequeo de K.
Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste de todo el arreglo ya
casi ordenado.
Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el ltimo valor debe
ser 1.
"Es como hacer un ordenamiento de burbuja pero comparando e intercambiando elementos."
Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte del subgrupo y se
aplica insercin directa.
El mtodo se basa en tomar como salto N/2 (siendo N el nmero de elementos) y luego se va reduciendo
a la mitad en cada repeticin hasta que el salto o distancia vale 1.
Procedimiento Shell Sort;
const
MAXINC = _____;
UTN - Informtica I

Capitulo XI

- 89 -

LENGUAJE C
incrementos = array[1..MAXINC] of integer;
var
j,p,num,incre,k:integer;
begin
for incre := 1 to MAXINC do begin /* para cada uno de los incrementos */
k := inc[incre]; /* k recibe un tipo de incremento */
for p := k+1 to MAXREG do begin /* insercin directa para el grupo que se encuentra cada K posiciones */
num := reg[p];
j := p-k;
while (j>0) AND (num < reg[j]) begin
reg[j+k] := reg[j];
j := j - k;
end;
reg[j+k] := num;
end
end
end;

Ejemplo:
Para el arreglo a = [6, 1, 5, 2, 3, 4, 0]
Tenemos el siguiente recorrido:
Recorrido
1
2
3
4
5

UTN - Informtica I

Salto
3
3
3
1
1

Lista Ordenada
2,1,4,0,3,5,6
0,1,4,2,3,5,6
0,1,4,2,3,5,6
0,1,2,3,4,5,6
0,1,2,3,4,5,6

Intercambio
(6,2), (5,4), (6,0)
(2,0)
Ninguno
(4,2), (4,3)
Ninguno

Capitulo XI

- 90 -