Material Puce 2 Agosto 2013

PONTFCA UNVERSDAD CATLCA DEL ECUADOR
FACULTAD DE NGENERA DE SSTEMAS

PROGRAMACN BSCA
Agosto 2013
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1
CONTENIO
ndice de contenido
CAPIT!"O # INT$O!CCI%N A "A P$O&$AMACI%N ..................................................'
INT$O!CCI%N A "EN&!A(E C.....................................................................................'
CAP)T!"O * +A$IAB"ES, CONSTANTES - TIPOS E ATOS ..................................1.
ASI&NACI%N M!"TIP"E ................................................................................................//
OPE$AO$ES E ASI&NACI%N ESPECIA"................................................................/0
+A$IAB"ES TIPO ENTE$O............................................................................................./.
+A$IAB"ES E P!NTO 1"OTANTE............................................................................../2
+A$IAB"ES O!B"E......................................................................................................./'
IENTI1ICACI%N de CONSTANTES ............................................................................/#
CON+E$SI%NES - P$OMOCIONES............................................................................../*
E3P$ESI%N MOO MI3TO.............................................................................................04
OPE$AO$ CAST ...........................................................................................................01
+A$IAB"E TIPO C5A$ ..................................................................................................0/
CAP)T!"O 6 MANIP!"ACI%N E ATA .......................................................................0.
"A 1!NCION scanf78..........................................................................................................0.
ENT$AA 9 SA"IA E !N c:ar....................................................................................0#
ENT$AA SA"IA CON 1O$MATO...............................................................................4
OPE$AO$ES $E"ACIONA"ES....................................................................................../
B"O;!ES E SENTENCIAS..............................................................................................
Cap<=>lo 14 Sal=os ? Condicionamien=os................................................................................2
SENTENCIAS CONICIONA"ES...................................................................................2
I1 E"SE I1 ...........................................................................................................................#
I1 ANIAOS......................................................................................................................6
SENTENCIA S@ITC5 ......................................................................................................24
OPE$AO$ CONICIONA" 7operador =ernario8............................................................2.
OPE$AO$ES E INC$EMENTO - EC$EMENTO .................................................22
Cap<=>lo 11 $epe=icin ? laAos...............................................................................................2'
B!C"ES..............................................................................................................................2'
B!C"ES ANIAOS.........................................................................................................'/
EC"A$ACIONES E SA"TO ........................................................................................'0
TraBaCo con Arreglos o Ma=rices .........................................................................................'#
Cap<=>lo 1/ S>Bprogramas, S>Br>=inas ? "iBrer<as .............................................................#4
1!NCIONES O M%!"OS ..............................................................................................#4
"iBrerias de 1>nciones : ......................................................................................................#6
Cons=an=es miemBro.............................................................................................................*1
OBCe=os de la "iBrer<a s=dliB.:..............................................................................................*2
MDS SOB$E +A$IAB"ES.................................................................................................*'
TI$AS E CA$ACTE$ES 7S=rings8..................................................................................*6
S=rings ? Carac=eres .............................................................................................................61
1>nciones con S=rings .........................................................................................................6/
AP!NTAO$ES ................................................................................................................66
Capi=>lo 10 In=rod>ccin a Es=r>c=>ras ? !niones ................................................................146
$E1E$ENCIAS A "OS E"EMENTOS 9 OPE$AO$ P!NTO ....................................114
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg/
INICI"IEACI%N E EST$!CT!$AS ...........................................................................110
EST$!CT!$AS ANIAAS..........................................................................................11*
EST$!CT!$AS - 1!NCIONES ...................................................................................1/4
OPE$AO$ 1"EC5A FG.................................................................................................1/0
!NIONES .........................................................................................................................1/.
BBLOGRAFA
a. BSICA
Bibliografa
(Normas APA)
Disponible en
Biblioteca a la
fecha
N!
"#emplares
Harvey M. D (2003) C++ Cmo programar .
Mexico: Pearson Edca!ion . S< 0
Dei!e"# Harvey M (20$0) %n!rodccin a "a
programacin orien!ada a o&'e!os. ()*: Pren!ice
Ha"".
Si 0
+is,op# -dy M ($...). -ava : /ndamen!os de
programacin
Mexico # Pearson Edca!ion.
Si 0
Dei!e"# Pa" -.
(20$0). Programacin in!ermedia en -ava.
Mexico: Pearson Edca!ion.
SI 0
b. C$%P&"%"N'A(IA
Bibliografa
(Normas APA)
Disponible en
Biblioteca a la
fecha
N!
"#emplare
s
'C' Programming ,Salim Y. Amdani ,Laxmi
Publications 2009 NO
The Art and Science of C , Roberts Eric,
Adission-Wesley 1995
NO
Big C++, Cay S. Horstmann and
Timothy A. Budd,m2009
NO
1001 Microsoft Visual C++ Programming
Tips , Kris Jamsa and Charles Wright
,2011
NO
C For Dummies, Dan Gookin John Wiley &
Sons 2004
NO
c. ("C$%"NDADA
Bibliografa
(Normas APA)
Disponible en
Biblioteca a la
fecha
N!
"#emplares
Mar0 1ee. (200.). C++ Programming for the
Absolute Beginner
USA : Cengage 1earning
NO

-osep, P. NO
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg.
2sse"" ($.33). Java Programming for the
Absolute Beginner
USA: Premier Press
).). BIB&I$'"CAS *I('+A&"S , SI'I$S -"B ("C$%"NDAD$S
:==p:HHIII.BooJfi.org
:==p:HHIII.oracle.comHCaKa
:==p:HHc.conclase.ne=HliBreriasH
:==p:HHc.conclase.ne=HliBreriasH

CAPITULO 7 INTRODUCCIN A LA PROGRAMACIN
IN'($D+CCI.N A &"N/+A0" C
C es un lenguaje de programacin de propsito general. C se conoce como un
lenguaje de nivel medio, debido a la elaboracin de programas ms rpido, similar a
otros lenguajes de alto nivel y de ms rpida ejecucin como los programas de
ensamblador y el lenguaje de mquina. C permite manejar un conjunto de
operadores, control de flujo y una moderada cantidad de expresiones. C tambin
contiene algunas caractersticas adicionales que le permiten ser utilizados en el nivel
inferior, salvando as la brecha entre los lenguajes de mquina y lenguajes de alto
nivel. Esta flexibilidad permite a C que se utilice para la programacin del sistema
(por ejemplo, para escribir sistemas operativos), as como para la programacin de
aplicaciones (por ejemplo, para escribir un programa para resolver un complicado
sistema de ecuaciones matemticas, o para escribir un programa, como la
facturacin de los clientes).
C en la actualidad se usa con casi todos los equipos y es un lenguaje estructurado.
CARACTERSTCAS DE C
Haremos una breve lista de algunas de las caractersticas de C que definen el
lenguaje y tambin han llevado a su popularidad como un lenguaje de programacin.
Naturalmente, vamos a estudiar muchos de estos aspectos durante el curso.
Pequeo tamao , los fuentes y objetos son bastante compactos
El uso extensivo de las llamadas a funciones
Escritura fcil - a diferencia de PASCAL o COBOL
Lenguaje estructurado
Nivel bajo de programacin disponibles
Muy flexible , hace uso de punteros en la memoria, matrices, estructuras y
funciones.
VARIANTES DE C
Aunque el lenguaje de programacin C es popular, no es perfecto. Cuando la
programacin orientada a objetos se hizo popular para el diseo y mantenimiento de
grandes programas, especialistas en informtica crearon una versin orientada a
objetos de C llamado C ++.
C++
Debido a que ms gente est escribiendo y la organizacin de programas de gran
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg'
tamao con programacin orientada a objetos, ms programas se escriben en C + +.
La mejor forma de aprender C++ es comprender primero las peculiaridades de C.
luego cuando se sienten cmodos con C, empiezan a estudiar C ++ y programacin
orientada a objetos . Mas adelante veremos las diferencias entre estos tipo de
programacin. Sin embargo , depende del programador el usar exclusivamente la
orientacin a objetos , es otras palabras el programador podra crear una mezcla de
C y C++ .
Microsoft ech un vistazo a C / C + + y decidieron que podan crear un lenguaje
mejorado, que dieron el nombre de C # (pronunciado C-sharp).
C #
C # tiene un par de ventajas sobre lenguajes como C, C + +, e incluso Java.
Orientada a Objetos
Una de las ventajas principales de C # que C + + es que C # es un verdadero
lenguaje orientado a objetos de programacin, por lo que tiene que usar
programacin orientada a objetos para escribir un programa en C #.
Te obliga a utilizar slo tcnicas orientadas a objetos de programacin puede
parecer un inconveniente hasta que te das cuenta de que C ++ es un lenguaje
hbrido que le permite elegir si desea utilizar programacin orientada a objetos.
Aunque C ++ da, el programador, una mayor flexibilidad, C ++ tambin puede ser
una mezcolanza de la programacin estructurada mezclados con programacin
orientada a objetos.
Tratando de descifrar como una mezcla de tcnicas de programacin puede ser
confuso. Al obligar a todos los programadores a usar programacin orientada a
objetos (y aislar a sus tcnicas de programacin estructurada slo dentro de los
objetos), programas de C # pueden ser mucho ms fcil de entender y modificar.
Objectie C
Objective-C es una programacin orientada a objetos (OOP) que constituye la base
del desarrollo de la mayora del software en Mac OS X. Se trata de un superconjunto
del lenguaje de programacin C, lo que significa que puede utilizar el cdigo C
directamente en Objective-C del programa. De hecho, gran parte de un programa de
Objective-C es simplemente C. nclye un pequeo nmero de extensiones para
facilitar la programacin orientada a objetos, lo que potencialmente puede hacer la
vida mucho ms fcil que un programador.
La filosofa de Objective-C es un minimalista . La orientacin a objetos
caractersticas de Objective-C se han diseado como una extensin compacta de C
y fcil de entender . Esto es a diferencia de C + +, por ejemplo, que tambin es un
superconjunto de C, pero que incluye muchas diferentes extensiones de C, y es
relativamente difcil de aprender. Cualquier persona que entienda C ++, o cualquier
otro lenguaje orientado a objetos para el caso, puede aprender Objective-C en pocas
horas. Para aquellos que no tienen conocimiento de programacin orientada a
objetos, Objective-C es uno de los idiomas con los que mejor que aprender, debido a
su simplicidad
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg#
Las siguientes secciones comprenden nicamente el lenguage C:
PALA!RAS RESERVADAS "PALA!RAS CLAVE#
Como en todos los lenguajes las palabras reservadas no se pueden utilizar como
identificadores. Tienen significados predefinidos, que no pueden ser cambiados por
un programador. No se puede dar una funcin o un nombre de identificador como
palabras clave. El uso incorrecto de palabras clave provocar un error de
compilacin. Palabras clave actan como bloques de construccin de instrucciones
del programa.
Hay 29 palabras clave reconocidas por el compilador de C :
ESTRUCTURA DE UN PROGRAMA C
Cada programa se compone de uno o ms mdulos llamados funciones. Una de las
funciones debe ser llamada main () esta es la funcin de inicio . El programa siempre
comenzar por la ejecucin de la funcin principal (main() ), la cual puede acceder a
otras funciones. Si un mdulo no tiene main() ste podr ser llamado por otros
programas pero el usuario nunca podr iniciarlo por si solo.
Un programa de C tiene bsicamente la siguiente forma:
Comentarios o Documentacin Opcional
Comandos de preproceso
Definiciones de tipos
Funciones prototipo (Declaraciones de tipos de
funciones y variables pasadas a la funcin
Declaracin de Variables
Funciones
Los siguientes puntos deben tenerse en cuenta para cualquier 'C' del programa:
Cada programa comienza con main () y debe haber una y slo una funcin
main () en un programa.
Todos los programas de C debe ser escrito en letras minsculas solamente.
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg*
auto goto struct default return void
break if switch do short while
case int typedef double signed extern
char long union else static for
continue register unsigned enum float
Variables y procedimientos son case-sensitive , es decir no es lo mismo var
que VaR, esto es independiente de la plataforma en la cual se est
compilando.
Cada sentencia debe terminar con punto y coma (;), lo que indica final de la
sentencia. Existen pocas excepciones que veremos adelante
Todos los identificadores deben ser declarados antes de ser utilizados.
Los comentarios pueden ser incluido en / * * /, los comentarios no son
sentencias ejecutables, y sirven para documentar el programa.
La primera lnea generalmente sera : #include <stdio.h>
Sentenci$% de P&eco'(i)$do&
Como hemos visto en los captulos anteriores , los programas deben compilarse. La
primera seccin en un programa C pueden contener una serie de instrucciones que
no forman parte del programa sino que son instrucciones para dar ciertas
instrucciones al compilador.
Para que el compilador sepa distinguir entre las sentencias del programa y las de
precompilacin colocaremos el signo numeral (#) en la primera columna.
La ms comn de esta es la sentencia include.
#include <stdio.h>
Note que la lnea NO termina con (;)
Los programas se escriben generalmente en mdulos que pueden ser re-utilizables.
Estos mdulos se agrupan en libreras que pueden estar distribuidas en cualquier
parte del disco duro . La instruccin include indica al compilador que el programa
usar uno o ms de los mdulos que se hallan entre brackets angulares ( < > ) y/o
comillas dobles ( " ) . Usaremos los angulares para definir libreras del sistema y
comillas para definir libreras propias del programador.
Es importante mencionar que las libreras estn distribuidas en dos archivos, los
archivos de cabecera y los archivos de cdigo.
Fuente: Internet
Stdio.h es la librera que contiene las rutinas de entrada salida que todo programa
generalmente necesita . La sentencia #include <stdio.h> indica al compilador que
incluya el archivo de cabeceras que contiene procedimientos de entrada / salida de
datos. Esta lnea se incluye en el comienzo del programa de C por encima de main().
El signo de nmero (#) indica que es una sentencia del pre-compilador y gua para
que el compilador encuentre cualquier funcin de esta librera.
A continuacin un ejemplo de programa :
/*Mi primer programa en C */
#include <stdio.h>
main()
{
printf("hola mundo \n);

}
comentario
incluir el archivo de cabeceras de /O
funcin principal
Llave de inicio
llamadas a una funcin para que imprima
algo \n representa salto de linea
Fin de la funcin
Una funcin es llamada por nombre, seguida por una lista de argumentos entre
parntesis la funcin printf () con el argumento de "hola, mundo \ n". printf () es una
funcin de librera cuya salida es, en este caso, la cadena de caracteres entre las
comillas dobles (").
Una secuencia de caracteres entre comillas dobles, como "hola mundo \ n", se llama
una cadena de caracteres o una cadena constante. La funcin printf () tambin se
puede utilizar para mostrar otro tipo de informacin que veremos en las siguientes
secciones.
En los editores, al escribir la informacin para mover el control a la nueva lnea se
utiliza la tecla ENTER. En C, no podemos hacer esto, para mover el cursor a la
nueva lnea se utiliza '\ n' , esto instruye al proceso de compilacin mover el control
a la nueva lnea. En el ejemplo anterior, el printf () mostrar la cadena "Hola
mundo" en la pantalla y '\ n' mover el cursor a la nueva lnea.
La funcin printf () es la declaracin de salida utilizada para imprimir la salida o el
mensaje, en pantalla , la letra ('f') significa "formato" o "funcin" indicando que
puede definirse en que formato deseamos que salga.
La funcin printf () es una funcin de biblioteca stdio para sacar algo a salida
estndar es decir, dispositivos, pantalla o monitor.
El formato general de printf () es:
printf ("cadena de control", arg1, arg2, ... .., argn)
La cadena de control dentro de las comillas es la salida real. Los otros argumentos
representan variables cuyo valor queremos desplegar. Cada argumento se
representa en el orden dentro de la cadena de las especificaciones.
El formato de los argumentos se definir con letras precedidas con el signo "%
A continuacin una tabla con los formatos que C permite:
Modificadores de formato de printf()
A continuacin algunos ejemplos de printf
printf("Color %s, numero1 %d, numero2 %05d, hex %x, real %5.2f.\n", "rojo", 12345, 89, 255, 3.14);
printf("El nmero entero es %d y el nmero flotante es %f",numeroEntero,numeroFlotante);
printf("La letra que falta sera %c",letra);
Reglas para los modificador de formato:
Deber existir la misma cantidad de variables que de formatos
An cuando el formato de todas las variables sea el mismo , deber repetir la
D$to Formato
1 nt %d or %i
2 Float %g or %f
3 Char %c
4 Unsigned int %u
5 Long int %ld
6 Unsigned long int %lu
7 Double %lf
8 Long double %Lf
S. No
especificacin el nmero de veces que sea necesario.
Se puede incluir un texto fijo en la cadena control , en este caso , el texto se
desplegar en la pantalla tambin.
En caso de querer desplegar el signo de % se deber "comentar el signo
usando otro % .
El colocar otros operadores en la cadena de control no causa que operacin
alguna se efecte.
Por otro lado el colocar operadores fuera de la cadena de control obligar al
compilador a realizar la operacin primero y luego el despliegue en pantalla.
El formato debe coincidir con el tipo de variable ,caso contrario la salida no
tendr sentido. Veamos el siguiente ejemplo :
#include<stdio.h>
#include<conio.h>
void main()
{
float f;
clrscr();
printf("Enter a float value\n");
scanf("%d",&f);
printf("f = %f \n", f);
getch();
}
Salida:
Enter a float value
4.7
f= 0.000000
________________________________________
Nota: clrscr es una funcin de la librera conio.h .Algunos compiladores podran no
soportarlo , en sy lugar se puede usar
system("cls);
REGLAS PARA LOS DENTFCADORES
Los identificadores son nombres que se dan a los diversos elementos del programa,
tales como variables, constantes, funciones y matrices. dentificador es una
secuencia de letras y dgitos. Las reglas que aplican son :
El primer carcter de un identificador debe ser una letra.
Maysculas y minsculas son permitidas y se tratan por separado, es decir,
una letra mayscula no es equivalente a la letra minscula correspondiente.
En cuanto a signos , el guin bajo (_) tambin puede ser incluido.
Los identificadores no deben ser palabras reservadas.
No puede haber espacios
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1/
Ejemplos de identificadores vlidos
a
tax05
address
roll_no
A
temp
TAX07
dt_of_birth
Ejemplos de identificadores no vlidos
2007tax
numero pagina
char
nicia con nmero
No puede tener blancos u otros signos
Palabra reservada
CAPTULO * VARIA!LES+ CONSTANTES , TIPOS DE
DATOS
Los tipos de datos especifica el tipo de informacin que se almacena. C es
compatible con varios tipos diferentes de datos, cada uno de los cuales son
representados de manera diferente dentro de la memoria del computador. Los
requisitos de memoria de cada tipo de dato determinar el rango permitido de
valores para ese tipo de datos. Los tipos de datos bsicos son los siguientes. Los
requisitos tpicos de la memoria tambin se les da.
ipos de datos ! su composici"n
Otros tipos de datos pueden ser creados en base a los anteriores
CONSTANTES
Las constantes son los identificadores que no cambia su valor durante la ejecucin
del programa. C tiene cuatro tipos bsicos
Constante entera
Constante de punto flotante
Constante de caracteres
Cadena constante (string)
Con%t$nte ente&$
Una constante entera es un nmero entero sin ningn tipo de valor fraccionario.
Constante de entero se puede escribir en tres sistemas numricos diferentes.
Decimal (base 10)
Octal (base 8)
Hexadecimal (base 16)
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1.
1 int or short 2 - 32768 to 32767
2 Unsigned int 2 0 to 65535
3 Long int 4 - 2147483648 to 2147483647
4 Float 4 3.4e-38 to 3.4e+38
5 Char 1 - 128to127
6 Unsigned char 1 0 to 255
7 Unsigned long 4 0 to 4294967295
8 Double 8 1.7e-308 to 1.7e+308
9 Long double 10 3.4e-4932 to 3.4e+4932
S. No. Ti(o de D$to byte Rango
Una constante octal puede ser cualquier combinacin de dgitos del 0 al 9. Si la
constante contiene ms de un dgito, el primer dgito debe ser distinto de 0, una
constante hexadecimal debe ser precedido por 0x.
Ejemplos
Ejemplo Decimales 1 30 50 23456
Ejemplos octales -1 -123 -234 -6743
Ejemplo hexadecimales -.2045 -/5678 -.f4567 -.abcdef
Es importante mencionar que el formato sirve nicamente para indicar que el dato
ingresado est en dicho sistema de numeracin , pero la representacin interna del
dato seguir siendo en binario .
Con%t$nte de (0nto 1)ot$nte
Una constante de punto flotante se compone de un nmero entero seguido por el
punto decimal y uno o ms nmeros decimales despus del punto decimal que hace
la parte fraccionaria.
Ejemplos
5E-5
0.009e-2
.234e-10
0.5
12.00278
2.
11.3
La letra e o # representa el valor exponencial base 10
Con%t$nte% C$&$cte&
Un carcter es constante est delimitado por comillas %i'()e%
Ejemplos
'Z' 'z' '8' '$'

St&in2 Con%t$nte
Es una cadena de caracteres que est delimitado por comillas dobles (")
Ejemplos
"Program "1234 " "123.45
Sec0enci$ de e%c$(e
Ciertos caracteres no imprimibles, as como la barra invertida (\) y el apstrofe ('), se
puede expresar en trminos de secuencia de escape. Una secuencia de escape
comienza siempre con una barra invertida y es seguido por uno o ms caracteres
especiales. Por ejemplo, un avance de lnea (LF), que se conoce como una nueva
lnea en C se puede representar como \n. La secuencia de escape siempre
representa un solo carcter, a pesar de que estn escritas en trminos de dos o ms
caracteres.
La secuencia de escape de uso general se enumeran a continuacin.
VARABLES
Cadenas y valores numricos se pueden almacenar en la memoria de la
computadora para su uso durante la vida del programa. Cada variable tiene que ser
asignada un nombre nico y se guarda en la memoria.
Una variable es un rea de memoria, que es asignado por el compilador y le da un
nombre. El contenido de una memoria (en el caso de variable) puede ser alterado o
cambiado durante la ejecucin de un programa.
Slo un valor se puede almacenar en cada variable, variables del tipo matriz tiene
un tratamiento especial ,pero en general hay un solo valor para cada variable en un
momento determinado . Poner un nuevo valor en una variable se reemplaza el valor
anterior. La lectura del contenido de una variable no elimina el contenido.
Es conveniente dar nombres significativos para las variables. Nombres significativos
para las variables son auto-documentados, fcil de entender y hace que el programa
fcil de leer.
Reglas para nombres de variables:
Nombre de la variable debe comenzar con caracteres alfabticos
Puede ser seguido por letras y o nmeros (0 a 9).
Otra vez, El compilador distingue las letras maysculas y minsculas.
No utilice palabras reservadas (palabras clave) como nombre de variable.
Ningn carcter especial, como un espacio en blanco, punto, punto y coma,
coma o una barra, etc se puede utilizar en nombre de la variable, excepto
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1'
subrayado '_'. Esto es independiente de la plataforma de programacin .
Ejemplos :
Nombres de variables vlidos count total average tot_amt
sum a avg mins
Nombre invlidos Float 2007sa "con espacio
"juan,perez
Dec)$&$ci3n de V$&i$b)e%
Para declarar una variable es necesario indicar primero que tipo de variable es y
luego su nombre . Opcional se puede iniciar con un valor determinado . Se pueden
definir mltiples variables de cada tipo separndoles con comas. El formato general
es :
<type> varname1,varname2,.!
Ejemplos:
int sum, numbers;
char ch1,ch2;
float amount, average;
Note que cada lnea termina con (;)
SENTENCAS DE ASGNACN
Despus de declarar las variables, se pueden asignar valores a las variables a
travs de sentencia de asignacin. Las variables deben ser declaradas antes de
asignar los valores. El formato de instruccin de asignacin es
varia$le % e&pression'
Note que cada lnea termina con (;)
Los valores son asignados a las variables usando el operador '='.
Ejemplos:
num = 148;
suma = suma + 5;
ch1 = 'A';
CH2 = 'Z';
cantidad = 143,95;

Declaracin e nicializacin
Cuando los valores de las variables se asignan en el momento de la declaracin se
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1#
llaman como la declaracin e inicializacin.
int numero = 100;
En la declaracin anterior, el nmero se declara la variable de tipo entero y al mismo
tiempo el valor 100 se asigna.
Ejemplos :
/* Programa para sumar dos nmeros */
# include <stdio.h>
main()
{
int num1,num2;
num1=40;
num2=50;
printf("La suma de los nmeros es %d, num1+num2);
}
/* Programa para declaracin variables*/
#include <stdio.h>
main()
{int hrs;
hrs = 24;
printf("Las %d horas del da .\n, hrs);
}
/* Programa usando dos declaraciones */
# include <stdio.h>
main()
{
int minutes, hours;
minutes = 60;
hours = 24;
printf("Hay %d minutos en una hora .\n, minutes);
printf("Hay %d horas en el da .\n, hours);
}
/* Programa para desplegar mltiples variable en un printf() */
#include <stdio.h>
main()
{
int units, dozens;
dozens = 5;
units = dozens * 12;
printf("%d unidad son equivalentes a %d docenas \n, units, dozens);
}
O(e&$do&e% A&it'4tico%
Hay cinco operadores aritmticos en C. Se llaman operadores binarios, ya que
operan sobre dos operandos .
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1*

+ adicin
- sustraccin
* multiplicacin
/ divisin
% Mdulo (el resto despus de la
divisin entera)
Ejemplo :
#include <stdio.h>
main()
{
int a = 4, b = 8, c = 13;
printf("%d mod %d = %d\n,b,a,b%a);
printf("%d mod %d = %d\n,c,a,c%a);
printf("%d mod %d = %d\n,c,b,c%b);
}
P&ecedenci$ de )o% o(e&$do&e% $&it'4tico%
Dado que al escribir el programa definimos frmulas en la misma lnea , se pueden
presentar situaciones ambiguas en las cuales no es claro cual es la secuencia de
los operadores : Ejemplo :
var= a*b-c;
Para solucionar esto algunos operadores tienen preferencia sobre los otros en las
expresiones. Por ejemplo, los operadores de multiplicacin y divisin tienen prioridad
sobre la suma y resta. Parntesis tiene la ms alta prioridad sobre todos los
operadores.
La siguiente tabla indica la precedencia de ANS C
(recedencia de operadores en )*+I , , fuente ---.ansi.com
Favor notar que los signos + y de la lnea 2 se refieren a cambio de signo y no a
las operaciones de suma y resta que figuran en la linea 4 .
Asumiendo lo siguiente
num1= 25 ;
num2 = 2 ;
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg/4
result=num1+num2*10; /*resultado = 45*/
result=(num1+num2)*10; /*resultado = 270*/
Los parntesis se utilizan para anular la precedencia.
Reglas sobre el uso de los operadores en general.
En caso de empate entre las operaciones de preferencia misma prioridad se
le da al operador que est primero.
Si hay ms de un conjunto de parntesis, las operaciones dentro del
parntesis ms interno se llevar a cabo en primer lugar, seguida por las
operaciones en el segundo parntesis ms interno y as sucesivamente.
Debemos recordar siempre que el uso de pares de parntesis. Un
desequilibrio por descuido de los parntesis derecho y / o la izquierda es un
error comn.
#include <stdio.h>
main()
{
int a = 5, b = 10, c = 15, answer;
answer = a + b / c;
printf("%d + %d / %d = %d\n, a ,b, c, answer);
answer = a * b c;
printf("%d * %d - %d = %d\n, a, b, c, answer);
answer = a * b / c;
printf("%d * %d / %d = %d\n, a, b, c, answer);
answer = (a + c) * b / a;
printf("(%d + %d) * %d / %d = %d, a, c, b, a, answer);
}
ASIGNACIN MULTIPLE
Es posible tener ms de una asignacin dentro de una instruccin ejecutable. En C,
el mismo valor puede ser asignado a ms de una las variables del mismo tipo que
utiliza la instruccin de asignacin mltiple. El formato es
var1 = var2 = expresin;
Aqu var1 y var2 son los nombres de variables y de expresin es el valor que se
asigna. Se puede extender por ms de dos variables tambin.
por ejemplo
num1 = num2 = 0;
x = a = c = 2;
La ejecucin de mltiples tareas se lleva a cabo derecha a izquierda, en el primer
ejemplo, num2 se le da el valor de 0, num1 se le da el valor de num2 (que ahora es
0).
#include <stdio.h>
main()
{
int a,b;
a=b=2;
printf("a=%d , b=%d.\n,a,b);
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg//
OPERADORES DE ASIGNACIN ESPECIAL
C contiene cinco operadores especiales de asignacin: + =, -=, *=, / = , % =.
Operadores especiales de asignacin se utilizan para procesar rpidamente. El
contenido de una variable opera en una expresin y asigna de nuevo a la variable.
Por ejemplo, considere el primer operador + =. La expresin de asignacin
varia$le . % e&pression es equivalente a varia$le % varia$le . e&pression
De la misma manera , la expresin de asignacin
varia$les /% e&pression es equivalente a varia$le %varia$le / e&presi"n
Veamos algunos ejemplos:
#include <stdio.h>
main()
{
int num = 1;
num += 5;
printf("num=%d\n, num);
num - = 3;
num *= 2;
num /= 2;
}
VARIA!LES TIPO ENTERO
Son variables cuyo valor es entero , es decir no utiliza fraccionarios. C utiliza un
distinta clase de variable dependiendo del tamao de bytes en memoria que debe
asignar para dicha variable . El siguiente cuadro indica el tipo y el rango de valores
que puede asignar.
Ejemplos:
main()
{
int int_var=32767;
short short_var=32767;
unsigned un_var=65535;
long long_var=2147483647;
printf("nteger=%d\n,int_var);
printf("Short integer=%d\n,short_var);
printf("Unsigned integer=%u\n,un_var);
printf("Long integer=%ld\n,long_var);
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg/.
VARIA!LES DE PUNTO 5LOTANTE
Variables de punto flotante son las variables que tienen un punto decimal (nmero
real). Podra ser positivo o negativo. La principal diferencia entre nmeros enteros y
de punto flotante son:
Entero slo contiene nmeros enteros, mientras que la variable de punto
flotante puede contener ya sea enteros o fracciones.
Variable de punto flotante pueden contener una gama ms amplia de nmero
que los enteros.
En la mayora de las computadoras, las ejecuciones de operaciones de punto
flotante son ms lentos y requieren ms memoria que la operacin entera.
Para esto , algunos procesadores cuentan con hardware especializado de
punto flotante.
Enteros son declarados por la palabra clave int, mientras que las variables
de punto flotante se declaran por palabra clave float .
La especificacin de formato % d se utiliza para una variable entera. Para punto
flotante la especificaciones puede ser %e , %f , y %g
Ejemplos:
/* Programa con puntos flotantes */
#include <stdio.h>
main( )
{
float num1=468.57,num2=369.2,answer;
clrscr();
answer =num1+num2;
printf("%f + %f=%f\n, num1,num2,answer);
answer=num1-num2;
printf("%f - %f=%f\n, num1,num2,answer);
answer=num1*num2;
printf("%f * %f=%f\n, num1,num2,answer);
answer=num1/num2;
printf("%f / %f=%f\n,num1,num2,answer);
}
En el programa anterior, la especificacin de formato % f se utiliza en la sentencia
printf, que indica al compilador que debe mostrar el contenido de la respuesta como
nmero de punto flotante
VARIA!LES DOU!LE
El tipo de datos double es el mismo que float excepto que se ocupa el doble de
memoria en comparacin con float . Si la precisin no es suficiente para un
problema particular que nos ocupa, las variables pueden ser declaradas de tipo
double.
Ejemplo:
#include <stdio.h>
void main()
{
float fahr, celsius;
int inf, sup, paso;
inf = 0; /* limite inferior de temperaturas */
sup = 300; /* limite superior de temperaturas */
paso = 20; /* tamao del incremento */
fahr = inf;
while (fahr <= sup) {
celsius = 5.0 / 0.9 * (fahr - 32.0);
printf("%3.0f\t%6.1f\n", fahr, celsius);
fahr = fahr + paso;
}
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg/'
IDENTI5ICACIN de CONSTANTES
Una constante es un identificador que tiene un valor fijo. Las constantes son
similares a las variables, excepto que el valor de la constante no se puede cambiar.
Una constante se define de la siguiente manera:
# define var/constante
# define es una directiva de preprocesador utiliza para configurar identificador
constante. var_name es el nombre de la constante. Para diferenciar las variables y
constantes, constant_name por convencin se usa las letras maysculas, aunque
las letras minsculas tambin se permiten. Por ejemplo:
#define P 3.14159
#define SZE 50
Las constantes se coloca normalmente al comienzo del programa antes del main() .
El pre-compilador sustituir todas la ocurrencias en el programa de constante con
el valor antes de la compilacin. Por ejemplo, en la declaracin sobre todos los
sucesos de la P en el programa se sustituye con 3,14159.
# define no debe terminar con un punto y coma (;).
Ntese que la asignacin de valor a la constante no lleva el signo igual (=) .
Ningn otro valor debe ser asignado a lo largo del programa. El tipo de datos de la
constante depende del valor constante que le asigne en el momento de las
declaraciones.
#include<stdio.h>
#define P 3.1519
main()
{
float radius = 5, area, circumfer;
area = P * radius * radius;
circumfer = 2 * P * radius;
printf("Area = %f \n, area);
printf("Circumference = %f \n, circumfer);
}
Ntese que las constantes podran estar definidas en el programa principal pero
tambin pueden venir de alguno de los objetos de las libreras.
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg/#
CONVERSINES , PROMOCIONES
C permite que se conviertan datos de un tipo a otro tipo en forma implcita y
explcitamente. En forma implcita significa que alguna conversiones ocurren sin que
el programador ingrese cdigo alguno . Sin embargo hay que tener cuidado porque
eventualmente las conversiones implican prdida de precisin.
Las siguientes reglas aplican a la conversin :
Un char, un int o short, con o sin signo, se pueden utilizar en una expresin
mezclado con un entero. Si un int puede representar todos los valores del tipo
original, entonces el valor se convierte a int, de lo contrario el valor se
convierte a unsigned int. Este proceso se llama promocin entera o
promocin a enteros.
Un int puede ser convertido a unsi0ned int , en este caso el valor convertido
resulta positivo.
Cuando un unsi0ned int es convertido a int , el valor resultante es un int si
este cabe dentro del rango de valores , si no , depende del compilador ya
que no est definido .
Conversiones de punto flotante a entero son posibles , en este caso la parte
fraccionaria es desechada , si el valor no puede ser representado por falta
de bits el valor resultante no esta especificado.
Cuando se convierte un int a punto float el valor se aproxima a la
representacin mayor o menor
Cuando se convierte de dou$le a float y el valor cabe en el float la conversin
se realiza sin problema , sin embargo si el valor no cabe el resultado es
indefinido.
Conversiones Aritmticas
Muchos operadores provocan conversiones una forma similar. El efecto es llevar
operandos en un tipo comn, que es igual al tipo del resultado. Este patrn se
llama las conversiones aritmticas habituales. En este caso se aplican la siguientes
reglas en el orden mencionado :
(1) Si cualquiera de los operandos es de tipo long double la conversin se realiza
a un long double. Caso contrario :
7/8 Si cualquiera de los operandos es dou$le el resto se convertiran a dou$le.
,aso contrario :
708 Si uno de los operandos es float el resto se convertiran a float. ,aso
contrario :
7.8 Si un operando es unsi0ned lon0 int el resto se convertiran a unsi0ned lon0
int .,aso contrario :
728 Si un operando es lon0 int y otro es unsi0ned int , el resultado depender si el
long puede representarse como unsigned int , si es posible el unsi0ned int es
convertido a lon0 , caso contrario los dos son convertidos en unsi0ned lon0
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg/*
int. ,aso contrario :
(6) Si uno de los operandos es lon0 int en otro es convertido a lon0 int .Caso
contrario:
(7) Si uno de los operandos es unsi0ned int , el otro es convertido a unsi0ned int .
Caso contrario :
(8) Los dos operandos deben ser de tipo int.
Ejemplo el valor entero se puede asignar a la variable de tipo float, el valor se
convierte a float y no se cambia, es decir, el valor no se cambia solamente el tipo
de dato. De la misma manera una variable float se puede convertir a entero , sin
embargo en este caso el compilador truncar la parte fraccionaria . Para entender
esto analice el siguiente programa:
#include<stdio.h>
main()
{
int ivar1,ivar2;
float fvar1,fvar2;
ivar1 = 5;
fvar1 = 123.456;
ivar2 = fvar1;
fvar2 = ivar1;
printf("ivar2=%d, fvar2=%f\n, ivar2, fvar2);
}
En el programa anterior, 'ivar1 " e ' ivar2 son variable enteras y dos variables float
'fvar1', 'fvar2' se declaran. El contenido de 'fvar1 "es decir, la variable de tipo float,
123.456 se asigna a la variable entero' ivar2. Por lo tanto el contenido de "ivar2 'ser
123 la parte fraccionaria se elimina. El contenido de 'ivar1 ", es decir variable int, 5
sern asignados a flote variable' fvar2. Por lo tanto el contenido ser 5.000000
E/PRESIN MODO MI/TO
C permite que las expresiones contengan operandos de distinto tipo . Por ejemplo,
un operando puede ser de tipo entero y el segundo puede ser de tipo flotante. Al
realizar la operacin de enteros y float, el entero para fines de clculo convierte a
float. De la misma manera, en la operacin de la float y doble . El float para fines
de clculo se convierte en double . Esto se conoce como conversin implcita.
Analice el siguiente programa
#include<stdio.h>
main()
{
int ivar=5,answer;
float fvar=123.35,result;
result=ivar * fvar;
printf("%d * %f = %f \n, ivar, fvar, result);
printf("%f en notacion cientfica es %e\n, result, result);
answer=ivar * fvar;
printf("%d * %f = %d\n, ivar, fvar, answer);
}
OPERADOR CAST
En las expresiones de modo mixto el tipo de datos se convierte implcitamente a
efectos de clculo. Pero muchas veces queremos convertir explcitamente el tipo de
datos de la variable, lo cual es posible a travs de operador cast. El operador de
conversin convierte explcitamente el tipo de datos de la variable a otro slo para
fines de clculo, pero el tipo de datos original de la variable no ser cambiado.
El valor de una expresin se puede convertir en otro tipo de datos si lo desea. Para
ello, la expresin debe ser precedido por el nombre del tipo de datos deseado, entre
parntesis. El formato general es :
(ipo de datos) la e&presi"n o varia$le
En el siguiente caso, la variable float es convertido a int y el valor de ivar sera de 3
debido a que el entero no puede representar los puntos decimales.
int a=7;
float b;
b=float(a)+1.0;
/*Aqui a se convierte a float */
float fvar = 3.3;
int ivar;
ivar = int(fvar);
Ejecute el siguiente ejemplo
#include<stdio.h>
main()
{
int intvar=25000;
intvar=intvar*10/10;
printf("ntvar = %d\n,intvar);
intvar=25000;
intvar=((long)intvar*10)/10;
printf("ntvar = %d\n,intvar);
}
VARIA!LE TIPO C6AR
El tipo char se utiliza para almacenar un nico carcter de informacin. Una
constante de carcter debe ser un nico carcter encerrado entre comillas simples.
por ejemplo, 's', 'b', '#', 'etc
Con el fin de mostrar un carcter constante, la especificacin de formato % c se
utiliza en la declaracin correspondiente printf ().
Ejemplo de variables tipo char .
main()
{
char ch1 = 'H',
ch2 = 'o',
ch3 = 'w',
ch4 = ' ',
ch5 = 'a',
ch6 = 'r',
ch7 = 'e',
ch8 = 'y',
ch9 = 'u',
ch10 = '?';
printf("%c%c%c%c%c%c%c%c%c%c%c%c\n", ch1, ch2, ch3, ch4, ch5, ch6, ch7,
ch4,
ch8, ch2, ch9,ch10);
}
Conversin de ASC a entero; La funcin atoi ()
Eventualmente tenemos que convertir nmeros que estn en carcter a entero , la
mejor forma de hacerlo e mediante una funcin de librera.
El atoi () convierte los nmeros al principio de una cadena en un valor entero. La
trata de convertir tiras o matrices de caracteres ASC. Por lo tanto atoi significa
"convertir un archivo ASC (texto) de la cadena en un valor entero." As es como se
puede leer enteros desde el teclado. E%t$ 10nci3n e% ($&te de )$ )ib&e&7$ %td)ib8
Aqu est el formato:
var%atoi(strin0)'
Veamos el si0uiente e1emplo :
# include <stdio.h>
#include <stdlib.h>

int main()
{
int age;
char years[ ]= "696";
printf("Cuantos aos tenia Matusalem ? \n");
age=atoi(years);
printf("Tena %d aos \n",age);
return(0);
}
CAPTULO 9 MANIPULACIN DE DATA
LA 5UNCION %c$n1"#
As como la mayora de programas necesitan salida de datos a la pantalla, tambin
necesitan datos de entrada desde el teclado. La manera ms flexible que el
programa puede leer los datos numricos desde el teclado es utilizando el scanf ()
funcin.
El scanf () lee los datos desde el teclado de acuerdo a un formato especificado y
asigna los datos de entrada a una o ms variables. Al igual que printf (), scanf () usa
la cadena de control para describir el formato de la entrada. La cadena de control
utiliza las especificaciones de conversin igual a la funcin printf (). El formato es:
scanf (2cadena de control2, ar03, ar04, ..., ar0n.)
La cadena de control indica al scanf () que lea los datos tipo caracteres y los
convierta a los tipos especficos de valores, y luego guardarlos en la ubicacin dada
por los argumentos de la direccin. Cada especificacin de conversin comienza con
el carcter de porcentaje (%). por ejemplo
scanf (25 d2, 6 a)'
Lee un entero decimal desde el teclado y lo asigna a la variable de tipo entero 'a'.
Se asume que la variable a ha sido declarada anteriormente.
Asimismo, la declaracin siguiente, se lee un valor de punto flotante desde el teclado
y lo asigna a la variable 'b'.
scanf (25 f2, 6 $)'
El smbolo & antes del nombre de la variable es el operador de C de direcciones.
Los datos se introducen desde el teclado van a esta direccin, es decir, guardar los
datos en la direccin de la variable, ms informacin sobre la direccin se tratarn
en punteros.
Revise el siguiente ejemplo:
#include<stdio.h>
main()
{
int num;
printf("Enter a number);
scanf("%d,&num);
printf("Square the number is %d\n, num*num);
}
En el programa anterior, cuando el compilador encuentra el scanf () la secuencia del
programa se interrumpe (espera la respuesta del usuario) hasta que el usuario
introduce un valor. Despus de recibir el valor del scanf () la funcin almacena el
valor en la direccin de la variable en formato entero, ya que la especificacin de
conversin utilizado es% d.
Analice el siguiente programa , asuma que el operador entra el numero 5 y enter:
Cual ser la salida?
#include<stdio.h>
main()
{
float realnum;
printf("Enter a real number: );
scanf("%d,&realnum);
printf("The number was %f \n,realnum);
}
Analice el siguiente programa , asuma que la entrada es 3.4 enter y 4.3 enter .Cual
ser la salida:
#include<stdio.h>
main()
{
float num1,num2;
printf("Enter a real number1: );
scanf("%f ,&num1);
printf("Enter a real number2: );
scanf("%f ,&num2);
printf("The sum of two numbers is %f \n,num1+num2);
}
Por ultimo , analice el siguiente:
#include<stdio.h>
main()
{
int a,b,answer;
printf("Enter the values of a & b: );
scanf("%d%d,&a,&b);
answer = a + b;
printf("a + b = %d\n,answer);
answer = a b;
printf("a b = %d\n,answer);
answer = a * b;
printf("a * b = %d\n,answer);
answer = a / b;
printf("a / b = %d\n,answer);
}
Ahora, es importante que el programador asegure que la cantidad de datos
ingresados pueden ser contenidos en la variable, caso contrario , los valores
ingresados en exceso sobreescibirn posiciones de memoria que pueden estar
asignados a otras variables. Ejemplo:
char name[10]; //declara un string para recibir 10 caracteres
scanf("%s", name); // lee 15 caracteres.
Para solventar este problema existe una llamada similare: scanf_s
#include<stdio.h>
int main()
{
char c;
printf("Enter a letter");
scanf_s("%c",&c);
return 0;
}
La funcin scanf_s es ms segura en el sentido de evitar que reas de otras
variables sean afectadas por el ingreso inesperado del usuario.
ENTRADA : SALIDA DE UN c;$&
Hay varias funciones de la librera estndar disponibles en C que se ocupa de las
operaciones de E/S en un solo carcter. Estas son funciones de E/S de un solo
char. Los siguientes son algunos de los caracteres de un solo funciones /O
disponible en C.
getchar ()
getch ()
getche ()
putchar ()
La funcin getchar recibe un carcter desde el dispositivo entrada estndar
(stdin) que por defecto es el teclado , sin embargo puede ser redirigido . Este
carcter puede ser asignado a una variable de la siguiente manera:
ch = getchar ();
Observe la diferencia entre la sintaxis de scanf () donde se utilizara el siguiente
formato
scanf ("% c", &ch)
La diferencia entre las dos sentencias es que getchar devuelve un carcter .
Mientras que scanf no devuelve nada , pero la variable ch tiene un nuevo valor.
getchar () se usa normalmente con entrada tipo buffer. Todos los chars ingresados
en el teclado entran en un buffer despus de la tecla ha sido presionada.
Veamos el siguiente programa , fjese la conversin de carcter a decimal .
#include<stdio.h>
main()
{
int ch;
printf("ntroduza un caracter: );
ch=getchar();
printf("The character was %c\n,ch);
printf("The ASC code of %c is %d\nch,ch);
}
Si se ejecuta el programa anterior, se ver que despus de que el mensaje
"ntroduzca un carcter:" el programa queda a la espera .Sin embargo, con el fin de
introducir un carcter que tendra que pulsar el carcter y la tecla ENTER. Los
cdigos ASC de ambos entraran en el bffer, getchar () tomara la primera de ellas,
dejando el carcter ENTER ("\ n") en el bfer. El segundo printf () que muestra el
contenido de la 'ch' de tipo char, mientras que en la tercera declaracin printf () dos
especificaciones de conversin y el uso %c %d para mostrar el contenido dos
veces. La primera especificacin de conversin% c muestra el contenido de la 'ch' es
decir, en formar el caracter, 'a' en tanto que la segunda especificacin de conversin
se muestra el valor ASC del contenido de la 'ch', es decir, 97
Nota: Para usar getchar (), es necesario incluir el encabezado del archivo 'stdio.h'.
# include <stdio.h>
La funcin getchar () devuelve un cdigo ASC de tipo entero que en el ejemplo
anterior 'ch' la variable debe ser declarada como de tipo int. El programa parece
funcionar si 'ch' se declara como tipo char, pero podra haber problemas en otros
programas, como veremos ms adelante.
2etc; "# < 2etc;e "#
Muchos compiladores tienen funciones alternativas para la entrada de un solo
carcter, que no utiliza un buffer. Tan pronto como un caracter es pulsado , el getch
() o getche () obtiene el carcter, sin esperar a una tecla ENTER para ser
presionado. E%t$% ))$'$d$% (e&tenecen $ )$ )ib&e&7$ conio." 8 Esto se conoce
como la entrada directa. Ntese la diferencia mientras se ejecuta el siguiente
programa:
#include<stdio.h>
#include<conio.h>
main()
{
int ch;
printf("Enter a character: );
ch=getche();
printf("\nThe character was %c\n,ch);
printf("The ASC code of %c is %d\n,ch,ch);
}
Si ejecutamos el mismo programa con la funcion getch() , observaremos que la
llamada funciona sin embargo la salida pantalla es diferente , con esta funcin no
obtenemos el eco
#include<stdio.h>
main()
{
int ch;
ch=getch();
printf(\nThe character was %c\n,ch);
printf("The ASC code of %c is %d\n,ch,ch);}
(0tc;$& "#
Esta funcin enva un nico carcter en el dispositivo de salida estndar stdout (por
defecto la pantalla). El caracter puede ser un carcter de control del dispositivo. El
formato es:
putchar (c)'
Pruebe el siguiente programa:
#include<stdio.h>
main()
{
int ch;
ch=getch();
putchar('\n'); /* New Line */
printf("The character is );
putchar(ch); /* Displays content of ch in character form */
putchar('\a'); /* beep or bell */
putchar('\n'); /* New Line */
}
El siguiente cuadro resume las capacidades de cada funcin:
Funcin Librera Echo? Buffer?
getchar() stdio si si
getch conio no no
getche conio si no
putchar stdio NA si
Not$= L$ )ib&e&7$ conio e% 1$b&ic$d$ (o& !o&)$nd < no e% ($&te de ANSI C + no
todo% )o% co'(i)$do&e% )$ %o(o&t$n
ENTRADA SALIDA CON 5ORMATO
Cuando se utiliza el 5tipo en las funciones printf () y scanf (), el programador
tiene la opcin de especificar un formato de la variable .
Adicionalmente un nmero positivo puede indicar el nmero de espaciado de
caracteres de la informacin que se va a imprimir o para indicar los dgitos mnimo
para ser ledo.
Por ejemplo, si se desea que la variable utilice exactamente 5 espacios o
posiciones se podr representar de la siguiente forma :
printf ("%5d", a);
y la sentencia :
scanf ("% 5d", & a);
Lea slo 5 dgitos e ignora el resto si hay ms de 5 dgitos.
Normalmente los valores numricos se alinean hacia la derecha mientras que los
textos se alinean hacia la izquierda . Para definir un alineamiento hacia la izquierda
se podr usar el signo menos (-) de la siguiente forma:
printf ("%-5d", a);
En otras ocasiones es necesario rellenar los espacios que no estn siendo usados
con ceros , esto puede hacerse de la siguiente forma:
printf ("% 05D", a)
Cuando tratamos con valores de punto flotante se hace necesario especificar la
cantidad de decimales con los que se desea la salida. Esto puede hacerse
mediante el uso del punto (.)
printf ("% .2 f", a);
El siguiente programa le ayudar a ver distintos uso de los modificadores de
formato.
#include<stdio.h>
#include <conio.h>
main()
{
int a=12345;
printf("%d%3d%5d%7d\n,a,a,a,a);
float x=345.678;
printf("%7f%7.3f%7.1f \n",x,x,x);
int m=1234;
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg.4
float y=98.76;
printf("%d\n,m);
printf("%10d\n,m);
printf("%010d\n,m+2);
printf("%-7.2f \n,y);
printf("%7.2f \n,y);
char c1 = 'A', c2 = 'B', c3 = 'C';
clrscr();
printf("%c %c %c\n, c1,c2,c3);
printf("%c %c %c\n,c1, c2, c3);
printf("%3c %3c %3c\n,c1,c2,c3);
printf("c1=%c c2=%c c3=%c\n,c1,c2,c3);
}
VARIA!LE LGICAS
Adems de las variables que ya hemos visto , C permite usar un tipo de variable
lgica o booleana. Estas variables estn definidas en una librera , la sdt$ool.h pero
algunos compiladores nuevos ya las tiene como nativas , es decir , ya no se
necesitara indicar al precompilador el include de std$ool.
Una variable lgica es una variable que solo puede tomar uno de los siguientes
valores , 1 o 0 o tambin llamados true o false .
La librera stdbool incluye la definicin de true y false . True es una condicin
verdadera y false una condicin falsa . Veamos un ejemplo:
#include <stdio.h>
#include <stdbool.h>
int main (void)

{
bool x = true;
bool y = false;

printf ("Los valores son : %d %d\n", x, y);
return 0;
}

En el ejemplo anterior , la palabra bool define un tipo de variable lgica , x e y son
variable lgicas . Fijese que el formato de salida del printf es %d , esto es porque
internamente la variable en un entero cuyo valor es 1 o 0 .
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg./
OPERADORES RELACIONALES
Los operadores relacionales se utilizan para tomar decisiones con sentencias de
alteracin del flujo del programa. Los operadores de relacin trabajan con
operandos (valores o variables). Se utilizan para comparar el valor o la variable si es
menor o igual o mayor que otra. Los operadores de relacin que se usa C se
muestran en la siguiente tabla.
7peradores Relacionales
El operando junto con los operadores de relacin constituye una expresin
relacional. La expresin relacional produce slo dos valores de un verdadero y 0
para falso.
"C" permite que se tomen decisiones mediante la evaluacin de una expresin dada
como verdadera o falsa. Tal expresin incluye los operadores relacionales y lgicos.
Dependiendo del resultado de la decisin, la ejecucin del programa procede en una
direccin u otra.
/* programa operadores relacionales */
#include<stdio.h>
main()
{
int num;
printf("Enter a number:);
scanf("%d,&num);
printf("Num < 20 = %d\n,(num<20));
printf("Num > 20 = %d\n,(num>20));
printf("Num == 20 = %d\n,(num==20));
}
En el programa , la sentencia de control indica que debe imprimir un tipo decimal,
el texto Num<20 es tomado como texto , aqu no hay ninguna evaluacin lgica .
Pero en el lado de la variable se est colocando la expresin (num<20) misma que
devuelve ya sea un boolean 1 o O.
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg..
!LO>UES DE SENTENCIAS
C permite la agrupacin de sentencias , que tienen que ser tratados como una
entidad y el grupo resultante se llama sentencia compuesta o bloque. Consiste en
sentencias encerradas entre llaves { }
{
printf ("Felicidades \ n");
printf ("Usted est aprobado");
}
Un bloque es sintcticamente equivalente a una sola sentencia. Los bloques son
muy tiles cuando la ramificacin o enlace de accin debe ser tomada en una serie
de declaraciones en funcin de una determinada decisin.
Ntese que an cuando se toma el bloque como una sola expresin, cada una de
las sentencias debe estar terminada por el (;).
C$(7t0)o ?- S$)to% < Condicion$'iento%
SENTENCIAS CONDICIONALES
Si la vida se mueve en una direccin, sera muy aburrido que es el caso de la
programacin tambin. Sera muy aburrido si las declaraciones en el programa slo
puede ser ejecutado en el orden en que aparecen. De hecho, una tarea comn de
un programa es instruir a la computadora a saltar a diferentes partes del cdigo si
cumplen determinadas condiciones. La decisin sobre dnde se mueven se realiza
por instrucciones condicionales. Hay tres sentencias condicionales if , if-else y
switch.
L$ %entenci$ i1
La sentencia if evalu el valor de la condicin de que ser verdadera o falsa, y si la
condicin es verdadera, la sentencia(s) siguientes se ejecuta de otro modo se
ignoran
El formato de la declaracin, si es la siguiente:
if(condition)
statement3'
statement4'
Dnde, la condicin es una expresin que se evala. Si la condicin es verdadera,
se ejecuta la primera sentencia (statement 1). Si es falsa, sentencia1 se ignora y el
programa contina en la siguiente instruccin despus de la condicional es decir,
construir, statement2.
Esta sintaxis es vlida nicamente cuando lo que se debe ejecutar cabe dentro de
una sentencia , es decir , si el programador requiere ejecutar ms de una sentencia
si la expresin es verdadera deber incluir las llaves de bloque.
Note que la sentencia if no tiene el punto y coma final (;)
Por ejemplo,
if (notas > = 30)
printf ("PASS");
printf ("Fin del programa");
En el ejemplo anterior, si 'notas> = 30' se imprime 'PASS' (expresion verdadera) y
a continuacin, 'fin del programa ".Si 'notas< 30' se evala como falso, 'PASS' no se
mostrar, el control pasa a la sentencia printf () que muestra 'Fin del programa'.
Si queremos algo ms que una sola instruccin que se ejecutar
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg.'
Las sentencias que se ejecutan con la evaluacin TRUE pueden ser sustituidas
por un bloque :
if(notas >= 30)
{
printf("PASS\n);
printf("Very Good\n);
}
printf("fin del programa);
Analice el siguiente programa :
#include<stdio.h>
main()
{
int num1,num2;
printf("Enter first integer: );
scanf("%d,&num1);
printf("Enter second integer: );
scanf("%d,&num2);
if(num1==num2)
printf("%d is equal to %d\n,num1,num2);
printf ("The End ");
}
#include<stdio.h>
main()
{
int n;
printf("Enter a integer: );
scanf("%d,&n);
if(n%2==0)
printf("The number is Even\n);
printf("THANKS.\n);
}
En el programa anterior, despus de la introduccin y la lectura de un nmero, si la
declaracin se encuentra que el residuo de 'n' y 2, es 0, la condicin es verdadera,
la funcin printf () declaracin siguiente si se ejecuta y muestra el mensaje 'nmero
es par 'de lo contrario se omite. En los dos casos (es decir, si la condicin es
verdadera o falsa) de la ltima instruccin printf("THANKS.\n) se ejecuta.
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg.#
I5 ELSE I5
Esta sentencia permite que las condiciones y sentencias sean anidadas . Esto
permite que despus de la tomar la decisin de ejecutar un bloque el bloque
contenga nuevos prrafos condicionales.
No existe limite a la cantidad de decisiones que se pueden anidar, sin embargo el
programador deber hacer que el cdigo sea fcilmente legible . El formato de esta
sentencia es el siguiente:
if(condition)
statement3'
else
statement4'
Si la condicin se prueba que es verdadera las sentencia statement1 ser
ejecutada , caso contrario se ejecutar la sentencia 2 .
De la misma manera se puede sustituir las sentencias que se ejecutarn en
cualquier caso por un bloque de sentencias de la siguiente forma
if (condition)
8
statements3'
statements4'
...
statementsn'
9
else
8
statements3'
statements4'
...
statementsn'
9
Analice el siguiente ejemplo:
#include <stdio.h>
main()
{
int num1,num2;
printf("Enter an integer: );
scanf("%d,&num1);
printf("Enter another integer: );
scanf("%d,&num2);
if(num1 ==num2)
printf("You have typed equal integers\n);
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg.*
else
printf("You have typed different integers\n);
}
En el programa anterior, despus de leer dos valores enteros de dos variables
"num1" y "num2", los valores se ponen a prueba en el estado con el if. Si ambos
valores son iguales, entonces la condicin si es verdadera y por lo tanto, la funcin
printf () inmediatamente despus de la declaracin, si se ejecuta. Si los dos valores
no son iguales, entonces la condicin si es falsa, y por lo tanto, la funcin printf ()
instruccin que sigue se ejecuta.
Otro ejemplo :
#include <stdio.h>
main()
{
int num1,num2;
scanf("%d,&num1);
printf("Enter another integer: );
scanf("%d,&num2);
if(num1 % num2==0)
printf("%d is divisible by %d\n,num1,num2);
else
printf("%d is not divisible by %d\n,num1,num2);
}
Ahora con bloques en ambos lados del if :
#include<stdio.h>
main()
{
float years, seconds;
printf("Enter your age in years:);
scanf("%f,&years);
if(years < 0)
{
printf(" am sorry\n);
printf("Age cannot be negative);
}
else
{
seconds = years * 365 * 24 * 60 * 60;
printf("Your lived for %f seconds,seconds);
}
}
I5 ANIDADOS
Cuando existe un if dentro de otro if se llama que anidados. En otras palabra , un if-
else dentro de otro if-else. Si la condicin del if exterior es verdadera entonces el
programa empieza a evaluar los if internos. El formato de la instruccin if anidada
puede ser de las siguientes formas:
if (condition)
{
if(condition)
statement1;
else
statement2;
}
else
statement3;
if(condition)
statement1;
else
{
if(condition 2)
statement2;
else
statement3;
}
if(condition)
{
if(condition 2)
statement4;
else
statement5;
}
else
{
if(condition 3)
statement6;
else
statement7;
}
Veamos el siguiente cdigo :
#include <stdio.h>
main()
{
int n;
printf("Please enter an integer: );
scanf("%d,&n);
if(n<=15)
{
if(n>=10)
printf("%d is between 10 and 15.\n,n);
}
else
printf("%d is not between 10 and 15.\n,n);
}
En el programa anterior, despus de leer un valor entero en la variable 'n', si los
controles de la condicin if el valor es inferior a 15, si el resultado de esta condicin
es cierta, las declaraciones de bloque entre llaves se ejecutan, de lo contrario la
funcin printf () instruccin que sigue a otro que se ejecuta.
C$%o% E%(eci$)e% =
Cuando en lugar de una comparacin colocamos una expresin , C hace una
"expansin automtica .Veamos el siguiente programa:
#include<stdio.h>
#include<conio.h>
void main()
{
int x;
clrscr();
x=12;
if(x)
printf("x is non zero");
getch();
}
#include<stdio.h>
#include<conio.h>
void main()
{
int x;
clrscr();
x=10;
if(x=10)
printf("x is equal to 10");
getch();
}
El programa a la izquierda , en este caso la sentencia if(x) es entendida como
if (!x=0), en otras palabras se esta preguntando si el valor de x es 0 . A la derecha ,
el if tiene una asignacin x=10, es expandida a if (!(10=0)) lo cual siempre dar un
resultado de true, indistintamente del valor.
SENTENCIA S@ITC6
La sentencia switch se utiliza para seleccionar una opcin entre mltiples opciones.
La sentencia switch hace que un grupo particular de la declaracin escoja entre
varios grupos disponibles. La seleccin se basa en el valor actual de una expresin
que se incluye dentro de la sentencia switch.
Demasiados construcciones if-else pueden volverse muy desordenada y difcil de
leer en un programa, especialmente en el caso de la comparacin de la entrada con
una amplia gama de posibilidades. Se trata de un mtodo alternativo de hacer esto
mediante el uso de la sentencia switch / case , el formato general es el siguiente.
s-itch(e&pression)
8
case constant3:
$loc: of statements3'
$rea:'
case constant4:
$loc: of statements4'
$rea:'
;..
case constantn:
$loc: of statementsn'
$rea:'
default:
$loc: of statements'
9
Switch evala la expresin y comprueba si es equivalente a constante1, si lo es, se
ejecuta bloque de statements1 hasta que encuentra la palabra clave break. En el
momento que la palabra clave break se encuentra, el control pasar a la final de la
sentencia switch. Si la expresin no se ha encontrado igual a constante1 se
comprobar si la expresin es equivalente a constant2. Si es as, que se ejecute el
bloque de statements2 hasta que encuentra la palabra clave break, y as
sucesivamente.
Por ltimo, si el valor de la expresin no ha coincidido con alguna de las constantes
especificadas previamente, el programa ejecutar las instrucciones incluidas en la
seccin por defecto. La clusula de default es opcional y se ejecuta si los casos no
se cumplen.
Note la inclusin de sentencia break al final de cada bloque. Esto es necesario
porque si, por ejemplo, no se incluyen despus de un bloqueo de sentencia1, el
control no cambiara hasta el final de la sentencia switch y se mantendra la
ejecucin del resto de los bloques de sentencias hasta que la primera aparicin de
un break o al final de la sentencia switch que se encuentre.
Para entender mejor veamos el siguiente programa :
#include <stdio.h>
main()
{
float value1,value2;
char operator;
printf("Type an expression: );
scanf("%f%c%f ,&value1,&operator,&value2);
switch(operator)
{
case '+':
printf("%.2f \n,value1+value2);
break;
case '':
printf("%.2f \n,value1-value2);
break;
case '*':
printf("%.2f \n,value1*value2);
break;
case '/':
if(value2==0)
printf("Divisible by zero\n);
else
printf("%.2f \n,value1/value2);
break;
default:
printf("Unknown operator\n);

}
}
En el programa anterior se realiza la entrada de 3 variables , dos son de tipo float y
una de tipo carcter . La idea es realizar la operacin aritmtica que se desee.
Dependiendo del operador aritmtico se transfiere control sobre determinado grupo
de sentencias.
Veamos un ejemplo sin el control break :
#include<stdio.h>
#include<conio.h>
void main()
{
char ch;
clrscr();
printf("Enter any character\n");
scanf("%c",&ch);
switch(ch)
{
default:
printf("No es vocal l\n");
break;
case'A':
case'a':
case'E':
case'e':
case'':
case'i':
case'O':
case'o':
case'U':
case'u':
printf("Es una vocal ");
break;
}
getch();
}
OPERADOR CONDICIONAL "o(e&$do& te&n$&io#
C incluye un operador muy especial llamado el operador condicional o ternario. Se
le llama ternarios, ya que utiliza tres expresiones. Simples operaciones
condicionales se pueden realizar con el operador condicional (?). Una expresin que
hace uso del operador condicional se denomina una expresin condicional. Tal
expresin se puede escribir en lugar de las ms tradicionales if-else.
sintaxis:
e&pression3# e&pression4$ e&pression<
nicialmente C evaluar la expresin condicional e&pression3 . Si expression1 es
verdadera entonces se evala expression2 y esto se convierte en el valor de la
expresin condicional. Sin embargo, si expression1 es falsa, entonces expression3
se evala y se convierte en el valor de la expresin condicional.
Veamos el siguiente programa:
main()
{
int first,second,biggest;
printf("Enter two positive integers\n);
scanf("%d%d,&first,&second);
bi22e%tA "1i&%t B %econd# C 1i&%t = %econdD
printf("Biggest of two numbers is %d,biggest);
}
Este tipo de construccin hace que el cdigo sea ms compacto , pero tambin mas
difcil de leer.
OPERADORES DE INCREMENTO , DECREMENTO
C utiliza dos operadores para incremento o decremento . Tambin se les llama auto
incremento y auto decremento. El operador de incremento permite incrementar el
contenido de la variable en 1, mientras que el operador de decremento disminuir el
contenido de la variable en 1.
Hay dos tipos de usos : prefijo de incremento (++ i) y el incremento postfijo (i ++).
Del mismo modo en decremento tambin son de dos tipos, es decir, prefijo (-- i) y
postfijo (i --).
En prefijo de incremento que el operador agrega uno a la variable y luego procede a
usarla y en el incremento de postfijo utiliza por primera vez la variable y luego aade
1 a la variable. De la misma manera trabaja el decremento .
Considere los siguientes dos ejemplos.
#include <stdio.h>
main()
{
int x=5;
printf("Value of x with increment operator is %d, ++x);
}
#include <stdio.h>
main()
{
int x=5;
printf("Value of x with increment operator is %d", x++);
}
El resultado de los dos programas es diferente debido a la localizacin del
operador .
Ejecute el siguiente programa para ver su utilidad
#include<stdio.h>
main()
{
int a=10;
clrscr();
printf("A=%d\n,a++);
printf("A=%d\n,++a);
a++;
++a;
printf("A=%d\n,--a);
printf("A=%d\n,a--);
printf("A=%d\n,a);
printf("A=%d\n,a--);
}
C$(7t0)o ?? Re(etici3n < )$Eo%
!UCLES
Si queremos que la ejecucin de sentencias se realice ms de una vez un bucle
puede ser lo aconsejado . Esto implica la repeticin de una parte del programa, ya
sea un nmero determinado de veces o hasta que una condicin en particular est
siendo satisfecha. En muchas situaciones, sabemos de antemano el nmero de
veces que se repite el bucle. Pero en muchas situaciones, no sabemos el nmero de
veces que se repite el bucle, el bucle se repite hasta que la condicin es verdadera.
Esta operacin se hace posible a travs de una estructura de control del bucle.
Hay tres maneras en que podemos repetir la instruccin requerida (s).
Ellos son:
while
do-while
for
!0c)e ti(o F;i)e
El bucle while se utiliza para ejecutar un block de cdigo mientras que la condicin
sea verdadera. Tan pronto como la condicin se vuelve falsa, no se ejecutar el
bucle y pasar el control a la instruccin inmediatamente despus del bucle while. Si
la condicin es falsa desde el principio, el bucle no se ejecuta, mientras que bucle se
puede ejecutar por cero o mltiples veces. El formato general de es:
-hile(condition)
8
statement3'
statement4'
.
.
statement(n)'
9
Para cualquier tipo de lazo tres puntos son importantes:
nicializacin del contador del bucle
Condicin, para poner a prueba si la condicin evala a verdadero o falso.
Aumentar o disminuir el contador del bucle, caso contrario el bucle no
acabar nunca
En general el diagrama de flujo de la sentencia while es el siguiente :
Ejecute el siguiente programa para su anlisis
main()
{
int i=1;
while(i<11)
{
printf("This is line number %d\n, i);
i++;
}
}
En el programa anterior, la variable 'i' se declara y se inicializa a 1. A continuacin,
inicia el bucle while que comprueba si el valor de 'i' es menor que 11. Si es cierto, el
bloque de sentencias se ejecutarn. Si es falso, el bloque de sentencias se omitirn
y saldr del bucle. En el lazo de determinado programa es ejecutado por 10 veces.
Tenemos que tener alguna forma de poner fin al ciclo en algn momento, por lo
tanto, en el bloque de sentencias, que debe proporcionar un mtodo que las fuerzas
condicin sea falsa en algn momento, de lo contrario el bucle continuar en bucle
para siempre. En este caso hemos incluido i + + que hace que la condicin sea falsa
cuando el proceso de incrementar la 'i' por una llega a 11.
Vemos el siguiente ejemplo de calculo de factorial :
#include<stdio.h>
main()
{
int num,original,factorial;
printf("Type a positive integer: );
scanf("%d,&num);
original=num;
factorial=1;
while(num>1)
{
factorial*=num;
num--;
}
printf("Factorial of %d=%d\n,original,factorial);
}
!0c)e ti(o doGF;i)e
El do-while es similar al bucle while, excepto que en el do-while las pruebas de la
condicin se realizan al final . El cuerpo del bucle se ejecutar al menos una vez en
el peor de los casos. El formato general de do-while es la siguiente:
do
{
statement 1;
statement 2;
.
.
statement (n);
} while(condition);
Hay una diferencia entre el funcionamiento de los bucles while y do-while. La
diferencia es el lugar donde se prueba la condicin. El while pone a prueba la
condicin antes de ejecutar cualquiera de las declaraciones dentro del bucle , es
decir, antes de entrar en el bucle de prueba En caso de que el do-while prueba la
condicin despus de haber ejecutado las sentencias dentro del bucle, es decir, al
final del bucle y se conoce como post-test.
El diagrama de flujo de do-while sera el siguiente :
Analice los siguientes programa :
#include<stdio.h>
main()
{
int n=1;
do
{
printf("The value of n is now %d\n,n);
n++;
}
while(n < =5);
}
#include<stdio.h>
main()
{
int num,rev;
printf("Enter the number to be reversed: );
scanf("%d,&num);
printf("Reverse number is :\n);
do
{
rev = num % 10;
printf("%d,rev);
num = num/10;
}
while(num!=0);
}
!0c)e ti(o 1o&
A menudo en programacin se desea hacer algo por un nmero determinado (fijo)
de veces. El bucle for es ideal para estos casos.
El bucle for nos permite especificar tres cosas acerca de un bucle en una sola lnea:
nicializar el contador del bucle.
Prueba el contador del bucle para comprobar si su valor ha alcanzado el
nmero de repeticiones deseado (valor final).
Aumentar o disminuir el valor del contador del bucle despus de cada vez
que las sentencias dentro del bucle se ha ejecutado.
La forma general de la declaracin, conforme a:
for(initiali=e counter ' condition ' increment or decrement counter)
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg'4
8
statement 3'
statement 4'
.
.
statement (n)'
9
El for trabaja de la siguiente forma :
Se realiza la inicializacin del contador : En general, es establecer el valor inicial de
una variable de contador. Esto se ejecuta slo una vez.
Se comprueba la condicin : Si es verdadera el bucle contina, de lo contrario el
bucle termina y las declaraciones se omiten. La condicin es generalmente una
declaracin relacional que comprueba el valor de la variable contador con un valor
de terminacin.
Si la condicin es verdadera, se ejecutan las instrucciones. Como es habitual, la
declaracin puede ser una sola declaracin o un bloque de sentencias encerradas
entre llaves.
Finalmente, lo que se especifique el incremento o decremento del campo (variable)
contador se ejecuta y el bucle se vuelve al paso inicial .
El diagrama de flujo de esta construccin es el siguiente :
Analice el siguiente cdigo
#include<stdio.h>
main()
{
int i;
printf("Count down\n);
for(i=10;i>0;i--)
printf("%2d\n,i);
}
main()
{
int i;
printf("Table of Results\n\n);
printf(" i i Square\n);
for(i=1;i<=10;i++)
printf("%4d%13d\n,i,i*i);
}
#include<stdio.h>
main()
{
int i,low,high,temp,sum=0;
printf("Please type in the low bound: );
scanf("%d,&low);
printf("Please type in the high bound: );
scanf("%d,&high);
if(high<low)
{
printf("Wrong Order, let use switch them\n);
temp=low;
low=high;
high=temp;
}
for(i=low;i<=high;i++)
sum+=i;
printf("\nThe sum of integers from %d to %d is:
%d\n, low,high,sum);
}
// El siguiente ejemplo usando variables booleanas
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> // Verificar si el compilador lo necesita

int main(void) {
bool seguir = true; // Tambien podria ser puesto seguir = 1;
int y=0;
while(seguir) {
printf("Sigue imprimiendo mientras la condicion sea true.\n %d",y++);
if (y==10) seguir = false; // Tambien podria ser seguir= 0;`
}
printf("Parando !\n");
return EXT_SUCCESS;
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg'/
!UCLES ANIDADOS
Cuando se tiene un lazo dentro de otro se conoce como bucles anidados. En este
caso el bucle externo comienza su ejecucin por la inicializacin de su contador de
bucle y el programa sigue su ejecucin hacia el bucle interno. El contador del bucle
interior se inicia y el bucle se ejecuta hasta que la condicin es verdadera. Tan
pronto como el estado del bucle interno se convierte en falsa el programa de control
se mueve hacia atrs al bucle exterior. La condicin del bucle externo es
incrementada o decrementada segn sea el caso y el control del programa regresa
a la del bucle interior, de nuevo el contador del bucle del bucle interno se inicia de
nuevo y el bucle interno se ejecuta hasta que la condicin del bucle interno es
verdadera y etc. Este proceso se detendr cuando la condicin de ambos es decir, el
bucle externo e interno se convierte en falsa.
Veamos el siguiente ejemplo :
#include<stdio.h>
main()
{
int i,j;
for(i=1;i < 4; i++) // outer loop
for(j=1;j < 3; j++) // inner loop
printf("%5d%5d\n",i,j);
}
En el programa anterior, el bucle externo se inicia la ejecucin de la inicializacin del
valor de 'i' a 1 y pasar el control al bucle interior, donde el valor de la 'j' es definido
como 1 y el bucle interior se repite dos veces. Despus de completar dos
iteraciones del bucle interno se vuelve falsa y se mueve el control al bucle exterior.
El lazo externo incrementa el valor de 'i' en 1. De nuevo el bucle interno se repite
dos veces. En total, el bucle exterior se repite tres veces y en cada iteracin del
bucle exterior del bucle interno se repite dos veces, es decir, un total de seis veces.
OPERADOR COMA (,)
En el bucle for se puede tener ms de la inicializacin separados por comas. Del
mismo modo que podamos tener mas de un incremento o decremento separados
por comas.
El programa se muestra el operador coma.
#include<stdio.h>
main()
{
int i,j,n;
printf("What number do you want a table for? );
scanf("%d,&n);
for(i=0,j=n;i<=n;i++,j--)
printf("%3d + %3d = %3d\n,i,j,n);
}
DECLARACIONES DE SALTO
Las instrucciones de salto provocan un salto incondicional a otra declaracin en el
resto del cdigo del programa. Se utilizan sobre todo para interrumpir las
instrucciones switch y bucles.
Las declaraciones de salto son:
Continue
Break
Goto
In%t&0cci3n Contin0e
La sentencia continue se utiliza para evitar el resto del flujo pase travs de un bucle.
El bucle no termina cuando una sentencia continue que se encuentre. Las
sentencias restantes del bucle se omiten y el clculo procede directamente a la
siguiente pasada por el bucle ( chequeo de condicin).
Veamos el siguiente ejemplo :
#include<stdio.h>
main()
{
int sum = 0,i,x;
for (i=0; i<4; i++)
{
scanf("%d,&x);
if (x < 0)
continue;
sum = sum + x;
}
printf("Sum = %d\n,sum);
}
El programa realiza la suma de los nmeros que han sido ingresados por el usuario,
sin embargo se desea que no se sumen los valores negativos. La prueba if <0 esta
asociada a un continue que indica al programa que debe saltar al inicio del bucle .
Ejecute el siguiente programa para observar los resultaos:
#include<stdio.h>
main()
{
int i,j;
clrscr();
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg'.
for(i=1;i<4;i++)
{
for(j=1;j<4;j++)
{
if(i==j)
continue;
printf("%5d %5d\n",i,j);
}
}
}
!&e$H
A menudo nos encontramos con situaciones en las que quiere saltar fuera de un
bucle de forma instantnea, sin tener que esperar para volver a la prueba
condicional. La palabra clave break que nos permite hacer esto. La sentencia break
termina la ejecucin del inmediato del, do-while , for o switch. El control pasa a la
siguiente declaracin del cuerpo del bucle o la sentencia compuesta de una
sentencia switch.
La sentencia tiene la siguiente sintaxis:
$rea:'
#include<stdio.h>
main()
{
int i;
for (i=1; i<=20; i++)
{
if(i==10)
break;
else
printf("%5d\n,i);
}
printf("Program over );
}
El siguiente programa permite encontrar nmeros primos:
#include<stdio.h>
main()
{
int num,i;
printf("Enter a number\n);
scanf("%d,&num);
i=2;
while(i<=num-1)
{
if(num%i==0)
{
printf("Not a prime number\n);
break;
}
i++;
}
if(i==num)
printf("Prime number\n);
}
Goto
La sentencia goto se utiliza para alterar la secuencia normal de la ejecucin del
programa mediante la transferencia de control a alguna otra parte del programa. En
su forma general, la sentencia goto se escribe como
la$elname:
sentencia3'
instrucci"n4'
.
.
.
0oto la$elname
Aqu, labelname es un nombre de un punto del cdigo a donde goto dnde saltar.
En el siguiente ejemplo esta etiqueta toma el nombre de repeat
#include<stdio.h>
main()
{
int num=1;
&e(e$t=
printf("%4d\t,num);
num++;
if(num<11)
goto repeat;
printf("\nProgram Over);
}
AIn c0$ndo e%t$ %entenci$ e% $ce(t$d$ (o& C + 2ene&$)'ente (&ooc$
(&ob)e'$% $) 'o'ento de )ee& e) (&o2&$'$+ (o& )o J0e %0 0%o no e%
&eco'end$do8
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg''
50ncion e.it
La funcin exit () se utiliza para salir del programa antes de su acabado natural.
// PROGRAMA PARA REVSAR NOTAS
#include<stdio.h>
#include stdlib.h>
main()
{
int marks;
printf("Enter marks\n);
scanf("%d,&marks);
if (marks<30)
goto end;
else
{
printf("Alumno aprobado\n);
exit(0);
}
end:
printf("Alumno reprobado\n);
exit(1)
}
La funcin exit pertenece a la librera stdlib.h
La funcin return es similar en el sentido que retorna resultados a quien le haya
llamado . Cuando return se usa en el main() su comportamiento es similar al exit() .
Sin embargo el uso de return es ms general , pudiendo usarse en funciones .
U%o% de c3di2o de &eto&no=
Todos los sistemas operativos modernos incluyen la funcionalidad de codgo de
retorno para conocer si el programa que est terminando tuvo una terminacin
normal o anormal. Por ejemplo : es posible conocer si el programa tuvo un error
interno como archivo no encontrado , parmetros invlidos , etc si es que el
programa retorna un valor cero (0) . Si es que el programa termin normalmente
deber retornar un cdigo uno (1) . Otros cdigos son posibles.
Adicionalmente , el programador puede recibir este cdigo mediante un lenguaje
de scripting como Perl, o cualquier shell de unix . A continuacin un ejemplo :
#!/bin/sh
# Script para probar cdigo de retorno
notas
if [ "$?" -ne "0" ];
then echo "alumno aprobado "
ejecutar programa pase de semestre
else
echo " alumno reprobado no se ejecuta pase de semestre
fi
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg'#
T&$b$jo con A&&e2)o% o M$t&ice%
!na matriz es una estructura de datos que puede almacenar mltiples elementos de
mismo tipo de datos (homogneo) bajo un mismo nombre. En otra forma de decir es
que la matriz es una coleccin de variables del mismo tipo todos los cuales son
referidos por un nombre comn.
Un elemento especfico de una matriz se accede por un ndice. La declaracin de
una matriz se realiza como sigue:
1ata2t3pe 4ariable2name 5si6e78
Ejemplo: int arr[5];
En la declaracin anterior que se declara una matriz denominada como arr y que
puede almacenar 5 elementos enteros. El tamao se especifica entre [] corchetes
(operador de subndice). El tamao debe ser dado cuando se declara una matriz.
Nombre de la matriz es un identificador que sigue las reglas de la escritura de un
identificador.
Debido a que cada elemento entero es de 2 bytes por lo que esta declaracin de
matriz invierte 10 bytes de memoria para la matriz durante la compilacin. Todos los
elementos de un array se almacenan en lugares contiguos con el primer elemento
accedido como nombre de la matriz [0], segundo nombre de la matriz [1] y as
sucesivamente. En nuestro caso, ser arr [0], matriz [1] hasta matriz [4]. El primer
elemento de una matriz comienza en el ndice 0 y el ltimo elemento en el ndice
arraysize-1.
Las siguientes reglas aplican a los arreglos :
Un arreglo es una estructura de datos homognea que almacena elementos
de tipo similar, es decir, 5 elementos de tipo int, 10 elementos de tipo flotante,
y 20 elementos del tipo char.
Todos lo elementos comparten el mismo nombre con distinto ndice
Al cambiar el valor de un elemento no cambia el valor del resto
Aunque cada elemento tiene el mismo no0mbre son tratados como variable
independientes.
La cantidad de espacio requerido para almacenar un arreglo se puede
calcular de la siguiente forma :
Tamao = sizeof (type) * numero_elementos
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg'*
En C no hay ningn control que refuerce que el programador no sobrepase la
ltima direccin. Esto es responsabilidad del programador.
No hay forma de insertar o eliminar un valor en medio de un arreglo , esto se
puede hacer nicamente va programa.
Veamos el siguiente ejemplo que inicializa un arreglo y luego lo despliega
#include<stdio.h>
#include<conio.h>
#define s 5
void main()
{
int a[5];
int i;
clrscr();
for(i=0;i<s;i++)
{
printf("\n Enter a[%d] element:",i);
scanf("%d",&a[i]);
}
printf("Array elements are \n");
for(i=0;i<s;i++)
printf("a[%d]= %d\n",i,a[i]);
getch();
}
El siguiente programa presenta otra forma de inicializacin:
#include<stdio.h>
#include<conio.h>
void main()
{
int a[ ]={34,56,78,89,67};
int i;
clrscr();
printf("Array element are \n");
for(i=0;i<5;i++)
printf("a[%d]=%d\n",i,a[i]);
getch();
}
El siguiente pr5ograma indica que pasa cuando no todos los elementos han sido
inicializados:
#include<stdio.h>
#include<conio.h>
void main()
{
int a[8]={34,56,78,89,67};
int i;
clrscr();
const int s=sizeof(a)/sizeof(int);
printf("Array elements are\n");
for(i=0;i<s;i++)
printf("a[%d]=%d\n",i,a[i]);
getch();
}
Array elements are
a[0]=34
a[1]=56
a[2]=78
a[3]=89
a[4]=67
a[5]=0
a[6]=0
a[7]=0
Por ltimo veamos que pasa cuando se trata de acceder ms halla del ndice:
int a[3] = {34,56,78,89,67}; Esto provocar un error de compilacin
int a[3] = {34,56,78,89,67};
int s=6;
printf("%d, a[s]);
Esto provocar un error en tiempo de
ejecucin
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg#4
C$(7t0)o ?K S0b(&o2&$'$%+ S0b&0tin$% < Lib&e&7$%
5UNCIONES O MDULOS
Una funcin es un pequeo mdulo o pedazo de cdigo que se puede acceder en
repetidas ocasiones desde varios lugares diferentes dentro de un programa. Sus
caractersticas principales son :
Se puede acceder desde distintos puntos con diferentes valores de los
parmetros dentro de un programa.
Evitar la programacin redundante de las mismas instrucciones.
Aumenta la claridad lgica de romper el programa en varias funciones
concisas.
Divide en pequeos mdulos (funciones) que hace ms fcil de entender y
depurar.
Hace ms fcil escribir programas y realizar un seguimiento de lo que estn
haciendo.
TPOS DE FUNCONES
Generalmente las funciones se pueden dividir en dos grandes categoras:
Funciones del sistema
Funciones definidas por el usuario
Las funciones permiten que un pedazo de cdigo sea utilizado desde cualquier
programa. En C , se separan las funciones del desarrollador del cdigo y del
programador. El programador desea utilizar las funciones predefinidas para lo cual
lo nico que le interesa es saber como usarla mas no como funciona internamente
dicha funcin. El desarrollador por otro lado es aquel que escribe el cdigo de la
funcin est centrado en los detalles de su implementacin. Para lograr esta
separacin de funciones, C define dos tipos de archivos:
1. Archivos de cabecera (header) .h
2. Archivos de cdigo compilado .obj o dll
Como programadores lo nico que debemos hacer es incluir una referencia al
precompilador indicando que se usar uno o ms objetos. Para esto usamos la
sentencia :
#include li$rer>a
50ncione% de1inid$% (o& e) %i%te'$
Las funciones disponibles en la biblioteca estndar de C se llaman las funciones del
sistema. Estas funciones del sistema se puede acceder a travs del archivo de
cabecera (header file) generalmente identificados por la extensin .h . Por ejemplo,
si desea utilizar las funciones printf () o scanf () tiene que incluir el archivo de
cabecera <stdio.h> en su programa, esto se realiza mediante la sentencia de pre-
proceso include . En C, hay muchas funciones del sistema que estn definidas en
los archivos de cabecera diferentes dependiendo de la categora. Por ejemplo, todas
las funciones estndar de entrada/salida estn disponibles en la librera <stdio.h>,
las matemticas estn en funciones <math.h>, relacionados con la consola en
<conio.h>. Cada vez que desee utilizar cualquier funcin definida en su programa
habr que incluir el archivo de cabecera correspondiente antes de main(), por
ejemplo, para encontrar la raz cuadrada de un nmero entero, la funcin sqrt (),
disponible en <math.h> .
Ntese que estas libreras del sistema deben estar delimitadas por <> .
50ncione% de1inid$% (o& e) 0%0$&io
Cuando las funciones definidas por el sistema no satisface sus necesidades, es
decir, el programador quiere realizar alguna tarea y no hay funcin estndar que
este disponible para realizar esa tarea, entonces, el programador puede escribir la
funcin y guardarla como funcin definida por el usuario . Escribir nuestra propia
funcin, hace necesario indicarle al compilador el nombre de la funcin, el nmero y
tipo de informacin que pasa a la funcin, es decir, los parmetros o argumentos y el
tipo de declaracin que retorna de la funcin. Las funciones son identificadas por su
nombre y pueden devolver un solo valor.
De1inici3n de 10ncione% (&o(i$%
Si desea utilizar la funcin definida por el usuario, debe indicar al compilador los
detalles de la funcin. Usted puede hacer esto escribiendo algo que se llama
definicin de la funcin o prototipo de la funcin. Una funcin no puede ser llamada
sin que su definicin este completa. El formato es el siguiente :
tipo?retorno nom$re?funcion(tipo nom$re , tipo nom$re ;.)'
Lo primero que se especifica es el tipo de data que retorna la funcin . Recuerde que
solo se permite una variable de retorno, aunque hay formas de evitar esta
limitacin . Si el retorno de la funcin es de tipo punto flotante , entonces el retorno
de tipo ser de float. No puede haber una sola declaracin de la funcin sin
instruccin de retorno. Cuando la funcin no retorna nada , habr que usar la
palabra clave void .
A continuacin tiene que darle un nombre a la funcin , es buena prctica colocar
un nombre que refleje el tipo de trabajo que har.
A continuacin entre parntesis se tiene que indicar el tipo de parmetros que
tomara , y el nombre de cada parmetro. No existe lmite en esta cantidad . Por
ejemplo si la funcin toma como dato un texto la variable deber ser declarada
como string . Los parmetros son una forma de pasar informacin a la funcin, la
funcin puede procesar esta informacin. Si no existen variables de paso puede
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg#/
quedar en blanco .
Posteriormente, usted deber incluir el cdigo de la funcin. La funcin puede estar
definida en el mismo archivo o en otro archivo. Si est definida en el mismo archivo
deber colocar el cdigo en cualquier lugar pero fuera del main(). Si la funcin est
en otro archivo entonces dicho archivo deber tener el include correspondiente con
el nombre delimitador por comillas. Ejemplo:
#include <stdio.h>
void rutina1(int a , char b);
main() {
..
rutina1(10, 'a')
...
}
void rutina1(int a , char b) {
...
//codigo de la rutina
.
}
#include <stdio.h>
#include "mi-libreria;
main() {
..
rutina1(10, 'a')
...
}
//archivo mi_librera.h
void rutina1(int a , char b) ;
/archivo mi_librera.c
void rutina1(int a , char b)
{
..
//codigo de la rutina
..
}
El principio y el final de la funcin se caracterizan por llave de apertura ({) y llave de
cierre (}). Las declaraciones entre { } es el cuerpo de la funcin. Aqu se puede
utilizar todo tipo de declaraciones o sentencias.
ALCANCE DE LAS VARIA!LES
Es el mbito de aplicacin o el rea o parte del programa en el que se reconoce o
dentro de la cual es accesible, es decir, en qu parte del programa de una variable
est activa. Un aspecto importante del diseo del programa es determinar el alcance
de las variables.
El mbito de las variables pueden ser de dos tipos:
Variable global
Variable local
El esqueleto a continuacin explica el alcance de las variables.
V$&i$b)e% 2)ob$)e%
Muchas veces el usuario quiere acceder a la variable en cualquier parte del
programa,(desde el main o desde cualquier funcin), entonces es necesario el uso
de variables globales. Las variables globales son accesibles en cualquier parte del
programa, es decir, su mbito es todo el programa, se crean cuando se inicia un
programa de ejecucin y se destruyen cuando un programa completa su ejecucin.
Se declaran por encima de la funcin main (). Cualquier cambio que se hizo con el
valor de la variable global se refleja en todas las funciones cuando se utiliza con
independencia, en funcin de que el cambio tiene lugar.
Ejecute el siguiente programa para ver su aplicacin
#include<stdio.h>
int gvar;
main()
{
gvar = 5;
printf("\ngvar = %d,gvar);
inc();
inc();
dec();
dec();
}
inc()
{
gvar++;
printf("\n on incrementing gvar = %d\n,gvar);
}
dec()
{
gvar--;
printf("\n on decrementing gvar = %d \n, gvar);}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg#.
En el programa anterior, 'gvar' variable global se declara por encima de main (). Dos
funciones inc () y dec () se definen en el programa. Ya que, "gvar 'es una variable
global que puede ser accesible en todas las tres funciones main (), inc () y dec ().
A&20'ento% o ($&L'et&o%
Las funciones pueden comunicarse unas con otras, lo que significa que la funcin
de llamada puede pasar la informacin a la funcin llamada. La informacin se pasa
a la funcin a travs de argumentos o parmetros. Una funcin llamante puede
enviar un paquete de valores para la funcin de llamada para operar o para controlar
la forma en operacin. Cuando la funcin llamante , enva la informacin se llama
como el argumento o el paso de parmetros. Note que la segunda lnea define el
uso de la funcin .
Veamos el siguiente cdigo:
#include<stdio.h>
void display(int); <-------------prototipo de la funcin
main()
{
int num=50;
clrscr();
printf("Passing a constant integer");
display(50);
printf("\nPassing content of variable");
display(num);
printf("\nPassing the value of an expression");
display(num*5-3);
}
void display(int val) <------
{ |--- cuerpo de la funcin
printf(" %d", val); |
} <-----+
#include<stdio.h>
main()
{
int num;
printf("Enter any number: );
scanf("%d,&num);
square(num);
}
square(int n)
{
int sq;
sq = n*n;
printf("Square of %d is %d\n, n, sq);
}
A&20'ento% &e$)e% < 1o&'$)es
Los argumentos reales: Cuando una funcin que llama pasa la informacin a la
funcin llamada, la informacin que se conoce como argumentos reales o
parmetros. Argumento real o parmetros se pasan de la funcin que llama a la
funcin llamada.
Los argumentos formales: Argumentos formales son los parmetros declarados en
los soportes en la definicin de la funcin despus del nombre de la funcin.
El tipo de datos de los argumentos formales debe ser igual a la de los argumentos
actuales y tambin debe estar en la misma forma que en la declaracin de la
funcin.
Lo% %i20iente% (0nto% deben %e& con%ide&$do% d0&$nte e) ($%o de $&20'ento%8
El nmero de argumentos reales y formales debe ser el mismo.
Tipo de datos de argumentos reales y formales debe ser el mismo.
Secuencia de argumentos reales y formales debe ser el mismo.
El siguiente programa permite convertir de minsculas a maysculas:
# include<stdio.h>
void lower_upper(char);
main()
{
char lower;
printf("Enter a lower case character: );
scanf("%c,&lower); /*actual argument*/
lower_upper(lower);
}

void lower_upper(char c1)
{
char upper;
upper=(c1 >= 'a' && c1 <= 'z' ) ? ('A' + c1 'a') : c1;
printf("Upper case character is %c,upper);
}
PASAR MAS DE UN ARGUMENTO
Ms de un valor puede ser pasado a una funcin como argumento, pero el nmero
y tipo de argumentos reales debe ser igual al nmero y tipo de argumentos formales
y tambin deben estar en la misma secuencia.
#include<stdio.h>
void largest (int , int);
main()
{
int num1,num2;
printf(" two numbers\n");
scanf("%d%d",&num1,&num2);
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg#'
largest(num1,num2);
}
void largest(int n1 ,int n2)
{
if(n1 > n2)
printf("%d is largest\n", n1);
else
printf("%d is largest\n", n2);
}
V$)o&e% Reto&n$do%
A travs de los valores de los parmetros pasados a la funcin, la funcin puede
realizar operaciones en esos valores y puede dar el valor procesado a la funcin
que llama mediante sentencia de retorno. Hay comunicacin de dos vas, funcin
que es llamada indica los valores a la funcin llamada a travs de argumentos y la
funcin llamada a cambio puede retornar un valor a la funcin que la llam.
Nota: Siempre hay un valor de retorno nico de la funcin.
#include<stdio.h>
main()
{
int num1,num2,prod;
printf("Enter two integers\n);
scanf("%d%d,&num1,&num2);
prod=product(num1,num2);
printf("%d * %d = %d\n,num1,num2,prod);
}
product(int n1,int n2)
{
return(n1 * n2);
}
PROTIPO DE LA 5UNCIN
Siempre que una funcin es llamada, el compilador dar por hecho que esta funcin
devuelve un valor de tipo int. Si queremos una funcin retorne un valor que no sea
un entero, entonces es necesario mencionar explcitamente
Como se ha mencionado el retorno de la funcin es siempre a travs de instruccin
de return. Por default se asume que el retorno es un tipo entero. Sin embargo es
buena prctica mencionarlo . En caso de que sea otro tipo distinto a un entero hay
que mencionarlo explicitamente . Ejemplo
rutina1( int entero1 , char caracter1) ; retorno implicito entero
float rutina2 ( int entero2 , char caracter2) :
A continuacin un ejemplo retornando un tipo float:
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg##
#include<stdio.h>
main()
{
float square(float); /* Function Declaration */
float a,b;
printf("Enter any number\n);
scanf("%f,&a);
b=square(a);
printf("Square of %.2f is %.2f \n,a,b);
}
float square(float x)
{
float y;
y=x*x;
return(y);
}
Otra forma de calcular el factorial usando funciones :
#include<stdio.h>
long factorial(int n);
main()
{
long int fact;
int num;
clrscr();
printf("Enter any positive integer:");
scanf("%d",&num);
fact = factorial(num);
printf("Factorial of %d is %ld",num,fact);
}
long factorial(int n)
{
long f=1;
while(n > 1)
{
f=f * n;
n--;
}
return (f);
}
RECURSVDAD
La recursividad es un proceso mediante el cual una funcin se llama repetidamente
a si misma , hasta que una condicin especificada se ha cumplido. El proceso se
utiliza para el clculo repetitivo en el que se afirma cada accin en trminos de un
resultado anterior.
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg#*
Con el fin de resolver un problema de forma recursiva, dos condiciones deben ser
satisfechas.
Debe haber algunos criterios, denominados criterios de base, para detener la
repeticin.
Cada vez que la funcin de llamar a s mismo, debe estar ms cerca de los
criterios de base.
Veamos el siguiente programa
#include<stdio.h>
main()
{
int n,fact;
printf("Enter an interger\n);
scanf("%d,&n);
fact=factorial(n);
printf("Factorial of %d is %d\n,n,fact);
}
factorial( int m)
{
if(m<=1)
return(1);
else
return(m*factorial(m-1));
}
&ibrerias 1e 9:nciones ;
Ya he mencionado que el compilador viene con una amplia gama de funciones
estndar que se declaran en los archivos de cabecera, a veces llamados archivos de
include. Estos representan una rica fuente de ayuda para usted cuando usted est
desarrollando sus propias aplicaciones. Ya hemos usado algunos de ellos, porque
los archivos de cabecera son un componente fundamental de la programacin en C.
Adicionalmente a las funciones propias del lenguaje es comn encontrar que
desarrolladores de software crean sus propias libreras, como por ejemplo Microsoft.
A continuacin las libreras standard de C:
C$bece&$ 50ncion$)id$d
<stdio.h> Entrada y salida
<stdarg.h>
Macros que soportar funciones con un numero
variable de parmetros
<math.h> Matemticas y punto flotante
<stdlib.h> Funciones de alocacin de memoria
<string.h> Funciones de tiras de caracteres (strings)
<stdbool.h> Tipos booleanos true/false
<complex.h> Soporte de operacin con nmeros complejos
<ctype.h> Funciones de clasificacin de caracteres
<wctype.h> Funciones de conversin de caracteres
Todos los archivos de cabecera de la tabla anterior contienen las declaraciones de
una serie de funciones, as como las definiciones de las diversas constantes. Son
todas las bibliotecas de la SO / EC estndar, por lo que todos los compiladores que
sigan los estndares debern proporcionar al menos el conjunto bsico de
funciones, pero por lo general van a proporcionar mucho ms.
Por otro lado , ANS C (tambin conocida como SO) define una librera un poco
ms extensa que incluye adems de las anteriores a:
C$bece&$ 50ncion$)id$d
<assert.h> Diagnostica estado de variables
<errno.h> Manejo de errores
<float.h> mplementacin de lmites de puntos flotantes
<limits.h> mplementacin de limites definidos
<locale.h> Manejo de variables de localizacin
<setjmp.h> Ejecucin de saltos no locales
<signal.h> Manejo de seales
<stddef.h> Definiciones globales como null , size_t etc.
<time.h> Manejo de variable tipo fecha y hora

Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg*4
Objeto% de )$ )ib&e&7$ %tdio
Las funciones declaradas en stdio.h pueden clasificarse en dos categoras:
funciones de manipulacin de ficheros y funciones de manipulacin de entradas y
salidas.
Nombre Descripci<n
9:nciones 1e manip:laci<n 1e archi4os
fclose
Cierra >n arc:iKo a =raKLs de s> p>n=ero.
fopen,
freopen,
fdopen
ABre >n arc:iKo para lec=>ra, para escri=>raHreescri=>ra o para adicin.
remove
Elimina >n arc:iKo.
rename
CamBia al arc:iKo de nomBre.
rewind
Coloca el indicador de posicin de arc:iKo para el s=ream ap>n=ado por
s=ream al comienAo del arc:iKo.
tmpfile
Crea ? aBre >n arc:iKo =emporal M>e es Borrado c>ando cerramos con la
f>ncin fclose().
9:nciones 1e manip:laci<n 1e entra1as 3 sali1as.
clearerr
espeCa los indicadores de final de arc:iKo ? de posicin de arc:iKo para el
s=ream ap>n=ado por s=ream al comienAo del arc:iKo.
feof
Compr>eBa el indicador de final de arc:iKo.
ferror
Compr>eBa el indicador de errores.
fflush
Si s=ream ap>n=a a >n stream de salida o de ac=>aliAacin c>?a operacin ms
recien=e no era de en=rada, la f>ncin fflush enK<a c>alM>ier da=o aNn sin
escriBir al en=orno local o a ser escri=o en el arc:iKoO si no, en=onces el
compor=amien=o no es= definido. Si s=ream es >n p>n=ero n>lo, la f>ncin
ffl>s: realiAa el despeCe para =odos los streams c>?o compor=amien=o es=
descri=o an=eriormen=e.
fgetpos
eK>elKe la posicin ac=>al del arc:iKo.
fgetc
eK>elKe >n carc=er de >n arc:iKo.
fgets
Consig>e >na cadena de carac=eres de >n arc:iKo.
fputc
EscriBe >n carc=er en >n arc:iKo.
fputs
EscriBe >na cadena de carac=eres en >n arc:iKo.
ftell
eK>elKe la posicin ac=>al del arc:iKo como nNmero de B?=es.
fseek
Si=Na el p>n=ero de >n arc:iKo en >na posicin alea=oria.
fsetpos
CamBia la posicin ac=>al de >n arc:iKo.
fread
lee diferen=es =amaPos de da=os de >n arc:iKo.
fwrite
EnK<a, desde el arra? ap>n=ado por p>n=ero, :as=a nmemb de elemen=os c>?o
=amaPo es especificado por =amaPo. El indicador de posicin de arc:iKos es
aKanAado por el nNmero de carac=eres escri=os correc=amen=e. Si eQis=e >n
error, el Kalor res>l=an=e del indicador de posicin de arc:iKos es
inde=erminado.
getc
eK>elKe >n carc=er desde >n arc:iKo.
getchar
Ig>al M>e getc.
gets
"ee carac=eres de en=rada :as=a M>e enc>en=ra >n sal=o de l<nea, ? los
almacena en >n Nnico arg>men=o.
printf,
fprintf,
sprintf
snprintf
!sados para imprimir salidas de da=os.
vprintf
TamBiLn >=iliAado para imprimir salidas.
perror
EscriBe >n mensaCe de error a s=derr.
putc
eK>elKe >n carc=er de >n arc:iKo.
putchar,
fputchar
Ig>al M>e p>=c7s=do>=8.
scanf,
fscanf,
sscanf
!=iliAado para in=rod>cir en=radas.
vfscanf,
vscanf,
vsscanf
TamBiLn >=iliAado para in=rod>cir en=radas.
setbuf
Es=a f>ncin es eM>iKalen=e a la f>ncin se=KB>f pasando los Kalores RIO1B1
para modo ? B!1SIE para =amaPo, o 7si ac>m>lador es >n p>n=ero n>lo8, con
el Kalor RIONB1 para modo.
setvbuf
Slo p>ede ser >sada desp>Ls de M>e el s=ream ap>n=ado por s=ream :a sido
asociado con >n arc:iKo aBier=o ? an=es de o=ra operacin c>alM>iera es
lleKada acaBo al s=ream. El arg>men=o modo de=ermina cmo s=ream ser
almacenado segNn lo sig>ien=e: RIO1B1 ocasiona la en=radaHsalida a ser
comple=amen=e almacenadoO RIO"B1 ocasiona la en=radaHsalida a almacenar
por l<neasO RIONB1 ocasiona la en=radaHsalida a no ser almacenado. Si
ac>m>lador no es >n p>n=ero n>lo, el arra? al M>e es ap>n=ado p>ede ser
>sado en KeA de la ac>m>lacin adC>dicada por la f>ncin se=KB>f. El
arg>men=o =amaPo especifica el =amaPo del arra?.
tmpnam
&enera >na cadena de carac=eres M>e es >n nomBre Klido para arc:iKos ? M>e
no es ig>al al nomBre de >n arc:iKo eQis=en=e. "a f>ncin =mpnam genera >na
cadena diferen=e cada KeA M>e es llamada, :as=a >n mQimo de TMPRMA3
Keces. Si la f>ncin es llamada ms Keces M>e TMPRMA3, en=onces el
compor=amien=o de la f>ncin es= definido segNn la implemen=acin del
compilador.
ungetc
puts
Imprime >na de cadena de carac=eres.
Constantes miembro
"as cons=an=es definidas en la caBecera stdio.h son:
Nombre Descripci<n
EOF En=ero nega=iKo 7int8 >sado para indicar Sfin 1e ficheroS.
BUFSI En=ero M>e indica el =amaPo del B>ffer >=iliAado por la f>ncin setbuf!".
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg*/
FI#E$%&E'&
%(
TamaPo mQimo de la cadena de carac=eres M>e con=ienen el nomBre de >n
fic:ero para ser aBier=o
FO)E$'&%(
NNmero mQimo de fic:eros M>e p>eden es=ar aBier=os sim>l=neamen=e.
'IOFBF
ABreKia=>ra de input/output fully buffered 7B>ffer en=radaHsalida =o=almen=e
lleno8O es >n en=ero M>e se p>ede pasar como parme=ro de la f>ncin
setvbuf!" para reM>erir bloqueo del buffer en la en=rada ? salida del
s=ream aBier=o.
'IO#BF
ABreKia=>ra de input/output line buffered 7...TT8O es >n en=ero M>e se p>ede
pasar como parame=ro a la f>ncin setvbuf!" para reM>erir line buffered
(??) en la en=rada ? salida del s=ream aBier=o.
'IO$BF
ABreKia=>ra de Sinp>=Ho>=p>= no= B>fferedS 7en=radaHsalida sin B>ffer8O es >n
en=ero M>e se p>ede pasar como parame=ro a la f>ncin setvbuf!" para
reM>erir M>e la en=rada salida del s=ream aBier=o f>ncione sin B>ffer.
#'tmpnam
TamaPo de la cadena de carac=res con la longi=>d s>ficien=e para almacenar
>n nomBre de fic:ero =emporal generado por la f>ncin tmpnam!".
$U##
Macro M>e represen=a la cons=an=e p>n=ero n>loO represen=a >n Kalor de
p>n=ero M>e no ap>n=a a ning>na direccin Klida de oBCe=o alg>no en
memoria.
SEE*'+U,
En=ero M>e se p>ede pasar como parme=ro a la f>ncin fseek!" para
indicar posicionamien=o rela=iKo a la posicin ac=>al del fic:ero.
SEE*'E$-
indicar posicionamien=o rela=iKo al final del fic:ero.
SEE*'SE.
indicar posicionamien=o rela=iKo al inicio del fic:ero.
.&)'&%(
El nNmero mQimo de nomBres de fic:eros Nnicos generaBles por la f>ncin
tmpnam!".
Objeto% de )$ )ib&e&7$% '$t;
Nombre Descripci<n
acos
arcocoseno
asin
arcoseno
atan
arco=angen=e
atan/
arco=angen=e de dos parme=ros
ceil
menor en=ero no menor M>e el parme=ro
cos
coseno
cosh
coseno :iperBlico
e0p!double 0"
f>ncin eQponencial, comp>=a e
x
abs
Kalor aBsol>=o
floor
ma?or en=ero no ma?or M>e el parme=ro
fmod
resid>o de la diKision de flo=an=es
fre0p
fracciona ? eleKa al c>adrado.
lde0p
=amaPo del eQponen=e de >n Kalor en p>n=o flo=an=e
log
logari=mo na=>ral
log12
logari=mo en Base 14
modf
oB=iene >n Kalor en p>n=o flo=an=e <n=egro ? en par=es
pow!0,3"
eleKa >n Kalor dado a >n eQponen=e, x
y
sin
seno
sinh
seno :iperBlico
s4rt
ra<A c>adrada
tan
=angen=e
tanh
=angen=e :iperBlica
Algunos ejemplos:
#include <stdio.h>
#include <math.h>
main()
{
float result;
float x = 0.5;
result = cos(x);
printf("The cosine of %f is %f \n, x,
result);
}
#include <stdio.h>
#include <math.h>
main()
{
float result;
float x = 4.0;
result = exp(x);
printf("'e' raised to the power of %f
(e ^ %f ) = %f\n, x, x, result);
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg*.
#include <stdio.h>
#include <math.h>
main()
{
float x = 2.0, y = 3.0;
printf("%f raised to %f is %f \n, x, y,
pow(x, y));
}
#include <stdio.h>
#include <math.h>
main()
{
float result, x;
x = 0.5;
result = tan(x);
printf("The tan of %f is %f \n, x,
result);
}
Objeto% de )$ Lib&e&7$ %td)ib8;
"as f>nciones M>e per=enencen a stdlib.h p>eden clasificarse en las sig>ien=es ca=egor<as:
conKersin, memoria, con=rol de procesos, ordenacin ? BNsM>eda, ma=em=icas.
Nombre Descripci<n
Con4ersi<n 1e tipos
atof 7ascii to float8 cadena de carac=eres a coma flo=an=e
atoi 7ascii to integer8 cadena de carac=eres a en=ero
atol !+ Standard #ibrar3"55
7ascii to long8
cadena de carac=eres a en=ero =amaPo largo
strtod 7string to double8 cadena de carac=eres a coma flo=an=e =amaPo doBle
strtol 7string to long8 cadena de carac=eres a en=ero largo
strtoul 7string to unsigned long8
cadena de carac=eres a en=ero largo sin signo
7posi=iKo8
/eneraci<n 1e n=meros pse:1o>aleatorios
rand
&enera >n nNmero pse>doFalea=orio
srand
Es=aBlece la semilla para el generador de nNmeros
pse>doFalea=orios
/esti<n 1e memoria 1in?mica
malloc, calloc, realloc
$eserKan memoria dinmica del :eap 7montn o
montculo8
free
"iBeran memoria deKolKiLndola al heap
Control 1e procesos
abort
=erminar eCec>cin anormalmen=e
ate0it
regis=rar >na f>ncin callBacJ para la salida del
programa
e0it !operating s3stem"
=erminar eCec>cin del programa
getenv
rec>perar >na KariaBle de en=orno
s3stem !+ Standard #ibrar3"
eCec>=ar >n comando eQ=erno
$r1enaci<n 3 b=s@:e1a
bsearch
BNsM>eda Binaria en >n arra?
4sort !+ Standard #ibrar3"
ordena >n Kec=or 7inform=ica8 >sando ;>icJsor=
%atem?ticas
abs, labs
Kalor aBsol>=o
div, ldiv
diKisin en=era o e>clidiana
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg*'
Objeto% de )$ Lib&e&7$ St&in28;
Esta librera contiene varias funciones para trabajar con tiras de caracteres. Las
funciones mas importantes son:
Varios ejemplos se presentan en la seccin de strings
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg*#
strcpy( s, const ct); Copia un string a otro
strncpy( s, const ct, int n); Copia un string a otro pero desde cierta posicin
strcat( s, const ct); Concatena dos strings
strncat( s, const ct, int n); Concatena dos strings pero desde cierta posicion
strcmp(const cs, const ct); Compara dos strings
strncmp(const cs, const ct, int n); Compara dos Strings perop desde cierta posicin
strchr(const cs, int c); REtorna un pointer a la primera ocurencia de c
strrchr(const cs, int c); Retorna un pointer a la ultima ocurrencia de c
strspn(const cs, const ct); Retorna la longitud del prefijo de ct en cs
strcspn(const cs, const ct); Retorna la longitud del prejijo de cs no contenido en ct
strpbrk(const cs, const ct); Retorna la primera ocurencia de cualquiert caracter en ct en cs o nulo si no lo encuentra
strstr(const cs, const ct); Retorna el primera ocurencia de ct en cs
strlen(const cs); Calcula la longitud de un string
MMS SO!RE VARIA!LES
V$&i$b)e Loc$)e%
Cuando las variables se declaran dentro de una funcin en particular vienen a ser
una clase de almacenamiento automtico. Tambin se le llama clase predeterminada
de almacenamiento, es decir, cuando se declara una variable dentro de cualquier
funcin sin ningn tipo de especificacin de la clase de almacenamiento por defecto
asume como variable automtica.
Sus caractersticas son:
Alcance: Tener mbito local, es decir, el alcance se limita a la funcin en la
que se declaran.
Visibilidad : Solo en la funcin en la que se declaran.
Tiempo de Vida : gual a la vida de la funcin, las variables se crean
automticamente cuando el control pasa a la funcin en que estas variables
se declaran y variables automticas son destruidas tan pronto como la
ejecucin de esa funcin se ha completado.
Valor inicial : No esta definido , puede ser basura
#include<stdio.h>
main()
{
int i,val;
for(i=1;i<=10;i++)
{
val=funct(i);
printf("%5d%5d\n,i,val);
}
}
funct(int x)
{
int sum=100;
sum+=x;
return(sum);
}
En el programa anterior la variable sum es creada cada vez que la funcin funct es
llamada.
V$&i$b)e de Re2i%t&o
La clase de registro de almacenamiento es igual a la anterior , las acciones de
todas sus caractersticas con la clase de almacenamiento auto, excepto que en lugar
de almacenar las variables en la memoria RAM, que se almacenan en los registros
internos de la CPU. Las otras caractersticas son:
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg**
Alcance: Tener mbito local, es decir, el alcance se limita a la funcin en la
que se declaran. Slo es visible a la funcin en la que se declaran.
Vida: La vida de estas variables es igual a la duracin de la funcin en la que
se declaran.
Almacenamiento: Las variables de registro de obtener almacenamiento en el
interior del registro interno del CPU.
Valor por defecto : No especificado puede ser basura.
Nota referirse al captulo 1 sobre el uso de registros
V$&i$b)e% E%tLtic$%
El valor de la variable esttica persiste hasta el final del programa. El alcance de la
variable esttica puede ser local o global. Depende de si la declaracin esttica se
da fuera de todas las funciones (incluida el main()), o dentro de una funcin
particular. Las variables internas estticas permanecen vivos hasta el final del
programa. Las caractersticas son las siguientes:
mbito de aplicacin: Su alcance puede ser local o global.
Vida: La vida de las variables estticas es igual al tiempo de vida del
programa ( no de la funcin). Las variables estticas conservan su valor
durante la ejecucin del programa. Si la misma funcin que se llama varias
veces, el valor de la variable esttica se mantiene, esta propiedad es muy til
para resolver problemas recurrentes.
Almacenamiento: Las variables estticas obtener almacenamiento en el
interior de la memoria principal (RAM).
Valor inicial por defecto: valor inicial por defecto de las variables estticas es
basura.
#include<stdio.h>
main()
{
int i;
for(i=1;i<=5;i++)
{example();}
}
example()
{
%t$tic int sum=10;
int sum1 =20;
sum+=10;
sum1+=10;
printf("sum=%d\t, sum1=%d,sum,sum1);
}
Est claro que significa que la variable sum esttica se conserva (es decir, se
mantiene activo), aun cuando la funcin ejemplo () termina. En contraste con la
prdida automtica de las variables auto y register su valor despus de cada salida
de la funcin. Tambin significa que la instruccin de inicializacin al comienzo de la
funcin ejemplo () . En otras palabras, las variables estticas se inicializan una sola
vez durante el tiempo de compilacin.
Tenga en cuenta que las variables locales estticas son similares a las variables
automticas, salvo que conservan su valor permanente para toda la duracin de la
ejecucin del programa.
V$&i$b)e% E.te&n$%
Las variables externas son las variables que se declaran fuera de toda funcin,
incluida la funcin main (). Generalmente estas variables se declaran antes de main
(). Las caractersticas de las variables externas son las siguientes:
Alcance: El alcance es global, es decir, son accesibles a travs del programa
como variables estticas, pero la principal diferencia entre esttica variables
globales y las variables externas es que las variables globales son estticas
globales para programa nico en el que se han declarado, mientras que las
variables externas son globales a dos o ms se unieron a los archivos de
programas, es decir, de varios archivos.
Vida: La vida de las variables externas es igual a la duracin del programa.
Almacenamiento: Las variables estticas obtener almacenamiento en el
interior de la memoria principal (RAM)
Valor inicial por defecto: El valor por defecto inicial de las variables externas
es cero.
#include<stdio.h>
int i; /* Declaracin de variable externa */
main()
{
printf("\n i=%d,i);
inc();
inc();
dec();
dec();
}
inc()
{
i=i+1;
printf("\n on incrementing i = %d\n,i);
}
dec()
{
i=i-1;
printf("\n on decrementing i = %d\n,i);
}
En el programa anterior, la variable externa 'i' se declara por encima de main ().
Cualquier modificacin en el valor de lo externo se refleja en todas las funciones con
independencia, en funcin de que el cambio tiene lugar.
TIRAS DE CARACTERES "St&in2%#
Para representar una tira de caracteres C no posee una clase nativa que pueda
usarse , en su lugar stos deben manipularse ya sea usando arreglos de caracteres
o funciones de libreras externas que proveen funciones para manipularlas.
Por ejemplo , cuando el compilador ve una constante cuyo contenido es "Hola ste
almacena la secuencia de caracteres en memoria terminados por un nulo (\0), y los
caracteres individuales pueden ser accesados mediante el indice de una matriz.
Para definir una matriz usaremos los corchetes de la siguiente forma:
char pala$ra@AB '
pala$ra@CB %DED'
pala$ra@3B %D7D'
pala$ra@4B %DFD'
pala$ra@<B %D)D'
pala$ra@GB %DHCD'
for (int i%C' i<I'i..) printf(J5cK,pala$ra@iB)'
El programa anterior imprimir "Hola.
Otras formas alternativas de inicializar un arreglo de caracteres son las siguientes:
char name1[ ] = {'S','N','E','H','A'};
char name2[ ] = {{'A'},{'P'},{'U'},{'R'},{'V'},{'A'}};
char name3[ ] = "KALYAN;
En la primera declaracin, la cadena se asigna a la matriz de caracteres, se incluye
el carcter entre comillas simples y estos entre llaves. En la segunda declaracin,
la cadena se asigna al conjunto de caracteres, por cada carcter se encierra entre
comillas simples y llaves y una llave general. Cada char de la cadena ocupa un
byte de memoria. El ltimo carcter es siempre '\ 0'. No es obligatorio escribir '\ 0' en
la cadena. El compilador automticamente pone '\ 0' al final de la cadena de
caracteres o de cadena. Los caracteres de la cadena se almacenan en posiciones
de memoria contiguas.
Veamos este ejemplo:
#include<stdio.h>
main()
8
char name@ B % J)FF7*+7 (R)L7K'
int i'
-hile (name@iB M% NHCO)
8
printf(J5cK, name@iB)'
i..'
9
9
La especificacin de conversin '% s' se puede utilizar para leer y mostrar conjunto
de caracteres a la vez.
Por ejemplo :
scanf("%s,array);
printf("%s,array);
Si la especificacin de conversin %s se utiliza tanto para la lectura y la impresin
de strings, el nombre de la matriz se utilizar sin el (&) ampersand. (ver ms
adelante punteros).
#include<stdio.h>
main()
8
char arr3@PB % 8N+O,NO,NRO,NI O,N*O,NQO,NHCO9'
char arr4@PB % J+RI*QK'
char arr<@PB % 88N+O9,8NO9,8NRO9,8NI O9,8N*O9,8NQO9,8NHCO99'
printf(JHn)rra!3 % 5sK,arr3)'
printf(JHn)rra!4 % 5sK,arr4)'
printf(JHn)rra!< % 5sK,arr<)'
9
include<stdio.h>
main()
8
char name@4CB'
printf(JIn0rese su nom$re: K)'
scanf(J5sK,name)'
printf(J+u nom$re es: 5sK, name)'
9
El siguiente programa permite manipular el string con la llamada getche()
#include<stdio.h>
#include<conio.h>
main()
8
char te&t@ICB'
int i,ch'
clrscr()'
printf(JIn0rese un strin0 :K)'
ch % 0etche()'
i%C'
-hile(chM%NHrO)
8
te&t@iB%ch'
i..'
ch%0etche()'
9
te&t@iB%NHCO'
printf(JHn strin0 in0resado es Hn 5sK , te&t )'
9
St&in2% < C$&$cte&e%
Como hemos visto C se apoya en los arreglos para crear tiras de caracteres , sin
embargo debemos tener en cuenta que las tiras de caracteres deben ser terminadas
en un carcter nulo a fin de poder trabajar correctamente. La primera
consecuencia de esto se puede observar en el tamao que ocurran un carcter y
un string de un carcter:
char ch = 'x'; // 1 byte reservado
char str[] = "x"; //2 bytes reservados
Aunque las variables ch y str representan el mismo carcter el tamao de las dos
no es igual .
Otra consecuencia es que si no controlamos la terminacin del string podriamos
tener el despliegue de basura en la pantalla .Veamos el siguiente programa:
#include<stdio.h>
#include<conio.h>
void main()
8
char str@B%8DmD,DoD,DhD,DaD,DnD9'
clrscr()'
printf(2Eello 5sHn2,str)'
0etch()'
9
+alida:
Eello mohanR
S
(Tasura)
50ncione% con St&in2%
gets() y puts()
gets () se utiliza para leer una cadena incluyendo espacios en blanco incrustados en
una matriz de caracteres, y puts() se utiliza para mostrar la cadena completa en la
pantalla.
#include <stdio.h>
main()
8
char strin0@UCB'
printf(JIn0rese un strin0:K)'
0ets(strin0)'
printf(JFa cadena in0resada es : 5sHnK, strin0)'
9
#include <stdio.h>
main()
8
char strin0@B % J#1emplo de asi0nacion de un strin0HnK'
puts(strin0)'
9
main()
8
char strin03@3CB'
int si=e,i'
printf(J#ntre una pala$ra de V chars:HnK)'
scanf(J5sK,strin03)'
printf(J#l strin0 3 es : 5sK,strin03)'
for(si=e%C'strin03@si=eBM%OHCO' si=e..)'
printf(JHn#l strin0 al reves es :HnK)'
for(i% si=e/3'i>%C'i//)
printf(J5cK,strin03@iB)'
9
Funciones Relacionadas a Strings
En C hay una serie de funciones estndar de manipulacin de cadenas disponibles
que forman parte del archivo de cabecera <strin0.h>. Las siguientes son las
funciones ms utilizadas.
%t&c(<"#
Copia la cadena desde el origen al destino. Esta funcin copia el contenido de una
cadena a otra. Copia de la cadena significa copiar los elementos de una matriz a
otra. El formato general de strcpy () es:
%t&c(< "c$den$ 1in$)+ %e&ieG10ente#D
#include<stdio.h>
#include<strin0.h>
main()
8
char str3@3CB, str4@3CB'
printf(JIn0rese un strin0: HnK)'
0ets(str3)'
strcp!(str4,str3)'
printf(J+trin0 ori0inal : HnK)'
puts(str3)'
printf(J+trin0 final : HnK)'
puts(str4)'
9
%t&nc(< "#
Es similar a strcpy (), excepto que copia un nmero de caracteres de origen a
destino. El formato general de strcnpy () es:
%t&nc(< "'et$G%ec0enci$+ %e&ieG10ente+ n#D
#include<stdio.h>
#include<strin0.h>
main()
8
char +3@3CB,+4@3CB'
printf(J#nter an! strin0: HnK)'
0ets(+3)'
strncp!(+4,+3,G)' WX copia G chars del +3 al +4 XW
strcpy() strcmp()
strncpy() strncmp()
strlen() strcmpi()
strupr() strncmpi()
strlwr() strset()
strrev() strnset()
strcat() strspn()
strncat()
+4@IB%OHCO'
printf(J7ri0inal: 5sHnK,+3)'
printf(J,opiada: 5sHnK,+4)'
9
%t&0(& "#
Esta funcin se utiliza para convertir cualquier caracter de la cadena a maysculas.
Cuando alguna cadena se pasa a esta funcin como un argumento convierte las
letras minsculas a maysculas. El formato general de strupr () es:
strupr(string)
#include<stdio.h>
#include<strin0.h>
main()
8
char str@3CB'
printf(J#nter an! strin0:HnK)'
0ets(str)'
printf(J)ntes strupr(): 5sHnK,str)'
strupr(str)'
printf(JLespues strupr(): 5sHnK,str)'
9
%t&)F& "#
Esta funcin se utiliza para convertir cualquier cadena en minsculas. Cuando algn
carcter de la cadena que se pasa como argumento es mayscula ser convertido
a minsculas. El formato general de strlwr () es:
strlwr (cadena);
#include<stdio.h>
#include<strin0.h>
main()
8
char str@3CB'
0ets(str)'
printf(J)ntes strl-r(): 5sHnK,str)'
strl-r(str)'
printf(JLespues strl-r(): 5sHnK,str)'
9
%t&&e"#
La funcion strrev() reordena los caracteres de la cadena , colocando los mismos
en orden inverso .El format de funcin es :
strrev(string);
#include<stdio.h>
#include<strin0.h>
main()
8
char str@3CB'
0ets(str)'
printf(J)ntes strrev(): 5sHnK,str)'
strrev(str)'
printf(JLespues strrev(): 5sHnK,str)'
9
%t&c$t "# < %t&nc$t "#
Las funciones strcat () y strncat () se utilizan para concatenar dos cadenas
diferentes. La diferencia entre strcat () y strncat () es strncat () slo se copia un
nmero especificado de caracteres, mientras que strcat () copia la cadena entera. El
formato general de strcat () y strncat () es:
strcat (string final , string fuente);
strncat (string final , string fuente,
#include<stdio.h>
#include<string.h>
main()
8
char +3@4IB,+4@4IB,+<@4IB,+G@4IB'
printf(J#nter first strin0: K)'
0ets(+3)'
printf(J#nter second strin0: K)'
0ets(+4)'
strcp!(+<,+3)'
strcat(+<,K J)'
strcat(+<,+4)'
printf(Jercer strin0 is: 5sHnK,+<)'
strcp!(+G,K&&&&&&& K)'
strncat(+G,+4,P)'
printf(J,uarto strin0 is: 5sHnK,+G)'
9
%t&c'( "#
Esta funcin se utiliza para comparar dos cadenas. Cuando dos cadenas se pasan
como argumento a esta funcin, se realiza la comparacin de cadenas que
comienzan con el primer carcter de ambos . La comparacin contina hasta que un
carcter diferente, o llega al final de cualquier cadena. La funcin devuelve cero si
las dos cadenas son iguales y si no se devuelve la diferencia numrica entre los
valores ASC de caracteres no coincidentes. Se comparan los strings con
maysculas y minsculas. El formato general de strcmp () es:
strcmp (cadena1, cadena2);
#include<stdio.h>
#include<string.h>
main()
{
char S1[10],S2[10];
int len;
printf("Entre string 1:\n);
gets(S1);
printf("Entre string 2: \n);
gets(S2);
len=strcmp(S2,S1);
if(len>0)
printf("String 2 es mayor que string 1\n);
if(len<0)
printf("String 2 ies menor que string 1\n);
if(len= =0)
printf("Strings iguales\n);
}
%t&nc'( "#
Se realiza la misma tarea que strcmp (), pero se utiliza para comparar slo los n
caracteres de la primera cadena con la segunda . Se comparan los strings con
maysculas y minsculas. El formato general de strncmp () es:
strncmp (cadena1, cadena2, n);
#include<stdio.h>
#include<strin0.h>
main()
8
char +3@3CB,+4@3CB'
int len'
printf(J#ntre strin0 3:HnK)'
0ets(+3)'
printf(J#ntre strin0 4: HnK)'
0ets(+4)'
len%strncmp(+4,+3,<)'
if(len>C)
printf(J+trin0 4 ma!or Yue strin0 3HnK)'
if(len<C)
printf(J+trin0 4 menor Yue strin0 3HnK)'
if(len%%C)
printf(J+trin0s i0ualesHnK)'
9
%t&c'(i "#
Es similar a strcmp () excepto que se utiliza para comparar cadenas sin maysculas
y minsculas, es decir, no toma en cuenta si los caracteres son maysculas o
minsculas. El formato general de strcmpi () es:
strcmpi (cadena1, cadena2);
#include<stdio.h>
#include<strin0.h>
main()
8
char +3@3CB,+4@3CB'
int len'
printf(J#nter strin0 3: HnK)'
0ets(+3)'
printf(J#nter strin0 4: HnK)'
0ets(+4)'
len%strcmpi(+4,+3)'
if(len>C)
printf(J+trin0 4 ima!or Y strin0 3HnK)'
if(len<C)
printf(J+trin0 4 menor Y strin0 3HnK)'
if(len% %C)
printf(J+trin0s % HnK)'
9
%t&nc'(i "#
Es similar a strcmpi (), pero se utiliza para comparar los n caracteres iniciales. El
formato general de strncmpi () es:
strncmpi (cadena1, cadena2, n);
%t&%et "#
Esta funcin reemplaza todos los caracteres de una cadena con un smbolo
determinado por el programador, es decir, los caracteres de la cadenas se
sustituyen con los argumentos dados por el programador. El formato de la funcin
es:
strset (cadena, smbolo).
#include<stdio.h>
#include<strin0.h>
main()
8
char strin0@3IB'
char s!m$olo'
puts(J#ntre strin0: K)'
0ets(strin0)'
puts(J#ntre s!m$olo : K)'
scanf(J5cK,6s!m$olo)'
printf(J)ntes del strset(): 5sHnK,strin0)'
strset(strin0,s!m$ol)'
printf(JLespues del streset(): 5sHnK,strin0)'
9
%t&n%et "#
Esta funcin es la misma que la de strset (). Aqu la longitud especificada es
siempre. El formato de esta funcin es:
strnset (cadena, smbolo, n),
donde, n es el nmero de caracteres que ser reemplazado
%t&%(n "#
Esta funcin devuelve la posicin de la cadena, desde donde la matriz de origen no
se corresponde con la final . Recuerde la que posicin inicial es nmero 0 ,El
formato de esta funcin es:
strspn (cadena1, cadena2);
#include<stdio.h>
#include<strin0.h>
main()
8
char str3@3CB,str4@3CB'
int len0th'
printf(J#ntre strin0 3: K)'
0ets(str3)'
printf(J#ntre strin0 4: K)'
0ets(str4)'
len0th%strspn(str3,str4)'
printf(JLiferentes desde la 5d posicion .HnK ,len0th)'
9
APUNTADORES
Cuando las variables se declaran al inicio del programa ciertas ubicaciones de
memoria se reservan para su uso , la cantidad de memoria depende del tipo de
dato como hemos visto en el captulo 10. Cada localidad de memoria tiene una
direccin numrica, el programador se refiere a posiciones de memoria por su
nombre, pero el compilador traduce estos nombres en las direcciones, es decir, el
programador se refiere a la ubicacin de la memoria por su nombre mientras que el
compilador con la direccin de memoria. Este proceso es automtico, por lo que el
programador no tiene que preocuparse de eso. En muchas situaciones el usuario
desea hacer referencia a estas direcciones directamente, con el fin de manipular el
contenido de las posiciones de memoria correspondientes.

La pregunta que uno se hace es porque necesitamos saber la direccin de una
variable ? Una de las razones es que las direcciones de memoria son globales para
todas las funciones, mientras que la variable local slo se puede acceder a las
funciones en las que se declaran. Si queremos modificar las variables locales
declaradas en una funcin desde otra funcin, entonces podemos pasar la direccin
de una variable local a otra funcin, y la segunda funcin puede utilizar esta
direccin para modificar el contenido de la primera funcin. Esto es posible porque
las direcciones de memoria son fijas, en caso de que la funcin conozca la direccin
de cualquier variable local de otra funcin podr modificar el valor de la variable . De
ah que la direccin numrica es esencial para la manipulacin.
Uno puede pensar que declarar todas las variables como globales en lugar de
trabajar con las direcciones de variable local. El problema con la variable global, es
que son accesibles a todas las funciones en el programa, si una funcin modifica la
variable global todas las funciones que utilizan la variable global se modifican. El
acceso a la ubicacin de memoria permite abordar slo las funciones para modificar
la variable a la que la direccin de la variable se pasa.
DE5INICIN , USOS DEL PUNTERO
Un puntero es una variable que almacena una direccin de memoria de otra variable
del mismo tipo. Las reglas para nombrar la variable de puntero son los mismos que
nombrar las variables generales y se declara de la misma manera como otras
variables, pero siempre es precedido por operador '*'.
Caractersticas de los punteros
Punteros almacena una direccin o espacio de memoria.
El tiempo de ejecucin con el puntero es ms rpido porque los datos se
accede con la direccin, es decir el acceso directo a posiciones de memoria.
La memoria se accede de manera eficiente con los punteros. El puntero se
asigna espacio de memoria y tambin libera es decir, asignacin dinmica de
memoria.
Los punteros se utilizan en estructuras de datos.
OPERADORES DE PUNTERO
Hay dos operadores asociados con los punteros: el asterisco (*) y ampersand (&).
Un asterisco (*) tiene dos propsitos.
En primer lugar, para declarar la variable puntero. El formato general de la
declaracin de puntero es el siguiente:
tipo de datos % pointer?varia$le,
donde: tipo de datos es el tipo de variable de puntero como integer, float, char, etc
Por ejemplo:
int * ptr;
En la declaracin anterior, "ptr" es una variable puntero del tipo de datos entero que
contiene la direccin de otras variables de tipo entero.
En segundo lugar, para acceder al valor sealado por la variable puntero. En breve
veremos el segundo propsito de asterisco (*).
Cuando un operador de direccin ampersand (&) se usa delante de la variable
devolver la direccin de memoria de esa variable.
Por ejemplo:
int a, * ptr;
ptr = &a;
* ptr = 50;
En las tres declaraciones, la primera declaracin se declaran dos variables de tipo
entero, variable 'a' y la variable de puntero ptr. Ninguna de las dos variables tiene
un valor asignado ya que solo las hemos definido. En la segunda instruccin, la
direccin de la variable 'a' (con '&') se asigna a la variable puntero 'ptr'. Tenga en
cuenta que el '*' de la segunda declaracin no se utiliza antes de "ptr". En la tercera
declaracin, valor 50 se asigna a la posicin de memoria apuntada por ptr es decir,
'a'. Tenga en cuenta que '*' se utiliza antes de "ptr".
La siguiente grfica explica la secuencia de datos:
Veamos en el siguiente programa:
#include <stdio.h>
main()
{
int a,*ptr;
ptr = &a;
*ptr = 50;
printf("Address of a = %u\n,ptr);
printf("Value of a = %d\n,a);
printf("Value of a = %d\n,*ptr);
printf("Value of a=%d\n,*(&a));
}
En el programa anterior tome en cuenta, que la impresin del valor de * y (& a) es lo
mismo que imprimir el valor de 'a'. El u% se usa con printf () para imprimir la
direccin de una variable. La direccin de cualquier variable es un nmero entero.
Dec)$&$ci3n de P0nte&o%
int *iptr;
float *fptr;
char *cptr;
En la primera sentencia "iptr 'es una variable de puntero de enteros y contendr la
direccin de otra variable de tipo entero. De la misma manera "fptr 'es una variable
puntero del float, que almacena la direccin de cualquier variable de tipo float, y
"cptr' es una variable de puntero de caracteres que almacena la direccin de
cualquier variable de caracteres.
El operador de indireccin (*) tambin se llama el operador de de-referencia.
Cuando el puntero se de- referencia, se accede al valor en esa direccin
almacenada por el puntero .
Normalmente cuando referenciamos una variable accedemos a su valor , cuando lo
hacemos a un puntero accedemos al direccin de la variable a la que est
apuntando , no a su valor propio que es una direccin .
El operador de indireccin (*) se utiliza tanto en la declaracin y en la de-
referencia.:
int a,*ptr;
*ptr = 50;
Cuando un puntero se declara, el astersco (*) indica que es un puntero, no una
variable normal.
Cuando el puntero se de-referencia, el operador de indireccin indica que el valor
en esa localidad de memoria almacenada en el puntero se va a acceder y no la
propia direccin.
#include<stdio.h>
main()
{
int num=50,*ptr;
ptr=&num;
printf("Direccion de num = %u\n,&num);
printf("Direccion de num = %u\n,ptr);
printf("Valor de num = %d\n,*ptr);
printf("Direccion del apuntador = %u\n,&ptr);
}
En el programa anterior, dos variables de tipo enteros se declaran, en primer lugar
es "num" y la segunda es la variable puntero 'ptr'. Supongamos que las direcciones
de "num" y "ptr" son 400 y 600. La direccin de "num" se asigna a "ptr". En la
primera instruccin printf (), la direccin de la variable "num" se muestra, es decir
400, ya que, tenemos el & antes de "num". En la segunda sentencia printf (), el
contenido de ptr es decir, 400 se muestra en la pantalla, ('*') no se utiliza antes de
"ptr". En la tercera declaracin printf (), el valor de la direccin de memoria apuntada
por 'ptr' se muestra es decir, 50, ('*') se utiliza antes de "ptr". En la ltima sentencia
printf (), la direccin de "ptr" se muestra, es decir 600.
Analice el siguiente programa
main()
{
int num1=30,*ptr,num2;
ptr=&num1;
num2=*ptr;
*ptr=40;
printf("num1 = %d, *ptr = %d, num2 = %d\n,num1,*ptr,num2);
}
PUNTEROS , 5UNCIONES
Cuando la funcin que llama desea pasar la informacin a la funcin llamada, esto
es posible a travs de parmetros o el paso de argumentos. Hay dos formas de paso
de argumentos a la funcin.
La llamada por valor es decir, valor que pasa de los parmetros o
argumentos
Llamada por referencia que pasa los apuntadores a los argumentos
L$ ))$'$d$ (o& $)o&: En llamada por valor, la funcin llamante enva el contenido
de la variable a la funcin llamada. En otras palabras, el valor de los argumentos
actuales se copian en los argumentos formales correspondientes cada vez que una
funcin se llama. Modificacin de estos valores (argumentos formales) en la funcin
no tiene ningn efecto sobre el valor de los argumentos actuales en la funcin
llamante.
El siguiente ejemplo muestra la llamada por el mtodo de valor.
#include<stdio.h>
main()
{
int num1=100,num2=200;
printf("Before swapping \n);
printf("num1: %d and num2: %d\n,num1,num2);
swap(num1,num2);
printf("After swapping\n);
printf("num1: %d and num2: %d\n,num1,num2);
}
swap(int a, int b)
{
int temp;
temp=a;
a=b;
b=temp;
printf("n function swap()\n);
printf("num1: %d and num2: %d\n,a,b);
}
En el programa anterior, el valor del argumento real es decir, 100 y 200 pasan al
argumento formal 'a' y 'b'. En swap (), 'a' y 'b' tiene la copia de 'num1' y 'num2'.
Cualquier modificacin en la 'a' y 'b' no afectar 'num1' y 'num2'.
Si se desea modificar los valores de num1 y num2 , la alternativa sera retornar los
valores formales a la rutina principal , sin embargo como solo podemos retornar
una variable esto no sera posible en el ejemplo . La alternativa es hacerlo por
referencia:
L)$'$d$ (o& &e1e&enci$: En la llamada por referencia, las direcciones de actuales
se pasan al argumento formal. Cualquier modificacin en los argumentos formales
afectan directamente el valor de los argumentos reales. Esto es debido a que el
argumento formal contiene la direccin del argumento real, as que cualquier cambio
en ese sentido la direccin del valor. El siguiente ejemplo muestra la llamada por el
mtodo de referencia.
#include<stdio.h>
include <stdio.h>
void swap ( int * , int *)
main()
{
int num1=100,num2=200;
printf("Before swapping\n");
printf("num1: %d and num2: %d\n",num1,num2);
swap(&num1,&num2);
printf("After swapping\n");
printf("Value of num1: %d\n",num1);
printf("Value of num2: %d\n",num2);
}
void swap(int *a, int *b)
{
int temp;
temp=*a;
*a=*b;
*b=temp;
printf("n function swap()\n");
printf("num1: %d and num2: %d\n",*a,*b);
}
En el programa anterior, la direccin de la 'num1' y 'num2' se pasan a los
argumentos formales. Tenga en cuenta, ya que la direccin de 'num1' y 'num2' se
pasan, los argumentos formales deben ser puntero a enteros, ya que las direcciones
se almacena principalmente en las variables de puntero. En la funcin swap () 'a' y
'b' son variables de puntero con la direccin de 'num1' y 'num2' variables de main ().
El efecto de cambiar 'a' y 'b' no es ms que intercambio de los punteros de "num1" y
"num2".
Otro ejemplo :
#include<stdio.h>
calc_area_per(int r,float *,float *);
main()
{
int radius;
float area,per;
printf("Enter radius of circle: ");
scanf("%d",&radius);
calc_area_per(radius,&area,&per);
printf("Area = %f\n",area);
printf("Perimeter = %f\n",per);
}
calc_area_per(int r,float *a,float *p)
{
*a = 3.14 * r * r;
*p = 2 * 3.14 * r;
}
RETORNAR MAS DE UN VALOR USANDO PUNTEROS
Podemos sacar ms de un valor en un momento de una funcin mediante una
llamada con el mtodo de referencia de los punteros que no es posible con el paso
por valor. El mtodo siguiente, se muestra a obtener ms de un retorno de la funcin
con puntero:
#include<stdio.h>
#include <conio.h>
int *incdec(int val);
main()
{
int value,*ptr;
clrscr();
printf("Enter a value:");
scanf("%d",&value);
ptr = incdec(value);
ptr++;
printf("ncremented value: %d\n",*ptr);
ptr--;
printf("Original value: %d\n",*ptr);
ptr--;
printf("Decremented value: %d\n",*ptr);
}
int *incdec(int v)
{
int *pptr;
*pptr=v;
pptr++;
*pptr = v + 10;
pptr--;
pptr--;
*pptr = v - 10;
pptr++;
return pptr;
}
Otros ejemplos de punteros :
/*suma con punteros*/
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,c,*pa,*pb,*pc;
clrscr();
pa=&a;
pb=&b;
pc=&c;
printf("Enter value of a and b \n");
scanf("%d%d",pa,pb);
*pc=*pa+*pb;
printf("a=%d\n",*pa);
printf("b=%d\n",*pb);
printf("c=%d\n",*pc);
getch();
}
#include<stdio.h>
#include<conio.h>
void main()
{
float a,b,*pa,*pb;
float a1,a2,a3,a4;
clrscr();
pa=&a;
pb=&b;
a=8.5;
b=6.0;
printf("Value of a=%f\n",*pa);
printf("Value of b=%f\n",*pb);
a1=*pa + *pb;
a2=*pa - *pb;
a3=*pa * *pb;
a4=*pa / *pb;
printf("a=%f\n",a);
printf("b=%f\n",b);
printf("Sum=%f\n",a1);
printf("Sub=%f\n",a2);
printf("Mul=%f\n",a3);
printf("Div=%f\n",a4);
getch();
}
#include<stdio.h>
#include<conio.h>
void main()
{
void
a_s_m_d(float,float,float*,float*,float*,float*);
float a,b,sum,sub,div,mul;
clrscr();
printf("Enter two float numbers\n");
scanf("%f%f",&a,&b);
a_s_m_d(a,b,&sum,&sub,&mul,&div);
printf("a=%f\tb=%f\n",a,b);
printf("Sum=%f\n",sum);
printf("Sub=%f\n",sub);
printf("Mul=%f\n",mul);
printf("Div=%f\n",div);
getch();
}
void a_s_m_d(float p,float q,
float*sm,float*sb,float*m
l,float*di)
{
*sm=p+q;
*sb=p-q;
*ml=p*q;
*di=p/q;
}
#include<stdio.h>
#include<conio.h>
void main()
{
void input(int*,int);
void show(int*,int);
int p[5];
clrscr();
input(p,5);
show(&p[0],5);
getch();
}
void input(int*a,int s)
{
int i;
for(i=0;i<s;i++)
{
printf("\n Enter array element %d:",i+1);
scanf("%d",a+i);
}
}
void show(int * a , int s)
{
int i;
for(i=0;i<s;i++)
{
printf("%d\n",*(a+i));
}
}
PUNTEROS Y MATRCES
Puntero a una matriz es muy simple. Slo tenemos que declarar un puntero a
data_type de la matriz. Por ejemplo, si tenemos un arreglo como float matriz [5],
podemos declarar un puntero float * puntero y puede asignar la direccin base de la
matriz (es decir, la direccin del primer elemento de la matriz) a este puntero ptr al
escribir :
(t& A $&&D o (t& A N $&&O-PD
Despus de esta asignacin de direcciones arr [0] es equivalente a ptr [0]
o * (ptr + 0) , como ptr da la direccin del primer elemento de la matriz arr, ptr +1 la
direccin de un segundo elemento de la matriz arr y as sucesivamente. En este
respecto da lo mismo ptr [i], i [PTR], * (ptr + i) y * (i + ptr).
Veamos el siguiente programa :
#include<stdio.h>
#include<conio.h>
void main()
{
void input(int*,int);
void show(int*,int);
int p[5];
clrscr();
input(p,5);
show(&p[0],5);
getch();
}
void input(int*a,int s)
{
int i;
for(i=0;i<s;i++)
{
printf("\n Enter array element %d:",i+1);
scanf("%d",a+i);
}
}
void show(int * a , int s)
{
int i;
for(i=0;i<s;i++)
{
printf("%d\n",*(a+i));
}
}
Salida
Enter array element 1:10
Array elements are
10
15
20
25
39
Asignaci<n 1in?mica 1e %emoria
Hasta ahora todas la variables que hemos usadas han debido ser inicializadas
previamente , y durante dicha inicializacin el compilador reservara un espacio de
memoria de acuerdo al tipo que se refiera.
Pero , hay veces que los programas no pueden saber cuantas variables vamos a
necesitar. Por ejemplo , suponga que usted est haciendo un procesador de palabra
tipo word o notepad . Sabra usted la cantidad de espacio que debe tener para el
texto que ingresar el usuario?? No es posible. Por lo tanto se debe recurrir a hacer
una solicitud al sistema para que nos asigne un espacio de cierto tamaa. Esto lo
hace con las llamadas tipo malloc y calloc que pertenecen a stdio.
Malloc y Calloc son muy similares , las dos retornan un puntero a una rea de
memoria . Pero como hemos visto no es lo mismo un puntero a entero , o a
doubles por ejemplo . El puntero que retorna malloc es un puntero indefinido , por lo
tanto siempre deberemos hacerle un cast al tipo de dato que guardemos . Veamos
este ejemplo :
#include <stdio.h>
#include <stdlib.h>
int main()
{
float *items;
int k, n;
printf("Entre el numero de items ingresar: ");
scanf("%d", &n);
ite'% A "1)o$t Q# '$))oc"%iEeo1"1)o$t# Q n#D
for(k = 0; k < n; k++)
{
printf("\nEntre el precio del item No. %d : ", k + 1);
scanf("%f", &items[k]);
}
for(k = 0; k < n; k++)
{
printf("\ntem %d Precio %5.2f ", k + 1, items[k]);
}
}
En este programa estamos solicitando una cantidad de espacio para alojar n floats.
Fijese en el cast del puntero ,
Otro ejemplo :
#include <stdio.h>
#include <stdlib.h>
char *decimal_to_binary(int);
main()
{
int n, c, k;
char *pointer;
printf("ngrese un Entero base 10\n");
scanf("%d",&n);
pointer = decimal_to_binary(n);
printf("Binary string of %d is: %s\n", n, pointer);
1&ee"(ointe&#D
return 0;
}
char *decimal_to_binary(int n)
{
int c, d, count;
char *pointer;
count = 0;
(ointe& A "c;$&Q#'$))oc"RK+?#D

for ( c = 31 ; c >= 0 ; c-- )
{
d = n >> c;
if ( d & 1 )
*(pointer+count) = 1 + '0';
else
*(pointer+count) = 0 + '0';
count++;
}
*(pointer+count) = '\0';
return pointer;
}
En este ejemplo hemos creado una funcin que retorna un puntero , el puntero es
obtenido como resultado del malloc . La funcin utiliza el puntero para guardas el
resultado de la conversion de entero a binario . De regreso en el main elpuntero es
utilizado como si fuera un arreglo ( recuerde que los arreglos son en relalidad
punteros) Por ltimo debemos usar la funcin free para liberar el espacio .
Favor notar que en caso de que exista un error en la funcion malloc esta devolver
un puntero nulo .
Ejemplo de calloc:
#include
#include
int main(){
long *pPuntero = NULL; // Creamos el Puntero!
long numTotal = 0; // Creamos una variable tipo long !
printf("\nCuantos numeros quieres alocar: "); // Pedimos Numero!
scanf("%ld", &numTotal); // Leemos numero!
if(numTotal <= 0){ // Si numTotal es menor o igual a 0
printf("\n\nEl Numero debe ser mayor a zero!\n");
printf("Terminando el Programa...\n\n");
return 0x1; // Terminamos el Programa!
}
pPuntero = (long *) calloc (numTotal, sizeof(long)); // Alocamos memoria
pedida!
if(pPuntero){ // si la memoria se aloco bien
printf("\n\nMemoria Alocada Correctamente!\n\n"); // imprimimos esto
}else{
printf("\nNo Hay Suficiente Memoria!\nTerminando el Programa...\n\n"); //
return 0x1; //Terminamos el programa
}
free(pPuntero);
return 0x0; // S todo salio bien, terminamos el programa
correctamente!
}
C$(it0)o ?R Int&od0cci3n $ E%t&0ct0&$% < Unione%
INTRODUCCIN
El captulo comienza con la introduccin de los tipos de datos definidos por el
usuario ms importantes que tambin se derivan de tipos que ya se han visto ,estos
son las estructuras y uniones en C.
Como usted ha aprendido, las matrices se pueden utilizar para recoger grupos de
variables del mismo tipo. La pregunta ahora es cmo se pueden agregar en la
misma estructura tipos de datos que no son iguales.
La respuesta es que se puede agrupar variables de diferentes tipos con un tipo de
datos llamado estructura. En C, una estructura agrupa diferentes elementos de
datos, de tal manera que se puede hacer referencia como una sola unidad.
Hay varias diferencias importantes entre una matriz y una estructura. Adems del
hecho de que los elementos de datos en una estructura pueden tener diferentes
tipos, cada elemento de datos tiene su propio nombre en lugar de un valor de
subndice. De hecho, los elementos de datos en una estructura se denominan
campos o miembros de la estructura.
Una estructura es un tipo de datos derivado que consiste en la recopilacin de datos
de tipo diferente, datos como int, char, float e incluso otra estructura tambin. Vemos
ejemplo de estructura. Para mantener la informacin acerca de los estudiantes que
tienen que almacenar su cdula, nombre, edad, direccin, clase, etc . Del mismo
modo para mantener la informacin sobre los empleados se debe almacenar r
cdigo de empleado, fecha de ingreso, salario, etc . Esto se ha visto en varios
ejemplos anteriores. Todos estos datos no pueden ser almacenados en un arreglo
por ser de distinto tipo. An si quisiramos usar arreglos de distintos tipos, se
necesitaran varios de arreglos, por ejemplo uno de enteros para la cdula, otros
de chars para los nombre, otro de doubles para los salarios etc. etc. Y el manejo de
los datos en esta forma sera muy engorroso.
Recordando las secciones que tiene un programa C :
Comentarios o Documentacin Opcional
Comandos de preproceso
De1inicione% de ti(o%
Funciones prototipo (Declaraciones de tipos de
funciones y variables pasadas a la funcin
Declaracin de Variables
Funciones
Las definiciones de tipos permite a C definir nuevos tipos de datos, entre ellos las
estructuras y uniones . En esta seccin el programador debe especificar cmo se
componen las estructuras para luego usarlas como cualquier tipo de variable.
La forma general de declaracin de una estructura es la siguiente:
struct struct_tag{
data_type1 variable1;
....................;
....................;
....................;
};
En el cual struct_tag representa el nombre que usted quiere darle a la variable,
data_type1,2,3 representa los tipos de datos primitivos que usted ya conoce ,por
ejemplo int, char, float , double , etc. Ntese que la estructura est encerrada en
llaves y que cada elemento termina en punto coma (;).
Por ejemplo , suponga que usted quiere hacer una programa para la Comision de
Trnsito de Quito , esta almacena la informacin de los autos que estn
registrados, cada auto est definido por una serie de variables como ao del carro ,
modelo etc. Pensando en forma elemental se podra pensar en definir varias
variables ao, modelo etc. , pero si queremos almacenar informacin de miles de
carros la cantidad de variables sera inmensa y su manejo muy complicado .
Una solucin sera crear un nuevo tipo de variable llamado automvil de la
siguiente forma:
%t&0ct $0to'oi) S
int $nioD
c;$& 'ode)O*PD
int ci)ind&$d$D
1)o$t (e%oD
TD
Recuerde que antes de utilizar este tipo de estructura usted debe declararle, esto es
antes de main(), usted ya puede utilizar este tipo de estructrura , para esto deber
definir las variables de este tipo . Por ejemplo:
%t&0ct $0to'obi)e %ed$n+ (icHU0(+ c0$t&o.c0$t&oD
Aqu se han definido tres variables , sedan , pick-up y cuatroxcuatro , cada una de
las cuales tiene la estructura mencionada anteriormente.
Una forma compacta de hacer la definicin y la declaracin es la siguiente :
%t&0ct $0to'oi) S
int $nioD
c;$& 'ode)O*PD
int ci)ind&$d$D
1)o$t (e%oD
T %ed$n+ (icHU0(+ c0$t&o.c0$t&oD
RE5ERENCIAS A LOS ELEMENTOS : OPERADOR PUNTO
Una vez que sean definido las variables debemos tener acceso los componentes
de de cada una de ellas , para esto usaremos el operador punto (.) en forma similar
a como lo hacemos en java. Por ejemplo :
%ed$n8$nio A K--7D
c0$t&o.c0$t&o8ci)ind&$d$ARV--D
De esta forma estamos asignando valores a las variables que componen la
estructura de datos sedan y cuatroxcuatro.
Veamos el siguiente ejemplo relacionado con datos de un computador :
#include<stdio.h>
#include<conio.h>
%t&0ct co'(0te&
S
1)o$t co%tD
int <e$&D
int c(0U%(eedD
c;$& c(0Ut<(eO?WPD
T 'ode)D
main(void)
{
clrscr();
printf("Que tipo de procesador tiene?\n");
gets(model.cpu_type);
printf("Que velocidad (MHz)tiene el CPU?\n");
scanf("%d", &model.c(0U%(eed);
printf("Ao de fabricacion?\n");
scanf("%d", &'ode)8<e$&);
printf("Cuanto cuesta?\n");
scanf("%f", &'ode)8co%t);
printf("Estos son los datos :\n");
printf("Anio: %d\n", model.year);
printf("Costo: $%6.2f\n", model.cost);
printf("CPU : %s\n", model.cpu_type);
printf("CPU velocidad: %d MHz\n", model.cpu_speed);
getch();
}
Note que el scanf tiene toma como variable el nombre de la estructura.variable.
Esto indica que debe ingresar el valor de ese parte nicamente, no de toda la
estructura.
Veamos otro ejemplo , esta vez con una estructura de nombre de personas y
edades:
#include<stdio.h>
#include<conio.h>
%t&0ct (e&%on$ S
c;$& n$'eO?-PD
int $2eD
TD
void main()
{
%t&0ct persona p;
clrscr();
printf("Enter name for person \n");
scanf("%s",p.name);
printf("Enter age for person\n");
scanf("%d",&p.age);
printf("Name=%s\n",p.name);
printf("Age=%d\n",p.age);
getch();
}
Es importante mencionar que la declaracin de la estructura no reserva ningn
espacio en particular, es solo una especie de plantilla que indica que existe un tipo
de dato estructura.
En el programa anterior, se define la estructura llamada persona. Luego dentro del
main usted indica al compilador que debe crear una variable de este tipo. Esto lo
har con la sentencia struct llamada p. De ah en adelante el programa se refiere a
la variable p y sus componentes como nombre y edad.
Tambin se puede definir una estructura dentro de una funcin en cuyo caso la
estructura solo ser vlida en esa funcin. Esto es lo mismo que cualquier variable
local o global como ya se ha visto. Por ejemplo:
#include<stdio.h>
#include<conio.h>
struct person
{
char name[20];
int age;
};
t<(ede1 struct person Per;
'$in()
{
Per p;
clrscr();
printf("Enter name for person\n");
scanf("%s",p.name);
scanf("%d",&p.age);
printf("Age=%d",p.age);
getch();
}
#include<stdio.h>
#include<conio.h>
'$in()
{
struct person
{
char name[20];
int age;
};
t<(ede1 struct person Per;
Per p;
clrscr();
printf("Enter name for person\n");
scanf("%s",p.name);
scanf("%d",&p.age);
printf("Age=%d",p.age);
getch();
}
En los programas anteriores se puede notar que se ha usado la sentencia typedef ,
esta sirve para definir la estructura como un tipo de dato nuevo llamado Per . De
esta forma se hace referencia a toda la estructura . Esto es equivalente a:
typedef struct
{
char name[20];
int age;
}persona ;
INICILIXACIN DE ESTRUCTURAS
Eventualmente es necesario inicializar las variables que forman parte de la
estructura, de la misma manera que inicializamos todas la variables del programa.
La sintaxis para las estructuras es la misma pero estn separadas por comas (,) y
dentro de llaves. Veamos el siguiente ejemplo:
#include <stdio.h>
#include <conio.h>
main(void)
{
struct employee {
int id;
char name[32];
};
%t&0ct e'()o<ee e'()e$do A S
?+
YPe&icoY
TD
clrscr();
printf("Employee Name: %s\n", empleado.name);
printf("Employee D #: %04d\n\n", empleado.id);
printf("\nHere are what you entered:\n");
printf("Name: %s\n", empleado.name);
printf("D #: %04d\n", empleado.id);
getch();
}

En el ejemplo anterior se ha creado una estructura de datos llamada employee ,
otra vez , esto crea ninguna variable en particular, es solo una plantilla de lo que
sern los employees, a continuacin creamos una variable llamada empleado que
es del tipo employee y procedemos a inicializar sus valores de nombre y id.
Alternativamente, tambin se puede declarar, definir e inicializar la estructura de un
sola vez , a pesar de ser un poco ms confuso el C lo permite.
struct employee {
int id;
char name[32];
} empleado = {
1,
"Perico"
};
Un ejemplo completo :
#include<stdio.h>
#include<conio.h>
void main()
{
struct person
{
char name[20];
int age;
};
struct person p1={"Maria",25};
struct person p2={"Marco",23}; // ..asi cualquier cantidad
clrscr();
printf("Person1 Details\n");
printf("Name=%s\tAge=%d\n",p1.name,p1.age);
printf("Person2 Details\n");
printf("Name=%s\tAge=%d\n",p2.name,p2.age);
getch();
}
Al igual que otros tipos de variable, usted puede hacer asignaciones de una
variable a otra . Veamos un ejemplo relacionado con celulares:
#include<stdio.h>
#include<string.h>
void main()
{
typedef struct
{
char cname[25];
char model[20];
int price;
}celular;
ce))0)$& '?={"NOKA","6600",12000};
ce)0)$& 'K+'RD
'KA'?D
strcpy(m3.cname,"SONY_ERR");
strcpy(m3.model,"K700i");
m3.price=m1.price;
printf("Mobile Details\n");
printf("Company Name=%s\tModel=%s",m1.cname,m1.model);
printf("\tPrice=%d\n",m1.price);
getch();
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1/4
En el ejemplo anterior hemos creado una estructura y le hemos asignado un tipo de
dato llamado celular. De este tipo de dato hemos creado tres variables llamada
m1,m2 ym3. Procedemos a inicializar la m1 y a asignar la m2 igual a la m1
.Despus vemos como usamos funciones de la librera string.h para copiar las
partes que son strings de un celular a otro .
A&&e2)o% de e%t&0ct0&$%=
Eventualmente usted requiere crear varios elementos del mismo tipo, para esto ha
usado siempre los arreglos. Ahora como podemos dar un nombre al tipo de dato
entonces podemos crear arreglos de estructuras .
El formato es el siguiente :
Ejemplo :
Suponga que requiere crear una gran cantidad de vehculos :

%t&0ct e;ic0)o
S
c;$& 'ode)o OK-PD
int $nioD
c;$& co'b0%tib)eD
TD
%t&0ct e;ic0)o )i%t$Uc$&&o%OVPD
Creamos una estructura llamada vehiculo, est compuesta por el modelo del carro,
un entero del ao y el tipo de combustible que usa como gasolina, diesel etc. Luego
creamos un arreglo llamado lista _ carros que tiene 5 elementos.
Veamos un ejemplo completo con estudiantes:
#include<stdio.h>
#include<conio.h>
void main()
{
t<(ede1 %t&0ct %t0dent
{
char sname[20];
int rollno;
char cname[20];
}student;
%t0dent %$&&OVPD
int i;
clrscr();
for(i=0;i<5;i++)
{
printf("\n Entre el numero de estudiante %d:",i+1);
scanf("%s",sarr[i].sname);
printf("\nEntre la materia del %d",i+1);
scanf("%s",sarr[i].cname);
printf("Entre el costo ");
scanf("%d",&sarr[i].rollno);
}
printf("\n Detalles del Estudiante \n\n");
printf("\SName\tCName\tRollNo\n");
for(i=0;i<5;i++)
{
printf("%s\t%s\t",sarr[i].sname,sarr[i].cname);
printf("%5d\n",sarr[i].rollno);
}}

En este ejemplo usamos typedef para definir como un tipo de variable, aunque no es
mandatorio , ayuda a que el cdigo sea ms legible. El nuevo tipo de dato se ha
llamado student y es el mismo nombre de la estructura. Una vez definido el tipo de
dato creo un arreglo de este tipo llamado sarr con 5 elementos. El resto del cdigo
es simple.

Veamos otros ejemplos :
#include<stdio.h>
#include<conio.h>
t<(ede1 %t&0ct
S
int d$<D
int 'ont;D
int <e$&D
Td0&$cionD
main()
{
d0&$cion d?+dK+dRD
int d,m,y;
clrscr();
printf("Entre la cantida de aos,mes y dias \n");
scanf("%d%d%d",&d1.year,&d1.month,&d1.day);
printf("Entre la segunda cantidad de aos meses y das\n");
scanf("%d%d%d",&d2.year,&d2.month,&d2.day);
d= (d1.day+d2.day) %30;
m=d1.month+d2.month+ (d/30);
y=d1.year+d2.year+ (m/12);
d3.day=d;
d3.month=m;
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1//
d3.year=y;
printf("\Primera duracin\n");
printf("%dyears%d months",d1.year,d1.month);
printf("and %d days\n",d1.day);
printf("\n Segunda duracion \n");
printf("%d years %d months",d2.year,d2.month);
printf("and %d days\n",d2.day);
printf("\n Suma de duracines \n");
printf("%d years %d months",d3.year,d3.month);
printf("and %d days \n",d3.day);
getch();
}
En este ejemplo hemos creado una estructura, la estructura como tal no tiene un
nombre asignado pero se ha asignado a un tipo de dato llamado duracin.
Posteriormente en el mail creamos 3 variables de este tipo d1,d2 y d3 .El resto es
simple.
Otro ejemplo de cmo usar estructuras en matemticas. Como ustedes saben los
numero complejos estn compuestos por una parte real y una imaginaria. Esto lo
podemos hacer fcilmente con estructuras. En este caso podramos no ha haber
usado estructuras ya que los dos tipo de datos son iguales ( float) , pero al usar
estructura podemo agrupar cada nmero complejo en una simple variable.
#include<stdio.h>
#include<conio.h>
t<(ede1 %t&0ct
S
1)o$t &e$)D
1)o$t i'$2D
Tco'()e.;
void main()
{
co'()e. c?+cK+cR+cZD
float a,b;
clrscr();
printf("Enter the real part for first complexnumber\n");
scanf("%f",&a);
printf("Enter the imag part for first complex number\n");
scanf("%f",&b);
c1.real=a;
c1.imag=b;
printf("Enter the real part for sec complex number \n");
scanf("%f",&a);
printf("Enter the imag part for sec complex number \n");
scanf("%f",&b);
c2.real=a;
c2.imag=b;
c3.real=c1.real+c2.real;
c3.imag=c1.imag+c2.imag;
c4.real=c1.real*c2.real - c1.imag*c2.imag;
c4.imag=c1.real*c2.imag + c1.imag*c2.real;
printf("\t Complex Number 1\n");
printf("\t %5.2f +j%5.2f\n",c1.real,c1.imag);
printf("\t Complex Number 2\n");
printf("\t%5.2f +%5.2f\n",c2.real,c2.imag);
printf("\tSum of C1 & C2\n");
printf("\t%5.2f + j%5.2f\n",c3.real,c3.imag);
printf("\t Mul of C1 & C2\n");
printf("\t%5.2f +j%5.2f\n",c4.real,c4.imag);
getch();
}
Ahora ya que es un experto en estructuras , veamos como anidarlas.
ESTRUCTURAS ANIDADAS
Suponga usted que quiere trabajar con datos de personas como nombre, edad, y
direccin. Usted podra guardar la direccin como un solo string , pero eso le impide
hacer trabajos en los cuales el comportamiento difiere si es de distinta ciudad . Por
esto , ha decidido quela direccin a su vez sea un estructura que est compuesta
por calle , nmero, ciudad y provincia . Esto es una estructura anidada. El cdigo
quedara as:
#include<stdio.h>
#include<conio.h>
struct direccion
{
char calle[10];
int no;
char ciudad[25];
char provicia[30];
};
struct persona
{
char nombre[25];
int edad;
struct direccion addr;
};
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1/.
Primero deber definir la estructura que no tiene ninguna dependencia y luego las
que tienen dependencia. El programa completo quedara as:
#include<stdio.h>
#include<conio.h>
struct direccion
{
char calle[10];
int num;
char ciudad[25];
char prov[30];
};
struct person
{
char nombre[25];
int edad;
%t&0ct di&eccion $dd&D
};
void main()
{
struct person p;
clrscr();
printf("Entre nombre y edad \n");
scanf("%s%d",p. nombre,&p.edad);
printf("Direccion calle,No,ciudad y prov\n");
scanf("%s%d",p.addr. calle,&p.addr.num);
scanf("%s%s",p.addr. ciudad,p.addr. prov);
printf("ngresado \n\n");
printf("Name:\t%s\tAge:\t%d\n",p. nombre,p.edad);
printf("Address:%s,%d\n",p.addr. calle,p.addr.num);
printf("\t%s,%s\n",p.addr. ciudad,p.addr. prov);
getch();
}
Otros ejemplos de estructuras anidadas comunes:
struct date
{
int day;
int month;
int year;
};
struct employee
{
char ename[20];
struct department
{
int code;
char name[32];
char position[16];
};
typedef struct department DPT;
struct employee
{
char dept[20];
struct date doj;
char qual[15];
};
DPT d;
int id;
char name[32];
};
En el ejemplo de la derecha se ha usado typedef para definir un tipo de variable
llamada DPT.
ESTRUCTURAS , 5UNCIONES
Como ya hemos visto una funcin permite recibir datos de cualquier tipo definido
as como retornar una variable, por lo tanto las estructuras puedes ser pasada y
devueltas de una funcin al igual que cualquier variable primitiva.
Veamos un ejemplo :
#include<stdio.h>
#include<conio.h>
typedef struct
{
int ecode;
char ename[30];
int esal;
}emp;
oid %;oF"e'(#D
void main()
{
emp p={1023,"Vijay",25000};
clrscr();
show(p);
getch();
}
oid %;oF"e'( (#
{
printf("Details of Employee\n");
printf("Name:\t%s\n",p.ename);
printf("Ecode:\t%d\n",p.ecode);
printf("Sal:\t %d\n",p.esal);
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1/'
En el ejemplo precedente hemos declarado una estructura de que no tiene nombre
y la hemos definido como un tipo de variable llamada emp. En este caso emp es
para todo propsito igual que un int, float. etc. Por otro lado definimos una funcin
llamada show que recibe datos del tipo emp. Fjese en el prototipo de la funcin y
la llamada a la funcin show.
Otro Ejemplo :
#include <stdio.h>
#include<conio.h>
// Primero creamos la estructura llamada computer
%t&0ct co'(0te&
S
1)o$t co%tD
int <e$&D
int c(0U%(eedD
c;$& c(0Ut<(eO?WPD
TD
// definimos un tipo de dato llamado SC
typedef struct computer SC;
// definimos el prototipo de la funcin
SC DataReceive(SC s);
main(void)
{
SC model;
clrscr();
model = DataReceive(model);
printf("Here are what you entered:\n");
printf("Year: %d\n", model.year);
printf("Cost: $%6.2f\n", model.cost);
printf("CPU type: %s\n", model.cpu_type);
printf("CPU speed: %d MHz\n", model.cpu_speed);
getch();
}
// cuerpo de la funcin
SC DataReceive(SC s)
{
printf("The type of the CPU inside your computer?\n");
gets(s.cpu_type);
printf("The speed(MHz) of the CPU?\n");
scanf("%d", &s.cpu_speed);
printf("The year your computer was made?\n");
scanf("%d", &s.year);
printf("How much you paid for the computer?\n");
scanf("%f", &s.cost);
return s;
}
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1/#
APUINTADORES A ESTRUCTURAS
En los ejemplos anteriores estbamos pasando por valor las estructuras de datos.
Primero hemos definido una estructura llamada computer que tiene las variables de
costo , ao , velocidad etc. Despus definimos un tipo de dato llamado SC y por
ltimo definimos el prototipo de la funcin la cual recibe una variable del tipo SC y
retorna una variable igual. Ya dentro del main definimos una variable de tipo SC
que se llama model ( la definimos pero no la incializamos) . Llamamos a la funcin
entregndole esta variable y a travs de los scanf inicializamos sus
componentes. Por ltimo retornamos la misma variable.
Debe ser claro para ustedes que el paso de la variable model se hace por valor.
Esto hace que sea ineficiente porque debemos disponer de almacenamiento
adicional para la variable. Mejor sera trabajar por referencia, esto es, apuntadores.
Al igual que los apuntadores a int, char etc. debemos definir apuntadores a
variables del tipo que se ha creado . Veamos el ejemplo:
#include <stdio.h>
#include<conio.h>
%t&0ct co'(0te&
S
1)o$t co%tD
int <e$&D
int c(0U%(eedD
c;$& c(0Ut<(eOR-PD
TD
t<(ede1 %t&0ct co'(0te& SCD
oid D$t$Receie"SC Q(t&U%#D
void main(void)
{
SC model;
DataReceive(&model);
printf("Here are what you entered:\n");
printf("Year: %d\n", model.year);
printf("Cost: $%d\n", model.cost);
printf("CPU type: %s\n", model.cpu_type);
printf("CPU speed: %d MHz\n", model.cpu_speed);
getch();
}
/* function definition */
void DataReceive(SC *ptr_s)
{
printf("The type of the CPU inside your computer?\n");
Programacin Bsica Preparado por : M.Sc Alfonso Prado Pg1/*
gets((*ptr_s).cpu_type);
printf("The speed(MHz) of the CPU?\n");
scanf("%d", &(*ptr_s).cpu_speed);
printf("The year your computer was made?\n");
scanf("%d", &(*ptr_s).year);
printf("How much you paid for the computer?\n");
scanf("%d", &(*ptr_s).cost);
}
La estructura y la definicin del tipo es similar al ejemplo anterior, pero el prototipo
de la funcin declara que el argumento es una apuntador a SC llamado ptr_s,
ntese el asterisco (*).
Al llamar a la funcin colocamos con argumento la direccin de model . Y dentro de
la funcin usaremos gets y scanf para leer de teclado los valores. Como solo
tengo el apuntador referenciaramos a las variables como *ptr_s.cost . Para que
no haya ambigedad en esto usaremos el apuntador entre parntesis , caso
contrario podra entenderse como la direccin de cost y no la direccin de model.
OPERADOR 5LEC6A GB
C incluye un operador "flecha (guin y mayor que) que nos ayudan a referencias
directamente un miembro de la estructura siempre que tenga su apuntador.
Ejemplo
ptr_s -> cpu_type sera equivalente a (*ptr_s).cpu_type
&(ptr_s->cpu_speed) sera equivalente a &(*ptr_s).cpu_speed
Esto hace mucho ms claro el programa .Veamos un ejemplo:
#include<stdio.h>
#include<string.h>
struct emp
{
int ecode;
char ename[30];
int esal;
};
void modify(struct emp*);
void main()
{
struct emp e={1023,"Vijay",25000};

modify(&e);
printf("Details of Employee\n");
printf("Name:\t%s\n",e.ename);
printf("Ecode:\t%d\n",e.ecode);
printf("Sal:\t%d\n",e.esal);
getchar();
}
void modify(emp *p)
{
p->ecode=1025;
strcpy(p->ename,"Hari");
(*p).esal=30000;
}
Este programa define en lneas 4 a la 8 una estructura llamada emp , compuesta
por 3 datos , el cdigo del empleado, el nombre y el salario . La lnea 3 contiene la
declaracin de la funcin , la cual no devuelve nada y tomo como argumento un
apuntador a la variable del tipo emp. La lnea 12 crea una variable llamada e y
asigna los valores a cada uno de los miembros de la estructura. En la lnea 14 se
llama a la funcin modify con el argumento la direccin de e. La funcin modify
cambia los valores , en las lneas 23 y 24 lo hace con el operador flecha y en la
lnea 25 a travs del apuntador . Ambos casos son iguales , el operador flecha y
el apuntador a una variable de la estructura funcionan de igual forma.
UNIONES
Una unin es un bloque de memoria que sirve para encerrar distintos tipos de
datos. Es similar a una estructura , excepto que los distintos componentes de datos
comparten la misma localidad de memoria. Como se mencion anteriormente una
estructura como tal no reserva memoria , es solo un plantilla, pero cuando ya se
inicializa en una variable cada elemento de la estructura tiene una localidad
diferente ( similar a un arreglo) , mientras que, en una unin no es as.
Veamos un ejemplo de unin y struct similares:
Estructura Union
struct estudiante {
int reg_no;
char sname[15];
char sex;
};
union estudiante {
int reg_no;
char sname[15];
char sex;
};
Cuando se compila se reservaran 18
bytes =2+15+1
Cuando se compile reservar solo 15
bytes
Debido a esta particularidad , cuando se usa unin solo un miembro puede ser
accesible en un momento determinado .
Declaracin de Union
unin automvil{
int anio,
char modelo[8];
int motor;
float costo;
};
De1ini& $&i$b)e% ti(o 0ni3n
Despus de declarar la unin , usted podr definir variables de dicho tipo , ( igual
que struct) , ejemplo:
unin automvil sedan, pickup, cuatroxcuatro;
O alternativamente, usted puede declarar la unin y definir las variables, por
ejemplo:
unin automvil{
int anio,
char modelo[8];
int motor;
float costo;
} sedan, pickup, cuatroxcuatro;
Si usted est definiendo la unin y las variables en la misma sentencia y no existe
necesidad de definir nuevas variable ms adelante en el programa , usted puede
omitir el nombre la unin . Es como que la unin no tiene nombre , pero las
variables si . Ejemplo :
unin {
int anio,
char modelo[8];
int motor;
float costo;
} sedan, pickup, cuatroxcuatro;
U%o de) o(e&$do& (0nto "8# < 1)ec;$ "GB#
El operador punto se lo puede usar para referenciar los componentes:
sedan.anio=2010;
Usted puede definir tambin una variable tipo apuntador a una unin:
union automvil *ptr;
Y referencias a lo miembros como :
ptr->anio=2008;
Ejemplo completo:
#include <stdio.h>
#include <string.h>
#include<conio.h>
void main(void)
{
union menu {
char name[23];
double price;
} dish;
clrscr();
printf("El contenido de la union : \n");
strcpy(dish.name, "Pollo asado ");
printf("Dish Name: %s\n", dish.name);

dish.price = 75.95;
printf("Dish Price: %5.2f\n", dish.price);
getch();
}
En el ejemplo anterior se ha creado una union llamada men , con la cual se crea
una variable llamada dish . La union tiene dos variable , name y price . Se usa una
funcin strcpy para inicializar el nombre , y la salida se realiza mediante una
referencia a las variable name y price.
Otro ejemplo :
#include<stdio.h>
#include<conio.h>
union person
{
int id;
char sex;
};
void main()
{
union person p;
clrscr();
p.id=15;
printf("d is %d\n",p.id);
p.sex='M';
printf("Sex is %c \n",p.sex);
(&int1"YSiEe o1 0nion i% [d\nY+%iEeo1"0nion (e&%on##D
getch();
}
En el anterior ejemplo , la union comprende 2 variables un entero y un char , la
primeras lneas crean la union y dentro del main se procede a unicializar la variable
p del tipo person. Hasta ah no hay nada nuevo. Fjese que luego de inicializar las
variables id y sex se ejecuta un printf para obtener el tamao de la estructura . Si
usted ejecuta el programa la salida del sizeof indicar 2 , porque el espacio
asignado es el mismo , como el id usa 2 bytes , en el mismo espacio cabe el char
de sex.
Ntese que el programa usa el espacio primero para el id y luego ejecuta el printf.
Lo mismo para sex. Pero que pasa si inicializamos las dos variable primero y luego
las desplegamos?? Vea el siguiente programa:
#include<stdio.h>
#include<conio.h>
union person
{
int id;
char sex;
};
void main()
{
union person p;
clrscr();
p.id=12;
p.sex='M';
(&int1"YID i% [d\nY+(8id#D
(&int1"YSE/ i% [c\nY+(8%e.#D
getch();
}
El primer printf desplegara 77 y el segundo la letra M , esto porque 77 es el ASC
de la M. Solo una variable podr ser usada a las vez. Esto tiene una consecuencia ,
vemos el siguiente ejemplo :
typedef union
{
char code;
int quan;
} item;
item i1= { 'L',20};
La construccin anterior es correcta, pero debido a lo anterior no es til.
Unione% < A&&e2)o%:
Al igual que con estructuras usted puede crear un arreglo de uniones. Veamos el
ejemplo siguiente:
#include<stdio.h>
#include<conio.h>
0nion intc;$&
S
int noD
c;$& c;D
TD
void main()
{
0nion intc;$& $&&OVPD
int i;
clrscr();
printf("Size of arr is %d\n",sizeof(arr));
for(i=0;i<=4;i++)
arr[i].no=i;
printf("Numbers are\n");
for(i=0;i<=4;i++)
printf("arr[%d].no=%d\n",i,arr[i].no);
for(i=0;i<=4;i++)
arr[i].ch='A'+i;
printf("Characters are \n");
for(i=0;i<=4;i++)
printf("arr[%d].ch=%c\n",i,arr[i].ch);
getch();
}
En el ejemplo anterior , creamos una union llamada intchar y creamos un arreglo de
intchars llamado arr con 5 elementos . Luego procedemos inicializar la variable no
con nmeros del 1 al 5 , desplegamos lo recin ingresado y luego hacemos lo
mismo con la variable ch.
En consecuencia , no tiene sentido inicializar todas las variables a la vez , porque
el ltimo valor es el que quedara. Por este motivo la incializacin se ve
generalmente as:
union u {
char ch;
int x;
} a_union = {'H'};
La pregunta que se debe hacer es : Para que sirve esto , como es esto mejor que
crear una estructura o un espacio tipo malloc.?
Union puede servir para dos tipos de aplicaciones :
1.- Referenciar el mismo espacio como tipos distintos:
2.- Crear estructuras ms flexibles.
Veamos un ejemplo de la primera:
#include <stdio.h>
#include<conio.h>
union u{
char ch[2];
int num;
};
int Unionnitialize(union u val,int i);// function declaration.
main(void)
{
union u val;
int x;
clrscr();
x = Unionnitialize(val, 1);
printf("The two character constants held by the union:\n");
printf("%c\n", x & 0x00FF);
printf("%c\n", x >> 8);
x=Unionnitialize(val,2);
printf("ahora el siguiente miembro %d",x);
getch();
}
/* function definition */
int Unionnitialize(union u val, int a)
{
if (a==1) {val.ch[0] = 'H';
val.ch[1] = 'i';}else{
val.num=666;}
return val.num;
}
En este ejemplo del primer uso :
-Definimos una union llamada u con 2 miembros, un arreglo de chars y un int.
El tamao final es de 2 bytes .
-Creamos una funcin para inicializar los valores de los miembros, la funcin
pasa como argumento una variable de tipo u llamada val , y devuelve un entero
-La funcin inicializa el arreglo de chars con las letras "H e "i y retorna el
valor que est en el val.
-De regreso al main , el valor es recogido como x ,
Se procede al printf . Fijese que para obtener el segundo char es necesario
recorrer la data ocho posiciones a la derecha.
-Cuando se repite el proceso con a=2, entonces el rea sirve para tratar el
valor del num.
Un ejemplo de una estructura ms flexible:
#include <stdio.h>
#include <string.h>
#include <conio.h>
struct encuesta
{
char nombre[20];
char c_d_p;
int edad;
int horas_ala_semana;
union {
char cable [16];
char dish [16];
} proveedor;
};
void DataEnter(struct encuesta *s);
void DataDisplay(struct encuesta *s);
void main(void)
{
struct encuesta tv;
DataEnter(&tv);
DataDisplay(&tv);
getch();
}
/* funccion de entrada*/
void DataEnter(struct encuesta *ptr)
{
char is_yes[3];
printf("Usa cable (Si o No)\n");
gets(is_yes);
if ((is_yes[0] =='S') ||(is_yes[0] == 's'))
{
printf("Entre la compaa de cable:\n");
gets(ptr->proveedor.cable);
ptr->c_d_p = 'c';
}
else
{
printf("Usa satelite? (Si o No)\n");
gets(is_yes);
if ((is_yes[0] == 'S')||(is_yes[0] == 's'))
{
printf("Entre compaia de satellite \n");
gets(ptr->proveedor.dish);
ptr->c_d_p = 'd';
}
else
{
ptr->c_d_p = 'p';
}
}
if (ptr->c_d_p != 'p'){
printf("Entre su nombre:\n");
gets(ptr->nombre);
printf("Su edad:\n");
scanf("%d", &ptr->edad);
printf("Cuantas horas ve la TV por semana:\n");
scanf("%d", &ptr->horas_ala_semana);}
}
/* funcin despiegue */
void DataDisplay(struct encuesta *ptr)
{
if (ptr->c_d_p=='p') {
printf("NO estas en nada\n");
}else{
printf("\Esto es lo entrado:\n");
printf("Nombre: %s\n", ptr->nombre);
printf("Edad: %d\n", ptr->edad);
printf("Horas que ve : %d\n", ptr->horas_ala_semana);
if (ptr->c_d_p == 'c')
printf("Su compaia de cable es: %s\n", ptr->proveedor.cable ) ;
if (ptr->c_d_p == 'd')
printf("Su compaa de satellite es: %s\n", ptr->proveedor.dish); }

}
En el ejemplo anterior, tenemos una estructura que refleja una encuesta que se
realiza en lnea. La encuesta trata de obtener si usted usa cable o satlite. Con una
estructura normal tendramos que usar dos variables una para cada caso .
Usando una variable como union usted puede tener una sola variable en la
estructura, que puede ser cable o satlite .

Material Puce 2 Agosto 2013

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Material Puce 2 Agosto 2013

Uploaded by

Copyright:

Available Formats

PONTFCA UNVERSDAD CATLCA DEL ECUADOR

FACULTAD DE NGENERA DE SSTEMAS

You might also like