Manual C

TABLA DE CONTENIDOS
TABLA DE CONTENIDOS..............................................................................................................................1
1.
INTRODUCCIN....................................................................................................................................3
1.1.
HISTORIA DEL C.................................................................................................................................3
1.2.
GENERALIDADES Y CARACTERSTICAS DEL LENGUAJE C..............................................................4
1.3.
VISTA EXTERNA E INTERNA DE UN PROGRAMA EN C.......................................................................6
1.3.1. Vista externa.................................................................................................................................6
1.3.2. Vista interna.................................................................................................................................8
2.
OPERADORES Y EXPRESIONES......................................................................................................10
2.1.
TIPOS FUNDAMENTALES DE DATOS..................................................................................................10
2.1.1. Caracteres (tipo char)................................................................................................................10
2.1.2. Nmeros enteros (tipo int)..........................................................................................................11
2.1.3. Nmeros reales (tipo float).........................................................................................................12
2.1.4. Nmeros reales (tipo double).....................................................................................................12
2.2.
IDENTIFICADORES............................................................................................................................13
2.3.
PALABRAS CLAVES..........................................................................................................................13
2.4.
COMENTARIOS..................................................................................................................................14
2.5.
VARIABLES......................................................................................................................................14
2.6.
CONSTANTES....................................................................................................................................17
2.6.1. Constantes enteras:....................................................................................................................18
2.6.2. Constantes reales:......................................................................................................................18
2.6.3. Constantes alfanumricas..........................................................................................................18
2.7.
INCLUSIN DE ARCHIVOS EN C.......................................................................................................19
2.8.
OPERADORES...................................................................................................................................19
2.8.1. Operadores Aritmticos.............................................................................................................19
2.8.2. Operadores Relacionales...........................................................................................................19
2.8.3. Operadores Lgicos...................................................................................................................19
2.8.4. Operadores Lgicos a Nivel de Bit............................................................................................20
2.8.5. Operadores de Asignacin.........................................................................................................20
2.9.
GRUPO DE PROCEDENCIA DE OPERADORES.....................................................................................20
2.10.
CONVERSIONES DE TIPO...................................................................................................................21
3.
ELEMENTOS DE PROGRAMACIN ESTRUCTURADA.............................................................23

3.1.
SENTENCIAS DE ENTRADA Y SALIDA DE DATOS.............................................................................23
3.1.1. Introduccin:..............................................................................................................................23
3.1.2. Funciones de entrada y salida...................................................................................................23
3.2.
SENTENCIAS DE CONTROL...............................................................................................................28
3.2.1. Introduccin...............................................................................................................................28
3.2.2. Sentencias de Control Simples...................................................................................................28
3.2.3. Sentencias de Control Cclicas..................................................................................................31
3.3.
VARIABLES - MBITO DE VALIDEZ.................................................................................................35
4.
TIPOS ESTRUCTURADOS DE DATOS.............................................................................................38

4.1.
DEFINICIN......................................................................................................................................38
4.2.
INICIALIZACION DE ARREGLOS.......................................................................................................39
4.3.
TIPOS ARREGLOS.............................................................................................................................41
4.3.1. Unidimensionales:.....................................................................................................................41
4.3.2. Multidimensionales....................................................................................................................42
4.4.
GENERALIDADES..............................................................................................................................43
4.5.
ARREGLOS Y CADENAS...................................................................................................................45
4.5.1. Qu es una cadena?.................................................................................................................45
4.6.
PROCESAMIENTO DE ARREGLOS.......................................................................................................54
4.7.
PASO DE ARREGLOS A FUNCIONES...................................................................................................54
5.
FUNCIONES...........................................................................................................................................57
UNI Universidad Nacional de Ingeniera

_________________________________________________________________________
5.1.
5.2.
5.3.
5.4.
5.5.
6.
QUE SON FUNCIONES.......................................................................................................................57

DECLARACIN DE FUNCIONES.........................................................................................................57
LLAMADAS A FUNCIN....................................................................................................................60
PARMETROS POR VALOR................................................................................................................60
PARMETROS POR REFERENCIA.......................................................................................................62
PUNTEROS Y MANEJO DE ARCHIVOS..........................................................................................64

6.1.
PUNTEROS........................................................................................................................................64
6.1.1. Concepto de Puntero..................................................................................................................64
6.1.2. Declaracin de punteros............................................................................................................64
6.1.3. Operadores de Punteros.............................................................................................................64
6.1.4. Aritmtica de Punteros...............................................................................................................68
6.1.5. Asignacin dinmica de Memoria.............................................................................................70
6.1.6. Punteros y arrays.......................................................................................................................74
6.1.7. Inicializaciones de punteros.......................................................................................................80
6.1.8. Punteros a funciones..................................................................................................................81
6.1.9. Modificador de acceso const y punteros....................................................................................82
6.1.10.
Declaraciones curiosas.........................................................................................................84
6.2.
ESTRUCTURAS..................................................................................................................................86
6.2.1. Concepto de estructura..............................................................................................................86
6.2.2. Declaracin................................................................................................................................86
6.2.3. Estructuras y funciones..............................................................................................................88
6.2.4. Arrays de estructuras.................................................................................................................91
6.2.5. Typedef.......................................................................................................................................92
6.3.
FICHEROS.........................................................................................................................................93
6.3.1. Apertura.....................................................................................................................................93
6.3.2. Cierre.........................................................................................................................................95
6.3.3. Funciones de Escritura y lectura...............................................................................................95
7.
GRFICOS EN EL LEGUAJE C.......................................................................................................102

7.1.
PROGRAMA TEXTO VS. PROGRAMA GRAFICO.................................................................................102
7.2.
INICIALIZACIN DEL MODO GRAFICO.............................................................................................103
7.3.
DIBUJAR EN EL MODO GRFICO (PRIMITIVOS GRFICOS).............................................................104
7.3.1. Pintar un punto:.......................................................................................................................104
7.3.2. Dibujar un segmento de recta:.................................................................................................105
7.3.3. Para dibujar una circunferencia:.............................................................................................105
7.3.4. Para trazar un rectngulo:......................................................................................................105
7.3.5. Dibujar un arco circular:.........................................................................................................105
7.3.6. Dibujar un arco elptico:..........................................................................................................105
7.4.
CAMBIAR EL ESTILO DE LNEA:......................................................................................................106
7.5.
FUNCIONES DE RELLENO................................................................................................................106
7.6.
FUNCIONES DE ESCRITURA DE TEXTO............................................................................................108
7.6.1. Mostrar texto en un lugar especfico.......................................................................................108
7.6.2. Seleccionar el estilo del texto...................................................................................................108
7.6.3. Cambiar los lmites del dibujo.................................................................................................108
7.6.4. Limpiar el viewport actual:......................................................................................................109
7.6.5. Otras.........................................................................................................................................109
REFERENCIAS..............................................................................................................................................110
1. Introduccin
_________________________________________________________________________
Programacin II
Pgina 2

_________________________________________________________________________
1.1.
Historia del C
C fue desarrollado originalmente en los aos setenta por Dennis Ritchie en Bell
Telephone Laboratories, Inc. (ahora una sucursal de AT&T). Es el resultado de dos
lenguajes anteriores, el BCPL y el B, que se desarrollaron tambin en los laboratorios
Bell. C estuvo confinado al uso en los laboratorios Bell hasta 1978, cuando Brian
Kernighan y Ritchie publicaron una descripcin definitiva del lenguaje. La definicin de
Kernighan y Ritchie se denomina frecuentemente K.&R C.
Tras la publicacin de la definicin de K&R, los profesionales de las computadoras,
impresionados por las muchas caractersticas deseables del C, comenzaron a promover
el uso del lenguaje. A mediados de los ochenta la popularidad del C se haba extendido
por todas partes. Se haban escrito numerosos compiladores e intrpretes de C para
computadoras de todos los tamaos y se haban desarrollado numerosas aplicaciones
comerciales. Es ms, muchas aplicaciones que se haban escrito originalmente en otros
lenguajes se reescribieron en C para tomar partido de su eficiencia y portabilidad.
Las primeras implementaciones comerciales de C diferan en parte de la definicin
original de Kernighan y Ritchie, creando pequeas incompatibilidades entre las
diferentes implementaciones del lenguaje. Estas diferencias reducan la portabilidad
que el lenguaje intentaba proporcionar. Consecuentemente, el Instituto Nacional
Americano
de
Estndares**
(comit
ANS
X3J11)
desarroll
una
definicin
estandarizada del lenguaje C. La mayora de los compiladores e intrpretes comerciales

de C actuales adoptan el estndar ANSCII. Algunos compiladores tambin pueden
proporcionar caractersticas adicionales propias.
En la dcada de los ochenta, Bjarne Stroustrup desarroll en los laboratorios Bell otro
lenguaje de programacin de alto nivel denominado C++. ste se basa en C, y por tanto
todas las caractersticas estndar de C estn disponibles en C++, Sin embargo, C++ no
es una mera extensin de C. Incorpora nuevos fundamentos que constituyen una base
_________________________________________________________________________
Programacin II
Pgina 3

_________________________________________________________________________
para la programacin orientada a objetos un nuevo paradigma de la programacin de
inters para los programadores profesionales.
1.2.
Generalidades y caractersticas del Lenguaje C
C es un lenguaje de programacin estructurado de propsito general. Sus instrucciones

constan de trminos que se parecen a expresiones algebraicas, adems de ciertas
palabras clave inglesas como if, else, for, do y while. En este sentido, C recuerda a
otros lenguajes de programacin estructurados como Pascal y Fortran. C tiene tambin
algunas caractersticas adicionales que permiten su uso a un nivel ms bajo, cubriendo
as el vaco entre el lenguaje mquina y los lenguajes de alto nivel ms convencionales.
Esta flexibilidad permite el uso de C en la programacin de sistemas (por ejemplo, para
el diseo sistemas operativos) as como en la programacin de aplicaciones (por
ejemplo, para redactar un programa que resuelva un complicado sistema de ecuaciones
matemticas o un programa que escriba las facturas para los clientes).
C se caracteriza por hacer posible la redaccin de programas fuente muy concisos,
debido en parte al gran nmero de operadores que incluye el lenguaje. Tiene un
repertorio de instrucciones relativamente pequeo, aunque las implementaciones
actuales incluyen numerosas funciones de biblioteca que mejoran las instrucciones
bsicas. Es ms, el lenguaje permite a los usuarios escribir funciones de biblioteca
adicionales para su propio uso. De esta forma, las caractersticas y capacidades del
lenguaje pueden ser ampliadas fcilmente por el usuario.
Hay compiladores de C disponibles para computadoras de todos los tamaos, y los
intrpretes de C se estn haciendo cada vez ms comunes. Los compiladores son
frecuentemente compactos y generan programas objeto que son pequeos y muy
eficientes en comparacin con los programas generados a partir de otros lenguajes de
alto nivel.
_________________________________________________________________________
Programacin II
Pgina 4

_________________________________________________________________________
Los intrpretes son menos eficientes, aunque resultan de uso ms cmodo en el
desarrollo de nuevos programas. Muchos programadores comienzan utilizando un
intrprete, y una vez que se ha depurado el programa (eliminado los errores del mismo)
utilizan un compilador.
Otra caracterstica importante de C es que los programas son muy portables, ms que
los escritos en otros lenguajes de alto nivel. La razn de esto es que C deja en manos
de las funciones de biblioteca la mayora de las caractersticas dependientes de la
computadora.
Toda versin de C se acompaa de su propio conjunto de funciones de biblioteca, que
estn escritas para las caractersticas particulares de la computadora en la que se
instale. Estas funciones de biblioteca estn relativamente normalizadas y el acceso a
cada funcin de biblioteca es idntico en todas las versiones de C. De esta forma, la
mayora de los programas en C se pueden compilar y ejecutar en muchas
computadoras diferentes prcticamente sin modificaciones.
1.3.
Vista Externa e Interna de un Programa en C
1.3.1. Vista externa

No referimos con vista externa a la forma en que se encuentra estructurado un
programa en C.
_________________________________________________________________________
Programacin II
Pgina 5

_________________________________________________________________________
A continuacin se explica de forma sencilla la estructura de un programa en C. Todo
programa en C consta de uno o ms mdulos llamados funciones. Una de las funciones
se llama main. El programa siempre comenzar por la ejecucin de la funcin main, la
cual puede acceder a las dems funciones. Las definiciones de las funciones
adicionales se deben realizar aparte, bien precediendo o siguiendo a main.
Cada funcin debe contener:
Una cabecera de la funcin, que consta del nombre de la funcin, seguido de

una lista opcional de argumentos encerrados entre parntesis.
Una lista de declaracin de argumentos, si se incluyen stos en la cabecera.

Una instruccin compuesta, que contiene el resto de la funcin.
Los argumentos son smbolos que representan informacin que se le pasa a la funcin
desde otra parte del programa. (Tambin se llama parmetros a los argumentos.).
Cada instruccin compuesta se encierra con un par de llaves, { }. Las llaves pueden
contener combinaciones de instrucciones elementales (denominadas instrucciones de
expresin) y otras instrucciones compuestas. As las instrucciones compuestas pueden
estar anidadas, una dentro de otra. Cada instruccin de expresin debe acabar en
punto y coma (;).
Los comentarios pueden aparecer en cualquier parte del programa, mientras estn
situados entre los delimitadores /* y */.
Por ejemplo: /* esto es un comentario */
Los comentarios son tiles para identificar los elementos principales de un programa o
para explicar la lgica subyacente de stos.
_________________________________________________________________________
Programacin II
Pgina 6

_________________________________________________________________________
He aqu un programa en C elemental que calcula el rea de un crculo y escribe el
resultado calculado. Luego se nombran todas las partes que contiene el programa en
forma de comentarios.
/*Programa para calcular el rea de un crculo*/
#include<stdio.h>
#define PI 3.1416
main ()
{
float area, radio;
radio = 10;
area = PI * (radio * radio);
printf ("Circulo.\n");
printf("%s%f\n\n", "Area de circulo radio 10: ", area);
}
Estructura de un Programa en C
/*
titulo (comentario) */
/*
acceso a archivo de biblioteca */
/*
definicion de una constante*/
/*
cabecera de funcin */
/*
declaracin de variables */
/*
inicializacion de la variable radio*/
/*
expresion para calcular el area */
/*
instruccin de entrada*/
/*
instruccin de salida*/
1.3.2. Vista interna

Nos referimos con vista interna, al proceso que se lleva acabo internamente, para crear
un programa ejecutable de un programa fuente escrito en c.
Primeramente hablaremos del compilador de C, que se llama GCC.
_________________________________________________________________________
Programacin II
Pgina 7

_________________________________________________________________________
GCC es un compilador integrado del proyecto GNU para C, C++, Objective C y Fortran;
puede recibir un programa fuente en cualquiera de estos lenguajes y generar un
programa ejecutable binario en el lenguaje de la mquina donde ha de correr. El
compilador es capaz de detectar ciertos errores durante el proceso de compilacin,
enviando al usuario el correspondiente mensaje de error.
La sigla GCC significa "GNU Compiler Collection". Originalmente significaba "GNU C
Compiler".
1.3.2.1. Etapas de compilacin.
El proceso de compilacin involucra cuatro etapas sucesivas:
Preprocesamiento, compilacin, ensamblado y enlazado.
Para pasar de un programa fuente escrito por un humano a un programa ejecutable se
realizan estas cuatro etapas en forma sucesiva.
Preprocesado.
En esta etapa se interpretan las directivas al preprocesador. Entre otras cosas, las
variables inicializadas con #define son sustituidas en el cdigo por su valor en todos los
lugares donde aparece su nombre.
Usaremos el ejemplo utilizado para demostrar la vista externa de un programa en c,
para explicar la etapa del preprocesado.
/*programa para calcular el area de un circulo */
#include<stdio.h>
#define PI 3.1416
main ()
{
float area, radio;
radio = 10;
area = PI * (radio * radio);
printf ("Circulo.\n");
_________________________________________________________________________
Programacin II
Pgina 8

_________________________________________________________________________
printf("%s%f\n\n", "Area de circulo radio 10: ", area);
}
En este ejemplo, en la expresin area=PI *(radio * radio);, la variable PI se

reemplaza por el valor antes definido (3.1416).
Compilacin.
La compilacin transforma el cdigo C en el lenguaje ensamblador propio del
procesador de nuestra mquina.
Ensamblado.
El ensamblado transforma el programa escrito en lenguaje ensamblador a cdigo
objeto, un archivo binario en lenguaje de mquina ejecutable por el procesador.
Enlazado
Las funciones de C incluidas en nuestro cdigo, tal como printf () en el ejemplo, se
encuentran ya compiladas y ensambladas en bibliotecas existentes en el sistema. Es
preciso incorporar de algn modo el cdigo binario de estas funciones a nuestro
ejecutable. En esto consiste la etapa de enlace, donde se renen uno o ms mdulos
en cdigo objeto con el cdigo existente en las bibliotecas.
2. Operadores y Expresiones
2.1.
Tipos fundamentales de datos
C no soporta un gran nmero de tipos de datos predefinidos, pero tiene la capacidad

para crear sus propios tipos de datos. Todos los tipos de datos simples o bsicos de C
son, esencialmente, nmeros. Los tipos de datos bsicos son:
_________________________________________________________________________
Programacin II
Pgina 9

_________________________________________________________________________
Enteros
Nmeros de coma flotante
Caracteres
A continuacin se detalla su nombre, el tamao que ocupa en memoria y el rango de
sus posibles valores.
Tipo
Ejemplo
Tamao
Rango de valores
char
1 byte
0 a 255
int
1024
2 bytes
-32768 a 32767
float
10.5
4 bytes
3'4 E-38 a 3'4 E+38
double
0.0025
8 bytes
1'7 E-308 a 1'7 E+308
2.1.1. Caracteres (tipo char)

Las variables carcter (tipo char) contienen un nico carcter y se almacenan en un
byte de memoria (8 bits). La declaracin de variables tipo carcter puede tener la forma:
char nombre;
char nombre1, nombre2, nombre3;
Se puede declarar ms de una variable de un tipo determinado en una sola sentencia.

Se puede tambin inicializar la variable en la declaracin. Por ejemplo, para definir la
variable carcter letra y asignarle el valor a, se puede escribir:
char letra = a;
A partir de ese momento queda definida la variable letra con el valor correspondiente a
la letra a. Recurdese que el valor a utilizado para inicializar la variable letra es una
constante carcter.
_________________________________________________________________________
Programacin II
Pgina 10

_________________________________________________________________________
Tambin puede utilizarse una variable char para dar valor a otra variable de tipo char:
carcter = letra; /*Ahora carcter es igual a z*/
Como una variable tipo char es un nmero entero pequeo (entre 0 y 255), se puede
utilizar su contenido de la misma forma que se utiliza un entero, por lo que estn
permitidas operaciones como:
letra = letra + 1;
letra _ minscula = letra _ mayscula + (a - A);
2.1.2. Nmeros enteros (tipo int)

Una variable tipo int se almacena en 2 bytes (16 bits). Una variable entera se declara, o
se declara y se inicializa en la forma: <tipo de dato> <nombre de la variable> = <valor
inicial>;
Ejemplos:
int numero;
int nota = 10;
int valor1, valor2;
Los enteros son adecuados para aplicaciones que trabajen con datos numricos.
2.1.3. Nmeros reales (tipo float)

En muchas aplicaciones hacen falta variables reales, capaces de representar
magnitudes que contengan una parte entera y una parte fraccionaria o decimal. Estas
variables son del tipo punto flotante. Estos requieren 4 bytes de memoria (32 bits).
Las variables tipo float se declaran de la forma: float nmero _ real; las variables
pueden ser inicializadas en el momento de la declaracin, de forma anloga a las
variables tipo int.
Ejemplos:
_________________________________________________________________________
Programacin II
Pgina 11

_________________________________________________________________________
float valor;
float valor1, valor2;
float valor = 99.99;
2.1.4. Nmeros reales (tipo double)

Las variables tipo float tienen un rango y sobre todo una precisin muy limitada,
insuficiente para la mayor parte de los clculos tcnicos y cientficos. Este problema se
soluciona con el tipo double, que utiliza 8 bytes (64 bits) para almacenar una variable.
Las variables tipo double se declaran de forma anloga a las anteriores:
double real_grande;
Por ltimo, existe la posibilidad de declarar una variable como long double, estas se
declaran en la forma:
long double real;
Ejemplos:
double h;
long double mayor;
double valor = 0.000056;
2.2.
Identificadores
Un identificador es una secuencia de caracteres, letras, dgitos y subrayados (_).Un

identificador es el nombre que damos a las variables y funciones. El primer carcter
debe ser una letra (algunos compiladores admiten carcter de subrayado). Las letras
maysculas y minsculas son diferentes.
Ejemplos:
nombre_clase
Indice
Dia_Mes_Ao
elemento_mayor
Cantidad_Total
Fecha_Compra_Casa
Habitacion120
En C el identificador puede ser de cualquier longitud; sin embargo, el compilador ignora

cualquier carcter fuera de los 32 primeros. C es sensible a las maysculas. Por
_________________________________________________________________________
Programacin II
Pgina 12

_________________________________________________________________________
consiguiente, C reconoce como distintos los identificadores ALFA, alfa y ALFa. Un
identificador no puede contener espacios en blanco, ni otros caracteres distintos de los
citados, como por ejemplo (*,+, etc.). En un identificador no pueden ser utilizadas las
palabras reservadas, tales como if, switch o else.
2.3.
Palabras Claves
En C, como en cualquier otro lenguaje, existen una serie de palabras clave (keywords)
que el usuario no puede utilizar como identificadores. Estas palabras sirven para indicar
al computador que realice una tarea muy determinada (desde evaluar una comparacin,
hasta definir el tipo de una variable) y tienen un especial significado para el compilador.
A continuacin vemos algunas de estas palabras clave:
auto
break
case
char
const
double
int
else
long
enum
register
extern
return
struct
switch
typedef
union
float
short
unsigne
2.4.
continu
e
for
signed
void
default
do
goto
sizeof
if
static
volatile
while
Comentarios
A la hora de programar es conveniente aadir comentarios para poder saber que

funcin tiene cada parte del cdigo. Adems facilitaremos el trabajo a otros
programadores que puedan utilizar nuestro archivo fuente.
Para poner comentarios en un programa escrito en C usamos los smbolos /* y */:
/* Este es un ejemplo de comentario */
/* Un comentario tambin puede
estar escrito en varias lneas */
El smbolo /* se coloca al principio del comentario y el smbolo */ al final. El comentario,

contenido entre estos dos smbolos, no ser tenido en cuenta por el compilador
_________________________________________________________________________
Programacin II
Pgina 13

_________________________________________________________________________
2.5.
Variables
Variables en Lenguaje C
Las variables en C pueden ser de varios tipos y sern utilizadas en funcin del tipo de
datos que queramos almacenar en ellas. Las variables NOMBRE, nombre, Nombre son
tres variables totalmente distintas. (Lenguaje Case Sensitive) y el nombre de una
variable no puede comenzar por nmero (pero puede contener varios) ni tener
caracteres especiales (se admite el guin bajo).
Por ejemplo: numero1, j10a, num_alumno, seran variables vlidas y 1abc, numero?,
num/alumnos seran variables invlidas.
Segn dnde estn declaradas, las variables pueden ser globales (declaradas fuera de
todo procedimiento o funcin) o locales (declaradas dentro de un procedimiento o
funcin). Las primeras sern accesibles desde todo el cdigo fuente y las segundas
slo en la funcin donde estn definidas.
Por otra parte, segn el tipo de datos a almacenar, las variables sern de tipo entero
(int), flotante (float), doble (double) o carcter (char).
El tipo int se utiliza para guardar nmeros enteros, es decir, que no tienen decimales. El
rango de valores admitidos vara segn la CPU utilizada. Para mostrar los valores
contenidos en este tipo de variables, nos serviremos de %i o %d.
Ejemplo:
/*Programa para mostrar variable en pantalla*/
#include<stdio.h>
main ()
{
int x=8;
int y=9;
printf("%i\n",x);
/*Podemos escribir varias variables en el mismo printf:*/
printf("%i %i",x,y);
}
_________________________________________________________________________
Programacin II
Pgina 14

_________________________________________________________________________
Siendo el resultado por pantalla:
8
8 9
Para todos los tipos, podemos definir variables en una sola lnea: int x=8,y=9; tendra
las mismas consecuencias que el cdigo anterior. Pero, debemos tener cuidado, pues:
int x,y=9; no dara lo mismo: "x" no tendra valor e "y" valdra 9.
Si imprimimos una variable a lo que no hemos asignado valor, el compilador no
reconocer ningn error, pero se imprimir un valor cualquiera. Adems, toda variable
puede cambiar su valor durante la ejecucin del programa y ser impresa las veces que
creamos oportunas.
Tras estas pequeas aclaraciones, seguiremos comentando el uso de variables con el
tipo float. Este tipo sirve para almacenar nmeros decimales o reales, as como el
double. El rango de valores admitidos en tan amplio que rara vez se nos quedar
obsoleto.
El modificador para operar con estos datos es %f y lo haremos del mismo modo que
con int. En otros artculos entraremos en detalles de cmo calcular el rango de valores
posibles y el tamao de las variables.
De momento, continuamos el tipo char, capaz de almacenar un nico carcter.
Internamente, un carcter es almacenado como un nmero, comprendido entre 0 y 128,
que hace referencia a su cdigo ascii (ascii standard).
Por ejemplo, declarando:
char letra='A'; /*los caracteres siempre entre comillas simples tendramos el
mismo efecto que: char letra= 65; puesto que el ascii de A es 65.*/
_________________________________________________________________________
Programacin II
Pgina 15

_________________________________________________________________________
El modificador del tipo carcter es %c y tambin es empleado de la misma forma.
Si declaramos una variable char y imprimimos con %d, nos devolver su cdigo ascii...
as podremos crearnos nuestra propia tabla de caracteres. Y, si, declaramos una
variable de tipo int y escribimos su valor con %c, nos devolver el carcter
correspondiente a ese nmero en el cdigo ascii.
2.6.
Constantes
Al contrario que las variables, las constantes mantienen su valor a lo largo de todo el
programa.
Para
indicar
al
compilador
que
se
trata
de
una
constante,
usaremos
la
directiva
#define
#define <identificador> <valor>
Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de

dato.
Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de
dato.
La directiva #define no slo nos permite sustituir un nombre por un valor numrico, sino
tambin por una cadena de caracteres.
_________________________________________________________________________
Programacin II
Pgina 16

_________________________________________________________________________
El valor de una constante no puede ser modificado de ninguna manera.
/* Uso de las constantes */
#include <stdio.h>
#define pi 3.1416
#define escribe printf
main() /* Calcula el perimetro */
{
int r;
escribe("Introduce el radio: ");
scanf("%d",&r);
escribe("El perimetro es: %f",2*pi*r);
}
2.6.1. Constantes enteras:

Una constante entera es una cantidad sin punto decimal(con signo positivo opcional)
cuyos valores mnimo y mximo en precisin sencilla (ENTERO CORTO que se
almacena en 2 bytes) son: -32768 y 32768.
una variante es la entera sin signo (que se almacena en 2 bytes), con los valores
mnimo y mximo de: 0 y 65535
Mientras que en doble precisin (ENTERO LARGO que se almacena en 4 bytes):
-2147843648 y 2147843648
2.6.2. Constantes reales:

Una constante real es una cantidad que incluye punto decimal (con signo positivo
opcional) cuyos valores mnimo y mximo aproximados (en precisin sencilla de 4
bytes) son: -3.4 10-38 y 3.4 1038 (6 dgitos vlidos).
_________________________________________________________________________
Programacin II
Pgina 17

_________________________________________________________________________
Mientras que sus valores aproximados de doble precisin (8 bytes) son: -1.79 10-308 y
1.79 10308
2.6.3. Constantes alfanumricas.

Una constante alfanumrica es un conjunto de caracteres delimitados por comillas
dobles como por ejemplo: "-32,768","uno mas uno","ABCFXY","SI","NO"
Con una longitud mxima de 255 caracteres en C. Es importante comentar que si el
valor alfanumrico es un solo carcter, se usa comilla simple, por ejemplo: 'a','u'
2.7.
Inclusin de Archivos en C
La inclusin de archivos no es ms que la declaracin o la llamada de la o las libreras

donde se encuentran definidas las instrucciones del lenguaje. Las libreras pertenecen
al desarrollo del lenguaje C. Una de las libreras importantes del lenguaje es la funcin
main(), que sin ella no permite que el programa se desarrolle, la cual se delimita con
llaves.
2.8.
Operadores
Son smbolos que indican al compilador que se lleve a cabo especficas manipulaciones
matemticas o lgicas. Hay cinco clases de operadores aritmticos, lgicos y bit,
relacionales y de Asignacin.
2.8.1. Operadores Aritmticos

+
Suma
Resta
_________________________________________________________________________
Programacin II
Pgina 18

_________________________________________________________________________
*
Multiplicacin
--
Decremento
Divisin
++
Incremento
Divisin Modulo
2.8.2. Operadores Relacionales

>
Mayor
<=
Menor o Igual
>=
Mayor o Igual
==
Igual
<
Menor
!=
Distinto o Diferente
2.8.3. Operadores Lgicos

&&
and (y lgico)
||
or (o lgico)
not
2.8.4. Operadores Lgicos a Nivel de Bit

&
Operacin and
<<
Desplazamiento a la Izquierda
Operacin or
>>
Desplazamiento a la Derecha
Operacin xor
2.8.5. Operadores de Asignacin

=
Asignacin Simple
*=
Multiplicacin con Asignacin
+=
Suma con Asignacin
/=
Divisin con Asignacin
-=
Resta con Asignacin
%=
Divisin Mdulo con Asignacin
2.9.
Grupo de Procedencia de Operadores
Categora del Operador

Operadores Monarios
Operadores
()
-, ++, --, !, sizeof
Asociatividad
Derecha Izquierda
_________________________________________________________________________
Programacin II
Pgina 19

_________________________________________________________________________
Multiplicacin, Divisin,
*, /, %
Izquierda Derecha
Suma y resta aritmticas
+, -
Izquierda Derecha
Operadores relacionales
<, <=, >, >=
Izquierda Derecha
Operadores de Igualdad
==, !=
Izquierda Derecha
Operadores Lgicos
&&
Izquierda Derecha
Operador condicional
?:
Derecha Izquierda
Operadores de Asignacin
=, +=, -=, *=, /=, %=
Derecha Izquierda
Divisin Modulo
2.10. Conversiones de tipo

Se conoce como conversin de tipo al proceso mediante el cual se ajusta el valor de
una variable de un tipo para que puede caber o ser usado como una variable de otro
tipo. Las conversiones se hacen todo el tiempo en un programa, por ejemplo cuando
sumamos un valor entero a un valor real. Pero en estos casos el compilador se encarga
de convertir el valor, son conversiones implcitas.
Si al convertir ganamos precisin, por ejemplo ir de un tipo int a float, se conoce como
promocin de tipos. Cuando hay prdida de precisin, las conversiones se conocen
como democin de tipos. El compilador normalmente emite un aviso o "warning",
cuando se hace una democin implcita, es decir cuando hay una democin automtica.
Existe una forma en que el programador puede controlar estas conversiones, y as
evitar estos warning a esta tcnica se le conoce como casting o conversiones explicitas.
_________________________________________________________________________
Programacin II
Pgina 20

_________________________________________________________________________
En general, el uso de "casting" es obligatorio cuando se hacen asignaciones, o cuando
se pasan argumentos a funciones con prdida de precisin. En el caso de los
argumentos pasados a funciones es tambin muy recomendable aunque no haya
prdida de precisin. Eliminar los avisos del compilador demostrar que sabemos lo
que hacemos con nuestras variables, an cuando estemos haciendo conversiones de
tipo extraas.
Un "casting" tiene una de las siguientes formas:
(<nombre de tipo>)<expresin>
<nombre de tipo>(<expresin>)
Esta ltima es conocida como notacin funcional.

Ejemplo:
/* Uso de las constantes */
#include <stdio.h>
#define pi 3.1416
#define escribe printf
main() /* Calcula el perimetro */
{
/*Variable tipo entero*/
int x = 10;
/*Variable tipo real*/
double d = 24.251555;
/*Conversion de tipo realizada por el compilador*/
printf("Antes de convertir x = %d y d = %f\n");
x = d;
/*El compilador emitira un warning "converting int to double"*/
printf("Despus de convertir por el compilador x = %d y d = %f\n");

/*Conversin explicita por el programador*/
x = (int) d;
/*Otra forma*/
x = int(d);
printf("Despus de convertir explicitamente x = %d y d = %f\n");
}
_________________________________________________________________________
Programacin II
Pgina 21

_________________________________________________________________________
3. Elementos de Programacin estructurada

3.1.
Sentencias de Entrada y Salida de Datos.
3.1.1. Introduccin:
Las funciones de Entrada y Salida de Datos se encuentran en la librera stdio.h y
bsicamente son getchar, putchar, scanf, printf, gets y puts. Estas son utilizadas para el
flujo o transferencia de datos entre el usuario y la computadora.
3.1.2. Funciones de entrada y salida

3.1.2.1. Funcin getchar:
Esta no requiere de argumento alguno y su funcin es la de entrada de un carcter.
Su sintaxis es:
getchar ();
_________________________________________________________________________
Programacin II
Pgina 22

_________________________________________________________________________
, por lo tanto asignar y leer un carcter desde el teclado. Tambin se puede utilizar
para encontrar un fin de archivo (EOF).
Ejemplo:
/*Uso de getchar()*/
#include <stdio.h>
main()
{
char a;
/*Declaracin de a como carcter*/
a = getchar();
/*Lee
un
carcter
del
teclado
lo
asigna
la
variable a*/
}
3.1.2.2. Funcin putchar:

Esta complementa a la funcin putchar, se utiliza para visualizar en pantalla un carcter,
y recibe como parmetro la variable que desea usarse.
Su sintaxis es:
putchar (variable usada);.
Ejemplo:
/*Uso de putchar*/
#include <stdio.h>
void main (void)
{
char b;
/* Declara b
*/
b = getchar();
/* Lee b
*/
putchar(b); /* muestra en pantalla el valor de b */

}
3.1.2.3. Funcin scanf:
_________________________________________________________________________
Programacin II
Pgina 23

_________________________________________________________________________
Se emplea para leer cualquier dato numrico, de caracteres sueltos o en cadena
introducido por el usuario.
Su sintaxis es:
scanf(cadena de control, arg1, arg2,....,argn);
en la cual la cadena de control son argumentos formados por el signo de porcentaje (%)
y un carcter de abreviacin el cual representa cada tipo de dato.
Y arg1, arg2, argn son los nombres de las variables que convendrn los datos que los
cuales sern ledos, estos nombres debern ir precedidos por un ampersand (&) cada
uno, excepto los nombres de formaciones como cadenas de caracteres.
Especificadores de formato
%d
Lee variable entera (decimal)
%c
Lee un carcter
%s
Lee una cadena de caracteres
%f
Lee variable punto flotante
%e
Lee variable punto flotante pero con notacin cientfica
%u
Lee variable entera sin signos
%x
Lee variable hexadecimal
%g
Lee variable punto flotante
%h
Lee variable entera cortas
%o
Lee variable enteras octales
Ejemplo:
/*Uso de scanf*/
#include <stdio.h>
main()
{
int a, b;
/*Declara los enteros a y b*/
char c[10]; /*declara la variable c de tipo char*/

/*Lee un entero, un entero sin signo y una cadena de caracteres*/
scanf("%d %u %s", &a, &b, c);
_________________________________________________________________________
Programacin II
Pgina 24

_________________________________________________________________________
}
3.1.2.4. Funcin printf:

La funcin printf se utiliza para la escritura de datos, y esta es anloga a la funcin
scanf.
Su sintaxis es:
printf(cadena de control, arg1, arg2, argn);
donde la cadena de control hace referencia a la abreviacin de los datos de salida al

igual que con la sentencia de entrada scanf, pero a diferencia de estos sus argumentos
no van precedidos de ampersands ya que no representan direcciones de memoria.
Especificadores de formato:
Carcter de conversin
Significado
Carcter
Entero decimal
E, f, g
Entero en coma flotante
Entero corto
Entero decimal, octal o hexadecimal
Entero octal
Cadena de caracteres seguida de un espacio
Entero decimal sin signo
Entero hexadecimal
[]
Cadena de caracteres que puede contener

espacios
_________________________________________________________________________
Programacin II
Pgina 25

_________________________________________________________________________
Ejemplo:
/*Uso de printf*/
#include "stdio.h"
main()
{
char frase[20]="Este es un ejemplo";
printf(" %s", frase);
/*
Imprime
muestra
en
pantalla
el
array
frase*/
}
3.1.2.5. Funcin gets:

Su uso facilita la lectura de datos ya que no recibe mas parmetros que el nombre de la
variable que queremos leer, esta se introducir del teclado, deber ser una cadena de
caracteres, podr contener espacios y terminar con un salto de lnea.
Ejemplo:
/*Uso de gets*/
#include <stdio.h>
main()
{
char ejem[16];
/*Lee una cadena con espacio para 15 caracteres mas el carcter nulo*/
gets(ejem);
}
3.1.2.6. Funcin puts:

Esta ltima funcin de las ms comunes de entrada y salida de datos es el equivalente
a gets, posee las mismas caractersticas, pero en salida de datos.
Ejemplo:
#include stdio.h
_________________________________________________________________________
Programacin II
Pgina 26

_________________________________________________________________________
void main(void)
{
char arreglo[30];
gets(arreglo); /* Lee un arreglo*/
puts(arreglo);
/* imprime el mismo arreglo*/
3.2.
Sentencias de Control
3.2.1. Introduccin
Estas se utilizan para hacer comprobaciones de condiciones, para realizar
repetidamente determinadas instrucciones, estas son palabras reservadas, por lo tanto
no necesitan de inclusin de libreras para su uso.
Principalmente son if-then-else, for, while, do-while, switch, break, goto y continue.
3.2.2. Sentencias de Control Simples

3.2.2.1. If else
Esta sentencia evala una condicin, para realizar una de dos acciones, dependiendo si
se cumple o no la condicin.
Es decir el valor de la expresin a evaluar puede ser verdadero o falso.
La parte else de la sentencia es opcional, y su sintaxis sera:
if(expresin evaluada) instruccin1 ;
_________________________________________________________________________
Programacin II
Pgina 27

_________________________________________________________________________
else instruccin2
tambin de forma sencilla

if(expresin) instruccin.
Otra caracterstica de esta sentencia es que se pueden anidar otros if-else dentro de
otros.
Ejemplo:
#include <stdio.h>
#include <conio.h>
main()
{
int a, b, c;
scanf( "%d %d %d", &a, &b ,&c);
if( a + b > c)
{
printf(" a + b es mayor que c");
}
else
{
if( a + b < c)
printf(" a + b es menor que c");
}
getch();
}
3.2.2.2. switch
Esta se utiliza para realizar una operacin o varias de un grupo de instrucciones.
Su sintaxis es la siguiente:
_________________________________________________________________________
Programacin II
Pgina 28

_________________________________________________________________________
switch (expresin) instruccin;
3.2.2.3. break
Se usa para terminar la ejecucin de bucles o salir de un switch.
Ejemplo:
/*Uso de switch y break:*/
#include <stdio.h>
#include <conio.h>
main()
{
int a;
scanf( "%d" , &a);
switch( a)
{
case 1: printf("Ha introducido un 1");
break;
break;
break;
default: printf("Intente del uno al tres");
}
getch();
}
3.2.2.4. goto
Esta instruccin se utiliza para cambiar el flujo secuencial de un programa, trasladando
el control hacia la parte donde se encuentra la etiqueta.
_________________________________________________________________________
Programacin II
Pgina 29

_________________________________________________________________________
Su sintaxis es:
goto etiqueta;
y etiqueta es un indicador que se encuentra en la parte donde queremos transferir el

control de la forma etiqueta: instruccin.
Ejemplo:
/*Uso de goto*/
#include <stdio.h>
#include <conio.h>
main()
{
int h, i,
Mensaje:
j, k;
printf("Los
Datos
que
Introduzca
deben
ser
tres
enteros
distintos de cero:\n");
printf("h, i y j: ");
scanf("%d %d %d" , &h, &i, &j);
if( (h!=0) && (i!=0) && (j!=0) )
{
k = h + i - j;
}
else
{
printf("Vuelva a intentarlo:\n");
goto Mensaje;
}
printf("El resultado de h + i - j = %d", k);
getch();
}
3.2.3. Sentencias de Control Cclicas
_________________________________________________________________________
Programacin II
Pgina 30

_________________________________________________________________________
En numerosas ocasiones, nos interesa repetir mas de una vez ciertas operaciones o
instrucciones. Tambin nos suele interesar los datos resultantes de algunas
operaciones para saber que operaciones debera ejecutar el programa y que
operaciones no. Para esto existen las sentencias de control de flujo y bucles.
Estas sentencias son: for, while, do while, if, else, switch, break y continue. Aunque las
sentencias if, else, break y continue no se utilizan para repetir un proceso, se utilizan
para cambiar el flujo de control de un programa. En funcin al resultado de ciertas
condiciones postuladas por el programador.
3.2.3.1. Bucle for:
for( dar valores iniciales ; condiciones ; incrementos )
{
Conjunto de instrucciones a ejecutar en el bucle
}
El bucle funciona recibiendo primero el valor inicial desde donde se va a empezar a

contar el nmero de repeticiones. Despus recibe la condicin a validar al fin de cada
ciclo para que el bucle se siga ejecutando. Y despus recibe el incremento, o
decremento, que la variable de valor inicial recibir para que la condicin se haga falsa
y el bucle llegue a un fin.
A continuacin veremos un ejemplo del uso del bucle for:
/*Uso de for*/
#include <stdio.h>
/*declaracin de bibliotecas de funciones*/
#include <conio.h>
main()
/*inicio de la funcin principal*/
{
int i,j;
/*declaracin de variables*/
/*inicio del bucle for*/

for( i=0, j=5; i<10; i++, j=j+5)
{
_________________________________________________________________________
Programacin II
Pgina 31

_________________________________________________________________________
/*instrucciones a repetir*/
printf("Hola!");
printf("\nEsta es la repeticin numero: %d.", i);
printf("\nEl valor de j es: %d", j);
}
/*detenemos el control hasta que se oprima una tecla para visualizar datos*/
getch();
return 0;
}
/*fin de funcin principal*/
Este ejemplo declara un bucle for que se repetir desde i=0 hasta i<10 (es decir 10
veces) la oracin Hola!, contara el numero de repeticiones e incrementara el valor de
j en 5 cada ciclo, hasta que la condicin sea falsa.
Como podemos observar en este ejemplo, cada parmetro que recibe el bucle tambin
puede estar seccionado, separados por comas y pudimos haber tenido mas de una
condicin as como tambin pudimos haber omitido cualquier parmetro.
3.2.3.2. Bucle while:
while ( condicin )
{
bloque de instrucciones a ejecutar
}
El bucle while ejecuta un conjunto de instrucciones mientras la condicin postulada se

cumpla.
Por ejemplo:
/*Uso de while*/
#include<stdio.h> /*declaracin de bibliotecas de funciones a usar*/
#include<conio.h>
main()
/*inicio del programa principal*/
{
int contador=100; /*declaracin de valor constante a variable*/
while(contador > 0)
{
/*inicio del bucle while*/
/*instrucciones a repetir*/
_________________________________________________________________________
Programacin II
Pgina 32

_________________________________________________________________________
printf("Faltan %d
para terminar el bucle while\n", contador);
contador--; /*reduce el numero de contador para poder hacer falsa

la condicin*/
}
getch();
/*detiene el programa para su visualizacin*/
return 0;
}
/*Fin funcin principal*/
En este ejemplo se imprime de manera regresiva el nmero de veces que hacen falta
para finalizar el bucle. Empezando desde 100. El orden de las instrucciones es
importante en este bucle ya que si intercambiamos de posicin las instrucciones el
conteo hubiese empezado desde 99. Es muy importante ponerle atencin al orden de
instrucciones en este bucle ya que puede producir errores muy difciles de encontrar.
3.2.3.3. Bucle do while:
do
{
Instrucciones a ejecutar
} while ( condicin );
La gran diferencia entre el while y el do while es que en este ltimo la condicin va

despus del conjunto de instrucciones, as dichas instrucciones podrn ejecutarse por
lo menos una vez. Su uso es similar al while.
Tenemos el siguiente ejemplo:
/*Uso de do-while*/
#include<stdio.h> /*declaracin de bibliotecas de funciones*/
#include<conio.h>
main()
/*inicio de la funcin principal*/
{
int i=1, j;
do
/*declaracin de variables*/
/*inicio del bucle do-while*/
{
j=i*2;
/*sentencias a evaluar dentro del bucle*/
_________________________________________________________________________
Programacin II
Pgina 33

_________________________________________________________________________
printf("La tabla del dos:");
printf("2 x %d = %d\n",i,j);
}while(i<=10);
i++;
/*fin del bucle y evaluacion de la condicion*/
getch();
}
En este ejemplo se imprime la tabla del 2 desde 1 hasta diez.

Aunque no es recomendado, debido a que se denota como mala practica de
programacin, si solo se desea repetir una sola instruccin, utilizando los diferentes
bucles, el programador puede omitir las llaves. Aunque no sea un problema en
programas sencillos, estos pequeos detalles son los que pueden ahorrar mucho
tiempo a la hora de corregir errores en programas mas complejos.
3.2.3.4. Funcin continue:
continue;
Funciona de forma similar a break. Sin embargo, en vez de forzar la terminacin, break.
Sin embargo, en vez de forzar la terminacin, continue fuerza una nueva iteracin del
bucle y salta cualquier cdigo que exista entremedio.
Para el bucle for, continue hace que se ejecuten las partes de prueba condicional y de
incremento del bucle. Para los bucles while y do-while, el control del programa pasa a la
prueba condicional.
3.3.
Variables - mbito de Validez
Como ya sabemos una variable en C es un espacio reservado en la memoria del

computador para guardar datos fluctuantes dentro de la ejecucin de un programa. Es
importante recordar que todos los datos guardados e interpretados por el computador
_________________________________________________________________________
Programacin II
Pgina 34

_________________________________________________________________________
son siempre binarios, as que el tipo nos permite decirle al compilador como interpretar
los datos. El tipo de variable determinara el trato que se le dar a cada variable.
Es en este ltimo punto en donde nos enfocaremos en este capitulo. Como
programador una de las primeras cosas que se aprenden es que el usuario de un
software es muy impredecible en cuanto a los datos que se le piden. Sin importar que
tan claras sean las instrucciones, es necesario saber si lo tecleado por el usuario se
adapta a los datos pedidos o no. Para poder as tomar medidas adecuadas para evitar
el fallo de cualquier aplicacin determinada.
Leer lo tecleado por el usuario y comparar si los datos adquiridos concuerdan con el
tipo solicitado es lo que llamamos validacin. Este mbito constituye una funcin muy
importante dentro de la programacin desde sus principios ya que la fiabilidad de un
software depende de los datos que contiene y es uno de los requisitos mas exigidos. Y
los programas desarrollados en C no son una excepcin.
Por ejemplo, si se desea verificar, en un programa que pide una carcter determinado,
sea solo caracteres y solamente caracteres se podra utilizar la siguiente validacin:
/*Uso de validacion*/
#include<stdio.h>
#include<ctype.h>
#include<conio.h>
main()
{
int a;
Again:
printf("Introduzca un carcter: ");
a = getchar();
tolower(a);
if(a >= 'a' && a <= 'z')
{ printf("El character intorducido fue el: %c\n",a);
else
{ printf("El dato no es valido, intente nueva mente\n");
goto Again;
getch();
_________________________________________________________________________
Programacin II
Pgina 35

_________________________________________________________________________
}
Otro ejemplo seria en un programa en donde se quiere abrir un fichero, se tiene que
verificar que el fichero no este vaco y se puede utilizar la siguiente validacin:
/*Uso de validacin 2*/
#include <stdio.h>
main(){
FILE* archivo;
int f[4];
double d[4];
archivo = fopen("fichero.txt","r");
if(archivo!=NULL){
int f[4],i;
double d[4];
fscanf(archivo,"%d %d %d %d\n",
&f[0],&f[1],&f[2],&f[3]);
fscanf(archivo,"%d, %d, %d, %d\n",
&f[0],&f[1],&f[2],&f[3]);
fscanf(archivo,"%lf ; %lf ; %lf ; %lf\n",
&d[0],&d[1],&d[2],&d[3]);
fclose(archivo);
}
}
En ambos ejemplos se nota la importancia de validar los datos con los que se trabajan
en un programa. En el caso de que un valor inesperado sea ledo el programa tomara
un curso apropiado para asegurar que el programa no falle y los datos obtenidos no
sean errneos.
_________________________________________________________________________
Programacin II
Pgina 36

_________________________________________________________________________
4. Tipos Estructurados de Datos

4.1.
Definicin
Arreglos
Es una variable que maneja una gran cantidad de datos del mismo tipo bajo un mismo
nombre .A cada elemento se le asigna un espacio de memoria, segn el orden o
secuencia, se puede acceder a cada elemento segn el espacio o localidad de memoria
que este elemento tenga.
Un arreglo debe de ir acompaado, del tipo del almacenamiento, este es opcional los
valores por defecto son automtico para arreglos definidos dentro de un funcin, y
externo para arreglos definidos fuera de una funcin, tambin de una especificacin
de tamao (numero de elementos), en este caso seria un digito entero positivo,
encerrado entre corchetes.
El lenguaje C si se accede a un arreglo de n trminos y el usuario se referencia a un
elemento que sobrepase al n-nmeros de elementos, este no provoca ningn mensaje
de error en el caso de que sobrepase el final durante una operacin de asignacin,
entonces se asignarn valores a otra variable o a un trozo del cdigo, esto es, si se
dimensionar. Como programador se es responsable de asegurar que todos los arreglos
sean lo suficientemente grandes para guardar lo que pondr en ellos el programa.
Por ejemplo, para declarar un arreglo de enteros llamado demos con diez elementos se
hace de la siguiente forma:
int demos[10];
En C, todos los arreglos usan cero como ndice para el primer elemento. Por tanto, el
ejemplo anterior declara un arreglo de enteros con diez elementos desde demos[0]
hasta demos[9].
_________________________________________________________________________
Programacin II
Pgina 37

_________________________________________________________________________
Tipo_almacenamiento tipo nombre [nmero _ elementos];
Tipo: el tipo de dato que poseen cada uno de los elementos.
Nombre: variable que identifica el arreglo.
Numero de elementos: este indica la cantidad de elementos que contendr el arreglo,
este referenciara el ndice del elemento al cual ser accedido
NOTA: No es el contenido que tendr el arreglo.
Tipo_almacenamiento: se refiere al tipo de almacenamiento
4.2.
Inicializacion De Arreglos
Un arreglo puede ser inicializado es decir asignrseles valores iniciales, los arreglos
automticos no pueden ser inicializados, no obstante las definiciones de arreglos
estticos y externos pueden asignrseles valores iniciales, los valores inicializados
deben de estar encerrados entre corchetes, escritos en el orden en que sern
asignados. Cuando un arreglo es inicializado es opcional nmero de elementos, ya que
los corchetes pueden estar vacos.
Ejemplo:
/*Uso de arreglos*/
#include <stdio.h>
#include <conio.h>
main()
{
double carro[20];
int i, t = 20;
for(i = 0; i < t; i++)
{
printf("Ingrese el valor %d: ", i+1);
scanf("%lf", &carro[i]);
}
for(i = 0; i < t; i++)
{
printf("%f\n", carro[i]);
getch();
}
_________________________________________________________________________
Programacin II
Pgina 38

_________________________________________________________________________
Inicializndolo en la misma declaracin, en la forma:
float v[6] = {1., 2., 3., 3., 2., 1.};
double d[] = {1.2, 3.4, 5.1};
int f[100] = {0};
int h[10] = {1, 2, 3};
int mat[3][2] = {{1, 2}, {3, 4}, {5, 6}};
Ejemplo:
/*Uso de arreglos*/
#include <stdio.h>
#include <conio.h>
main()
{
float v[6] = {1.0f, 2.0f, 3.0f, 3.0f, 2.0f, 1.0f};
int c;
printf("Valores del arreglo*/
for(c = 0; c < 6; c++)
{
printf("%f\n", v[c]);
}
getch();
}
Donde en el primer y segundo ejemplo es necesario poner un punto decimal tras cada
cifra, para que sta sea reconocida como un valor de tipo float o double.
Recurdese que, al igual que las variables escalares correspondientes, los arrays con
modo de almacenamiento external y static se inicializan a cero automticamente en el
momento de la declaracin.
Sin embargo, esto no est garantizado en los arrays auto, y el que se haga o no
depende del compilador.
_________________________________________________________________________
Programacin II
Pgina 39

_________________________________________________________________________
4.3.
Tipos Arreglos
Los arreglos se clasifican en dos grupos:
4.3.1. Unidimensionales:
Tambin llamados vectores llamados as, de una dimensin o lineales; sin embargo no
cambia el mbito de los elementos, todos contendrn un espacio de memoria.
Su sintaxis:
Tipo-datos nombre [tamao];
Si notas el arreglo contiene un par de corchetes que indican que los elementos del
arreglo estarn almacenados de forma lineal en cada espacio de memoria
Ejemplo char Demos [4];
1
Demos [0]
Demos [1]
Demos [2]
Demos [3]
Cada casilla corresponde a un nico nmero de espacio o tambin llamados ndices el

tamao del arreglo es de 4 elementos como se especifica en el grafico.
En C el primer elemento de un arreglo esta indicado con el ndice cero, as si se quiere
acceder al primer elemento de un arreglo se escribir de esta forma: char Demo [0], y
as sucesivamente i se quiere acceder al n-ensimo elemento seria char Demo [n-1].
4.3.2. Multidimensionales
_________________________________________________________________________
Programacin II
Pgina 40

_________________________________________________________________________
Tambin existen arreglos multidimensionales, C por ser un lenguaje muy interactivo
incorpora en su gama de herramientas, este tipo de arreglos los cuales permiten
almacenar mas informacin ms organizadas, por lo general son llamadas matrices.
Las dimensiones que se incluyen en este grupo son arreglos bidimensionales (dos
pares de corchetes o 2 ndices) se podra representar grficamente como una tabla con
filas y columnas, tridimensionales (3 pares de corchetes o 3 ndices) Este es
comnmente usado para trabajos grficos en 3D.
En general la definicin de un arreglo multidimensional ser;
Tipo de dato
nombre [tamao1] [tamao2] [tamano3]. [Tamao n].
En el siguiente ejemplo se ilustra un pequeo programa en c en el cual se utiliza 1 for

para leer las filas y otro para leer las columnas de un arreglo bidimensional.
Hemos visto que un arreglo unidimensional de n elementos puede ser visto como un
espacio de memoria lineal ya que todos sern almacenados de manera secuencial
.Similarmente bidimensionales de pxd puede ser como una tabla de valores que tiene
pxm filas y d columnas tal como se ilustra en la figura:
Se tiene un arreglo bidimensional A[p][d]:
x
Filas
A00
A10
A20
A30
A01
A11
A21
A31
A02
A12
A22
A32
Columnas
A03
A13
A23
A33
A04
A14
A24
A34
A05
A15
A25
A35
Cada variable en cada cuadro representa la posicin en arreglo los
A06
A16
A26
A36
subndices
00,01,02,03, el primer nmero no es ms que la posicin de fila y el segundo indica

a la columna. As A11 indica que el elemento est ubicado en la fila 1 (a simple vista
podramos decir que se refiere a la segunda fila)y en la columna 1 y as sucesivamente.
_________________________________________________________________________
Programacin II
Pgina 41

_________________________________________________________________________
Al acceder al valor de un elemento especfico se deber jugar con estas posiciones, por
esto es importante saber cul es la posicin en memoria.
4.4.
Generalidades
Ya hemos visto como operan los arreglos a nivel de hardware, ahora, como escribirlo en
C:
He aqu una m lista de declaracin de arreglos bidimensionales:
char frutas[2][3]={manzana, pera , uva, naranja, noni, mango};
int valores[23][45];
static double lista[20][15];
float grupo [45][80];
La primera lnea define un arreglo de frutas de 2 filas y 3 columnas (2*3=6, lo cual
serian 6 elementos) y si notas esta
inicializado con los elementos manzana en la
posicin 0,0, pera 0,1, uva 0,2, naranja 1,0, noni 1,1, mango 1,2,
Si un arreglo bidimensional es inicializado se debe tener cuidado se debe tener cuidado
ya que el orden natura l de los elementos se pueden alterar formando grupo de valores
iniciales encerrados entre llaves ({..}).Los valores dentro de cada par interno de llaves
sern asignados alos pares elementos del arreglo cuyo ultimo ndice vare mas
rpidamente .Por e ejemplo en un arreglo bidimensional los valores
almacenados
dentro de un par de llaves sern asignados alos elementos de una fila , ya que el
segundo ndice (columna) se incrementara ms rpidamente .Si hay pocos elementos
dentro de cada par de llaves , al resto de cada par de filas se le asigna aran 0. Loor
otra parte, el numero de valores dentro de cada par de llaves no p puede exceder del
tamao de fila definido. Es de agrupacin
puede ser til en la generalizacin de
arreglos de mayor dimensin.

_________________________________________________________________________
Programacin II
Pgina 42

_________________________________________________________________________
Ejemplo:
int
valores[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Esta asignacin seria as:

Valores[0][0]=1
Valores[0][1]=2
valores[0][2]=3
valores[0][3]=4
Valores[1][0]=5
Valores[1][1]=6
valores[1][2]=7
valores[1][3]=8
Valores[2][0]=9
valores[1][2]=10
valores[2][2]=11
valores[2][3]=12
Una variacin a este caso con la utilizacin de la n llaves internas es :

int valores[3][4]={
{1, 2,3}
{4, 5,6}
{7, 8,9}
{10, 11,12,}
}
Esto nos lleva alo mismo, los cuatro valores del primer par de llaves internas son
asignados a los elementos de la primera fila del arreglo los valores de segundo par de
llaves son asignados a la segunda fila del arreglo .Ntese que el par de llaves internos
se necesitan para contener las llaves internas. En caso de que en las llaves sean
agrupados ms elementos de los que se especifican en el tamao del arreglo ejemplo:
int valores[][]=
{
{1, 2, 3, 4,5}
{6, 7, 8, 9,10}
{11, 12, 13, 14,15}
}
El compilador lo detectara como un error, ya que el nmero de elementos excede al

tamao del arreglo ya declarado.
Si en algn dado caso el arreglo contuviese un elemento menos del tamao
especificado, es decir,
int valores[3][4]={1,2,3,4,5,6,7,8,9,10,11};
El elemento ser rellenado con cero en este caso ser de la siguiente manera:
_________________________________________________________________________
Programacin II
Pgina 43

_________________________________________________________________________
Valores[0][0]=1
Valores[0][1]=2
valores[0][2]=3
valores[0][3]=4
Valores[1][0]=5
Valores[1][1]=6
valores[1][2]=7
valores[1][3]=8
Valores[2][0]=9
valores[1][2]=10
valores[2][2]=11
valores[2][3]=0
4.5.
Arreglos y Cadenas
4.5.1. Qu es una cadena?

Una cadena no es ms que la secuencia de caracteres consecutivos incluyendo
espacios en blancos esta parte de la pronacin es muy importante de conocer ya que
se trabajo al menos en con la manipulacin de cadenas de caracteres, ya que la
mayora de programas se utiliza esta naturaleza de nuestro lenguaje.
A veces
resulta complicado trabajar con cadenas de caracteres si no es con la
auxiliaran de los arreglos como anteriormente lo habamos dicho en un arreglo

unidimensional ser fcil, trabajar con cadenas de caracteres, porque cada carcter de
una cadena se estacionaria en cada casilla un carcter, Pero a veces las cadenas de
caracteres necesitan operar como entidades propias es decir ser almacenadas en un
solo espacio de memoria (casilla).
El siguiente programa es un boleto que trabaja con arreglos bidimensionales para
almacenar en un espacio de memoria los nombres de las personas que viajaran en un
determinado vuelo, y tambin se utilizan dos arreglos unidimensionales para almacenar
el destino y categora que el cliente desee. La aerolnea necesita que luego que el
usuario ingrese sus datos y preferencias se imprima de manera implcita el nmero de
boletos, que el usuario a su preferencia llenara. A continuacin el cdigo
en el
compilador de C:
/*Programa de un boleto en c*/
_________________________________________________________________________
Programacin II
Pgina 44

_________________________________________________________________________
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
main()
{
char nomb[50][20];
int
i,bol;
int dest[50], cat[50];

/******************************************************/
printf("BIENVENIDOS
SU
AEROLINEA
DOSSELL\ndigite la cantidad de
boletos: ");
scanf("%d",&bol);
for(i=0; i < bol; i++)
{
printf("\nNombre: ");
scanf("%s", nomb[i]);
printf("\nDestino:\n(1):Bluefields\n(2):San
juan\nDestino
seleccionado ");
scanf("%d", &dest[i]);
printf("Categoria:\n(1):Alta\n(2):Media\n(3):Baja\nCategoria
seleccionada ");
scanf("%d", &cat[i]);
}/*fin del primer for*/
system("cls");
/*Imprime los
boletos con los datos antes almacenados, */
for(i=0; i < bol; i++)

{
printf("\n\nAerolinea Dossell\n");
printf("Numero de boletos: %d\n",i+1);
printf("Nombre: %s\n",nomb[i]);
if(dest[i] == 1)
{
printf("Destino: Bluefields");
printf("\nHora de salida: 9:00 am\nHora de llegada: 12:00
pm\n");
}
else
{
_________________________________________________________________________
Programacin II
Pgina 45

_________________________________________________________________________
printf("Destino: San juan ");
printf("\nHora de salida: 1:00pm\nHora de llegada: 3:00pm");
}
if(cat[i]==1)
{
printf("\nCategoria: Alta\nCosto:C$250 ");
}
else if(cat[i]==2)
{
printf("\nCategoria: Media\nCosto:C$230\n");
}
else
{
printf("\nCategoria: Baja\nCosto:220\n");
}
printf("Asiento numero: %d\n",i);
getch();
}
system("cls");
printf("Buen viaje");
getch();
}
La salida del programa seria la siguiente:

Cuantos boletos desea? 2
Nombre:
dorissell Narvez Prez
Destino:
(1):Bluefields.
(2):San juan.
Destino seleccionado
Categora:
(1):Alta
(2):Media
(3):Baja
Categoria seleccionada: 3
_________________________________________________________________________
Programacin II
Pgina 46

_________________________________________________________________________
Nombre: Jorge Luis Meyer
Destino:
(1):Bluefields.
(2):San juan.
Destino seleccionado
Categora:
(1):Alta
(2):Media
(3):Baja
Categoria seleccionada:
/* despus de un entre*/
Aerolnea Dossell
Numero de
boleto:1
Nombre: dorissell Narvez Prez

Destino:Bluefields
hora de salida: 9:00 am
hora de llegada: 12:00 pm
Categoria: Baja
Costo$ 220.
Asiento numero:0
Aerolnea Dossell
Numero de boleto:2
Nombre:jorge Luis Meyer
Destino:Bluefields
hora de llegada: 12:00 pm
Categoria: Mediana
Costo$ 230.
Asiento numero:0
Ntese que el nmero de asiento ser siempre cero ya que la variable i esta inicializada
en cero. Si usted desea que el compilador arroje el nmero de boletos igual como el
nmero de asiento lo
nico que abra que modificar es que al imprimir sustituya la
variable i por la variable que almacena el nmero del boleto, de esta manera estamos
diciendo que segn el nmero de boleto es el nmero del asiento del cliente. O bien si
usted desea agregarle un digito de entrada se podra hacer de las siguiente forma.
printf(Asiento numero:2104-0%d,i);
Y esto aparecer de la siguiente manera:

Aerolnea Dossell
Numero de boleto:2
Nombre: Jorge Lus Meyer
_________________________________________________________________________
Programacin II
Pgina 47

_________________________________________________________________________
Destino: Bluefields
hora de
llegada: 12:00 pm
Categoria: Mediana
Costo$ 230.
Asiento numero: 2104-02.
La lgica del programador es lo que hace la calidad y eficiencia de un programa y

adems lo ms importante que hace lo ms completo y comprensible que sea para el
usuario.
Es importante aadir a este tema la funciones de biblioteca para manipular cadenas,
estas libreras son comnmente conocidas como funciones de strings tales como:
stdlib.h y ctype.h que incluyen una gama de funciones de biblioteca como atof, que
convierte la porcin inicial de una cadena a una representacin de double., y la funcin
atoi, que al contrario convierte la porcin inicial en y un entero.
atof(variable que indica la cadena )
atoi(variable que indica la cadena )
Ejemplo 1:
El siguiente programa convierte un cadena a double y a una cadena de representacin
entero. Ntese que en la utilizacin de las funciones de biblioteca son incluidas sus
libreras antes declaradas en la cabecera del programa.
/*Uso de atoi y atof*/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main()
{
char n1[20] = "10254.4116";
printf("Cadena \'%s\' convertida a double = %f\n", n1, atof(n1));
printf("Cadena \'%s\' convertida a entero = %d\n", n1, atoi(n1));
getch();
_________________________________________________________________________
Programacin II
Pgina 48

_________________________________________________________________________
}
Ejemplo 2:
El siguiente cdigo es de un programa para leer una cadena de caracteres minscula a
mayscula. Se utilizan la funcin toupper: esta funcin tiene como parmetro la variable
que almacena el arreglo de cadena de caracteres, la cual convertir a mayscula , en
caso de que est este en minscula.
# include<stdio.h>
# include<conio.h>
/* declaracin de libreras */
# include<ctype.h>
main()
{
char
cadena[]="la victoria se consigue cayendo levantndose y volver a
caer";
int i;
printf("Cadena antes de convertir:\n%s\n", cadena);
for(i=0;cadena[i];i++)
{
cadena[i]=toupper(cadena[i]);
}
printf("Cadena despues de convertir:\n%s\n", cadena);
}
getch();
/*fin del programa principal*/
Ejemplo 3:
En el siguiente cdigo muestra ms funciones strings como:
sprintf():
imprime un mensaje .
strstr(cad 1, cad 2):localiza la primera aparicin en la cadena apuntada por la

constante escrita en el argumento
de la secuencia de caracteres
(excluyendo el carcter nulo), es decir la primera cadena , en la segunda

cadena .
strcat():
aade una copia de la primera cadena escrita en el argumento de la

funcin , incluyendo el carcter nulo en la segunda cadena que se escribi
en el argumento de la funcin.
# include<stdio.h>
# include<string.h>
/*declaracin de libreras */
_________________________________________________________________________
Programacin II
Pgina 49

_________________________________________________________________________
# include<conio.h>
main()
{
char mensaje[50];
char mens1[30]= "lo siento mucho ";/*declaracin de arreglos de cadenas
*/
char mens2[6]="mucho";
char mens3[]="mu";
printf("strstr(mens1[], mens2[])=%s\n",strstr(mens1, mens2));
if (strstr(mens2,mens3))/*localiza la primera letra m'*/
{
strcat(mens1,mens2);/*copia 'mucho' de ultimo de la cadena 'lo
siento mucho'*/
sprintf(mensaje,"\nhola %s", mens1);
puts(mensaje);
}
getch();
}/*fin del programa principal*/
La salida del programa seria hola lo siento mucho mucho
Ejemplo 4:
El siguiente cdigo es acerca de un programa interactivo Para definir la profesin del
usuario.
Se utilizan las funciones, sprintf () y puts (): esta ltima tiene la misma funcin como la
conocemos pone un mensaje existente en el sistema y lo visualiza.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int main()
{
char nombre[10],mensaje[200];
unsigned int edad =0, U;
system("cls");
_________________________________________________________________________
Programacin II
Pgina 50

_________________________________________________________________________
printf("\nCual es su nombre: "); gets(nombre);
printf("\nCual es su edad: "); scanf("%d", &edad);
printf("\nCual ES LA UNIVERISDAD EN LA QUE ESTUDIAS\n");
printf("1):UNI \n2):ex\n3);UNAN\nSeleccione una opcion: ");
scanf("%d", &U);
system("cls");
if(U==1)
{
sprintf(mensaje, "\nHola%s.\ntienes %d aos de edad \n sers un
ingeniero de la %s", nombre,edad, "UNI");
}
else if(U==2)
{
sprintf(mensaje, "\n\nHola %stienes%d aos\n sers un licenciado
en ciencias comerciales de: %s", nombre,edad, "EX");
}
else
{
sprintf(mensaje,
"\n\nHola%s,
tienes%d
aos\n
sers
un
licenciado de la %s ", nombre,edad, "UNAN");

}
puts (mensaje); getch();
}
Ejemplo 5:
Este programa utiliza las funciones strcpy (copia dos cadenas), strcat, strcmp (compara
dos cadenas).
/*programa que lee
tres cadenas para formar dos copias las comparala y define
su longitud**/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h>
main()
{
char
pn[50]="DORISSELL",
cn[50]="
PEREZ",
tn[50]="NARVAEZ",
sn[50]="SOCORRO ", *n, *p;
_________________________________________________________________________
Programacin II
Pgina 51

_________________________________________________________________________
int c;
system("cls");
strcat(pn," del ");
/* copia "DORISSELL del" es decir 'del ' a la
cadena pn*/
n=strcat(pn, sn); /* copia "DORISSELL del SOCORRO", aadi */
printf("%s\n",n); /* imprime la cadena r almacenada en la varible n*/
p=strcat(tn,cn);
printf("%s\n",p);
c=strcmp(pn,tn);
/*Compararlas dos cadenas
"DORISSELL" y "NARVEZ"*/
printf("pn es ");
if (c<0)
printf("menor que");
else if(c == 0)
printf("igual que");
else
printf("mayor que");
printf(" tn\n");
strcat(pn,tn);
printf("pn=%s\n",pn);
printf("la cadena pn contiene: %d caracteres\n", strlen(pn));
getch();
}
4.6.
Procesamiento de arreglos.
No se permiten operaciones que impliquen arreglos completos. Por lo tanto para

realizar operaciones de asignacin de dos arreglos similares (mismos tipo de datos,
misma dimensionalidad y mismo tamao), deben de realizarse elemento por elemento.
Esto es posible normalmente dentro de un bucle donde cada paso del bucle se usa
para procesar un elemento del arreglo.
4.7.
Paso de arreglos a funciones.
Un arreglo completo puede ser pasado a una funcin, para tal hecho el nombre del
arreglo debe de aparecer solo, es decir sin: corchetes ni ndices como un argumento
_________________________________________________________________________
Programacin II
Pgina 52

_________________________________________________________________________
actual dentro de la llamada a la funcin. El correspondiente argumento formal se
escribe de la misma manera, pero debe de ser declarado como un arreglo de la funcin.
Al escribir prototipos de funciones que incluyan argumentos de arreglos una pareja
vaca de corchetes debe seguir el nombre del arreglo, es posible omitir el nombre del
argumento del arreglo pero entonces una pareja vaca de corchetes debe seguir al tipo
de datos de argumento de arreglo.
Cuando se pasa una arreglo a una funcin no se pasan a esta (funcin) los valores de
los elementos del arreglo, porque el nombre del arreglo se interpreta como la direccin
del primer elemento del arreglo por lo tanto lo arreglos se dice que son pasados por
referencia a una funcin.
Si un elemento del arreglo es modificado dentro de la funcin, esta modificacin ser
reconocida en la parte del programa desde la que se hizo la llamada.
Ejemplo:
/*Programa
modificados
que
los
pasa
un
valores
arreglo
se
de
elementos
escriben
en
tres
programa
principal
una
ocasiones
funcin
para
donde
son
mostrar
los
cambios*/
#include <stdio.h>
#include <conio.h>
#define max 4
void cambiar (int numeros []);
main()
{
int sum, numeros[max];
clrscr();
printf("\t\ndesde
el
antes
de
llamar
la
funcin\n\n");
for(sum=0; sum<=max; ++sum)
{
_________________________________________________________________________
Programacin II
Pgina 53

_________________________________________________________________________
numeros[sum]= sum +1;
printf("a[%d]=%d\n",sum,numeros[sum]);
}
cambiar(numeros);
printf("\ndesde
el
programa
principal
despus
de
llamar
la
funcin:\n\n");
for(sum=0; sum<=max; ++sum)
printf("numeros[%d]=%d\n", sum, numeros[sum]);
getch();
}
void cambiar(int numeros[])
{
int sum;
printf("desde la funcin despus de modificar los elementos\n\n");
for(sum=0;sum<=max;++sum)
{
numeros[sum]=10;
printf("numeros[%d]=%d\n", sum, numeros[sum]);
}
return;
}
En este ejemplo podemos observar que al arreglo se le asigna los valores de a[0]=1,
a[1]=2, a[2]=3 en la funcin main, luego estos valores se trasladan a la funcin
cambiar , donde se le asigna el valor de 10 a cada elemento del arreglo estos valores
se escriben en main, y finalmente arreglo es escrtto una vez que se le pasa el control a
main.
Podemos llegar a la conclusin que los elementos de numeros se modifican dentro
de main despus de hacer una llamada a la funcin cambiar.
_________________________________________________________________________
Programacin II
Pgina 54

_________________________________________________________________________
5. Funciones
5.1.
Que son funciones
Las funciones en el lenguaje C son subprogramas, cuya finalidad es hacer una tarea
especfica y retornar un valor al programa principal, si es requerido. Otra funcin de las
funciones es el de hacer el programa principal no muy extenso.
5.2.
Declaracin de funciones
Las funciones se declaran, se definen, son llamadas desde el programa principal, son
hechas o creadas por el usuario, y estn compuestas por una cabecera y el cuerpo de
la funcin.
_________________________________________________________________________
Programacin II
Pgina 55

_________________________________________________________________________
La sintaxis de una funcin es la siguiente: (lo que esta entre corchetes no es siempre
necesario utilizarlo)
[clase] [tipo] nombre (
tipo argumento formal 1,
tipo argumento forma 2, ...,
tipo argumento formal n)
{
[Declaraciones]; --> parmetros actuales
Instrucciones;
return (expresin);
}
El return devuelve el carcter convertido al punto del programa de llamada de la

funcin.
El parmetro actual es aquel que se recibe en la funcin y debe tener dato. El
parmetro actual es declarado dentro del programa principal.
El parmetro o argumento formal es aquel que se recibe en la definicin de la funcin y
los parmetros, tanto formales como actuales debe de ser iguales.
La declaracin de las funciones puede ser implcita o explicita. La implcita se da
cuando la funcin es llama y no existe una declaracin previa, y por defecto C
construye una funcin prototipo de resultado entero. En la explicita se permite conocer
las caractersticas de la funcin antes de ser usada, es decir se conoce el tipo. La
declaracin de funciones se hace despus de la declaracin de las libreras.
La
llamada de las funciones de hacen desde el programan principal, es decir dentro del
main. Con la siguiente sintaxis:
[Variable] = nombre _ funcin ([argumentos actuales o parmetros actuales]);.
Ahora veremos algunos ejemplos de lo descrito anteriormente:

Ejemplo:
#include <stdio.h>
/* libreras */
#include <conio.h>
_________________________________________________________________________
Programacin II
Pgina 56

_________________________________________________________________________
/* declaracin explicita (no es necesaria si el valor de
retornos es entero)
*/
int escribir (int y);
main()
{
/* Inicio del Programa Principal */

int r, b=5;
/* declaracin de variables */
/* asignacin a r el valor de la funcin con parmetro actual llamando a la

funcin */
r = escribir (b);
printf("r = %d \n", r); /* salida del valor r */
getch();
/* espera una tecla para salir */
/* fin del programa principal */
int escribir (int y)
/* definicin de la funcin con parmetro formal */
{
return (y *3);
/* instruccin que retorna el valor a la funcin
*/
}
Ejemplo:
/* libreras */
#include <stdio.h>
#include <conio.h>
#include <math.h>
/*declaracin explicita (no es necesaria si el valor de
retornos es entero)*/
float hipotenusa (float a, float b);

main()
{
/* Inicio del Programa Principal */
/* declaracin de variables */
float a, b, h;
clrscr();
/*borra pantalla*/
printf("Escriba el valor de los catetos: ");

scanf("%f %f", &a, &b);
h = hipotenusa(a,b);
/* llamada de la funcin hipotenusa*/
printf("el valor de la hipotenusa es = %f",h); /*imprime el valor de la

hipotenusa*/
getch();
/* espera una tecla para salir */
/* fin del programa principal */
/* definicin de la funcin con parmetro formal */

float hipotenusa (float a, float b)
_________________________________________________________________________
Programacin II
Pgina 57

_________________________________________________________________________
{
/*instruccin de la funcin*/
float y;
y = sqrt ((pow (a,2))+ (pow (b,2)));
/* instruccin que retorna el valor a la funcin */
return y;
}
5.3.
Llamadas a funcin
Se conoce como llamada a funcin cuando se invoca o manda a ejecutar una funcin
previamente creada, ya sea que esta se encuentre el las libreras o sea programada por
el usuario. Una llamada a funcin es una expresin con todo lo que ello implica.
Para llamar a una funcin se escribe el nombre de la funcin y entre parntesis se
especifican los valores que se desean dar a los argumentos.
Ej:
mi_funcion(expr1, expr2, )
Cada Expresin se evala y el valor devuelto es pasado como argumento a la funcin,

la expresin debe devolver un tipo compatible al argumento de la funcin, o se puede
forzar otro tipo mediante la conversin de tipos.
No es obligatorio guardar el valor devuelto por la funcin, si es que esta devuelve
alguno, hay momentos en que no necesitamos saber que devuelve la funcin, por
ejemplo: la funcin printf y scanf devuelven un valor entero al ser llamadas, pero es
poco comn para la mayoria utilizar estos valores.
_________________________________________________________________________
Programacin II
Pgina 58

_________________________________________________________________________
5.4.
Parmetros por valor.
Existen dos formas mediante las cuales se pueden pasar valores a las funcin, las
formas en que utilicemos una u otra forma depende de la necesidad que se nos
presente, el primero es el paso por valor, los que significa que el realidad nosotros el la
funcin recibimos una copia del dato mandado, no el dato original, por lo tanto cualquier
modificacin sobre este dato no afectar al valor de donde fue llamada la funcin, un
ejemplo practico sera intercambiar los valores de dos variables:
Ejemplo:
#include <stdio.h>
#include <conio.h>
/*Declaracion de la funcion*/
void intercambiar(int a, int b);
main()
/*Programa principal*/
{
/*Declaracion de variables*/
int a = 10, b = 20;
printf("Valores antes de llamar a la funcion:\na=%d\tb=%d\n", a, b);
intercambiar(a, b);
/*Llamada a la funcion*/
printf("Valores despus de llamar a la funcion:\na=%d\tb=%d\n", a, b);

getch();
}/*Fin del main*/
/*Definicion de la funcion*/
void intercambiar(int a, int b)
{
int c;
c = a;
a = b;
b = c;
}
Resultado:
Valores antes de llamar a la funcin:
_________________________________________________________________________
Programacin II
Pgina 59

_________________________________________________________________________
a=10 y b=20
Valores despus de llamar a la funcin:
a=10 y b=20
Como podemos ver a pesar de haber modificado los valores recibidos dentro de la
funcin los valores originales no fueron alterados.
5.5.
Parmetros por referencia
Se les conoce como parmetros por referencia porque en realidad cuando se llama a la
funcin no se manda una copia del dato como parmetro sino una referencia al dato
original, o en otras palabras donde se encuentra este dato, esto permite a la funcin
modificar el dato original ya que esta tiene la direccin donde se encuentra almacenado
y simplemente precede a modificar el valor de esa direccin, veamos el ejemplo anterior
pero con parmetros por referencia.
#include <stdio.h>
#include <conio.h>
/*Declaracion de la funcion*/
void intercambiar(int *a, int *b);
main()
/*Programa principal*/
{
/*Declaracion de variables*/
int a = 10, b = 20;
printf("Valores antes de llamar a la funcion:\na=%d\tb=%d\n", a, b);
intercambiar(&a, &b);
/*Llamada a la funcion*/
printf("Valores despus de llamar a la funcion:\na=%d\tb=%d\n", a, b);

getch();
}/*Fin del main*/
/*Definicion de la funcion*/
void intercambiar(int *a, int *b)
_________________________________________________________________________
Programacin II
Pgina 60

_________________________________________________________________________
{
int c;
c = *a;
*a = *b;
*b = c;
}
Resultado:
Valores antes de llamar a la funcin: a=10 y b=20
Valores despus de llamar a la funcin: a=20 y b=10
A diferencia del ejemplo anterior ahora los valores de las variables si fueron
modificados, para declarar parmetros por referencia utilizamos el smbolo * antes del
nombre del parmetro, adems de esto para poder acceder al valor del parmetro y no
su direccin se debe anteponer *, esto le indica al compilador que queremos acceder al
dato no a la direccin, tambin
es importante aclarar que a la hora de enviar los
parmetros se debe utilizar el operador & el cual devuelve la direccin de memoria

donde se encuentra almacenado el dato. De manera general la declaracin de
parmetros por referencia quedara de la forma.
<tipo> <nombre_funcon> (
<tipo> *<identificador>,
<tipo> *<identificador>,
...)
_________________________________________________________________________
Programacin II
Pgina 61

_________________________________________________________________________
6. Punteros Y Manejo De Archivos

6.1.
Punteros
6.1.1. Concepto de Puntero.

Un Puntero contiene una direccin de memoria.
Cuando una variable contiene la direccin de otra variable se dice que la primera
variable apunta a la segunda.
Dicho de forma especfica, un puntero es una variable que contiene la direccin de
memoria de otra variable. Se utilizan para pasar informacin entre una funcin y sus
puntos de llamada.
6.1.2. Declaracin de punteros

La forma general para declarar una variable puntero es:
tipo *nombre;
donde tipo es cualquier tipo valido de C (tambin llamado tipo base) y nombre es el
nombre de la variable puntero.
_________________________________________________________________________
Programacin II
Pgina 62

_________________________________________________________________________
6.1.3. Operadores de Punteros.

Existen dos Operadores especiales de punteros: & y *. Estos dos operadores son
monarios y no tienen nada que ver con los operadores binarios de multiplicacin (*) y de
and a nivel de bits (&).
6.1.3.1. Operador &.

& es un operador monario que devuelve la direccin de memoria de su operando. Por
ejemplo, si queremos guardar en el puntero x la direccin de memoria de la variable
num, deberemos hacer lo siguiente:
x=&num;
Ejemplo:
#include<stdio.h>
#include<conio.h>
/*Funcion principal*/
main()
{
int
x = 10;
/*Declaracion de variable*/
/*Se muestra el valor y la direccion de memoria de x*/

printf("x=%d\n&x =%p\n",x,&x);
getch();
}
Salida del ejemplo anterior:

x=10
&x = 8FBC: OFFE.
_________________________________________________________________________
Programacin II
Pgina 63

_________________________________________________________________________
Nota:
El valor y formato de las direcciones de las variables que se imprimen en esta
leccin (con el cdigo de formato %p) son dependientes de la implementacin. En
mi caso las direcciones se escriben en formato segmento offset, y e valor de la
direccin de una variable es distinto segn cuando y desde donde se ejecuta el
programa
6.1.3.2. Operador*
El operador * es el complemento de &. Es un operador monario que devuelve el valor
de la variable localizada en la direccin que sigue es decir devuelve el valor de la
variable cuya direccin es contenida por el puntero. Este ejemplo sita el contenido de
la variable apuntada por x, es decir num, en la variable a:
a=*x;
Ejemplo1:
#include<stdio.h>
#include<conio.h>
/*Funcion principal*/
main()
{
int x = 10;
/*Declaracion de x*/
printf("x = %d \n",x);
/*Se muestra el valor de x*/
printf("*&x = %d", *&x);
/*Se
muestra
el
valor
apuntado
por
direccion
&x*/
getch();
}
Salida del ejemplo1:

x = 10
*&x = 10
_________________________________________________________________________
Programacin II
Pgina 64

_________________________________________________________________________
Ejemplo 2:
#include<stdio.h>
#include<conio.h>
main()
{
int x = 10;
int *px;
px = &x;
printf("x = %d\n",x);
printf("&x = %p\n", &x);
printf("px = %p\n", px);
printf("&px = %p\n", &px);
printf("*px = %d", *px);
getch();
}
Salida del ejemplo:

x = 10
&x = 8FC4: OFFE
px = 8FC4: OFFE
&px = 8FC4: OFFA
*px = 10
Grficamente:
px
8FC4: OFFE
10
8FC4: OFFE
8FC4: OFFE
_________________________________________________________________________
Programacin II
Pgina 65

_________________________________________________________________________
En el ejemplo anterior se observa que hay tres valores asociados a los punteros:
Direccin en la que se encuentra.
Direccin a la que apunta.
Valor contenido en la direccin apuntada.
Nota:
Al ejecutar el siguiente programa los resultados pueden ser inesperados ya que
estamos asignado el valor 10 en una posicin de memoria no reservada.
#include<stdio.h>
#include<conio.h>
main()
{
int *p;
printf("Direccin: %p", p);
printf("Valor antes de asignar: %d", *p);
*p = 10;
printf("Valor asignado: %d", *p);
getch();
}
Seria correcto:
#include<stdio.h>
#include<conio.h>
main()
{
int x; /*se reserva memoria para x*/
int *p; /*se reserva memoria para la variable p, no para la posicin de
memoria a la que apunta p*/
printf("Direccion de:\n&x = %p\np = %p\n", &x, p);
p = &x; /*p apunta a valor de x*/
printf("Direccion despues de asignar:\n&x = %p\np = %p\n", &x, p);
*p = 10; /*equivalente a x = 10*/
printf("Valor de x: %d\nValor apuntado por *p: %d\n", x, *p);
getch();
}
6.1.4. Aritmtica de Punteros.
_________________________________________________________________________
Programacin II
Pgina 66

_________________________________________________________________________
Existen 4 operadores que realizan operaciones aritmticas que pueden utilizarse con
punteros. Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello
podemos usar los operadores de suma, resta, incremento y decremento (+, -, ++, - -). Si
tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la posicin 30000 y
hacemos: p1=p1+5; el puntero almacenar la posicin 30010, porque apunta 5 enteros
por encima ( 10 bytes ms ).
Ejemplo:
#include<stdio.h>
#include<conio.h>
main ()
{
int *p;
#define imprimir_p printf("\np = %p",p);
imprimir_p;
printf ("\tsizeof (*p) = %d",sizeof(*p));
p++; imprimir_p;
p -=5; imprimir_p;
getch();
}
Salida del ejemplo:

p = 7203:8D51
sizeof (*p) = 2
p = 7203:8D53
p = 7203:8D49
En el ejemplo se aprecia que si hacemos p++; no aumenta el valor de p en 1 sino que

aumenta en 2, que s el tamao en bytes de un int, es decir, el tamao del objeto al que
apunta.
Por lo tanto, la sentencia p++ hay que interpretarla de la siguiente forma:<<p apunta al
siguiente elemento del tipo base>>. Lo mismo se puede decir e los dems operadores
aritmticos aplicados a los punteros.
_________________________________________________________________________
Programacin II
Pgina 67

_________________________________________________________________________
Toda la aritmtica de punteros esta en relacin con el tipo base del puntero por lo que el
puntero esta siempre apuntado al elemento apropiado del tipo base.
6.1.5. Asignacin dinmica de Memoria.

Supngase que queremos hacer un programa que lea n valores enteros introducidos
por teclado por el usuario, los almacene en un vector y los imprima en un orden inverso.
Solucin:
#include<stdio.h>
#include<conio.h>
main()
{
#define NMAX 100 /*nmero mximo de elementos*/
int v[NMAX]; /*vector*/
int n = 0; /*nmero de elementos introducidos*/
int varaux;/*variable auxiliar*/
register
int i; /*indice*/
do
{
printf("\nIntroduce nmero de valores a leer (1 - %d): ", NMAX);
scanf ("%d", &n);
} while (n < 1 || n > NMAX);
for (i = 0; i <= n - 1; i++)
{
printf("Introduce valor %d: ", i+1);
scanf("%d", &varaux);
v[i] = varaux;
}
printf("\n\nvalores en orden inverso: \n");
_________________________________________________________________________
Programacin II
Pgina 68

_________________________________________________________________________
for(i = n - 1; i >= 0; i--)
printf("Valore %d = %d\n", i+1, v[i]);
getch();
}
Si el usuario introduce como valor de n, el valor 10, estaremos desperdiciando, si un int

ocupa 2 bytes, 90*2 bytes de memoria. Adems, el usuario no puede introducir ms de
NMAX valores. Estas restricciones vienen impuestas porque el tamao de un array en
la declaracin ha de ser una expresin constante. La asignacin de memoria en este
caso se dice que es esttica porque se determino en el momento de la compilacin.
Cuando la asignacin de memoria se determina en tiempo de ejecucin se dice que es
asignacin dinmica.
Veamos como se hara el programa anterior con asignacin dinmica y luego pasamos
a explicarlo:
#include<stdio.h>/*printf(), scanf()*/
#include<conio.h>/*getch();*/
#include<malloc.h>/*malloc(), free()*/
main() {
int *v; /*vector*/
/*nmero de elementos introducidos y variable auxiliar*/
int n = 0, varaux;
register int i; /*indice*/
printf("\nIntroduce nmero de valores a leer: ");
scanf("%d", &n);
v = (int *) malloc(n * sizeof(int));
if (v == NULL)
printf("Memoria insuficiente.");
else
{
for (i = 0; i <= n - 1; i++)
{
printf("Introduce valor %d: ", i+1);
scanf("%d", &varaux); v[i] = varaux;
}
printf("\n\n valores en orden inverso: \n");
_________________________________________________________________________
Programacin II
Pgina 69

_________________________________________________________________________
for(i = n - 1; i >= 0; i--)
printf("Valor %d = %d", i+1, v[i]);
free(v);
}
getch();
}
La primera sentencia de main() es:

int *x;
En esta declaracin estamos declarando v como un puntero a entero.

La siguiente lnea <<extraa>> para nosotros es:
v = (int *) malloc (n * sizeof (int));
La funcin malloc reserva memoria; acepta como argumento los bytes de memoria a
reserva y devuelve un puntero al primer byte de la zona de memoria reservada; los
bytes de memoria solicitados los reserva en un espacio de memoria contiguo. Si no hay
suficiente memoria, devuelve NULL. Un puntero que tiene el valor NULL es un puntero
que no apunta a ningn sitio.
El prototipo de esta funcin se encuentra en el fichero malloc.h (de ah el incluir este
fichero en nuestro ejemplo) y es el siguiente:
void * malloc (unsigned in bytes);
Veamos que devuelve un puntero a void; esto quiere decir que devuelve un puntero que
apunta a cualquier tipo base, o dicho de otro modo, un puntero que apunta a una
direccin de memoria sin tener tipo base.
El c de Kernighan y Ritchie, como no tiene tipo void, el prototipo de esta funcin es:
char * malloc (unsigned int bytes);
_________________________________________________________________________
Programacin II
Pgina 70

_________________________________________________________________________
En ambos casos, el tratamiento por parte del usuario de esta funcin es exactamente el
mismo. Veamos otra vez la llamada a esta funcin en nuestro ejemplo:
v = (int *) malloc (n * sizeof (int));
Al valor devuelto por la funcin malloc (puntero a void o puntero a char) siempre se le
realiza un moldeado (debemos recordar que esto se hacia con: (tipo)) para adecuarlo al
tipo base de nuestro puntero que va a apuntar a esa zona de memoria reservada. En
nuestro caso el molde es:
(int *x) /*puntero a entero*/
El puntero que le pasamos a malloc ha de ser el nmero de bytes de memoria a

reservar. Esto siempre se hace siguiendo la frmula:
nmero_de_elementos * sizeof (tipo_de_cada_elemento).
Que traducido a nuestro caso queda:

n * sizeof (int)
Otra forma e hacer lo mismo es:

N * sizeof (*x)
Que suele ser muy corriente. Las dos formas son equivalentes.
La memoria asignada por malloc se desasigna con la funcin free(). Esta memoria
asignada no se desasigna al salir del bloque de cdigo en que fue asignada como
ocurre con las variables locales sino con la funcin free(liberar) o al terminar el
programa. Por lo tanto, siempre que asignemos memoria con malloc, tenemos que
desasignarla con free cuando ya no nos sea necesaria.
El prototipo de la funcin free se encuentra en el fichero malloc.h y es el siguiente:
void free (void *p);
Un
puntero
void
como
parmetro
indica
que
acepta
cualquier
puntero,
independientemente del tipo base al que apunta. El puntero que se le pasa a free como
_________________________________________________________________________
Programacin II
Pgina 71

_________________________________________________________________________
argumento ha de ser un puntero que apunta al principio de una zona reservad
anteriormente por malloc; sino es as, se puede caer el sistema.
El resto del ejemplo no tiene ya ninguna dificultad.
Hay otra funcin, en la librera <alloc.h> equivalente a malloc, que es la funcin calloc
cuyo prototipo es el siguiente:
void * calloc (
unsigned nmero_de_elementos_a_reservar,
unsigned tamao_en_bytes_de_cada_elemento);
Esta funcin es igual que malloc con la nica diferencia de sus parmetros.
En turbo C, los prototipos de las funciones malloc(), calloc() y free(), adems de estar
en el fichero alloc.h, tambin estn en el fichero stdlib.h
6.1.6. Punteros y arrays.

Existe una estrecha relacin entre los punteros y los arrays. El nombre de un array es
un puntero al primer elemento del array.
A cualquier elemento de un array podemos acceder mediante la aritmtica de punteros
y viceversa, cualquier puntero lo podemos indexar con los []:
6.1.6.1. Arrays unidimensionales:
p[i] == *(p+i)
6.1.6.2. Arrays bidimensionales:
p[i][j] == *(p+(i *longitud_fila)+k) == *(*(p+i)+j)
6.1.6.3. Arrays muldimensionales:
_________________________________________________________________________
Programacin II
Pgina 72

_________________________________________________________________________
Se sigue cualquiera de los dos procedimientos ejemplarizados en los arrays
bidimensionales.
Ejemplo de acceso a un Array con un Puntero.
#include<stdio.h>
#include<conio.h>
main()
{
/*Arreglo unidimensional*/
float v[3] = {1.1, 2.2, 3.3};
/*Se muestran los valores*/
printf ("v[1] = %g; *(v+1) = %g", v[1], *(v+1));
getch();
}
Salida: v[1] = 2.2; *(v+1) = 2.2

Ejemplo de acceso a elementos indexando un puntero con [ ].
#include<stdio.h> /*printf (), NULL*/
#include<malloc.h> /*malloc (), free ()*/
#include<conio.h>
main()
{
float *p;
if ((p = (float *)malloc(3*sizeof (float)))== NULL)
printf("\nERROR: Memoria insuficiente.");
else
{
*p = 1.1; *(p+1) = 2.2; *(p+3) = 3.3;
printf ("*(p+1) =%g p[1] =%g",*(p+1), p[1]);
free(p);
}
getch();
}
Salida: *(p+1) = 2.2; p[1] = 2.2
_________________________________________________________________________
Programacin II
Pgina 73

_________________________________________________________________________
Nota:
Los programadores profesionales de C suelen utilizar la notacin puntero en vez de la
notacin array porque es bastante ms rpido y ms cmodo, aunque para los no
acostumbrados a esta notacin se ve un poco extrao al principio.
Vemos que en la notacin array, para acceder a un determinado elemento, el
compilador tiene que hacer una serie de clculos para averiguar en que posicin est,
mientras que en la notacin puntero basta con una simple suma.
No obstante, cuando el cdigo queda ms claro en la notacin array que con la
notacin puntero es preferible la primera notacin.
Cuando se trabaja con cadena de caracteres si se debe utilizar la notacin puntero, no
ya solo por eficiencia sino tambin por convencin.
Una estructura comn en C es el array de punteros. Recordar que el argumento array
de la funcin main () es un array de punteros a caracteres.
Hay tres formas equivalentes de declarar el argumento argv en la funcin main():
main (int argc, char argv[ ][ ]);
main (int argc, char *argv[ ]);
main (int argc, char **argv);
Se observa que en la primera declaracin no se ha especificado el tamao de la

segunda dimensin de argv cuando habamos dicho antes que era necesario, esto solo
est permitido hacerlo en la funcin main().
La declaracin para un array de 10 punteros a int es:
int
*x[10];
_________________________________________________________________________
Programacin II
Pgina 74

_________________________________________________________________________
Para asignar la direccin de una variable entera llamada ver al tercer elemento del array
de punteros, se escribe:
x[2] = &var;
Ejemplo de array de cadenas de caracteres.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
void error (int numero_de_error)
{
char *errores[ ] =
{
"error al intentar abrir fichero",
"error al intentar cerrar fichero",
"error al intentar leer de fichero",
"error al intentar escribir en fichero"
};
printf ("Error %d. %s.",
numero_de_error, errores [numero_de_error]);
getch();
exit(1);
}
main()
{
int n = 1;
error(n);
}
Un array de puntero es lo mismo que punteros a punteros.

Este ejemplo comprueba dicha afirmacin.
#include<stdio.h>
#include<conio.h>
main ()
{
int x, *p, **q;
_________________________________________________________________________
Programacin II
Pgina 75

_________________________________________________________________________
x = 10;
p = &x;
q = &p;
printf("x = %d; *p = %d; **q = %d",x,*p,**q);

getch();
}
Salida:
x = 10; *p = 10; **q = 10.
Vamos a mostrar dos formas de implementar la siguiente funcin: la funcin a

implementar acepta como argumentos una matriz de enteros y un elemento, y devuelve
1 si ese elemento se encuentra en la matriz o 0 si dicho elemento no se encuentra en la
matriz.
/*Las funciones a buscar_en_matriz_versin_1()
buscar_en_matriz_versin_2() son equivalentes pero la segunda es mucho ms
eficiente*/
#include<stdio.h>
#include<conio.h>
#define N 3
int buscar_en_matriz_version_1(int m[N][N], int x)
{
register int i, j;
int encontrado = 0;
for (i = 0; ! encontrado && i < N; i++)
for (j = 0; ! encontrado && j< N; j++)
if (m[i][j]== x)
encontrado = 1;
return (encontrado);
}
int buscar_en_matriz_version_2 (int m[N][N], int x)
{
register int i;
int encontrado = 0;
int *pm = (int*)m; /*declara pm como puntero a int y lo hace a puntar a
m*/
for (i = 1; ! encontrado && i<= N *N; i++)
{
if (*pm == x)
_________________________________________________________________________
Programacin II
Pgina 76

_________________________________________________________________________
encontrado = 1;
else
pm++;
}
return(encontrado);
}
main()
{
int matriz [N][N] = {{1,2,3}, {-1,-2,-3}, {5,6,7}};
int resultado_1 = buscar_en_matriz_version_1 (matriz,6);
printf("\n resultado_1 = %d", resultado_1);
getch();
}
Salida:
resultado_1 = 1
resultado_2 = 0
resultado_3 = 1
resultado_4 = 0
_________________________________________________________________________
Programacin II
Pgina 77

_________________________________________________________________________
6.1.7. Inicializaciones de punteros

Un puntero que tiene el valor NULL es un puntero que no apunta a ningn sitio.
Una inicializacin muy comn en C se ilustra con el siguiente ejemplo:
char *p = cadena\n;
En este caso el compilador guarda cadena\n en memoria y hace que p apunte al

principio de la cadena, es decir, el carcter c.
Ejemplo de inicializaciones equivalentes.
int x = 10;
<==>
int *p = &x;
int x = 10;
int *p;
p = &x;
int x, *p, y;
<==>
int x;
int *p;
int y;
int *p, *q, r = 10;
<==>
int *p ;
int *q;
int r =10;
int v[2] = {1,2}, f (void), *p, x = 3; <==>
int v[2] = {1,2};

int f (void);
int *p;
int x = 3;
_________________________________________________________________________
Programacin II
Pgina 78

_________________________________________________________________________
6.1.8. Punteros a funciones.

Una caracterstica algo confusa pero muy til de C es el puntero a funcin. La confusin
surge porque una funcin tiene una posicin fsica en memoria que puede asignarse a
un puntero aunque la funcin no es una variable. La direccin de la funcin es el punto
de entrada de la funcin; por tanto, un puntero a funcin, puede utilizarse para llamar a
la funcin.
Ejemplo:
#include<stdio.h> /*printf ()*/
#include<conio.h>
main()
{
/*escribir es una funcin que acepta un int como argumento y no devuelve
nada*/
void escribir (int);
/*pf es un puntero a una funcin que acepta un int como argumento y no
devuelve nada*/
void (*pf)(int);
pf = escribir;
escribir (1); /*llama a la funcin escribir*/
(*pf)(2); /*llama a la funcin escribir a travs e un puntero*/
getch();
}
void escribir (int numero)
{
printf ("%d", numero);
}
_________________________________________________________________________
Programacin II
Pgina 79

_________________________________________________________________________
Salida: 12
6.1.9. Modificador de acceso const y punteros.

El modificador de acceso const aplicado a punteros ofrece varias posibilidades.
Vemosla en los siguientes ejemplos:
main()
{
char *p1 = "abc";
/*puntero*/
const char *p2 = "abc"; /*puntero a constante*/

char *const p3 = "abc";
/*puntero constante*/
const char *const p4 = "abc";
/*puntero constante a constante*/
*p1 = 'd'; /*correcto*/

*p2 = 'd'; /*error*/
*p3 = 'd'; /*correcto*/
*p4 = 'd'; /*error*/
p1++; /*correcto*/
p2++; /*correcto*/
p3++; /*error*/
p4++; /*error*/
p1 = p2; /*warning*/
p1 = p3; /*correcto*/
p1 = p4; /*warning*/
p3 = p1; /*error*/
p3 = p2; /*error*/
p3 = p4; /*error*/
p4 = p1; /*error*/
p4 = p2; /*error*/
p4 = p3; /*error*/
_________________________________________________________________________
Programacin II
Pgina 80

_________________________________________________________________________
}
Las lneas que contienen el mensaje de error provocan un error de compilacin.
Las lneas que contienen el mensaje de warning provocan en algunos compiladores un

mensaje de conversin de puntero sospechosa que se puede solucionar haciendo la
conversin de una forma explcita:
p1 = (char *) p2;
p1 = (char *) p4;
Si ahora hacemos:
*p1 = d;
Estamos
modificando los valores apuntados por p2 y p4; es decir, los valores
apuntados por p2 y p4; es decir, los valores apuntados por p2 y p4 no pueden ser
modificados por estos punteros pero si pueden ser modificados indirectamente por otro
puntero.
Otro ejemplo de cmo se puede modificar el valor de una constante indirectamente a
travs de un puntero:
Const int x = 10;
/*x es una variable constante*/
x = 20;
/*esto provoca un error en compilacin*/
*(int*)&x = 20;
/*esto es correcto: obtenemos su direccin, que es del

tipo (const int*) y la moldeamos al tipo (int *), una
vez hecho esto accedemos al valor de esa direccin con
el operador de contenido* */
_________________________________________________________________________
Programacin II
Pgina 81

_________________________________________________________________________
6.1.10. Declaraciones curiosas.

El C permite la creacin de formas de datos muy elaboradas.
Cuando se hace una declaracin, el nombre (o identificador) que usamos se puede
modificador aadindole uno o varios modificadores:
Modificador
*
()
[]
Significado
indica puntero
indica una funcin
indica un array
La clave para desentraar las declaraciones que mostraremos a continuacin es

averiguar el orden en que se aplican los modificadores.
Para ello se siguen tres reglas:
La prioridad de un modificador es tanto mayor cuanto ms prximo este el identificador.
Los modificadores [ ] y () tienen mayor prioridad que *.
Se pueden usar parntesis para agrupar parte de la expresin otorgndole la mxima prioridad.
Ejemplo:
main ()
{
/*array de arrays de int*/
int x1 [8][8];
/*puntero a puntero a int*/
int **x2;
/*array de 10 punteros a int*/
int *x3[10];
_________________________________________________________________________
Programacin II
Pgina 82

_________________________________________________________________________
/*puntero a array de 10 int*/
int (* x4)[10];
/*array de 3 punteros a array de 4 int*/
int **x5 [3][4];
/*puntero a array de 3*4 int*/
int (**x6)[3][4];
/*puntero a funcin que devuelve un tipo int*/
int (*x8) (void);
/*funcin que acepta un puntero a char como argumento y que devuelve un
puntero a un puntero a una funcin que devuelve un carcter*/
char(*(* x11(char*)))(void);
/*puntero a funcin que devuelve un puntero a puntero a carcter y acepta dos
argumentos: el primero es un puntero a puntero a puntero a carcter, y el
segundo es un array de 10 punteros a carcter*/
char**(*x12) (char ***, char *[10]);
/*funcin que acepta un puntero a puntero a puntero a constante y devuelve un
puntero constante a constante*/
const void *const x13 (const void ***);
/*funcin que no devuelve nada y acepta como argumento un puntero a funcin
que no devuelve nada y acepta como argumento un puntero a funcin que no
devuelve nada y no acepta ningn argumento*/
void x14 (void (*) (void(*)(void)));
/*funcin que acepta un int
como argumento y devuelve un puntero a una
funcin que acepta un int como argumento y que devuelve un int*/

int(*(x15 (int))) (int);
}
_________________________________________________________________________
Programacin II
Pgina 83

_________________________________________________________________________
6.2.
Estructuras
6.2.1. Concepto de estructura

Una estructura es un conjunto de una o ms variables, de distinto tipo, agrupadas bajo
un mismo nombre para que su manejo sea ms sencillo. Su utilizacin ms habitual es
para la programacin de bases de datos, ya que estn especialmente indicadas para el
trabajo con registros o fichas.
6.2.2. Declaracin
La sintaxis de su declaracin es la siguiente:
struct tipo_estructura
{
tipo_variable nombre_variable1;
};
Donde tipo_estructura es el nombre del nuevo tipo de dato que hemos creado. Por
ltimo, tipo_variable y nombre_variable son las variables que forman parte de la
estructura.
Para definir variables del tipo que acabamos de crear lo podemos hacer de varias
maneras, aunque las dos ms utilizadas son stas:
Una forma de definir la estructura:
struct trabajador {
char nombre[20];
char apellidos[40];
int edad;
_________________________________________________________________________
Programacin II
Pgina 84

_________________________________________________________________________
char puesto[10];
};
struct trabajador fijo, temporal;
Otra forma:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
}fijo, temporal;
En el primer caso declaramos la estructura, y en el momento en que necesitamos las
variables, las declaramos. En el segundo las declaramos al mismo tiempo que la
estructura. El problema del segundo mtodo es que no podremos declarar ms
variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo
estructura, la estructura tiene que estar declarada previamente. Se debe declarar antes
de la funcin main.
El manejo de las estructuras es muy sencillo, as como el acceso a los campos ( o
variables ) de estas estructuras. La forma de acceder a estos campos es la siguiente:
variable.campo;
Donde variable es el nombre de la variable de tipo estructura que hemos creado, y

campo es el nombre de la variable que forma parte de la estructura. Lo veremos mejor
con un ejemplo basado en la estructura definida anteriormente:
temporal.edad=25;
Lo que estamos haciendo es almacenar el valor 25 en el campo edad de la variable

temporal de tipo trabajador.
Otra caracterstica interesante de las estructuras es que permiten pasar el contenido de
una estructura a otra, siempre que sean del mismo tipo naturalmente:
_________________________________________________________________________
Programacin II
Pgina 85

_________________________________________________________________________
fijo=temporal;
Al igual que con los otros tipos de datos, tambin es posible inicializar variables de tipo
estructura en el momento de su declaracin:
struct trabajador fijo={"Pedro","Hernndez Surez", 32, "gerente"};
Si uno de los campos de la estructura es un array de nmeros, los valores de la

inicializacin debern ir entre llaves:
struct notas
{
char nombre[30];
int notas[5];
};
struct notas alumno={"Carlos Prez",{8,7,9,6,10}};
6.2.3. Estructuras y funciones

Podemos enviar una estructura a una funcin de las dos maneras conocidas:
6.2.3.1. Por valor
Su declaracin sera:
void visualizar(struct trabajador);
Despus declararamos la variable fijo y su llamada sera:

visualizar(fijo);
Por ltimo, el desarrollo de la funcin sera:

void visualizar(struct trabajador datos)
_________________________________________________________________________
Programacin II
Pgina 86

_________________________________________________________________________
Ejemplo:
/*Paso de una estructura por valor*/
#include <stdio.h>
#include <conio.h>
struct trabajador
{
char nombre [20];
char apellidos [40];
int edad;
char puesto [10];
};
void visualizar (struct trabajador);
main() /*rellenar y visualizar*/
{
struct trabajador fijo;
printf ("Nombre: ");
scanf("%s", fijo.nombre);
printf("\nApellidos: ");
scanf("%s", fijo.apellidos);
printf("\nedad: ");
scanf("%d", &fijo.edad);
printf("\nPuesto: ");
scanf("%s", fijo.puesto);
visualizar(fijo);
getch();
}
void visualizar (struct trabajador datos)
{
printf("Nombre: %s", datos.nombre);
printf("\nApellidos: %s", datos.apellidos);
printf("\nedad: %d", datos.edad);
printf("\npuesto: %s", datos.puesto);
}
_________________________________________________________________________
Programacin II
Pgina 87

_________________________________________________________________________
6.2.3.2. Por referencia:
Su declaracin sera:
void visualizar(struct trabajador *);
Despus declararemos la variable fijo y su llamada ser:

visualizar(&fijo);
Por ltimo, el desarrollo de la funcin ser:

void visualizar(struct trabajador *datos)
Fjate que en la funcin visualizar, el acceso a los campos de la variable datos se

realiza mediante el operador ->, ya que tratamos con un puntero. En estos casos
siempre utilizaremos el operador ->. Se consigue con el signo menos seguido de mayor
que.
Ejemplo:
/* Paso de una estructura por referencia. */
#include <stdio.h>
#include <conio.h>
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
};
void visualizar(struct trabajador *);
main() /* Rellenar y visualizar */
{
struct trabajador fijo;
printf("Nombre: ");
scanf("%s",fijo.nombre);
printf("\nApellidos: ");
_________________________________________________________________________
Programacin II
Pgina 88

_________________________________________________________________________
scanf("%s",fijo.apellidos);
printf("\nEdad: ");
scanf("%d",&fijo.edad);
printf("\nPuesto: ");
scanf("%s",fijo.puesto);
visualizar(&fijo);
getch();
}
void visualizar(struct trabajador *datos)
{
printf("Nombre: %s",datos->nombre);
printf("\nApellidos: %s",datos->apellidos);
printf("\nEdad: %d",datos->edad);
printf("\nPuesto: %s",datos->puesto);
}
6.2.4. Arrays de estructuras

Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se
conoce como array de estructuras:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
};
struct trabajador fijo[20];
As podremos almacenar los datos de 20 trabajadores. Ejemplos sobre como acceder a

los campos y sus elementos: para ver el nombre del cuarto trabajador, fijo[3].nombre;
Para ver la tercera letra del nombre del cuarto trabajador, fijo[3].nombre[2];. Para
inicializar la variable en el momento de declararla lo haremos de esta manera:
struct trabajador fijo[20]=
{{"Jos","Herrero Martnez",29},{"Luis","Garca Snchez",46}};
_________________________________________________________________________
Programacin II
Pgina 89

_________________________________________________________________________
6.2.5. Typedef
El lenguaje 'C' dispone de una declaracin llamada typedef que permite la creacin de
nuevos tipos de datos. Ejemplos:
/* acabamos de crear un tipo de dato llamado entero */
typedef int entero;
entero a, b=3;
/* declaramos dos variables de este tipo */
Su empleo con estructuras est especialmente indicado. Se puede hacer de varias

formas:
Una forma de hacerlo:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
};
typedef struct trabajador datos;
datos fijo,temporal;
Otra forma:
typedef struct
{
char nombre[20];
char apellidos[40];
int edad;
}datos;
datos fijo,temporal;
_________________________________________________________________________
Programacin II
Pgina 90

_________________________________________________________________________
6.3.
Ficheros
Ahora veremos la forma de almacenar datos que podremos recuperar cuando

deseemos. Estudiaremos los distintos modos en que podemos abrir un fichero, as
como las funciones para leer y escribir en l.
6.3.1. Apertura
Antes de abrir un fichero necesitamos declarar un puntero de tipo FILE, con el que
trabajaremos durante todo el proceso. Para abrir el fichero utilizaremos la
funcinfopen().
Su sintaxis es:
FILE *puntero;
puntero = fopen ( nombre del fichero, "modo de apertura" );
donde puntero es la variable de tipo FILE, nombre del fichero es el nombre que
daremos al fichero que queremos crear o abrir. Este nombre debe ir encerrado entre
comillas.
Tambin podemos especificar la ruta donde se encuentra o utilizar un array que
contenga el nombre del archivo ( en este caso no se pondrn las comillas ).
Algunos ejemplos:
puntero=fopen("DATOS.DAT","r");
puntero=fopen("C:\\TXT\\SALUDO.TXT","w");
Un archivo puede ser abierto en dos modos diferentes, en modo texto o en modo
binario. A continuacin lo veremos con ms detalle.
_________________________________________________________________________
Programacin II
Pgina 91

_________________________________________________________________________
6.3.1.1. Modo texto
w crea un fichero de escritura. Si ya existe lo crea de nuevo.
w+ crea un fichero de lectura y escritura. Si ya existe lo crea de nuevo.
a abre o crea un fichero para aadir datos al final del mismo.
a+ abre o crea un fichero para leer y aadir datos al final del mismo.
r+ abre un fichero de lectura y escritura.
abre un fichero de lectura.
6.3.1.2. Modo binario
wb crea un fichero de escritura. Si ya existe lo crea de nuevo.
w+b
ab abre o crea un fichero para aadir datos al final del mismo.
a+b
rb abre un fichero de lectura.
r+b
crea un fichero de lectura y escritura. Si ya existe lo crea de nuevo.
abre o crea un fichero para leer y aadir datos al final del mismo.
abre un fichero de lectura y escritura.
La funcin fopen devuelve, como ya hemos visto, un puntero de tipo FILE. Si al intentar
abrir el fichero se produjese un error ( por ejemplo si no existe y lo estamos abriendo en
modo lectura ), la funcin fopen devolvera NULL. Por esta razn es mejor controlar las
posibles causas de error a la hora de programar. Un ejemplo:
FILE *pf;
pf=fopen("datos.txt","r");
if (pf == NULL) printf("Error al abrir el fichero");
freopen(): Esta funcin cierra el fichero apuntado por el puntero y reasigna este puntero
a un fichero que ser abierto. Su sintaxis es:
freopen(nombre del fichero,"modo de apertura",puntero);
Donde nombre del fichero es el nombre del nuevo fichero que queremos abrir, luego el
modo de apertura, y finalmente el puntero que va a ser reasignado.
_________________________________________________________________________
Programacin II
Pgina 92

_________________________________________________________________________
6.3.2. Cierre
Una vez que hemos acabado nuestro trabajo con un fichero es recomendable cerrarlo.
Los ficheros se cierran al finalizar el programa pero el nmero de estos que pueden
estar abiertos es limitado.
Para cerrar los ficheros utilizaremos la funcin fclose();. Esta funcin cierra el fichero,
cuyo puntero le indicamos como parmetro. Si el fichero se cierra con xito devuelve 0.
fclose (puntero);
Un ejemplo ilustrativo aunque de poca utilidad:

FILE *pf;
pf=fopen("AGENDA.DAT","rb");
if ( pf == NULL ) printf ("Error al abrir el fichero");
else fclose(pf);
6.3.3. Funciones de Escritura y lectura

A continuacin veremos las funciones que se podrn utilizar dependiendo del dato que
queramos escribir y/o leer en el fichero.
6.3.3.1. Funcin fputc
fputc( variable_caracter , puntero_fichero );
Escribimos un carcter en un fichero (abierto en modo escritura). Un ejemplo:

FILE *pf;
char letra='a';
/* otra forma de controlar si se produce un error */
if (!(pf=fopen("datos.txt","w")))
{
printf("Error al abrir el fichero");
exit(0);
else fputc(letra,pf);
fclose(pf);
6.3.3.2. Funcin fgetc

_________________________________________________________________________
Programacin II
Pgina 93

_________________________________________________________________________
fgetc( puntero_fichero );
Lee un carcter de un fichero (abierto en modo lectura). Deberemos guardarlo en una

variable. Un ejemplo:
FILE *pf;
char letra;
/* controlamos si se produce un error */

if (!(pf=fopen("datos.txt","r")))
{
exit(0); /* abandonamos el programa */
}
else
{
letra=fgetc(pf);
printf("%c",letra);
fclose(pf);
}
6.3.3.3. Funcin putw

putw( variable_entera, puntero_fichero );
Escribe un nmero entero en formato binario en el fichero. Ejemplo:

FILE *pf;
int num=3;
if (!(pf=fopen("datos.txt","wb"))) /* controlamos si se produce un error
*/
{
}
else
{
fputw(num,pf);
/*
tambin
podamos
haber
hecho
directamente:
fputw(3,pf); */
fclose(pf);
}
6.3.3.4. Funcin getw

_________________________________________________________________________
Programacin II
Pgina 94

_________________________________________________________________________
getw( puntero_fichero );
Lee un nmero entero de un fichero, avanzando dos bytes despus de cada lectura. Un
ejemplo:
FILE *pf;
int num;
if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error
*/
{
}
else
{
num=getw(pf);
printf("%d",num);
fclose(pf);
6.3.3.5. Funcin fputs

fputs( variable_array, puntero_fichero );
Escribe una cadena de caracteres en el fichero. Ejemplo:
FILE *pf;
char cad="Me llamo Vicente";
{
}
Else
/* o tambin as: fputs("Me llamo Vicente",pf); */

fputs(cad,pf);
fclose(pf);
}
6.3.3.6. Funcin fgets

_________________________________________________________________________
Programacin II
Pgina 95

_________________________________________________________________________
fgets( variable_array, variable_entera, puntero_fichero );
Lee una cadena de caracteres del fichero y la almacena en variable_array. La

variable_entera indica la longitud mxima de caracteres que puede leer. Un ejemplo:
FILE *pf;
char cad[80];
*/
{
}
else
{
fgets(cad,80,pf);
printf("%s",cad);
fclose(pf);
}
6.3.3.7. Funcin fprintf

fprintf( puntero_fichero, formato, argumentos);
Funciona igual que un printf pero guarda la salida en un fichero. Ejemplo:

FILE *pf;
char nombre[20]="Santiago";
int edad=34;


}
else
{
fprintf(pf,"%20s%2d\n",nombre,edad);
fclose(pf);
6.3.3.8. Funcin fscanf
_________________________________________________________________________
Programacin II
Pgina 96

_________________________________________________________________________
fscanf( puntero_fichero, formato, argumentos );
Lee los argumentos del fichero. Al igual que con un scanf, deberemos indicar la
direccin de memoria de los argumentos con el smbolo & ( ampersand ). Un ejemplo:
FILE *pf;
char nombre[20];
int edad;
*/
{
}
else
{
fscanf(pf,"%20s%2d\",nombre,&edad);
printf("Nombre: %s
Edad: %d",nombre,edad);
fclose(pf);
}
6.3.3.9. Funcin fwrite

fwrite( *buffer, tamao, n de veces, puntero_fichero );
Se utiliza para escribir bloques de texto o de datos, estructuras, en un fichero. En esta

funcin, *buffer ser la direccin de memoria de la cul se recogern los datos; tamao,
el tamao en bytes que ocupan esos datos y n de veces, ser el nmero de elementos
del tamao indicado que se escribirn.
6.3.3.10. Funcin fread

fread( *buffer, tamao, n de veces, puntero_fichero );
_________________________________________________________________________
Programacin II
Pgina 97

_________________________________________________________________________
Se utiliza para leer bloques de texto o de datos de un fichero. En esta funcin, *buffer es
la direccin de memoria en la que se almacenan los datos; tamao, el tamao en bytes
que ocupan esos datos y n de veces, ser el nmero de elementos del tamao
indicado que se leern.
Puedes encontrar ejemplos sobre la apertura y cierre de ficheros, as como de la lectura
y escritura de datos, en el archivo IMAGECAT.C. Se trata de un programa que crea un
catlogo en formato HTML a partir de las imgenes que se encuentran en un directorio
determinado.
6.3.3.11. Funcin rewind
rewind( puntero_fichero );
Sita el puntero al principio del archivo.

6.3.3.12. Funcin fseek
fseek( puntero_fichero, long posicion, int origen );
Sita el puntero en la posicion que le indiquemos. Como origen podremos poner:
0 o SEEK_SET, el principio del fichero
1 o SEEK_CUR, la posicin actual
2 o SEEK_END, el final del fichero
6.3.3.13. Funcin rename

rename( nombre1, nombre2 );
Su funcin es exactamente la misma que la que conocemos en MS-DOS. Cambia el

nombre
del
fichero
nombre1
por
un
nuevo
nombre,
nombre2.
6.3.3.14. Funcin remove

remove( nombre );
_________________________________________________________________________
Programacin II
Pgina 98

_________________________________________________________________________
Como la funcin del DOS del, podremos eliminar el archivo indicado en nombre.
6.3.3.15. Funcin feof
Deteccin de final de fichero
feof( puntero_fichero );
Siempre deberemos controlar si hemos llegado al final de fichero cuando estemos

leyendo, de lo contrario podran producirse errores de lectura no deseados. Para este
fin disponemos de la funcin feof( ). Esta funcin retorna 0 si no ha llegado al final, y un
valor diferente de 0 si lo ha alcanzado.
7. Grficos en el Leguaje C
_________________________________________________________________________
Programacin II
Pgina 99

_________________________________________________________________________
7.1.
Programa texto vs. programa grafico
Antes de comenzar con el modo grfico es necesario adentrarse en los conceptos

bsicos que permiten conocerlo a plenitud. Los programas que hemos hecho hasta
ahora se basan en un modo pobre en el que slo puede mostrarse caracteres, dicho
modo es conocido como modo texto o alfanumrico.
En estos modos, generalmente la pantalla se encuentra dividida por una matriz de 80
columnas y 25 filas. Cada celda de dicha matriz slo puede contener un carcter.
El inconveniente de este modo es que si quieres hacer un grfico tienes que ilustrarlo
con base a caracteres y lo peor es la resolucin limitada (80 x 25). Los modos grficos
se caracterizan por su variada combinacin de resolucin y colores.
Un pxel es la unidad mnima de dibujo en una pantalla. En las pantallas actuales, un
pxel tiene forma cuadrada y su color propio el cual es formado de una combinacin de
tres colores bsicos (Rojo, Verde, Azul).
Resolucin es la cantidad de pxeles por fila y columna de una pantalla en ese modo.
Por ejemplo, 640 pxeles por fila y 480 por columna caben en el modo VGA.
Cuando vayamos a utilizar los modos grficos debemos tener en cuenta que la esquina
superior izquierda es el origen de coordenadas y que la mxima coordenada posible es
(x-1,y-1).
Por ejemplo, si la resolucin es VGA (640x480) la coordenada mxima posible es
(639,479) medida a partir de la esquina superior izquierda.
Podemos ver, entonces las grandes diferencias entre los modos texto y grafico. Se
puede crear fcilmente un dibujo a partir de conjuntos de pxeles y colores, pero es no
_________________________________________________________________________
Programacin II
Pgina 100

_________________________________________________________________________
quiere decir que no puedan mostrarse caracteres, ya que estos son tambin conjuntos
de puntos.
7.2.
Inicializacin del modo grafico
Para poder utilizar el modo grfico, antes que nada debe iniciarse. Primero hay que
detectar el adaptador:
int gdriver=DETECT, gmode;
Donde gdriver=DETECT especifica que queremos que se auto-detecte el tipo genrico

de tarjeta grfica que tenemos instalada y gmode abrir el modo y combinacin de
colores predeterminado. Frecuentemente la tarjeta grafica ms habitual es la VGA y el
modo grafico 640 x 480 con 16 colores.
Otra alternativa para detectar la tarjeta grafica es usar la instruccin detectgraph:
detectgraph(int *adaptador, int *modo);
En el primer argumento se guarda la tarjeta grafica detectada, en modo se almacena el

modo por defecto.
initgraph(&gdriver,&gmode,bgi);
La instruccin initgraph inicia el modo grafico con los argumentos correspondientes. El

primer argumento corresponde al tipo de tarjeta grafica que tengamos, el segundo
refiere al modo grafico que queremos, y el tercer parmetro al directorio donde se
encuentran los ficheros BGI, los cuales contienen informacin acerca de los modos de
videos y funciones graficas.
Cabe destacar que el uso de ficheros BGI (Borland Graphics Interface) es un
inconveniente en cuanto a que estos ficheros deben mantenerse en la misma de
carpeta del programa compilado para que funcione, es una opcin enlazarlos con el
programa ya compilado pero esto aumenta notablemente el tamao del programa.
int graphresult( );
_________________________________________________________________________
Programacin II
Pgina 101

_________________________________________________________________________
Reporta el estado del modo grfico. Enva 0 si no ocurri error, de lo contrario retorna
un valor en el rango[-1,-16].
char grapherrormsg(int error_id);
Manda un apuntador al mensaje de error respecto al valor retornado en graphresult.

Si queremos terminar el modo grafico y regresar al modo texto usaremos la funcin
closegraph(). No es necesario ningn argumento.
closegraph();
La funcin restorecrtmode() nos devuelve al modo original.

restorecrtmode();
7.3.
Dibujar en el modo grfico (Primitivos Grficos)
7.3.1. Pintar un punto:

putpixel(int x, int y, int color);
(x,y) es la ubicacin del punto que queremos pintar.

En color se indica una constante COLORS o bien el numero del color correspondiente.
0
1
2
3
BLACK
BLUE
GREEN
CYAN
4
5
6
7
RED
MAGENTA
BROWN
LIGHTGRAY
8
9
10
11
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
12
13
14
15
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
7.3.2. Dibujar un segmento de recta:

line(int x1,int y1, int x2,int y2);
(x1,y1) y (x2,y2) puntos extremos del segmento de recta
_________________________________________________________________________
Programacin II
Pgina 102

_________________________________________________________________________
7.3.3. Para dibujar una circunferencia:

circle(int x, int y, int r);
(x,y) es el centro de la circunferencia.

r es el radio de la circunferencia.
7.3.4. Para trazar un rectngulo:

rectangle(int x1 , int y1 , int x2 , int y2);
(x1,y1) es la esquina superior izquierda del rectngulo.

(x2,y2) es la esquina inferior derecha del rectngulo.
7.3.5. Dibujar un arco circular:

arc(int x , int y, int ai , int af , int r);
(x,y) es el centro del arco circular.

(ai-af) ngulo inicial y final del arco circular
r radio del arco circular
7.3.6. Dibujar un arco elptico:

ellipse(int x, int y, int ai, int af, int rx, int ry);
(x,y)
centro del arco eliptico
(ai-af) ngulo inicial y final del arco eliptico

rx, ry radio horizontal y vertical del arco eliptico
7.4.
Cambiar el estilo de lnea:

setlinestyle(int estilo, int separacin ,int
ancho);
Estilo especifica el estilo a usar.

_________________________________________________________________________
Programacin II
Pgina 103

_________________________________________________________________________
0
1
2
Lnea Continua
Guiones
Guiones largos y cortos
3
4
Guiones largos
Puntos
Separacin especifica la separacin entre los elementos de una lnea no continua.

Ancho, el grosor de lnea.
7.5.
Funciones de relleno
7.5.1.1. Rellenar una regin

floodfill(int x , int y , int frontera);
Rellena a partir del punto (x,y) el rea limitada por el color frontera.
En frontera se indica una constante COLORS o bien el numero del color
correspondiente.
0
1
2
3
BLACK
BLUE
GREEN
CYAN
4
5
6
7
RED
MAGENTA
BROWN
LIGHTGRAY
8
9
10
11
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
12
13
14
15
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
7.5.1.2. Elegir patrn de relleno

setfillstyle(int patron, int color);
El patrn puede tomar un valor de 0 a 12.

0
1
2
Patrn Vaco
Slido
Lneas horizontales gruesas
7
8
9
Lneas horizontales y verticales cruzadas

Lneas diagonales cruzadas
Lneas diagonales cruzadas muy juntas
_________________________________________________________________________
Programacin II
Pgina 104

_________________________________________________________________________
3
4
5
6
Lneas diagonales finas

Lneas diagonales gruesas
Lneas diagonales gruesas
Lneas diagonales finas
10
11
12
Puntos separados.
Puntos cercanos
Patrn definido por el usuario
En color se indica una constante COLORS o bien el numero del color correspondiente.
0
1
2
3
BLACK
BLUE
GREEN
CYAN
4
5
6
7
RED
MAGENTA
BROWN
LIGHTGRAY
8
9
10
11
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
12
13
14
15
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
7.5.1.3. Dibujar una barra rectangular

bar(int x1 , int y1, int x2 , int y2);
(x1,y1) esquina superior izquierda de la barra

(x2,y2) esquina inferior derecha de la barra
7.5.1.4. Dibujar una barra 3-D
bar3d(int x1, int y1, int x2, int y2, int altura, int tapa);
(x1,y1) esquina superior izquierda de la barra

(x2,y2) esquina inferior derecha de la barra
Altura es la profundidad de la barra
Tapa especifica si la barra debe incluir o no tapa
7.5.1.5. Dibujar un sector circular
pieslice(int x, int y, int ai , int af , int r);
(x,y) centro del arco del sector circular

(ai-af) ngulo inicial y final del arco del sector circular
r radio del arco del sector circular.
7.6.
Funciones de escritura de texto
7.6.1. Mostrar texto en un lugar especfico

_________________________________________________________________________
Programacin II
Pgina 105

_________________________________________________________________________
outtextxy(int x , int y , char *texto);
Muestra el texto indicado a partir del punto (x,y).
7.6.2. Seleccionar el estilo del texto

settextstyle(int fuente , int orientacin , int tamao);
fuente define el tipo de letra.

0
Normal
Sans Seriff
Triplex
Gtica
Fuente pequea
Orientacin describe si el texto es horizontal o vertical.

Tamao aumenta las dimensiones de los caracteres.
7.6.3. Cambiar los lmites del dibujo.

setviewport(int x1, int y1, int x2, int y2, int recorte);
Un viewport es una zona rectangular delimitada para el dibujo

Las coordenadas en un viewport son relativas a su esquina superior izquierda.
(x1, y1) y (x2, y2) esquinas superior izquierda e inferior derecha del viewport.
El recorte especifica si se ve slo el viewport o todo.
7.6.4. Limpiar el viewport actual:

clearviewport();
7.6.5. Otras
Obtener la coordenada mxima horizontal.
Horizontal:
int getmaxx( );
Vertical:
int getmaxy();
Obtener la coordenada actual.

Horizontal:
int getx( );
Vertical:
int gety( );
_________________________________________________________________________
Programacin II
Pgina 106

_________________________________________________________________________
Moverse a una coordenada especifica.
moveto(int x , int y);
Cambiar color de
0
1
2
3
Dibujo y texto:
setcolor(color);
Fondo de pantalla:
setbkcolor(color);
BLACK
BLUE
GREEN
CYAN
4
5
6
7
RED
MAGENTA
BROWN
LIGHTGRAY
8
9
10
11
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
12
13
14
15
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
Obtener el color actual de.

Dibujo y texto:
int getcolor( );
Fondo de pantalla:
int getbkcolor( );
Un pixel en particular:
int getpixel(int x , int y);
(x,y)
coordenadas del pixel al cual se quiere extraer
el color
Borrar toda la pantalla
cleardevice( );
_________________________________________________________________________
Programacin II
Pgina 107

Manual C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Manual C

Enviado por

Direitos autorais:

Formatos disponíveis

TABLA DE CONTENIDOS

ELEMENTOS DE PROGRAMACIN ESTRUCTURADA.............................................................23

TIPOS ESTRUCTURADOS DE DATOS.............................................................................................38

UNI Universidad Nacional de Ingeniera

QUE SON FUNCIONES.......................................................................................................................57

PUNTEROS Y MANEJO DE ARCHIVOS..........................................................................................64

GRFICOS EN EL LEGUAJE C.......................................................................................................102

UNI Universidad Nacional de Ingeniera

estandarizada del lenguaje C. La mayora de los compiladores e intrpretes comerciales

UNI Universidad Nacional de Ingeniera

Generalidades y caractersticas del Lenguaje C

C es un lenguaje de programacin estructurado de propsito general. Sus instrucciones

UNI Universidad Nacional de Ingeniera

Vista Externa e Interna de un Programa en C

1.3.1. Vista externa

UNI Universidad Nacional de Ingeniera

Una cabecera de la funcin, que consta del nombre de la funcin, seguido de

Una lista de declaracin de argumentos, si se incluyen stos en la cabecera.

UNI Universidad Nacional de Ingeniera

acceso a archivo de biblioteca */

definicion de una constante*/

inicializacion de la variable radio*/

expresion para calcular el area */

1.3.2. Vista interna

UNI Universidad Nacional de Ingeniera

UNI Universidad Nacional de Ingeniera

En este ejemplo, en la expresin area=PI *(radio * radio);, la variable PI se

Tipos fundamentales de datos

C no soporta un gran nmero de tipos de datos predefinidos, pero tiene la capacidad

UNI Universidad Nacional de Ingeniera

3'4 E-38 a 3'4 E+38

1'7 E-308 a 1'7 E+308

2.1.1. Caracteres (tipo char)

Se puede declarar ms de una variable de un tipo determinado en una sola sentencia.

UNI Universidad Nacional de Ingeniera

2.1.2. Nmeros enteros (tipo int)

2.1.3. Nmeros reales (tipo float)

UNI Universidad Nacional de Ingeniera

2.1.4. Nmeros reales (tipo double)

Un identificador es una secuencia de caracteres, letras, dgitos y subrayados (_).Un

En C el identificador puede ser de cualquier longitud; sin embargo, el compilador ignora

UNI Universidad Nacional de Ingeniera

A la hora de programar es conveniente aadir comentarios para poder saber que

El smbolo /* se coloca al principio del comentario y el smbolo */ al final. El comentario,

UNI Universidad Nacional de Ingeniera

UNI Universidad Nacional de Ingeniera

UNI Universidad Nacional de Ingeniera

Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de

UNI Universidad Nacional de Ingeniera

2.6.1. Constantes enteras:

2.6.2. Constantes reales:

UNI Universidad Nacional de Ingeniera

2.6.3. Constantes alfanumricas.

La inclusin de archivos no es ms que la declaracin o la llamada de la o las libreras

2.8.1. Operadores Aritmticos

UNI Universidad Nacional de Ingeniera

2.8.2. Operadores Relacionales

2.8.3. Operadores Lgicos

2.8.4. Operadores Lgicos a Nivel de Bit

2.8.5. Operadores de Asignacin

Multiplicacin con Asignacin

Suma con Asignacin

Divisin con Asignacin

En este ejemplo, en la expresin area=PI (radio radio);, la variable PI se

/El compilador emitira un warning "converting int to double"/

/Declaracin de a como carcter/

/Declara los enteros a y b/

char c[10]; /declara la variable c de tipo char/

/declaracin de bibliotecas de funciones/

/inicio de la funcin principal/

/inicio del bucle for/

/fin de funcin principal/

/inicio del programa principal/

/inicio del bucle while/

/detiene el programa para su visualizacin/

/Fin funcin principal/