Está en la página 1de 51

ELEMENTOS DE PROGRAMACIÓN EN C

PARTES DE UN PROGRAMA EN C:
Un programa escrito en C está conformado por pequeños módulos de código
llamados funciones.
El módulo principal o programa principal está conformado por la función que
denominamos main( ) las instrucciones que conforman ésta se encierran entre { }.
Sobre la parte superior de la función main() y dentro de la función se pueden declarar los
siguientes objetos que pueden manipular un programa.
. !irecti"as para #ncluir arc$i"os% #includ
&. !irecti"as para incluir macros y constantes #d!in
'. !eclaración de (rototipos de funciones
). !eclaración de *ariables globales
+. !eclaración de tipos de datos.
,. !entro del main() se encuentran las declaraciones de "ariables y las
instrucciones que definen procesos que debe reali-ar la computadora.
..(or fuera del main() y después de la lla"e / que cierra el main aparecen las
declaración de las funciones.
DIRECTI"A INCLUDE (A#c$i%&' c&n ()n'i*n $):
0os arc$i"os con e1tensión $ (Ejemplo2 ')di&+$, c&ni&+$ etc )se llaman arc$i"os de
cabecera% contienen información técnica que requiere el compilador para la buena
operación de las funciones que usan nuestros programas.
3uestro programa está usando directi"as para incluir arc$i"os son2
#includ 4stdio.$5
#includ 4conio.$5
0os arc$i"os con e1tensión $ "iene con el compilador. (ero también podemos crear
arc$i"os de este tipo propios.
DIRECTI"A #d!in: (D!inici*n d Mac#&')
0a directi"a #d!in se utili-a para definir un identificador y una cadena que será
sustituida por cada "e- que el identificador se utilice en el programa. 6l identificador se le
denomina nombre de la macro y al proceso de reempla-amiento sustitución de macro.
3uestro programa está usando directi"as para incluir (macro) constantes son E-m.l&'2
#d!in mensaje 7El sistema no tiene Solución8
9tro tipo de macro podr:a ser2
#d!in ;#E<=9
#d!in >60S9 ?
Una "e- se define una macro se puede usar el nombre de ella como parte de la definición
de otra% ejemplo2
#d!in U39
@d!in !9S U39 A U39
@d!in =<ES U39 A !9S
DECLARACIÓN DE "ARIA/LES:
6ntes del main() o después de él se deben definir las "ariables% ejemplo2
!l&a) a% b% 1B
0as "ariables que se declaran dentro del main() se dice que son "ariables locales%
las que se declaran fuera se dicen globales% cuando "eamos el concepto de función
ampliaremos la diferencia entre estos tipos de "ariables.
0a siguiente tabla muestra los distintos tipos de dato que podemos usar en ; para declarar
"ariable en un programa en ;.
TIPOS DE DATOS /0SICOS RECONOCIDOS POR TUR/O C
TIPO
TAMA1O n
/2)' d la "a#ia3l
RANGO d "al&#'
4u Pud Almacna# Cuand& U'am&'
c$a# ?..&++ CDE...EFE% G
in) & H'&.,...'&.,I
(ara almacenar
nJmeros enteros
d&u3l I ..EH'?I....E'?I
(ara almacenar
nJmeros <eales
!l&a) ) 'EH'I..'E'I *ariables que
almacenan nJmeros
reales.
.&in)# & byte (unteros near% KKes%
Kes% ss
(ara "ariables que
guardan direcciones
de memoria
l&n5 d&u3l ? bytes '.)EH)L'& a . E )L'& *ariables <eales
6unci*n 'can!():
(ermite entrar datos por el teclado y almacenarlos en las "ariables en memoria.
P#&)&)i.& d la !unci*n 'can!():
'can!(cadna7!&#ma)&% lista de "ariables)8
0a función 'can! lee los datos que son escritos desde el teclado% e1amina la
cadna7!&#ma)&% y con"ierte los caracteres escritos en el formato especificado% para
luego colocarlos en memoria.
!onde la cadna7!&#ma)& consta de tres caracteres
. Especificador de formato
&. ;aracteres de espacio en blanco (9 9)% el tabulador (9:)9) o el salto de l:nea (9:n9)
'. ;aracteres Simples
0a función 'can!( ) de"uel"e el nJmero de datos a los que se les asigno
e1itosamente un lugar en memoria en el momento de la lectura
0os especificadores de formato de entrada "an precedidos por el signo ; y le
indican a la función 'can! a que tipo de dato se "a a con"ertir% el dato que se digite en esa
entrada.
Si alguno de los datos entrados scanf no puede con"ertirlos en algJn de los tipos de
datos especificados% la ejecución de la función terminaráB asignando los caracteres le:dos
$asta ese punto a su argumento% algunos de los especificadores % más comunes son2
ESPECI6ICADOR
DE
6ORMATO
TIPO DE DATO
;c 0eer un sólo carácter
;d 0eer un entero decimal
;i 0eer un entero decimal
;l 0eer un entero largo
; 0eer un entero en coma flotante
;! 0eer un entero en coma flotante
;$ 0eer un entero corto
;& 0eer un numero octal
;' 0eer una cadena de caracteres
;( 0eer un nJmero $e1adecimal
0os '.aci&' n 3lanc& en la cadena de control $acen que la función 'can! salte
un o más caracteres en la secuencia de entrada.
E-m.l&: El siguiente cuadro muestra los elementos de la sinta1is de la función 'can!
El especificador de formato ;d le indica que los caracteres que se escriban en el
teclado deben ser con"ertidos en este caso a un nJmero entero.
0a "ariable de nombre %a# debe ser declarada de tipo in)+
0a e1presión <%a# es la dirección en memoria donde se encuentra la "ariable %a# +
6unci*n .#in)!( ):
0a función printf nos permite en el lenguaje ; imprimir en pantalla mensajes yMo
"alores en la pantalla de la computadora.
P#&)&)i.& d la !unci*n .#in)!:
.#in)!( cadna7!&#ma)&, lista de argumentos)8
0a cadna d !&#ma)& consiste de una secuencia de caracteres simples% secuencias
de escape yMo especificadores de formato% todos ellos delimitados por = (c&milla' d&3l')
Scuncia d E'ca. Ca#>c)# d Salida
:a Sonar alerta
:3 <etroceso
:! Salto de (ágina
:n Salto de 0:nea
n&m3# d la !unci*n
'can!(=;d=,<%a#)8
Especificador de Formato
&.#ad&# d di#cci*n
N&m3# d la %a#ia3l
Scuncia d E'ca. Ca#>c)# d Salida
:) =abulador Nori-ontal
:% =abulador *ertical
:# <etorno de ;arro
:? !oble ;omillas
:@ ;omilla Simple
:: Oarra #n"ertida
:A Signo de #nterrogación
:DDD ;ódigo 9ctal
:(BBB ;ódigo Ne1adecimal de un carácter
E'.ci!icad&# d !&#ma)&:
0as '.ci!icaci&n' d !&#ma)& "ienen dadas por el s:mbolo de P seguido de uno
o mas especificadores permitidos% por la sinta1is2
;C3and#a'DCanc$&DC.#cDC6ENE$EFD)i.&
Ca#>c)#
)i.&
Ti.&
A#5umn)&
6&#ma)& d C&n%#'i*n
d entero Entero decimal
i entero entero decimal con signo
u entero entero decimal con signo
& entero entero octal sin signo
( entero entero $e1adecimal sin signo
G entero entero $e1adecimal sin signo
! punto
flotante
"alor con signo QHRdddd.ddd
punto
flotante
"alor con signo QHRd.dddeQsignoRddd
E punto
flotante
"alor con signoQHdRd.dddEQsignoRddd
5 punto
flotante
salida como en f o en e dependiendo del "alor de precisión
G punto
flotante
salida como en f o en e dependiendo del "alor o precisión
c carácter
simple
carácter simple
' ;adena cadena de caracteres
P puntero dirección almacenda en el puntero
C3and#aD: Es opcional% con ella especificamos cómo "a aparecer la con"ersión del
nJmero cuando se escriba.
/ANDERA E6ECTO
H Sustifica el resultado por la i-quierda
I Escribe el signo (I & H) del resultado
@ J Escribe un espacio blanco a la cabe-a de lo que escribe% si el dato
es positi"o% o un signo H si el resultado es negati"o
Canc$&D: Es un numero entero positi"o% opcional con el cual se indica el m:nimo nJmero
de caracteres con los que se debe presentar un dato de algJn tipo.
Si la longitud se encabe-a con un cero% la salida se rellenará con ceros en lugar de
blancos.
Si la longitud es un T% printf utili-ará el "alor suministrado por la lista de
argumentos% como la especificación de longitud.
4+.#cD: Es opcional y perteneciente a la especificación de formato% indica la precisión
del "alor de salida y siempre aparecerá precedida de un punto para separarla de otras
especificaciones.;on un nJmero entero después del punto se especifica el numero de
posiciones decimales que se $an de imprimir para un nJmero en punto flotante.
#includ C')di&+$D
#includ Cc&ni&+$D
%&id main()
{ !l&a) aKLM+LNOP, 3KHQR+LNN8
in) dKFSQ8
cl#'c#()8
TTEl ca#>c)# :n $ac 4u $a2a cam3i& d lUna
TTEl %al&# O '.ci!ica l )&)al d '.aci&' n 3lanc&, S dic cuan)&' lu5a#' dcimal'
.#in)!(=:n aK;O+S!=,a)8 .#in)!(=:n 3K;O+S!=,3)8
TTEn l 'i5uin) .#in)! a5#5am&' la 3and#a mn&' H 2 l )a3ulad&# $&#iV&n)al :)
TTTam3iWn a5#5am&' l ca#>c)# d c&n)#&l E
.#in)!(=:n:):)XXXXXXXXXXXXXXXXXXXX=)8
.#in)!(=:n:):) U'and& l H 2 la E ' 'c#i3 a c&m& :)K;HY+SE=,a)8
.#in)!(=:n:):) N& u'and& H 2 la ' 'c#i3 a c&m& :)K; Y+S=,3)8
TTEn la' 'i5uin)' lUna' u'am&' la 3and#a I
TTO3'#% 4u '&l& 'c#i3i* l n l&' ca'&' n 4u l %al&# #a n5a)i%&
.#in)!(=:n:):)XXXXXXXXXXXXXXXXXXXX=)8
.#in)!(=:n:):) U'and& l H 2 la E ' 'c#i3 a c&m& :)K;IHY+SE=,a)8
.#in)!(=:n:):) N& u'and& H 2 la ' 'c#i3 a c&m& :)K;I Y+S=,3)8
TTEn la' 'i5uin)' lUna' u'am&' '.aci& n 3lanc& n %V d I
.#in)!(=:n:):)XXXXXXXXXXXXXXXXXXXX=)8
.#in)!(=:n:):) U'and& l H 2 la E ' 'c#i3 a c&m& :)K; HY+SE=,a)8
.#in)!(=:n:):) N& u'and& H 2 la ' 'c#i3 a c&m& :)K; Y+S=,3)8
5)c$()8
}
ENTRADA Z SALIDA EN CII
0a biblioteca estándar de EMS para ;% descrita por el arc$i"o de cabecera ')di&+$
está disponible en ;AA. Sin embargo% ;AA introduce sus propios arc$i"os de cabeceraB
por ejemplo% i&')#am+$, !')#am+$ 2 ')#')#am+$, que implementan su colección
particular en funciones de EMS.
cin, c&u)
En ;AA los flujos stdin% stdout son2 cin, c&u)+ Estos dos flujos se abren
automáticamente cuando comien-a la ejecución de programas% y se con"ierte en la
interfa- entre el programa y el usuario. El flujo cin esta asociado con el teclado del
terminal. El flujo c&u) se asocia con el monitor de ":deo.
L&' &.#ad&#' DD 2 CC
0a entrada y salida en CII $a sido significati"amente real-ada y perfeccionada por la
biblioteca de operadores de flujo 55 (U5) !#&mU o e1tracción ) y 44 (U.u) &nU o
inserción). ;ada operador está sobrecargado propiedad de ;AA que delega en el
compilador la responsabilidad de determinar que operador lógico o función nombrada
debe ejecutarse basándose en los tipos de datos de las "ariables asociadas. ;ada uno de
los operadores 44 y 55 puede manipular todos los tipos de datos estándar% clases
incluidas.
0os siguientes dos ejemplos muestran de manera rápida la mayor facilidad de
manejo de EMS (entrada y salida)
Utili-ando printf 2 .#in)!(=Un entero ;d% un real ;!=% a%b)B
6$ora equi"alente en CII: c&u) CC=Un entero= 44a44U%un realU44bB
Utili-ando scanf para entrar datos2 'can!(=PdPfPcU%Ventero%Vreal%Vcaracter)B
a$ora en CII: cin 55 entero 55real55caracterB
9bser"e como el operador de e1tracción% reali-a la entrada de información. 3o se
necesito preceder las "ariables de entrada con el operador de dirección V.
En CII el operador de e1tracción se encarga de calcular la dirección% de almacenamiento
de la "ariable% los requisitos de almacenamiento y el formato.
Salida 6&#ma)ada n CII
(odemos "er el operador de salida% 44% como un medio rápido y tipo borrador% para la
salida de muc$os tipos comunes de información. Sin embargo cuando se necesita más
precisión% ;AA la proporciona con la función !&#m. 0a función !&#m tiene dos
propiedades que permiten su uso fle1ible en el alto ni"el .
(rimero pueden escribir una lista de argumentos de longitud arbitraria.
Segundo% la impresión está controlada por formatos simples de la misma forma que printf
en stdio.$
Ejemplos 2
cout 44 !&#m(=Wn aXP..&f =%a)8
cout44 !&#m(=WnWtWt Usando el H y la E se escribe a como WtXPAHL.&E=%a)B
(ero esto no es necesario para la "ersión '. y posteriores
OPERACIÓN DE ASIGNACIÓN:
Es la operación mediante la cual se le asigna un "alor determinado a una "ariable
en memoria.
SINTAGIS: 4#dentificador5X4e1presión5
Estamos indicando a la computadora que e"alJe la e1presión y la almacene en la
"ariable que se identifica por el identificador. una e1presión puede ser un "alor de
constante% o fórmula matemática.
E-m.l&':
NorasX'?B salarioX+???B caracterXY;Y8 salarioXsalario A ???B
NUNCA se escribe la e1presión a la i-quierda del operador de asignación2
salarioT& X salKtotal
OPERADORES ARITMETICOS
OPERADOR OPERACIÓN [UE REALI\A
A Sumar
H <estar
T Zultiplicar
M !i"idir
P ;alcular el <esiduo de di"isión entera
AA #ncremento
HH <estar
El operador P calcula el residuo que queda al di"idir dos nJmeros enteros% el
siguiente programa muestra lo que reali-a ese operador 2
@include 4stdio.$5
@include 4conio.$5
"oid main( "oid)
[ int aX'%bX& B
printf(7Pd8%aPb)%
/
0os operadores AA o \ son operadores que no e1isten en lenguajes como O6S#; y
(6S;60 y que permiten abre"iar muc$as e1presiones aritméticas.
Suponga que tenemos el siguiente programa en ; 2
@include4stdio.$5
@include4conio.$5
"oid main( "oid)
[ int aX' %e% c% dX&'% bX+B
aXaAB cXbAA%
eXAAd
printf(7Pd Pd Pd Pd8%a%c%b%d) B
/
OTROS OPERADORES DE ASIGNACIÓN
En ; e1isten los siguientes operadores de asignación 2AX% TX% X% MX y PX% donde la
sinta1is cuando se quiere utili-ar uno de esos operadores es 2
Cidn)i!icad&#DC&.#ad&# d a'i5naci*nDC(.#'i*nD
*eamos algunos ejemplos del uso de esos operadores 2
EGPRESIÓN EGPRESIÓN
E[UI"ALENTE
aXaA& aAX& B
<esiduo de di"idir a y
b
como aX' y bX&
escribe
El programa imprime ) como el "alor de a% pues
aXaA incrementa el "alor de a en y lo almacena en a.
El programa imprime como "alor de c un + pero como
"alor de b escribe ,.
0a ra-ón de este e1traño comportamiento es que en
cXbAA% primero se asigna a la "ariable c el "alor de b y
luego se incrementa el "alor de b en uno mediante el
operador AA.
El "alor que escribe de e es &)% primero suma uno a d y
luego asigna el resultado a e. El "alor que escribe de d
es &)
bXbA(iA) bAXiA+ B
-X-M? -MX? B
jX jP(jH&) jPX(jH&)
El identificador es una "ariable.
]ERAR[U^A DE LOS OPERADORES ARITM_TICOS :
;uando la computadora e"alJa una e1presión aritmética sigue los siguientes criterios
para obtener el resultado.
. En una operación aritmética que incluya "arios operadores aritméticos% los
operadores AA%HH tienen la má1ima prioridad% le siguen en prioridad T% M% P.
&. En una e1presión aritmética compuesta% las operaciones que están asociadas con
los operadores A% H se ejecutan después de $aberse ejecutado todos los operadores
aritméticos enunciados en la primera regla.
' . Si en una e1presión e1isten "arios operadores aritméticos que tengan la misma
prioridad% estos se resuel"en de i-quierda a derec$a
E]EMPLO2

x
b b ac
a
·
− t −
&
)
&
0a e1presión queda bien escrita si se usan los paréntesis as:2
] X (Hb A sqrt(b T b H )TaTc)) M (& T a)B
CON"ERSlÓN DE TIPO DE DATOS:
Se dice que una e1presión de asignación in"olucra operaciones de modo mi1to cuando
in"olucra "ariables de distinto tipo.;uando ; y ;AA% e"alJan una e1presión que in"olucra
"ariables de distinto tipo reali-a con"ersión automática de un tipo de dato a otro%
[u im.licaci&n' )in '& ^ Es bueno tener presente que los datos de diferente
tipo son almacenados de modo diferente en memoria.
E]EMPLO:
Si en un programa en ; tenemos que a y b son "ariables de tipo float y c es de tipo
int% las siguientes e1presiones2
aX+.? B bX&.? B cXaMb B
6lmacenar:an en c el "alor & pues la di"isión da &.+ pero al con"ertirlo a entero lo trunca
E]EMPLO: resulKfloatX"alorKfloatT"alorKint%
0a operación anterior es de tipo mi1to% cuando se "a a reali-ar la multiplicación el
"alor de la "ariable "alor int se con"ierte a nJmero float y luego se $ace la multiplicación.
El proceso se reali-a as:2 la computadora lee el "alor almacenado en la "ariable y es
con"ertido a float para la reali-ación de la multiplicación pero sin cambiar el "alor en
memoria% cuando se reali-a la multiplicación el resultado es float.
E1iste una jerarqu:a de con"ersión en la que el dato de prioridad más baja es con"ertido
temporalmente al tipo de prioridad más alta para reali-ar cálculos. 0a siguiente tabla
muestra la jerarqu:a de con"ersiones desde la prioridad más alta $asta la más baja2
double
float
long
int
s$ort
;uando un tipo es con"ertido a otro tipo que tiene más d:gitos significati"os% el
"alor del nJmero y su precisión quedan inalterados.
E]EMPLO:
Supongamos que tenemos el siguiente programa2
"alorlKintX' B "alor&KfloatX) B
"alorKfloatX..? B
resulKfloatX"alorKfloat A "alorlKintM"alor&KfloatB
0a computadora al di"idir %al&#l7in)M%al&#S7!l&a) dic$a operación es de tipo mi1ta por
tanto el ' se con"ierte a nJmero float y la di"isión da ?. .+ que al sumarle . da ...+.
DE6INICIÓN DE 6UNCIONES :
0as computadoras no saben reali-ar por si mismos operaciones complejas como2
calcular un logaritmo% e"aluar la función seno% la tangente% por tal moti"o es necesario
que los lenguajes% den al programador% instrucciones que le permitan al computador saber
como calcular dic$os "alores.
El ; del estándar 63S# define && funciones matemáticas que entran en las siguientes
categor:as2 >unciones trigonométricas% $iperbólicas% logar:tmicas y e1ponenciales% otras.
=odas las funciones matemáticas necesitan que se incluya el arc$i"o de cabecera ma)$+$
en cualquier programa que las utilice.
d&u3l l&5( d&u3l () :
(ermite calcular el logaritmo neperiano (base e) del argumento 1. (roduce error si 1 es
negati"o o si 1 X?.
E]EMPLO: _X log (1) A ,B
d&u3l l&5FM(d&u3l ()
(ermite calcular el logaritmo en base ? del argumento 1. (roduce error si 1 es negati"o o
si 1 X?.
E]EMPLO2 _X log ?(1) A ,B
d&u3l (.(d&u3l ():
(ermite calcular el e1ponencial del argumento 1% es decir permite calcular e
1
E]EMPLO: _X e1p(1)B
d&u3l '4#)( d&u3l ():
(ermite calcular la ra:- cuadrada del argumento. El argumento debe ser mayor o igual
que cero y real% el resultado es real. Se usa de igual manera que las funciones anteriores.
d&u3l .&`(d&u3l 3a', d&u3l (.):
3os de"uel"e el argumento base ele"ado a e1p(base
e1p
)
E]EMPLO: El siguiente programa escribe dos ele"ado al cuadrado
@include 4mat$.$5
@include 4stdio.$5
"oid main("oid)
[
printf(UPlfUY%po`(&%&))
/
d&u3l 'in( d&u3l (), d&u3l c&'(d&u3l ()
Estas dos funciones nos permiten calcular Seno y ;oseno respecti"amente de sus
argumento dado en radianes. Se usa de igual manera que las funciones anteriores.
d&u3l a)an( d&u3l ()
Esta función de"uel"e el arco tangente de 1. El "alor de 1 debe estar en el rango de H a lB
en cualquier otro caso se produce un error de dominio. El "alor se especifica en radianes
.
d&u3l a)anS( d&u3l 2, d&u3l () :
Esta función de"uel"e el arco tangente de yM1. Utili-a el signo de su argumento para
obtener el cuadrante del "alor de"uelto. El "alor de 1 se especifica en radianes.
d&u3l a3'(d&u3l () :
;alcula el "alor absoluto de un nJmero dado.
d&u3l !a3'(d&u3l () :
!e"uel"e el "alor absoluto de 1.
d&u3l !l&&#(d&u3l ():
=oma el argumento y retorna el mayor entero que no es mayor que 1. (or ejemplo
floor de .?& de"uel"e .?% el floor de H.?& de"uel"e H&.
d&u3l !m&d(d&u3l (, d&u3l 2) :
0a función fmod calcula el residuo de la di"isión entera de 1My.
INSTRUCCIONES DE CONTROL 2 CICLOS REPETITI"OS
6LU]O DE CONTROL:
Se llama flujo de control de un programa al orden en que se ejecutan las
instrucciones que lo conforman.
El flujo de control de los programas% es lineal% esto significa que la computadora
ejecuta una a una las instrucciones que se le indican% sin alterar el orden en que se
escriben.
EGPRESION LÓGICA:
Una e1presión lógica en ; es una sentencia que al ser e"aluada% la computadora da un
"alor ? si es falsa y un "alor distinto d c#& si es "erdadera.
OPERADORES DE RELACIÓN:
0os siguientes operadores los utili-aremos para construir e1presiones lógicas y establecen
relaciones que pueden ser falsas o "erdaderas.
OPERADOR SIGNI6ICADO
5X Zayor o igual que
4X Zenor o igual que
X X #gual que
aX !iferente
4 Zenor que
5 Zayor que
E]EMPLO:
6AO5X;T&B ]X XYSYB ]45SB
0a e1presión2 -X aAb5XcT&B
;ompara el "alor de la suma de a y b con el doble de c% si es menor almacena en -
el "alor ? si es mayor o igual almacena un "alor distinto de cero.
OPERADORES LÓGICOS:
OPERADORES SIGNI6ICADO
<< 2
EE &
a n&
E]EMPLOS:
Si tenemos la e1presión 2 a(+5') al e"aluarla el resultado que da es ?.
0a e1presión2 -Xa(+5')B 6lmacena ? en la "ariable -
0a e1presión2 -Xa(aAb5XcT&)
6lmacena en la "ariable - si el resultado de comparar aAb con el doble de c es menor%
puesto que la proposición es falsa% al negarla da "erdadera
PRIORIDAD DE OPERADORES:
=eniendo los operadores ya definidos% debemos definir la prioridad nue"amente as:2
CATEGOR^A
DEL
OPERADOR
OPERADORES ASOCIATI"A
9peradores Zonarios H%AA%HH%a% si-eof(tipo) !erec$a a #-quierda
Zultiplicación di"isión y
residuo
T% M% P #-quierda a !erec$a
Suma y sustracción
aritmética
A% H #-quierda a derec$a
9peradores de relación 4% 4X% 5% 5X #-quierda a derec$a
9peradores de igualdad X X % aX #-quierda a derec$a
y VV #-quierda a derec$a
o bb #-quierda a derec$a
9peradores de
asignación
X% AX% H X% TX% MX% PX #-quierda a derec$a
0as e1presiones entre paréntesis se e"alJan primero.
0os operadores de asignación tiene menor prioridad que todos los otros
operadores. (or tanto las operaciones monarios% aritméticos% de relación% de igualdad y
lógicos se reali-an antes que las de asignación.
INSTRUCCIÓN i! ((.#'i*n l*5ica) l':
0a instrucción si e"alJa la e1presión lógica% si ésta es "erdadera% ejecuta la
instrucción definida en 4acci*n 65% si es falsa se ejecuta la instrucción inmediata al l'
definida en 4acci*n O5% después de eso ejecuta la instrucción siguiente a la 4acción O5 y
las que le siguen
E1presión lógica
Si N&
6cción 6 6cción O
i! (e1presión lógica)
CAcci*n AD8
l'
CAcci*n /D8
E]EMPLO2
Escriba un programa en lenguaje ; que le permita a un estudiante calcular la nota
definiti"a de tres notas% que tienen el mismo "alor porcentual. El programa debe imprimir
la nota definiti"a y un mensaje adecuado que diga Ycano la materiaY% o Y(erdió la ZateriaY%
segJn si la nota sea mayor igual que cero o menor que cero.
@include 4stdio.$5
"oid main()
[ double nota% nota&% nota'B
double definiti"aB
clrscr()B
printf(UEscriba la primera notaWnU)B
scanf(UPlfU%Vnota)B
printf(UEscriba la segunda notaWnU)B
scanf(UPlfU%Vnota&)B
printf(UEscriba la tercera notaWnU)B
scanf(UPlfU%Vnota')B
definiti"aX(notaAnota&Anota')M'B
if (definiti"a5X,)
printf(USu nota es Pf c639U%definiti"a)B
else
printf(USu nota es Pf (E<!#9U%definiti"a)B
getc$()B
/
9tra "ersión del programa usando la instrucción que $emos "isto es2
@include 4iostream.$5
@include 4conio.$5
@define gano Ucano la ZateriaU
@define perdio U(erdio la ZateriaU
%&id main()
[ d&u3l nota% nota&% nota'B
d&u3l definiti"aB
clr'cr()B
c&u)44UEscriba la primera notaUB
cin55notaB
c&u)44UEscriba la segunda notaUB
cin55nota&B
c&u)44UEscriba la tercera notaUB
cin55nota'B
definiti"aX(notaAnota&Anota')M'B
i! (definiti"a5X,)
c&u)44USu nota es U44definiti"a44ganoB
else
c&u)44USu nota es U44definiti"a44perdioB
getc$()B
/
SENTENCIA COMPUESTA:
;uando un programador% necesita que la computadora ejecute más de una
instrucción en el momento de que la e1presión lógica sea "erdadera o sea falsa% lo indica
encerrando entre lla"es [ / las instrucciones que siguen al )$n & al l'.
E]EMPLO:
Escriba un programa que lea tres nJmeros reales a% b% c. Una "e- le:dos% el programa debe
calcular la solución a la ecuación2
A X B X C T T
&
? + + ·
y debe escribir las soluciones reales si e1isten y las soluciones complejas.
@includ 4iostream.$5
@includ 4conio.$5
@includ 4mat$.$5
@d!in imagin YiY
%&id main(%&id)
[ d&u3l a%b%c%
discri% preal%
1% 1&% pimagB
cl#'c#() B
c&u)44UE'c#i3 l&' c&!icin)' ^UB
cin 55a55b55cB
discriX.&`(b%&)H)TaTcB
i! (discri5X?)
{ 1X(HbA'4#)(discri))M(&Ta)B
1&X(HbH'4#)(discri))M(&Ta)B
cout44U]XU441B

bTb H )TaTc 5X ?
discri2XbTb H )TaTc
La a%b%c
3o Si
x
b discri
a
&
&
·
− −
T

x
b discri
a

&
·
− +
T

pimag
discri
a
·
&T

preal
b
a
·

& T

E'c#i3a2
YY1&XY%1&
E'c#i3a2
YY1XY%1
E'c#i3a2
YY1&XY%preal%YHiY%pimag
E'c#i3a2
YY1XY%preal%YAiY%pimag
La2 Enter
E'c#i3a2
YY =ermine de resol"er la ecuacion% presione Enter Y
cout44U1&XU441&B
}
l' {
prealXHbM(&Ta)B pimagXsqrt(abs(discri))M(&Ta)B
c&u)44UWn 1XU44preal448imagin844pimagB
c&u)44UWn 1XU44preal448imagin844HpimagB
}
getc$()B
/
I6 ANIDADOS :
=endremos situaciones lógicas en las cuales después de $acernos una pregunta se
nos $ace necesario $acer una nue"a pregunta% en esos caso tenemos entonces que después
del )$n yMo l' es necesario "ol"er a tener una sentencia i! )$n l' decimos entonces
que anidamos i!.
E]EMPLO:
Se requiere un programa que lea 6 y permita e"aluar la función
#includ C')di&+$D
#includ Cma)$+$D
%&id main()
{ d&u3l a,28
cl#'c#()8
.#in)!(= En)# un num#& #al =)8
'can!(=;l!=,<a)8
i! (aCQ)
2KLXa I '4#)(IIa)8
l'
i! ((aDKQ)<<(aCKY))
2KaILH(aIS)TQ8
l'
2K(.(QXl&5(a))IOXa8
.#in)!(=2K;O+Sl!=,2)8
5)c$()8
}
INSTRUCCIÓN `$il
y
x x x
x
x
x
x x x
·
+ + >
+ −
+
<· <·
+ >·
¹
'
¹
¹
¹
+ '
+
&
'
' L
. L
'
T
T
0a instrucción `$ile $ace que la computadora repita la ejecución de las
instrucciones mientras la condición es "erdadera.
En el lenguaje C esa instrucción tiene la siguiente sinta1is2
!entro de las instrucciones a repetir debe $aber al menos una instrucción que
$aga que la condición sea falsa% de lo contrario no saldrá del ciclo.
E]EMPLO:
Escribir un programa que lea un nJmero entero n% luego de lo cual la computadora debe
escribir todos y cada uno de los nJmeros entre y n luego debe escribir cuanto "ale la
suma de esos nJmeros.
@include 4iostream.$5
@include 4conio.$5
"oid main()
[ float n% numero% suma B
goto1y(?%?)B
te1tcolor(lig$tyello`)B
cout44UWn Escriba numero $asta donde desea que cuente ^UB
cin55nB
numeroXB
sumaX?B
`$ile (numero4Xn)
[ suma AX numeroB
cout44numeroB
numero AX B
/
goto1y(?%&)Bcout44U0a sumaXU44sumaB
getc$()B
/
E]EMPLO:
Escriba un programa que lea un nJmero entero n y luego calcule y escriba los n primeros
términos de la serie ?% % % &% '% +% I% '% &% ')% ++% IL.........
@include4iostream.$5
@include4conio.$5
"oid main()
[ double n% t% af% ai% an% sumaB
`$il ((.#'i*n l*5ica )
{
In')#ucci&n' a
R.)i#
}
E1presion lógica
#nstrucciones
a
<epetir
clrscr()B
cout44UEscriba el nJmero de terminos a crearUB
cin55nB
afX?B aiXB anX?B
tXB sumaX?B
`$ile (t4Xn)
[ cout44an44U%WtUB
sumaAXanB
af X aiB
aiX anB
an Xaf A anB
tAXB
/
cout44UWnWnWala suma "aleU44 sumaB
getc$()B
/
INSTRUCCIÓN d& T `$il ((.#'i&n l*5ica):
0a instrucción doM`$ile la utili-an los programadores para indicarle al computador que
debe ejecutar una o "arias instrucciones mientras que una condición definida en la
e1presión lógica sea "erdadera% a diferencia del `$ile% la condición se e"alJa después de
ejecutar las instrucciones a repetir al menos una "e-.
d&
{
#nstrucciones a
<epetir
}`$il((.#'i*n l*5ica)8
E]EMPLO:
Escriba un programa que lea un nJmero entero n y luego calcule y escriba los n
primeros términos de la serie ?% % % &% '% +% I% '% &% ')% ++% IL.........
Este programa es el mismo que "imos en las páginas del `$ile% obser"e como se puede
reali-ar lo anterior usando el d&T`$il.
@include4iostream.$5
Min)#a' e1pr. lógica
In')#ucci&n'
a
R.)i#
@include4conio.$5
"oid main()
[ double n% t% af% ai% an% sumaB
clrscr()B
te1tcolor(O0UE)B
cout44UEscriba el numero de termino a crearUB
cin55nB
afX?B aiXB
anX?B
tXB
sumaX?B
do
[ cout44an44U%WtUB
sumaXsuma A anB
af X aiB
aiX anB
anXaf A anB
tXtAB
/`$ile (t4Xn)B
cout44UWnWnWala suma "aleU44 sumaB
getc$()B
/
LA INSTRUCCIÓN for:
0a utili-an los programadores para indicarle al computador que ejecute un
conjunto finito de instrucciones mientras una condición dada se cumpla.
0a sinta1is de la forma general de la sentencia for es2
for (inicialiVaci*nB c&ndici*nB inc#mn)&)
'n)ncia7a7-cu)a#B
El bucle for permite muc$as "ariaciones% pero e1isten tres partes principales2
.La inicialiVaci*n2 3ormalmente es una sentencia de asignación que se utili-a para la
iniciali-ar una "ariable de control del bucle.
&.La c&ndici*n2 Es una e1presión lógica que determina cuando finali-a el bucle.
'.El inc#mn)&2 ;omo cambia la "ariable de control cada "e- que se repite el bucle.
0as tres secciones se separan por 8 (.un)& 2 c&ma) el bucle se repite $asta que la
condición sea falsa.
E]EMPLO2
Escriba un programa que calcule el factorial de un numero entero n.
@includ 4i&')#am.$5
@includ 4c&ni&.$5
%&id main ( )
[
float factorial X % n% factorB
clrscr ( )B
cout44 UEntre un numero al cual le quiere calcular el factorialUB
cin55 nB
for (!ac)&# K nB factorB factorHH)
[ factorialTXfactorB
/
cout44n44UaXU44 factorialB
/
EL OPERADOR COMA+
0a coma en U;U tiene como función encadenar "arias e1presiones. Esencialmente%
la coma produce una secuencia de operaciones. ;uando se usa en la parte derec$a de una
sentencia de asignación% el "alor asignado es el "alor de la ultima e1presión de la lista
separada por coma.
E]EMPLO:
y X??B MT y toma el "alor de ??TM
1 X( y X yH+?%??My)B MT y "ale +? y ??M+? es &TM
tras la ejecución 1 X&.
Se puede pensar en el operador coma% teniendo el mismo significado que la
palabra en español normal U$a- esto y esto y estoU.
"ARIACIÓN DEL CICLO for:
Utili-ando el operador coma se puede $acer que el ciclo for tenga dos o mas
"ariables de control del bucle.
E]EMPLO:
Escribe un programa que lea un numero entero n% el programa debe encontrar
cuanto suman los n primeros nJmeros pares e impares.
@include 4iostream.$5
@include 4conio.$5
"oid main ( )
[ int n% par% sum%imp% sump% sumi% numerosB
clrscr ( )B
sumXsumpXsumi X ?B
cout44U;ual es el "alor de nUB
cin55nB
for(numeros X % parX&% impXB numeros4X nB AAnumeros% parAX &% impAX &)
[ cout44UWnWtWt impar U44imp44U par U44parB
sumpAXparB
sumiAXimpB
/
cout44U WnWt S imparesXWaU44sumi44U S paresXWaU44sumpB
getc$()B
/
INSTRUCCIÓN break
Se puede usar para for-ar la terminación inmediata de un bucle% saltando la
e"aluación de la condición normal del ciclo.
;uando se encuentra la instrucción break dentro de un bucle finali-a
inmediatamente% y la ejecución continua con la instrucciones que siguen al ciclo.
INSTRUCCIÓN c&n)inu+
0a sentencia continue% fuer-a una nue"a iteración del bucle y salta cualquier código que
e1ista entre medios.
do [
cout44UEntre un numero igual a ??UB
cin551B
if ( 14?) continueB
cout44 1B
/ `$ile (1aX??)B
El ciclo anterior repite la lectura mientras 1 sea negati"o.
(ara los bucles `$ile y doH`$ile% una sentencia continue $ace que2 el control del
programa no ejecute la prueba del condicional y continue el proceso de iteración.
En el bucle for se ejecuta se ejecuta la parte del incremento del bucle% seguida de la
prueba condicional y finalmente $ace que el bucle continue.
E]EMPLO:
Escriba un programa que lea un nJmero entero n y determine si n es primo o no.
<ecuerde que un nJmero es primo si no e1isten nJmeros en el inter"alo entre & y nM& que
di"idan a n.
@include 4iostream.$5
@include 4conio.$5
"oid main()
[ int n% di"isor%esB
clrscr()B
cout44UEscriba el numero que "a anali-ar^UB
cin55nB
di"isorX&B esXB
`$ile (di"isor4XnM&)
[ if(n P di"isorXX?)
[ cout44UWnU44n44U no es primoUB
esX?B
breadB
/
else
[ di"isorAXB
/
/
if (es)
[ cout44UWnU44n44U es primoUB
/
getc$()B
/
0a "ariable ' se $ace al
empe-ar el ciclo% y se pone
cero si en algJn momento
algun di"isor di"ide a n.
Solo al finali-ar el proceso
se c$eque si es es uno.
En ; este if es
equi"alente a
escribir2
if (esXX)
0a instrucción break $acen que el ciclo termine en el momento en que se encuentra
algJn di"isor de n.
;uando se termina el ciclo la computadora c$eque si la "ariable ' tiene almacenado un F
si eso es "erdad el nJmero es primo.
INSTRUCCIÓN '`i)c$:
Esta instrucción permite "erificar si una "ariable de tipo c$ar o int tiene un "alor
determinado.
'`i)c$(variable){
ca' constanteF2 instruccionesB
3#ab8
ca' constanteS 2 instrucciones&B
3#abB
........
ca' constanten 2 instrucciones'B
3#abB
d!aul) : #nstrucciones por defectoB
}
0a instrucción '`i)c$ compara el "alor de la "ariable con la c&n')an)F% si son
iguales ejecuta las in')#ucci&n'F y llega al 3#ab% y ejecuta luego las instrucciones
siguientes a la lla"e }+
Si no son iguales compara el "alor de la "ariable con el "alor de la c&n')an)S% sino
son iguales compara con el de la c&n')an)Q% y as: sucesi"amente.
Si no e1iste ninguna constante igual al "alor de la "ariable ejecuta el d!aul), si
este e1iste% sino continua con la ejecución de las instrucciones después de la lla"e }+
El bread en cada caso es opcional% sino e1iste se ejecutan las instrucciones
siguientes $asta encontrar un 3#ab.
E-m.l&:
Escriba un programa que presente un menJ con tres opciones2 0a opción Sumar%
& <estar% ' Salir.
Si el usuario presiona la opción % la computadora le pregunta por dos nJmeros
enteros y por el "alor del resultado de la suma y le dice si el resultado es correcto o no.
Si el nJmero presionado es el &% la computadora le pregunta por dos nJmeros
enteros y por el "alor de la diferencia y le dice si el resultado es correcto o no.
Si es ' termina con la ejecución del programa.
#includ Ci&')#am+$D
#includ Cc&ni&+$D
%&id main()
{ c$a# &.ci&n8
!l&a) a,3,#'.u')a8
d&{
cl#'c#()8
5&)&(2(FM,FM)8
c&u)CC=La' &.ci&n' '&n:=8 5&)&(2(FM,FS)8 c&u)CC=FHSuma# d&'
num#&'=8
5&)&(2(FM,FQ)8 c&u)CC=SHR')a# d&' num#&'=8
5&)&(2(FM,FR)8 c&u)CC=QHT#mina# l .#&c'&=8
&.ci&nK5)c$()8
'`i)c$ (&.ci&n){
ca' 9F9:cl#'c#()85&)&(2(FM,FS)8
c&u)CC=E'c#i3a un num#& =8 cinDDa8
5&)&(2(FM,FQ)8
c&u)CC=E'c#i3a l &)#& 'umand& =8
cinDD38
5&)&(2(FM,FR)8
c&u)CC=Cuan)& 'uman =CCaCC=I=CC38 cinDD#'.u')a8
i! (#'.u')aKK(aI3))
{
5&)&(2(FM,FN)8 c&u)CC=R'.u')a c&##c)a =8
}
l'
{
5&)&(2(FM,FN)8
c&u)CC=La #'.u')a n& ' =CC#'.u')aCC= la #' c&##c)a ' =CCaI38
}
5&)&(2(FM,FO)8c&u)CC=T#min .#'i&n cual4ui# )cla=8
5)c$()8
3#ab8
ca' 9S9:cl#'c#()8 5&)&(2(FM,FS)8
c&u)CC=E'c#i3a un num#& =8 cinDDa8
5&)&(2(FM,FQ)8 c&u)CC=E'c#i3a l 'u')#and& =8
cinDD38 5&)&(2(FM,FR)8
c&u)CC=Cual ' la di!#ncia n)# =CCaCC=H=CC38 cinDD#'.u')a8
i! (#'.u')aKK(aH3))
{ 5&)&(2(FM,FN)8 c&u)CC=R'.u')a c&##c)a =8
}
l'
{
5&)&(2(FM,FN)8
c&u)CC=La #'.u')a n& ' =CC#'.u')aCC= la #' c&##c)a ' =CCaH38
}
5&)&(2(FM,FO)8 c&u)CC=T#min .#'i&n cual4ui# )cla=8
5)c$()8 3#ab8
ca' 9Q9:cl#'c#()8 5&)&(2(FM,FM)8c&u)CC=T#min=8
3#ab8 d!aul) : 5&)&(2(FM,FO)8
c&u)CC=P#'i&n '&l& F,S & Q=8
}
}`$il (&.ci&naK9Q9)8
}
"ECTORES Z MATRICES EN C:
0os "ectores y matrices también conocidos como 6rreglos% son "ariables en
memoria que pueden almacenar más de un dato del mismo tipo. Estas "ariables tienen una
caracter:stica y es que nos referimos a los elementos% almacenados en los "ectores o
matrices% utili-ando un nombre y nJmeros enteros que indican la posición de la celda en
el "ector o la matri-.
En ;AA podemos tener "ectores que almacenen datos de tipo2 carácter% enteros%
reales% punteros% estructuras.
P#&.idad':
. 0os datos indi"iduales se llaman elementos.
&. =odos los elementos tienen que pertenecer al mismo tipo de dato.
'.=odos los datos son almacenados en celdas contiguas en la memoria de la
computadora% y el sub:ndice del primer dato es el cero.
). El nombre del array es una ;te. que representa la dirección en memoria que ocupa el
primer elemento del "ector.
DECLARACIÓN DE UN "ECTOR:
(ara declarar un "ector siga la siguiente estructura2
)i.&7d7da)& n&m3#c )amad& e
!onde el tamaño es un nJmero entero que indica cuantas posiciones tiene el "ector.
E-m.l&: n&m3#
!l&a) n&m3#cRe8
M F S Q
in) da)&'cQe8
M F S
9bser"e en la declaración anterior el nJmero entero n entre corc$etes indica
cuantas posiciones tiene el "ector en memoria.
0as celdas en memoria se numeran desde ? $asta nH.
El "ector nombre puede almacenar nJmeros de tipo float% el "ector datos puede
almacenar ' nJmeros enteros.
INICIALI\ACIÓN DE ARREGLOS:
; permite darle "alores a las celdas de un "ector de la siguiente manera2
. (or omisión% cuando son creados. El estándar ANSI d C especifica que siempre que
declaremos un "ector (arreglo)% este se iniciali-a con ceros.
&. E1pl:citamente% al declarar el "ector suministrando datos iniciales constantes.
'. !urante la ejecución del programa.
En los siguientes renglones les "amos a mostrar como reali-ar dic$as acciones.
Sin)a(i':
)i.& n&m3#7dl7a##5l&c)amad&eK{ li')a d %al&#' }
InicialiVaci*n E(.lUci)a:
Significa que en el momento de declarar el "ector% se especifican los "alores as:2
in) numeroQ'RX[%&%'/B
num#&
& '
!l&a) $orasQ ) RX[F+S%FQ.PY%SQ.L%RL.P/B
$&#a'
F+S FQ+PY SQ+L RL+P
M F S Q
InicialiVaci*n n )im.& d -cuci*n:
Significa que la computadora ejecuta un ciclo `$il o !&# y con la instrucción
'can! o cin el programa almacena los "alores en las "ariables.
E-m.l&':
El siguiente ciclo muestra como se pueden almacenar datos en un "ector de n
posiciones% usando la instrucción cin2
!&# (iKM8iCn8IIi)
{
5&)&(2(FM,FL)8
c&u)CC=En)# ac=CCiCC=eK=8
cinDDacie8 }
E]EMPLO:
Escribir un programa que lea un nJmero entero n y la computadora lea y almacene
n componentes reales en dos "ectores a y b. 0uego debe calcular el producto escalar entre
a y b y escribir el resultado.
#includCi&')#am+$D
#includCc&ni&+$D
%&id main()
{ d&u3l acSMe,3cSMe8
d&u3l .#&d'cala#8
in) i,n8
d&{
TTE') d& `$il n& .#mi) 4u ' u'n ma' d SM clda'
5&)&(2(FM,FS)8cl#&l85&)&(2(FM,FM)8
c&u)CC=Cuan)a' clda' )inn l&' %c)&#'=8
cinDDn8
i! (nDSM){
5&)&(2(FM,FS)8
c&u)CC=El %c)&# n& .ud dcla#a#' c&n ma' d SM=8
}
}`$il (nDSM)8
!&# (iKM8iCn8IIi)
{
5&)&(2(FM,FL)8
c&u)CC=En)# ac=CCiCC=eK=8
cinDDacie8
3ote el ciclo "a
desde iX? $asta nH
5&)&(2(FM,FN)8
c&u)CC=En)# 3c=CCiCC=eK=8
cinDD3cie8
}
.#&d'cala#KM8
!&# (iKM8iCn8IIi)
{ .#&d'cala#IK3cieXacie8
}8
!&# (iKM8iCn8IIi)
{ c&u)CC=:)=CCacie8
}
c&u)CC=:n=8
!&# (iKM8iCn8IIi)
{ c&u)CC=:)=CC3cie8
}
c&u)CC=:n:) T#min .#'i&n cual4ui# )cla, El .#&duc)& 'cala#K=CC.#&d'cala#8
5)c$()8
}
ARREGLOS /IDIMENSIONALES:
El lenguaje ; y ;AA permite declarar arreglos de forma matricial. (ara declararlos
siga la siguiente sinta1is2
tipoKdeKdato n&m3#7a##5l&QnumeroKfilasRQnumeroKcolRB
E]EMPLO
!l&a) acQecQe8
a
? &
? ') )+ '
'+ ,. )+
& & ') +,
!onde la matri- a tiene ' filas y tres columnas en la memoria de la computadora.
INICIALI\ACIÓN DE ARREGLOS MATRICIAL:
; permite darle "alores a las celdas de una matri- de la siguiente manera2
. (or omisión% cuando son creados. El estándar ANSI d C especifica que siempre que
declaremos una matri-% esta se iniciali-a con ceros.
&. E1pl:citamente% al declarar la matri- suministrando datos iniciales constantes.
'. !urante la ejecución del programa.
Sin)a(i':
)i.& n&m3#7dl7a##5l&c)amad&ec)amad&SeK{ li')a d %al&#' }
InicialiVaci*n E(.lUci)a:
Significa que en el momento de declarar la matri-% se especifican los "alores as:2
in) numeroQ'RQ'RX[ [%&%'/%
[)%+%,/
[.%I%L/ /B
6qui se escribe
el *ector a
6qui se calcula el
producto escalar
num#&
& '
) + ,
. I L
InicialiVaci*n n )im.& d -cuci*n:
Significa que la computadora ejecuta un ciclo `$il o !&# y con la instrucción
'can! o cin el programa almacena los "alores en las "ariables.
E-m.l&':
El siguiente ciclo muestra como se pueden almacenar datos en una matri- de m
filas y n columnas% usando la instrucción cin2
for(iX?Bi4nBAAi)
for(jX?Bj4mBAAj)
[ goto1y(?%')B
cout44UEscriba aQU44i44U%U44j44URUB
cin55aQiRQjRB
/
El ciclo anidado anterior entra los datos a una matri-% por filas.
E-m.l&: El siguiente ciclo muestra como se pueden almacenar datos en una matri- de m
filas y n columnas% usando la instrucción cin2
for(jX?B j4m BAAi)
for(iX?Bi4nBAAj)
[ goto1y(?%')B
cout44UEscriba aQU44i44U%U44j44URUB
cin55aQiRQjRB
/
El ciclo anidado anterior entra los datos a una matri-% por columnas.
ESCRI/IR UNA MATRI\:
(ara escribir en la pantalla la computador los datos de una matri- que se encuentra
en la memoria% siga las siguientes instrucciones2
for(iX?Bi4mBAAi)
[ for(jX?Bj4rBAAj)
[ cout44UWtU44aQiRQjRB/
cout44UWnUB
/
cout44UWnUB
E]EMPLO:
Escriba un programa que lea dos nJmeros enteros m y n% la computadora entonces
permite entrar mTn elementos a una matri- 6 y a una matri- O% luego de ello obtiene una
matri- ;% que es la suma de 6 y O.
(ara cada i% se escriben
todos los elementos de
la fila% pues j "aria.
;ada que se termina de
recorrer todos los j $ay
que cambiar de fila.
#includCi&')#am+$D
#includCc&ni&+$D
%&id main()
{ in) i,-,m,n8
!l&a) acFMecFMe,3cFMecFMe,ccFMecFMe8
cl#'c#()8
5&)&(2(FM,FM)8
c&u)CC=Cuan)a' !ila' )inn la' ma)#ic'A=8 cinDDn8
5&)&(2(FM,FS)8
c&u)CC=Cu n)a' c&lumna' )inn la' ma)#ic'A=8
cinDDm8
!&#(iKM8iCn8IIi)
!&#(-KM8-Cm8II-)
{ 5&)&(2(FM,FQ)8
c&u)CC=E'c#i3a ac=CCiCC=,=CC-CC=e=8
cinDDaciec-e8
5&)&(2(FM,FR)8
c&u)CC=E'c#i3a 3c=CCiCC=,=CC-CC=e=8
cinDD3ciec-e8
}
TX P#&c'& d la 'uma d la' ma)#ic' XT
!&#(iKM8iCn8IIi)
!&#(-KM8-Cm8-II)
cciec-eKaciec-eI3ciec-e8
!&# (iKM8iCn8iII)
{ !&#(-KM8-Cm8-II)
{ c&u)CC=:)=CCcciec-e8}
c&u)CC=:n=8
}
5)c$()8
}TX 6in dl P#&5#ama XT
E]EMPLO:
Escriba un programa que lea tres nJmeros enteros m, # 2 n% la computadora
entonces permite entrar mX# elementos a una matri- 6 y #Xn elementos a una matri- /%
luego de ello obtiene una matri- C% que es la multiplicación entre A 2 /.
c A B
Con i m
j n
ij ik k j
k
r
·
·
·
·

T
2
...


(ara desarrollar dic$o producto se reali-a el siguiente ciclo anidado2
for(iX?Bi4mBAAi)
[ for(jX?Bj4nBAAj)
[ cQ i RQ j RX?B
for(dX?Bd4rBAAd)
cQ i RQ j RAXaQ i RQ d RTbQ d RQ j RB
Se garanti-a que cada
celda ;QiRQjRX? al iniciar
el cálculo de los aQiR
QdRTbQdRQjR
/
/
El siguiente es el código del programa que encuentra el producto de las dos matrices.
#includCi&')#am+$D
#includCc&ni&+$D
%&id main(%&id)
{ in) i,-,m,n,#,b8
!l&a) acFMecFMe,3cFMecFMe,ccFMecFMe8
cl#'c#()8 5&)&(2(FM,FM)8
c&u)CC=Cuan)a' !ila' )in la ma)#iV AA=8 cinDDm8
5&)&(2(FM,FS)8 c&u)CC=Cuan)a' c&lumna' )in la ma)#iV AA=8
cinDD#8 5&)&(2(FM,FR)8
c&u)CC=Cu n)a' c&lumna' )in la ma)#iV /A=8 cinDDn8
!&#(iKM8iCm8IIi)
{ !&#(-KM8-C#8II-)
{ 5&)&(2(FM,FN)8 cl#&l()8
c&u)CC=E'c#i3a l Ac=CCiCC=,=CC-CC=e=8 cinDDaciec-e8
}
}
!&#(iKM8iC#8IIi)
{ !&#(-KM8-Cn8II-)
{ 5&)&(2(FM,FP)8 cl#&l()8
c&u)CC=E'c#i3a /c=CCiCC=,=CC-CC=e=8 cinDD3ciec-e8
}
}
!&#(iKM8iCm8IIi)
{ !&#(-KM8-Cn8II-)
{ cciec-eKM8
!&#(bKM8bC#8IIb)
cciec-eIKaciecbeX3cbec-e8
}
}
!&#(iKM8iCm8IIi)
{ !&#(-KM8-C#8II-)
{ c&u)CC=:)=CCaciec-e8}
c&u)CC=:n=8
}
c&u)CC=:n=8
!&#(iKM8iC#8IIi)
{ !&#(-KM8-Cn8II-)
{ c&u)CC=:)=CC3ciec-e8}
c&u)CC=:n=8
}
c&u)CC=:n=8
!&#(iKM8iCm8IIi)
{ !&#(-KM8-Cn8II-)
c&u)CC=:)=CCcciec-e8
c&u)CC=:n=8
}
c&u)CC=:n=8
5)c$()8
}
E-m.l&:
Escriba un programa en lenguaje ; que lea los nJmeros enteros m y n% luego
permite entrar mTn elementos en una matri- 6.
0uego la computadora encuentra un "ector O que almacena el má1imo elemento de
cada columna de la matri-.
0a estrategia consiste en suponer inicialmente que el má1imo de cada columna es
el primer elemento de la columna es decir el aQ?RQ j R2
for(jX?Bj4nBAAj)
[ mXaQ?RQjRB
for(iX?Bi4nBAAi)
[ if(m4aQiRQjR)
[ mXaQiRQjRB
/
/
bQjRXmB
/
#includCc&ni&+$D
#includCi&')#am+$D
%&id main(%&id)
{ !l&a) acFMecFMe,3cFMe8
in) m,n,-,i8
cl#'c#()8
c&u)CC=:):nE'c#i3a la dimn'i*n d la ma)#iV=8
cinDDn8
!&#(-KM8-Cn8II-)
3c-eKM8
!&#(iKM8iCn8IIi)
!&#(-KM8-Cn8II-)
{ c&u)CC=:n:nE'c#i3a l Ac=CCiCC=,=CC-CC=e=8
cinDDaciec-e8
}
!&#(-KM8-Cn8II-)
{ mKacMec-e8
!&#(iKM8iCn8IIi)
{ i!(mCaciec-e)
{ mKaciec-e8
(ara cada columna
(para cada j)%
suponemos que el
má1imo es el primer
elemento de ella
;omparamos cada elemento
aQiRQjR de la columna j con todos
el má1imo (m)
6lmacenamos el
má1imo de cada
columna j% en la celda j
del "ector
}
}
3c-eKm8
}
!&#(-KM8-Cn8II-)
c&u)CC=:)=CC3c-e8
5)c$()8
}
CADENAS DE CARACTERES+
(ara almacenar en la memoria de un computador% una cadena de caracteres% es
necesario en el lenguaje ;% declarar un arreglo ("ector) de caracteres.
;uando la computadora almacena una cadena de caracteres% guarda después del
Jltimo carácter% el carácter nuloB que se especifica CW?E. (or está ra-ón para declarar
arrays de caracteres es necesario que el nJmero de posiciones que se declaren sea de uno
más que la cadena más larga que pueda contener.
Esto significa que% si se desea almacenar una frase como2 3acional es campeón
necesitamos declarar un "ector as:2
c$ar frase Q&?RB
En memoria la "ariable !#a' almacna l da)& a'U2
3 a c i o n a l e s c a m p e ó n YWoY
0as "ariables de tipo c$ar se pueden iniciali-ar de la siguientes maneras2
En l m&mn)& d dcla#a#l&':
c$ar nombre de array QtamañoR X UcadenaUB
c$ar nombre del arrayQtamañoR X [lista de caracteres /
E-m.l&2
c$ar aguaKestado'QIRXU0iquidoUB
de esta manera se añade automáticamente el caracter nulo al final de la cadena.
E-m.l&:
c$ar frase Q&?R X U3acional es campeónUB
ó
c$ar frase Q&?R X [ Y3Y%YaY%YcY%YiY%YoY%YnY%YaY%YlY%Y Y %YeY%YsY%Y Y%YcY%YaY%YmY%YpY%YeY%YóY%YnY%9:M9 /B
D'.uW' d la Dcla#aci*n d la %a#ia3l:
P&# mdi& d una a'i5naci*n d cada un& d l&' ca#ac)#':
Si declaramos los siguientes "ectores de caracteres2
c$ar aguaKestadoQ)RB
c$ar aguaKestado&Q.RB
(odemos iniciali-ar la "ariable aguaKestadoQ)R as:2
aguaKestadoQ?R X YgYB
aguaKestadoQRX YaYB
aguaKestadoQ&RX YsYB
;uando se
enumeran los
elementos se debe
declarar el
elemento de fin de
cadena.
aguaKestadoQ'RX YW?YB
P&# mdi& d una in')#ucci*n d Lc)u#a:
Se puede utili-ar la función cin% pero no podrá digitar espacios en blanco pues la
instrucción cin no los l.
(ara poder entrar datos que contenga espacios en blanco utilice la función
cin+5)(nombreK"ector%longitud)B
!onde nombreK"ector es la "ariable donde se "a almacenar lo que se digita%
lóngitud es un nJmero entero que indica cuantos elementos se "an almacenar.
6UNCIONES PARA EL MANE]O DE CADENAS+
6unci*n ')#c.2() pertenece a 4')#in5.$5 copia la cadena apuntada por s& en la
apuntada por s.
'in)a(i'2 c$ar Tstrcpy (c$ar Ts% const c$ar Ts&)B
Ejemplo2
Suponga que se declara una "ariable as:2
c$ar fraseQ +RB
!#a'

!espués de la ejecución de ')#c.2(frase%UZioU)B
0a "ariable en memoria es2
En el lenguaje ; está pro$ibido cosas como2
fraseXUZioUB
6unci*n ')#ca)() : pertenece a 4string.$5 Une la cadena apuntada por s& en la
apuntada por s.
sinta1is2 c$ar Tstrcat ( c$ar Ts% const c$ar Ts&)B
jemplo2
Suponga que declara las siguientes dos "ariables2
c$ar fraseQ&+RXU0a casaU% frase&Q?RXU es miaUB
!espués de ejecutar la instrucción strcat(frase%frase&)B en la memoria dla
computadora la "ariable !#a' se puede "er as:2
!#a'
0 a ; a s a e s Z i a W?
6unci*n ')#ln(): !e"uel"e la longitud de una cadena+
sinta1is2 int strlen ( const c$ar Ts)B
6unci*n ')#cm. ( c&n') c$a# X'F, c&n') c$a# X'S)
;ompara s y s&. !e"uel"e cero si las dos cadenas son iguales% mayor que cero si
la cadena apuntada por s es mayor que s& y menor que cero si la cadena apuntada por s
es menor que la apuntada por s&.
E-#cici&2 Escriba un programa que lea una palabras. 0uego el programa debe in"ertir la
palabra as: obtenida e imprimir la palabra que se obtiene al re"és.
*ariable en memoria
E-m.l&:
Si la .ala3#a ' l&5#&d' d3 im.#imi#: 'd&#5&l+
#includCi&')#am+$D
#includCc&ni&+$D
#includC')di&+$D
#includC')#in5+$D
%&id main(%&id)
{ c$a# !#a'cLMe,in%#'acLMe8
d&u3l l&n5i)ud,i8
cl#'c#()8
c&u)CC=:):nE'c#i3a la .ala3#a 4u d'a in%#)i# =8
cin+5)(!#a',RY)8
l&n5i)udK')#ln(!#a')8
!&#(iKM8iC')#ln(!#a')8IIi)
{ l&n5i)udKl&n5i)udHF8
in%#'acieK!#a'cl&n5i)ude8
}
in%#'ac')#ln(!#a')eK9:M98
c&u)CC=:n:n:)La in%#'a d =CC!#a'CC= ' =CCin%#'a8
c&u)CC=:):n:nT#minf=8
5)c$()8
}
E-#cici&: Escriba un programa que lea dos cadenas de caracteres y determine cual
cadena es mayor que la otra% el programa debe imprimir la longitud de la cadena mayor.
E-#cici&: Escriba este programa y analice que $ace% use para ello la ejecución paso a
paso% y obser"e el estado de las "ariables% mientras ejecuta el programa.
# includ C')di&+$D
# includ Cc&ni&+$D
# d!in )amlina FMM
%&id main ()
{
c$a# c, lUna c)amlinae8
in) i8
.#in)! (g :n $&la a C&m& ) llama' A g)8
!&# ( iKM8 ( cK 5)c$a#()) aK J:n@8 IIi)
lUna cie K c 8
lUna cie K J:M@ 8
.#in)! (g :n 5u')& n c&n&c#) g)8
!&# ( iKM8 lUna cie aK J:M@ 8 IIi)
.u)c$a# ( lUna cie)8
.#in)! (g :n Sa3' 4u )u n&m3# dl)#ad& al #%W' ' g)8
`$il ( iaKM)
.u)c$a# ( lUna cHHie )8
.#in)! (g :n:n [u )n5a' muc$a' !licidad' a :n:n:a g)8
5)c$ ()8
}
"ARIA/LES DE TIPO PUNTERO:
[UE ES UNA "ARIA/LE DE TIPO PUNTERO A
Una "ariable de tipo puntero es una "ariable que almacena la dirección en memoria
en que inicia una "ariable.
En el gráfico anterior la "ariable a es una "ariable de tipo puntero% pues almacena
el nJmero SMMM que es la dirección en memoria donde comien-a la "ariable da)&', que es
un %c)&# de carac)eres con siete posiciones.
a
&??? &??? ;
&?? 6
&??& <
&??' 0
&??) 9
&??+ S
&??, W?
datosQ.R
COMO SE DECLARA UNA "ARIA/LE DE TIPO PUNTERO A
(ara declarar una "ariable de tipo puntero proceda de la siguiente forma2
)i.& d da)& d la %a#ia3l a la 4u a.un)a Tn&m3#7%a#ia3l8
E]EMPLO: in) TpB
0a "ariable . es una "ariable puntero a "ariable n)#a% en otras palabras% . puede
guardar la dirección en memoria en que empie-an "ariables de tipo n)#&. c$a# XotraB
0a "ariable &)#a es una "ariable puntero a "ariable c$a#% en otras palabras% &)#a
puede guardar la dirección en memoria en que empie-an "ariables de tipo c$a#.
COMO SE LE DA "ALORES A UNA "ARIA/LE DE TIPO PUNTERO:
(ara almacenar en una "ariable de tipo puntero la dirección en que está una
"ariable en memoria e1isten dos métodos2
. Utili-ando el operador < (&.#ad&# d di#cci*n)B
&. Utili-ando la función mall&c()
UTILI\ANDO EL OPERADOR <2
El operador < lo utili-amos en los programas% cuando deseamos almacenar en una
"ariable de tipo puntero la dirección en que se inicia una "ariable en memoria.
E]EMPLO: Si en un programa en C se tiene la declaración siguiente2 in) a% X3B
bXVaB
E]EMPLO2
El siguiente ejemplo muestra como podemos alcan-ar a "ariar el "alor de una
"ariable entera% con el uso de un "ariable puntero a ella.
#includ Cc&ni&+$D
#includ Ci&')#am+$D
%&id main()
{ in) a,X.un)#&,inc#mn)&8
cl#'c#()8 5&)&(2(FM,FM)8
c&u)CC=E'c#i3a un num#& n)#& =8
cinDDa8 5&)&(2(FM,FS)8
c&u)CC=Di5a n cuan)& inc#mn)& a =CCa8
cinDDinc#mn)&8
.un)#&K<a8
X.un)#&KX.un)#& I inc#mn)&8
c&u)CC=:n:)La %a#ia3l a ')a n la di#cci*n =CC.un)#&8
c&u)CC=:n:)La %a#ia3l almacna =CCX.un)#&8
5)c$()8
}
EL OPERADOR X , OPERADOR DE INDIRECTO O DESRE6ERENCIA:
El ejemplo anterior utili-ó el operador T de una nue"a manera en el lenguaje ;% y
es muy importante que la entendamos% dic$o operador cuando se escribe a la i-quierda de
una "ariable de tipo puntero% nos permite acceder a la "ariable a la que apunta el puntero.
cuarda en la "ariable 3 la
dirección en memoria en que
está la "ariable entera a.
El operador X aqui está indicando que en la
"ariable apuntada por la dirección
almacenada en puntero sume el incremento.
En otras palabras como en .un)#& se
almaceno la dirección de la "ariable a
entonces% estamos diciendo que aumente el
"alor de a en el inc#mn)&.
Es decir2
TpunteroXTpuntero A incrementoB
es equi"alente a
aXaAincrementoB
6nalice y refle1ione el siguiente ejemplo2
Suponga que se tiene un programa en ; as:2
in) santosX% yX&% -Q?RB
in) TpunteroB
MT 0a "ariable puntero guarda la dirección donde está la "ariable santos en memoria%
decimos que el puntero apunta a santosTM
punteroXVsantosB
MT0a "ariable y guarda el "alor de la "ariable Santos TM
yXTpunteroB
TpunteroX?B MT 0a "ariable santos a$ora guarda ? TM
E]EMPLO: El siguiente ejemplo muestra como se puede acceder a los elementos de un
"ector con el uso de un puntero.
#includ Ci&')#am+$D
#includ Cc&ni&+$D
%&id main()
{ in) acLeK{FNP,FSM,SN,HN,O}
in) i,X.un)#&8
cl#'c#()8
.un)#&Ka8
!&# (iKM8iCn8iII)
{ c&u)CCX(.un)#&II)8
}
5&)&(2(FM,FM)8
c&u)CC=T#min, .#'i&n cual4ui# )cla=8
5)c$()8
}
E1plicación% la instrucción punteroXa% asigna en la "ariable puntero la dirección
donde comien-a el "ector a% es decir la dirección de la celda aQ?R.
<ecuerde que cuando definimos un "ector se dijo que el nombre de todo "ector es una
constante que tiene el "alor de la dirección inicial del "ector
for (iX?Bi4nBiAA)
[ cout44T(punteroAA)B
/
En el ciclo anterior la "ariable puntero se incrementa en unidad% lo que significa
que el puntero "a alcan-ando las direcciones de las celdas aQ?R% aQR% aQ&R% aQ'R% .... aQnR.
ARITM_TICA DE PUNTEROS:
<ecordemos que cuando se declara una "ariable en un programa en ;% lo $acemos para
que la computadora reser"e el espacio suficiente para poder representar los datos en
memoria.
(or eso cuando declaramos una "ariable como2 in) a% TpunteroB
0a computadora crea en memoria la "ariable 2
Di#cci*n
a
&
El gráfico muestra que la "ariable a ocupa en memoria & bytes% cada byte en
memoria tiene una dirección% podemos decir que la "ariable a% ocupa los bytes y & de la
memoria.
;uando escribimos aX')B
0a computadora almacena en la "ariable a% el nJmero ') en esos dos bytes as:2
Di#cci*n
a ? ? ? ? ? ? ? ?
& ? ? ? ? ? ?
;uando en un programa en ;% escribimos2
punteroXVaB
0a computadora almacena en la "ariable puntero% el nJmero que es la dirección
en memoria donde se inicia la "ariable a.
(ero qué es lo que $ace la computadora cuando escribimos2
punteroX puntero A B o punteroAXB o AApunteroB
0o que dir:amos es que en la "ariable puntero a$ora se almacena un S, .u' 3in,
'a ' una 'u.&'ici*n mu2 l*5ica .&# l& %i')& $a')a a4uU, .#& ' !al'a+
;uando la computadora "a incrementar en uno el "alor de una "ariable que es un
puntero% aumenta la dirección almacenada en el puntero en dos bytes% obteniendo de esta
manera la siguiente dirección de una "ariable donde podr:a estar un dato de tipo entero.
0a regla general es entonces2 por cada unidad que se incremente el "alor en una
"ariable puntero% se incrementa la dirección en el nJmero de byte que ocupa el tipo de
"ariable en memoria a la cual apunta el puntero.
E]EMPLO:
6nalice el siguiente ejemplo% utili-ando un computador% sino lo entiende "uel"a a leer el
item anterior o consulte con su profesor2
@include 4conio.$5
@include 4iostream.$5
"oid main()
[ int aQ+RX[,I%&?%&,%H,%./B
int i%TpunteroB
clrscr()B
cout44UEl "ector es2WnUB
for (iX?Bi4+BAAi)
cout44UWtU44aQiRB
iX?B
punteroXaAiBMT (untero guarda la posición inicial del "ector TM
cout44UWn (untero "ale U44punteroB
cout44UWn esa direccion tiene U44TpunteroB
cout44UWn Es lo que $ay en aQU44i44URUB
iXiA&BMT i "ale & TM
punteroXaAiB MT dirección almacenada en puntero es ) bytes después de la de aQ?R
MT <ecuerde por cada unidad que se incrementa el puntero a int TM
MT Se incrementa en dos byte la dirección TM
cout44UWnU44U(untero "ale U44punteroB
cout44UWn esa direccion tieneU44TpunteroB
cout44UWn Es lo que $ay en aQU44i44URUB
cout44UWn=ermine% presione cualquier teclaUB
getc$()B
/
INICIALI\ACIÓN DE UN PUNTERO A CARACTERES:
Una manera más "ersátil de manejar una cadena de caracteres en memoria es por medio
de la declaración de la forma siguiente2
c$a# T"ariableXU;adena de caracteresUB
0a "ariable se dice que es un puntero a cadena de caracteres2
Ejemplo2 c$a# T!#a' X UA##&V a la V&##aUB
;uando la computadora encuentra dic$a declaración ocurre lo siguiente2
& ' ) + , . I L ? & '
)

+
, .
frase 6 r r o - a l a - o r r a W?
0a computadora crea un espacio en memoria de . bytes y guarda all: la frase
A##&V a la V&##a, determina en que dirección queda almacenado el primer carácter de la
frase% luego crea la "ariable !#a' y guarda en esa "ariable la dirección donde quedo
almacenado el primer carácter% para nuestro ejemplo la dirección .
E]EMPLO:
El siguiente ejemplo muestra como escribir al re"és la frase
#includ Ci&')#am+$D
#includ C')#in5+$D
#includ Cc&ni&+$D
%&id main()
{ c$a# X.ala3#aK=A##&V a la V&##a=8
in) indic8
cl#'c#()8
!&#(indicK')#ln(.ala3#a)HF8indicDKM8indicHH)
{ c&u)CCX(.ala3#aIindic)8}
5)c$()8
}
E]EMPLO2
Este programa muestra como lle"ar los caracteres a un "ector de caracteres2
@include 4conio.$5
@include 4iostream.$5
@include 4string.$5
@include 4stdio.$5
@define Z6]#Z6S0E=<6S L
"oid main()
[ c$ar cadenaQZ6]#Z6S0E=<6SR% TpunteroB
int iB
clrscr()B
punteroXcadenaB
for (iX?Bi4Z6]#Z6S0E=<6SBiAA)
[
TpunteroXgetc$ar()B
AApunteroB
/
TpunteroXYW?YB
cout44U0os caracteres le:dos sonU44cadenaB
punteroXcadenaA(Z6]#Z6S0E=<6SH)B
cout44UWnUB
for(iX?Bi4Z6]#Z6S0E=<6SBiAA)
[ putc$ar(Tpuntero)B
HHpunteroB
/
getc$()B
/
A'i5naci*n Din>mica d Mm&#ia:
;uando se compila un programa de ;% la memoria de la computadora se di"ide en
) -onas que contienen el código del programa% toda la información global% la pila el
montón. El montón es un área de memoria libre (a "eces denominada almacenamiento
libre) y que es utili-ada por las funciones mall&c 2 !#.
6UNCIÓN mall&c:
;uando utili-amos la función malloc en un programa es porque queremos $acer uso
de una "ariable que será creada en el área de memoria conocido como el montón. 0a
función mall&c reser"a el espacio en esa área y retorna la dirección donde inicia el
espacio de memoria.
Sin)a(i': malloc(tamaño)B
(ertenece a la librer:a ')dli3.$
!onde )amad& es un nJmero entero con el cual indicamos cuantos bytes de la
memoria del montón deseamos reser"ar% la función retorna un número que es la
dirección en memoria donde se inicia el espacio que reservo% si fracasa intentando
reser"ar el espacio% retorna el "alor NULL.
La 6unci*n !#:
0ibera el espacio en memoria utili-ado en la memoria del montón y creado por la
función malloc. Se utili-a cuando no necesitamos tener en memoria ese espacio.
Sin)a(i': !#(nombre de "ariable puntero)8
Una "e- se utili-a la función !# ésta le asigna al puntero el "alor NULL% y deja el
espacio a donde apuntaba el puntero libre o disponible.
La !unci*n 'iV&!:
Sir"e para que la computadora calcule el tamaño de un tipo de dato dado% de
acuerdo con la máquina.
Sin)a(i': 'iV&!(tipo de dato)8
!onde tipo de dato es la palabra in), !l&a), l&n5 in), c$a# )c.
E]EMPLO:
Suponga en un programa en ;% quiere calcular el factorial de un nJmero n usando
"ariables creadas con la función malloc.
#includ Cc&ni&+$D
#includ C')dli3+$D
#includ Ci&')#am+$D
%&id main()
{ in) X.,Xi,X!ac)&#ial8
cl#'c#()8.K(in)X)mall&c('iV&!(in)))8
i! (.KK NULL)
{ c&u)CC=:n Mm&#ia in'u!icin)=8
(i)(M)8
}
l'{
c&u)CC=Pa#a 4u nhm#& 4ui#& l !ac)&#ial=8
cinDDX.8
}
!ac)&#ialK(in) X)mall&c('iV&!(in)))8
i! (!ac)&#ial KK NULL)
{ c&u)CC=Mm&#ia in'u!icin)=8
(i)(M)8
}
iK(in) X)mall&c('iV&!(in)))8
i! (iKK NULL)
{ c&u)CC=Mm&#ia in'u!icin)=8
(i)(M)8
}
l'{
X!ac)&#ialKF8
!&# (XiKF8(Xi)CK(X.)8II(Xi))
X!ac)&#ialXK Xi8
c&u)CC=:n=CCX.CC=aK=CCX!ac)&#ial8
}
!#(i)8
!#(.)8
!#(!ac)&#ial)8
c&u)CC=:n T#min .#'i&n )cla =8
5)c$()8
}
E]EMPLO:
El siguiente ejemplo muestra como podemos crear un arreglo de dimensión n en
memoria% y como podemos almacenar los n datos en el espacio reser"ado con la función
malloc% para finalmente escribir y sumar las n componentes del "ector.
#includ Cc&ni&+$D
#includ C')dli3+$D
#includ Ci&')#am+$D
%&id main()
{
in) X.,i,n,X'uma8
d&{
cl#'c#()8
5&)&(2(FM,FM)8
c&u)CC=Cuan)a' .&'ici&n' 4ui# 4u )n5a l %c)&#=8
cinDDn8
.K(in)X)mall&c(nX'iV&!(in)))8
i! (.KK NULL)
{ c&u)CC=:n Mm&#ia in'u!icin)=8
(i)(M)8
}
l'{ 5&)&(2(FM,FS)8
c&u)CC=Li')&, .ud #'#%a# l '.aci&=8
!&# (iKM8iCn8IIi)
{ 5&)&(2(FM,FQ)8 c&u)CC=E'c#i3a l Ac=CCiCC=e=8
cinDDX(.Ii)8 }
}
'umaK(in) X)mall&c('iV&!(in)))8
i! ('uma KK NULL)
{ c&u)CC=Mm&#ia in'u!icin)=8
(i)(M)8
}
X'umaKM8
!&# (iKM8iCn8iII)
{ c&u)CC=:)=CCX(.Ii)8
X'umaIKX(.Ii)8
}
c&u)CC=:nLa 'uma ' K=CCX'uma8
!#('uma)8
!#(.)8
c&u)CC=:n T#min .#'i&n )cla n .a#a !inaliVa# =8
}`$il (5)c$()aK9n9)8
}
6UNCIONES:
0as funciones son los bloques constructores de ; y el lugar donde se da toda la
acti"idad del programa.
la forma general de una función es2
'.ci!icad&#KdK)i.& n&m3#K!unci*n (parámetros formales )
[ declaracion de "ariables locales
cuerpo de la funciónB
#)u#n ("alor de"uelto)B
/
'.ci!icad&#KdK)i.&2 especifica el tipo de "alor que de"uel"e la función cuando
ejecuta el proceso% para lo cual fue programada.
En otras palabras indica que tipo de datos sale de la función en el momento de ejecutar el
#)u#n+
El especificador de tipo puede ser cualquier palabra como2 !l&a), in), c$a#, l&n5
in), d&u3l, in) X, !l&a) X, c$a# XB los Jltimos dos indican que la función retorna un
puntero% en otras palabras la función de"uel"e la dirección de algJn objeto en memoria.
Si no se especifica ningJn tipo el compilador asume que la función retorna un
entero. Si se escribe la palabra %&id indica que la función no retorna nada% y por tanto en
la función no $ay e1presión #)u#n & ')a .ud i# '*la n la !unci*n.
Si se escribe %&id T indica que la función retorna la dirección a un objeto de un
tipo cualquiera.
La li')a d .a#>m)#&' !&#mal'2 está constituida por una lista de nombres de
variables con sus )i.&' asociados% separadas por comas.
0e sir"en a la función para recibir información en el momento en que es llamada%
los parámetros son "ariables que toman sus "alores en el momento en que la función es
llamada desde el main() o desde cualquier función% y en ese momento reciben los
"alores que la función no puede saber por si misma pero son necesarios para poder
reali-ar la tarea para la cual fue programada.
E]EMPLO2
(iense siempre que "aya a construir una función como si fuese a construir una máquina.
*amos a construir una función que calcula el factorial de un nJmero.
(ara que la máquina pueda reali-ar su
tarea% necesita que le entremos el nJmero al
cual le "amos a calcular el factorial.

Entra el nJmero
al que "amos a
calcular el
factorial
Sale el factorial
del nJmero
=ambién necesita una salida por donde la función retorna el producto de su tarea% en este
caso el factorial calculado. Esos son los parámetros formales y el "alor retornado por una
función.
Una función puede no tener parámetros en cuyo caso la lista de parámetros
contiene sólo la palabra cla"e %&id.
La' %a#ia3l' l&cal':
Son todas aquellas "ariables que son necesarias para que el cuerpo de la función
pueda reali-ar sus tareas.
El cu#.& d la !unci*n:
Son las instrucciones que le indican a la función como reali-a el proceso que debe
lle"ar a cabo.
0a sentencia #)u#n2
=iene dos usos importantes2 primero% fuer-a una salida inmediata de la función en
que se encuentra% o sea % $ace que la ejecución del programa "uel"a al lugar del código
desde donde se llamó a la función. En segundo lugar % se puede utili-ar para de"ol"er un
"alor.
6 continuación se e1aminan ambos usos.
Salida d una !unci*n:
Una función puede terminar su ejecución y "ol"er al sitió en que se le llamo de dos
maneras2 0a primera ocurre cuando se $a ejecutado la Jltima sentencia de la función lo
que% conceptualmente% significa que se encuentra la lla"e } del final de la función.
0a mayor:a de las funciones emplean la sentencia #)u#n para terminar la
ejecución% bien % porque se tiene que de"ol"er un "alor o bien para simplificar el código
de la función y $acerlo más eficiente permitiendo mJltiples puntos de salida.
Es bueno tener en cuenta que una función puede tener "arios #)u#n.
"al&# D%ul)&:
=odas las funciones% e1cepto aquellas tipo %&id% de"uel"en un "alor. Este valor se
especifica explícitamente en la sentencia #)u#n. Si una función no es especificada
como "oid y si no se especifica un "alor de "uelta% entonces el "alor d%ul)& .&# la
!unci*n 4uda )Wcnicamn) ind!inid&.
Zientras que una función no se declare como %&id% puede ser usada como
operando en cualquier e1presión aritmética "alida de ;.
(or tanto el %al&# d%ul)& en el return es un "alor que está almacenado en una
"ariable% o es una constante.
EL USO DE LOS PROTOTIPOS:
(ara que una función quede bien declarada en un programa en ; se $ace necesario
la declaración anticipada de la función. Esta declaración anticipada se denomina prototipo
de función.
0os prototipos tienen dos cometidos especiales2
. #dentificar el tipo de dato que de"uel"e la función
&. Especificar el tipo y el nJmero de argumentos que utili-a la función.
LLAMADA DE UNA 6UNCIÓN :
Se puede llamar a una función especificando su nombre seguido de una lista de
argumentos encerrados entre paréntesis y separados por comas. Si la llamada a la
función no requiere ningJn argumento % se debe escribir a continuación del nombre de la
función un par de paréntesis "ac:os. 0os parámetros que se utili-an en la llamada normal
a una función% se llaman parámetros actuale y debe $aber uno por cada parámetro formal.
Llamada .&# %al&# , llamada .&# #!#ncia:
En general % se pueden pasar argumentos a las funciones de dos formas .
El primer método se denomina llamada .&# %al&#:
En este método se c&.ia l %al&# que tiene almacenado el parámetro actual (la
"ariable utili-ada en la llamada) en el parámetro formal% y los cambios que se $agan en el
cuerpo de la función sobre las "ariables que son parámetros de la función no afectan a las
"ariables que se usan en la llamada.
E]EMPLO2
Escriba una función que reciba por "alor un nJmero n y retorne el factorial del
nJmero.
El prototipo de la función es2 d&u3l factorial(double m)B
0a función factorial es2
d&u3l !ac)&#ial(d&u3l ()
{ d&u3l !ac)&#, !F8
!FKF8
!&# (!ac)&#K(8!ac)&#DKF8!ac)&#HH)
!FXK!ac)&#8
#)u#n !F8
}
El siguiente programa muestra como se utili-a la función factorial para calcular el
"alor de el nJmero combinatorio2
m
n
m
m n n
¸
¸

_
,
·

a
( )aT a
#includ Ci&')#am+$D
#includ Cc&ni&+$D
d&u3l !ac)&#ial(d&u3l m)8 TT P#&)&)i.& d la 6unci&n 6ac)&#ial
%&id main()
{
d&u3l c&m3ina)&#ia8 in) m, n8
cl#'c#()8 5&)&(2(FM,FM)8
c&u)CC=En)# l num#& d lmn)&' A=8 cinDDm8
5&)&(2(FM,FS)8 c&u)CC=En)# d a cuan)&' %a )&ma# A=8
cinDDn8 c&m3ina)&#iaK!ac)&#ial(m)T(!ac)&#ial(n)X!ac)&#ial(mHn))8
5&)&(2(FM,FQ)8 c&u)CC=C&m3ina)&#iaK =CCc&m3ina)&#ia8
5)c$()8
}
d&u3l !ac)&#ial(d&u3l ()
{ d&u3l !ac)&#, !F8
!FKF8
!&# (!ac)&#K(8!ac)&#DKF8!ac)&#HH)
!FXK!ac)&#8
#)u#n !F8}
*ariable 0ocales
0as "ariables locales no
pueden usar los mismos
nombres de los parámetros.
<etorna
el
factorial
0a llamada .&# #!#ncia2
En este método se copia la dirección de la "ariable en el parámetro de la función.
!entro de la función se usa la dirección para acceder al argumento usado en la llamada.
Esto significa que los cambios $ec$os a los parámetros afectan a las "ariables usadas en
la llamada de la función
E]EMPLO2
Escriba una función que reciba por "alor un nJmero n y retorne el factorial del nJmero.
%&id !ac)&#ial(d&u3l m,Xd&u3l !F)
{ d&u3l !ac)&#8
X!FKF8
!&# (!ac)&#K(8!ac)&#DKF8!ac)&#HH)
X!FXK!ac)&#8
}
El siguiente programa muestra como se utili-a la función factorial para calcular el
"alor de el nJmero combinatorio2
m
n
m
m n n
¸
¸

_
,
·

a
( )aT a
#includ Ci&')#am+$D
#includ Cc&ni&+$D
%&id !ac)&#ial(d&u3l m, d&u3l X!F)8 TT P#&)&)i.& d la 6unci&n 6ac)&#ial
%&id main()
{
d&u3l c&m3ina)&#ia, !F,!S,!Q8
in) m, n8
cl#'c#()8 5&)&(2(FM,FM)8
c&u)CC=En)# l num#& d lmn)&' A=8 cinDDm8
5&)&(2(FM,FS)8 c&u)CC=En)# d a cuan)&' %a )&ma# A=8
cinDDn8
!ac)&#ial(m,<!F)8
!ac)&#ial(n,<!S)8
!ac)&#ial(mHn,<!Q)8
c&m3ina)&#iaK!FT(!SX!Q)8
5&)&(2(FM,FQ)8
c&u)CC=C&m3ina)&#iaK =CCc&m3ina)&#ia8
5)c$()8
}
%&id !ac)&#ial(d&u3l (,d&u3l X!F)
{ d&u3l !ac)&#8
X!FKF8
!&# (!ac)&#K(8!ac)&#DKF8!ac)&#HH)
X!FXK!ac)&#8
}
E]EMPLO2
f es un parámetro formal que es un puntero% eso
significa que al momento de llamar a la función
pasamos la dirección de la "ariable.
9bser"e como se llama la función
factorial% aqui pasamos la
dirección de la "ariable f% donde
nos calcula el factorial de m
TfX Nace que la "ariable cuya dirección se paso en la
llamada a la función se $aga
Escriba una función que reciba la dirección en donde se encuentran dos nJmeros enteros
y retorna los dos nJmeros intercambiados.
%&id '`a.(int Ta% int Tb)
[ int tempB
tempXTaB
TaXTbB
TbXtempB
/MM>in de la funcion s`ap
E]EMPLO:
Escriba una función que reciba dos nJmeros enteros y retorne el má1imo comJn di"isor
de los dos nJmeros% usando el método de euclides. 0a función que calcula el má1imo
comJn di"isor utili-a la función s`ap del ejemplo anterior.
in) mcd(int a% int b)
[ int cB
if (a4b)
s`ap(Va%Vb)B
cXa P bB
`$ile (caX?)
[ aXbB bXcB cXa P bB
/
#)u#n bB
/MM >in de la funcion mcd
El siguiente programa muestra como se pueden utili-ar las funciones de los Jltimos
ejemplos para crear un programa que lee cuatro numeros enteros y calcula el má1imo
comun di"isor2
@include 4conio.$5
@include 4stdio.$5
@include 4stdlib.$5
@include 4iostream.$5
"oid s`ap(int Ta% int Tb)B
int mcd(int a% int b)B
"oid main()
[
int a% b% c% dB
clrscr()B goto1y(?%?)B
cout44UEscriba cuatro numeros enteroUB
cin55a55b55c55dB goto1y(?%&)B
cout44UEl ma1imo comun di"isor deU44a44U%U44b44U%U44c44U%U44d44 UXU44
mcd(mcd(a%b)%mcd(c%d))B
getc$e()B
/
"oid '`a.(int Ta% int Tb)
[ int tempB
tempXTaB
TaXTbB TbXtempB
/MM>in de la funcion s`ap
int mcd(int a% int b)
[ int cB
if (a4b)
s`ap(Va%Vb)B
cXa P bB
`$ile (caX?)
[ aXbB bXcB cXa P bB /
return bB/MM >in de la funcion mcd
Pa'& d A##a2' unidimn'i&nal' a !unci&n'
(ara declarar parámetros que son "ectores% se escribe el nombre del "ector seguido
Q R% no $ay necesidad de especificar el tamaño del "ector.
(ara pasar array unidimensionales a funciones % en la llamada a la función se pone el
nombre del array sin :ndice.
Esto pasa la dirección del primer elemento del array a la función. En ; no se
puede pasar un array completo como argumento a una funciónB en su lugar% se pasa
automáticamente un puntero.
E]EMPLO2
El siguiente programa muestra como una función recibe un "ector y la dimensión
del "ector y retorna la suma de sus componentes% también muestra como una función
permite leer un "ector.
@include 4conio.$5
@include 4stdio.$5
@include 4iostream.$5
float suma (float 1 Q R% int dimens)B
"oid lee (float 1 Q R% int dimens)B
"oid main("oid)
[
int i% nB
float aQ?R% totalB
do [
cout44UEntre cuantos nJmeros tiene el "ector^UB
cin55nB
if (n5X?)
cout44UWn_o no puedo con "ectores tan grandesUB
/ `$ile (n5X?)B
lee (a%n)B
totalXsuma(a%n)B
for (iX?Bi4nBiAA)[
cout44UWtU44aQiRB
/
cout44UWn0a suma es XU44totalB
/ MTfin del programaTM
"oid lee(float 1Q R% int dimens)
[ int iB
for (iX?Bi4dimensBiAA)
[ cout44UEntre 6QU44i44URUB
cin551QiRB
/
/ MTfin de leeTM
float suma (float 1Q R% int dimens)
[ float sumitaX?B
int iB
for (iX?Bi4dimensBiAA)
sumitaAX1QiRB
return sumitaB
/ MTfin de sumaTM
El anterior ejemplo muestra como cuando se usa un array como argumento de una
función% se escribe el nombre del arreglo y lo que se pasa es su di#cci*n. 0o anterior es
una e1cepción al con"enio ; de paso de parámetros por "alor.
Pa'& d A##a2' 3idimn'i&nal' a !unci&n'
(ara declarar parámetros que son matrices% solo $ay que especificar el nombre del
"ector seguido Q RQnumero de columnasR% no $ay necesidad de especificar el nJmero de
filas.
(ara pasar array bidimensionales a funciones % en la llamada a la función se pone
el nombre del array sin :ndices.
Esto pasa la dirección del primer elemento del array a la función. En ; no se puede
pasar un array completo como argumento a una funciónB en su lugar% se pasa
automáticamente un puntero.
E]EMPLO2
El siguiente programa muestra dos funciones% que pasan por referencia matrices. 0a
función lma)#iV% permite almacenar mTn elementos en una matri- 6 cualquiera% la
función )#aVa retorna la tra-a de una matri-.
@include 4iostream.$5
@include 4conio.$5
@define mfilas &?
@define mcolum &?
"oid lma)#iV(float aQRQmcolumR%int nfilas%int ncolum)B
float )#aVa(float aQRQmcolumR%int nfilas)B
"oid main()[
int i%j%nB
float matri-QmfilasRQmcolumRB
clrscr()B
goto1y(?%?)B
cout44U;uantas filas tiene 6UB
cin55nB
leematri-(matri-%n%n)B
clrscr()B
goto1y(?%&)B
cout44U0a tra-a esXU44tra-a(matri-%n)B
getc$e()B
/
"oid lma)#iV(float aQRQmcolumR%int nfilas%int ncolum)
[ int i% jB
for (iX?Bi4nfilasBAAi)
for (jX?Bj4ncolumBAAj)
[ cout44UEscriba el aQU44i44U%U44j44URUB
cin55aQiRQjRB
/
/
float )#aVa(float aQRQmcolumR%int nfilas)
[ int iB
float =ra-aX?B
for (iX?Bi4nfilasBAAi)
=ra-aAXaQiRQiRB
return =ra-aB
/
[uW d%ul% main ( )
;uando se usa una sentencia #)u#n en main( )% el programa de"uel"e un código
de terminación al proceso que lo llamo, en este caso el sistema operati"o.
(ara el sistema operati"o un ? indica que el programa $a terminado normalmente. =odos
los demás "alores indican que se $a producido algJn tipo de error.
A#5umn)&' d main()
=urbo ; soporta tres argumentos dentro de la función main(). 0os dos primeros
son2 a#5c y a#5%% que permiten pasar información al programa de ; mediante argumentos
de l:nea de ordenes en el momento de in"ocar el programa desde el sistema operati"o.
El parámetro a#5c contiene el numero de argumentos de la l:nea de ordenes y es un
numero entero. Siempre "ale uno por lo menos% ya que el nombre del programa cuenta
como primer argumento.
El parámetro a#5% es un array de punteros a caracteres. ;ada elemento del array
apunta a un argumento de la l:nea de ordenes. =odos los argumentos de la l:nea de
ordenes son cadenasB cualquier nJmero tendrá que ser con"ertido por el programa al
formato de nJmero correcto.
E-m.l&2 Escriba este programa en el editor de ;.
@include4stdio.$5
main(int argc% c$ar T arg"Q R)
[ cout44arg"Q?RB
crábelo con el nombre mio% compile y salga al sistema operati"o% situese en el directorio
bin dentro del directorio bc y cuando tenga c2WbcWbin5 escriba mi& 2 presione E3=E<.
eue sucedió^
Ejemplo2 Ejecute el siguiente programa.
@include4stdio.$5
main(int argc% c$ar T arg"Q R)
[ int "er% cuentaB
if (argc4&) [
cout44U!ebe introducir la cantidad a contar WnUB
cout 44Uen la l:nea de ordenes. (ruebe de nue"o.WnU)B
return B
/
if (argcXX' Vd astrcmp(arg"Q&R% 7"er8)) "erXB
else "erX?B
for (cuentaXatoi(arg"QRB cuentaB HHcuenta)
if ("er) printf(7Pd8% cuenta)B
printf(7Pc8% CWaE)B
return ?B
/
ESTRUCTURAS
En ; una estructura es una colección de "ariables que se referencian bajo el mismo
nombre. Una estructura proporciona un medio con"eniente para mantener junta
información relacionada.
6l crear o definir una estructura se forma una plantilla que puede usar el programador
para definir una "ariable de tipo estructura. 0a "ariables que conforman la estructura son
llamadas (elementos) de la estructura.
E]EMPLO2
struct dire[
c$ar nombreQ'?RB
c$ar direcciónQ'?RB
c$ar ciudadQ'?RB
int telefonoB
int prefijoB
/B
(ara definir una "ariable de tipo estructura se procede as:2
struct dire clienteB
0a "ariable en memoria se la puede imaginar as:2
CLIENTE
39ZO<E !#<E;;#93 ;#U!6! =E0E>939 (<E>#S9
!e lo anterior se debe sacar como conclusión que la "ariable cliente almacena +
datos diferentesB que son 39ZO<E% !#<E;;#93% ;#U!6!% =E0E>939% (<E>#S9.
9tra manera de declarar la misma "ariable es as:2
typedef struct[
c$ar nombreQ'?RB
c$ar direcciónQ'?RB
c$ar ciudadQ'?RB
int telefonoB
int prefijoB
/direB
En este caso $emos definido un tipo de dato de nombre di# que es una estructura
(ara definir "ariables de ese tipo solo necesitamos escribir2 dire clienteB
ESEZ(092
Se desea crear una "ariable de tipo estructura para almacenar un nJmero complejo.
<ecuerde que un nJmero complejo% tiene parte real% parte imaginaria
Si entendimos lo anterior% entonces podemos escribir2
typedef struct [
double pKrealB
double pKimaginarioB
/complejoB
(ara definir una "ariable compleja% escribimos a$ora2
complejo a%bB
COMO SE ENTRAN DATOS A UN CAMPO DE UNA "ARIA/LE
ESTRUCTURA:
(ara entrar datos a una "ariable de tipo estructura lo podemos $acer de dos maneras2
(or medio de una instrucción de lectura o por medio de una instrucción de asignación2
ENTRANDO UN DATO CON LA INSTRUCCION cin:
(ara entrar datos con está instrucción proceda as:2
cin55n&m3#7%a#ia3l+n&m3#7cam.&B
E]EMPLO2
0a instrucción2 cin55a.pKrealB
(ermite entrar un nJmero real a la "ariable pKreal de la "ariable a
ENTRANDO UN DATO CON LA INSTRUCCION DE ASIGNACION:
(ara entrar datos con está instrucción proceda as:2
n&m3#7%a#ia3l+n&m3#7cam.&K%a#ia3l8
ESEZ(092
El siguiente programa muestra como podemos utili-ar una "ariable de tipo
estructura en un problema de suma de complejos2
#includ Cc&ni&+$D
#includ Ci&')#am+$D
%&id main()
{ )2.d! ')#uc) {
!l&a) .a#)7#al8
!l&a) .a#)7ima5ina#ia8
}c&m.l-&8
c&m.l-& a,3,c8
cl#'c#()8 5&)&(2(FM,FM)8cl#&l()8
c&u)CC=E'c#i3a la .a#) #al d a=8 cinDDa+.a#)7#al8
5&)&(2(FM,FS)8cl#&l()8 c&u)CC=E'c#i3a la .a#) ima5ina#ia d a=8
cinDDa+.a#)7ima5ina#ia8 5&)&(2(FM,FM)8cl#&l()8
*ariable o
constante
c&u)CC=E'c#i3a la .a#) #al d 3=8cinDD3+.a#)7#al8
5&)&(2(FM,FS)8cl#&l()8 c&u)CC=E'c#i3a la .a#) ima5ina#ia d 3=8
cinDD3+.a#)7ima5ina#ia8
c+.a#)7#alKa+.a#)7#al I 3+.a#)7#al8
c+.a#)7ima5ina#iaKa+.a#)7ima5ina#ia I 3+.a#)7ima5ina#ia8
5&)&(2(FM,FQ)8 c&u)CCa+.a#)7#alCC=I i=CCa+.a#)7ima5ina#ia8
5&)&(2(FM,FR)8 c&u)CC3+.a#)7#alCC=I i=CC3+.a#)7ima5ina#ia8
5&)&(2(FM,FL)8 c&u)CCc+.a#)7#alCC=I i=CCc+.a#)7ima5ina#ia8
5)c$()8 }