Escolar Documentos
Profissional Documentos
Cultura Documentos
NDICE
1
2
INTRODUCCIN.....................................................................................................5
INTRODUCCIN A LA PROGRAMACIN..........................................................6
1.1
RESOLUCIN DE PROBLEMAS A TRAVS DE LA COMPUTADORA.. .6
1.1.1
Definicin del Problema..............................................................................6
1.1.2
Anlisis del Problema..................................................................................6
1.1.3
Prueba y Depuracin...................................................................................6
1.1.4
Mantenimiento.............................................................................................7
1.2
ALGORITMOS.................................................................................................8
1.2.1
DEFINICIN Y CARACTERSTICAS DE LOS ALGORITMOS...........8
1.2.2
REGLAS PARA LA CONSTRUCCIN DE ALGORITMOS...................9
1.2.2.1
TIPOS DE ALGORITMOS.................................................................9
1.2.3
DIAGRAMAS DE FLUJO LINEALES....................................................11
1.2.3.1
Tipos de Datos....................................................................................11
1.2.3.1.1 Datos Numricos............................................................................11
1.2.3.1.2 Cadenas..........................................................................................12
1.2.3.1.3 Lgicos...........................................................................................13
1.2.3.1.4 Tipos Compuestos..........................................................................13
1.2.3.2
Constantes y variables........................................................................14
1.2.3.3
Operadores.........................................................................................15
1.2.3.3.1 Operadores Aritmticos.................................................................15
1.2.3.3.2 Operadores Div y Mod..................................................................16
1.2.3.3.3 Operadores Relacionales................................................................16
1.2.3.3.4 Prioridad De Operadores Aritmticos y Relacionales...................17
1.2.3.3.5 Operadores Lgicos.......................................................................19
1.2.3.3.6 Prioridad De Los Operadores Lgicos...........................................20
1.2.3.4
Asignacin..........................................................................................20
1.2.3.4.1 Asignacin Aritmtica...................................................................21
1.2.3.4.2 Asignacin Lgica.........................................................................21
1.2.3.4.3 Asignacin de caracteres...............................................................22
1.2.3.5
Entrada y Salida de Informacin........................................................22
1.2.4
ESTRUCTURAS ALGORTMICAS........................................................23
1.2.4.1
Estructura Secuencial.........................................................................23
1.2.4.2
Estructuras condicionales...................................................................25
1.2.4.3
IF, IF...ELSE.......................................................................................25
ALTERNATIVA SIMPLE (SI-ENTONCES/IF-THEN).................................25
1.2.4.3.1 Alternativas Mltiples (segn_sea, caso de / case)........................26
1.2.4.4
Estructuras Repetitivas.....................................................................28
1.2.4.4.1 Estructura Mientras (while)...........................................................28
1.2.4.4.2 Estructura Repetir (repeat).....................................................30
1.2.4.4.3 Estructura Desde/Para (for)....................................................30
2 LENGUAJE DE PROGRAMACIN C.................................................................32
2.1
HISTORIA DE C.............................................................................................32
2.2
Caractersticas clave de C................................................................................33
2.3
Compiladores de C..........................................................................................34
Pag.2
2.4
Palabras reservadas de C (ANSI-C)................................................................35
2.5
Primer programa en C.....................................................................................36
2.6
Identificadores.................................................................................................37
2.7
Constantes y Variables.....................................................................................37
2.7.1
Variables....................................................................................................37
2.7.1.1
Reglas para nombres de variables......................................................37
2.7.1.2
Tipos de Datos numricos..................................................................38
2.7.1.3
Declaracin de Variables....................................................................38
2.7.1.4
Inicializacin de Variables.................................................................38
2.7.2
Constantes..................................................................................................38
2.7.2.1
Constantes Literales...........................................................................39
2.7.2.2
Constantes simblicas........................................................................39
2.7.2.3
Declaracin de Constantes.................................................................39
2.7.2.3.1 La directiva #Define.....................................................................39
2.7.2.3.2 Const..............................................................................................39
2.8
Enunciados, expresiones y operadores............................................................40
2.8.1
Enunciados................................................................................................40
2.8.2
Expresiones................................................................................................40
2.8.3
Operadores.................................................................................................40
2.8.3.1
Operador de asignacin......................................................................40
2.8.3.2
Operadores matemticos....................................................................40
2.8.3.2.1 Operadores Unuarios:....................................................................40
2.8.3.2.2 Operadores Binarios......................................................................41
2.8.3.3
Operadores de Relacin.....................................................................42
2.8.3.4
Operadores lgicos.............................................................................42
2.9
ENTRADA Y SALIDA DE DATOS...............................................................43
2.9.1
Funcin puts()............................................................................................43
2.9.2
Funcin Printf().........................................................................................43
2.9.3
Funcin Scanf().........................................................................................43
2.9.4
Funcin Gets()...........................................................................................44
2.10 Estructuras de Control.....................................................................................44
2.10.1 Estructuras condicionales..........................................................................44
2.10.1.1 El Enunciado IF..................................................................................44
2.10.1.2 El enunciado IF.Then..Else........................................................45
2.10.1.3 EL enunciado Switch.........................................................................45
2.10.2 Estructuras ciclicas....................................................................................47
2.10.2.1 El enunciado For................................................................................47
2.11 FUNCIONES...................................................................................................47
2.11.1 Prototipo de Funcin.................................................................................48
2.11.2 Definicin de Funcin...............................................................................48
2.11.3 Estructura de una funcin..........................................................................48
2.11.4 Llamado de funciones................................................................................48
2.11.5 Paso de Argumentos..................................................................................48
2.12 Arreglos...........................................................................................................49
2.12.1 Arreglos Unidimensionales (Vectores)......................................................49
2.12.1.1 Inicializar un arreglo..........................................................................50
2.12.1.2 Asignacin de un arreglo:..................................................................50
2.12.2 Arreglos Bidimensionales (MATRICES)..................................................51
2.12.2.1 Definicin...........................................................................................51
2.13 REGISTROS...................................................................................................54
Pag.3
Pag.4
1 INTRODUCCIN
Pag.5
2 INTRODUCCIN A LA PROGRAMACIN
1.1
Documentacin
Pag.6
1.1.4 Mantenimiento
Se lleva a cabo despus de terminado el programa, cuando se detecta que es
necesario hacer algn cambio, ajuste o complementar al programa para que siga
trabajando de manera correcta. Para poder realizar este trabajo se requiere que el
programa este correctamente documentado.
Pag.7
1.2 ALGORITMOS
1.2.1 DEFINICIN Y CARACTERSTICAS DE LOS ALGORITMOS.
Un algoritmo es una secuencia de pasos lgicos necesarios para llevar a cabo
una tarea especfica, como la solucin de un problema. Los algoritmos son
independientes tanto del lenguaje de programacin en que se expresan como de la
computadora que los ejecuta. En cada problema el algoritmo se puede expresar en un
lenguaje diferente de programacin y ejecutarse en una computadora distinta; sin
embargo el algoritmo ser siempre el mismo.
A primera vista, se puede pensar que el conocimiento de estos algoritmos y
estructuras de datos no tienen una aplicacin prctica inmediata. Sin embargo, su
conocimiento y correcta aplicacin sirven para producir programas mejores, en el
sentido de que aprovechan mejor la memoria del sistema, son ms rpidos, eficientes,
robustos y tolerantes a fallos.
Las aplicaciones de estos algoritmos en algunos casos son inmediatas; por
ejemplo, hallar el trayecto ms corto entre dos estaciones es algo que interesa a
muchos viajeros del metro y se pueden obtener aproximaciones bastante buenas del
mundo real utilizando algunos de los algoritmos que obtienen distancias mnimas.
Otros algoritmos sirven para procesar cadenas, lo cual sirve de base para
analizadores lxicos o algoritmos criptogrficos, por ejemplo.
Adems, tener conocimientos adecuados de algoritmia y estructuras de datos
facilita el poder pasar de un lenguaje de programacin a otro con mucha mayor
facilidad: puesto que ya se tiene la base, slo hace falta superar las dificultades
tcnicas particulares de cada lenguaje.
Las caractersticas fundamentales que debe cumplir todo algoritmo son:
Pag.8
TIPOS DE ALGORITMOS.
N2: Tiempo de ejecucin cuadrtico. Suele ser habitual cuando se tratan pares
de elementos de datos, como por ejemplo un bucle anidado doble. Si N se
duplica, el tiempo de ejecucin aumenta cuatro veces. El peor caso de entrada
del algoritmo Quick Sort se ejecuta en este tiempo.
Pag.9
Pag.10
Tipos de Datos
Un dato se define como la expresin general que describe los objetos con los
cuales opera una computadora. Los datos de entrada se transforman por el programa,
despus de las etapas intermedias, en datos de salida.
Numricos
Lgicos
Cadenas
Enteros
Es un conjunto finito de los nmeros enteros. Los enteros son nmeros
completos, no tienen componentes fraccionarios o decimales y pueden ser negativos y
positivos.
Algunos ejemplos son :
Pag.11
37
-10 9
15.25
50
Reales
Consiste en un subconjunto de los nmeros reales. Estos nmeros siempre tienen
un punto decimal y pueden ser positivos o negativos. Un nmero real consiste de un
nmero entero y una parte decimal. Algunos ejemplos son :
0.52 664.32
6.579 8.0
-9.3 -47.23
1.2.3.1.2 Cadenas
Son los datos que representan informacin textual (palabras, frases, smbolos,
etc). No representan valor alguno para efectos numricos. Pueden distinguirse porque
son delimitados por apstrofes o comillas.
Se clasifica en dos categoras :
Pag.12
Hola Mortimer
12 de octubre de 1496
Enunciado cualquiera
1.2.3.1.3 Lgicos
Tambin se le denomina Booleano, es aqul dato que solo puede tomar uno de
dos valores : Falso y verdadero.
Se utiliza para representar las alternativas (si/no) a determinadas condiciones.
Por ejemplo, cuando se pide si un valor entero sea primo, la respuesta ser verdadera
o falsa, segn sea.
Las categoras y tipos que se mencionaron anteriormente se conocen como Tipos
Simples, puesto que no poseen una estructura compleja.
En forma adicional, cada lenguaje puede proporcionar la utilizacin de Tipos
Compuestos, siendo estos, datos que tienen una estructura predeterminada.
Pag.13
a.- SUB-RANGO:
Son aqullos en los que se especifica con precisin el intervalo
de valores vlidos para un dato.
Ejemplos:
0..100
'A'..'Z'
Los Reales no son vlidos para crear enumerativos, ya que su intervalo no est
definido.
b.- ENUMERATIVOS :
valores para un dato.
Ejemplos:
(0,25,40,52)
1.2.3.2
Constantes y variables
Numricos
Pag.14
Constantes
36
Variables
A
450.35
Nom
0.58
Edad
'A'
Cadena
'Juan'
Ciudad
'La Paz'
Estatura
Falso
Lgicos
Verdadero
Operadores y Operandos
1.2.3.3
Operadores
Aritmticos.
Relacionales.
Lgicos.
Operador
Pag.15
Operacin
Suma
Resta
Multiplicacin
Divisin real
Div
Divisin entera
Mod
Residuo
Exponenciacin
Ejemplos:
7+3 = 10 10 Div 4 = 2
7-3 = 4 20 Mod 3 = 2
7*3 = 21 5 Mod 7 = 5
10/4= 2.5 4 ^ 2 = 16
En la expresin 7+3, los valores 7 y 3 se denominan operandos. El valor de la
expresin 7+3 se conoce como resultado de la expresin.
Resultado
Expresin
Resultado
10.5/3.0
3.5
10 Div 3
1/4
0.25
18 Div 2
2.0/4.0
0.5
30 Div 30
30/30
1.0
10 Mod 3
6/8
0.75
10 Mod 2
Operador
Significado
<
Menor que
>
Mayor que
Igual que
<=
>=
<>
Diferente de
Operador
Prioridad
Alta
*, /, Div
+, -, Mod
Relacionales
Baja
Cuando se desea realizar una operacin con baja prioridad por adelantado, debe
agruparse a los operandos involucrados.
4 + 12 /2 = 10 (sin agrupar)
(4 + 12) /2 = 8 (con agrupador)
Pag.18
Ejemplo:
Obtener los resultados de las expresiones:
-4 * 7 + 2 ^ 3 / 4 - 5
Solucin:
-4 *7 + 2 ^
Resulta:
-4 * 7+ 8/4 -5
-28 + 8/4 -5
-28 + 2 - 5
-26 - 5
-31
(A*B) +3 A y B
A + (B/C) + D
Operador
Relacin
not
Negacin (No)
and
Conjuncin (Y)
or
Disyuncin (O)
xor
Disyuncin Exclusiva
(O/SOLO)
El operando es falso
AND
OR
XOR
NOT(X)
NOT(Y)
X AND Y
X OR Y
X XOR Y
Pag.20
Not 4 > 6
a 4.
1.2.3.4
Asignacin
Pag.21
1.2.3.4.1
Asignacin Aritmtica
1.2.3.4.2
Asignacin Lgica
1.2.3.4.3
Asignacin de caracteres
1.2.3.5
Los clculos que realizan las computadoras requieren para ser tiles la Entrada
de los datos necesarios para ejecutar las operaciones que posteriormente se
convertirn en resultados, es decir, Salida.
Las operaciones de entrada permiten leer determinados valores y asignarlos a
determinadas variables. Esta entrada se conoce como operacin de Lectura (read).
Los datos de entrada se introducen al procesador mediante dispositivos de entrada
(teclado, unidades de disco, etc). La salida puede aparecer en un dispositivo de salida
(pantalla, impresora, etc). La operacin de salida se denomina escritura (write).
Pag.22
Cada expresin toma un valor que se determina tomando los valores de las
variables y constantes implicadas y la ejecucin de las operaciones indicadas.
Estructura Secuencial.
Estructura Secuencial
....
Pag.23
Pag.24
Ejemplo:
Calcular el salario neto de un trabajador en funcin del nmero de horas
trabajadas, precio de la hora de trabajo y considerando unos descuentos fijos al
sueldo bruto en concepto de impuestos (20 por 100).
Pseudocdigo
Inicio
{clculo salario neto}
leer nombre, horas, precio_hora
salario_bruto
horas * precio
impuestos
0.20 * salario_bruto
salario_neto
salario_bruto_impuestos
escribir nombre, salario_bruto, salario_neto_bruto, salario_neto
Fin
Diagrama de flujo
Pag.25
1.2.4.2
Estructuras condicionales
1.2.4.3
IF, IF...ELSE
Pseudocdigo en espaol
Si <condicin> entonces
<accin S1>
Fin_si
Pag.26
Pseudocdigo en ingls
If <condicin> then
<accin S1>
end_if
Diagrama de Flujo
Pseudocdigo.
En ingls la estructura de decisin mltiple se representa
Case expresin of
[e1]: accin S1
[e2]: accin S2
:
[en]: accin Sn
else
accin Sx
end_case
Pag.27
Ejemplo:
Se desea disear un algoritmo que escriba los nombres de los das de la
semana en funcin del valor de una variable DIA introducida por teclado.
Los das de la semana son 7; por consiguiente, el rango de valores de DIA
ser 1..7, y caso de que DIA tome un valor fuera de este rango se deber
producir un mensaje de error advirtiendo la situacin anmala.
Inicio
Leer DIA
Segn_sea DIA hacer
1: escribir('Lunes')
2: escribir('Martes')
3: escribir('Mircoles')
4: escribir('Jueves')
5: escribir('Viernes')
6: escribir('Sabado')
7: escribir('Domingo')
else
escribir('Error')
fin_segn
fin
Pag.28
1.2.4.4
Estructuras Repetitivas.
Mientras (while)
Repetir (repeat)
Desde (for)
Pseudocdigo en espaol
Mientras condicin hacer
Accin S1
Accin S2
:
accin Sn
Fin_mientras
Pseudocdigo en ingls
while condicin do
<Acciones>
:
End_while
Ejemplo:
Contar los nmeros enteros positivos introducidos por teclado. Se
consideran dos variables enteras NUMERO y CONTADOR (contar el nmero
de enteros positivos). Se supone que se leen nmeros positivos y se detiene el
bucle cuando se lee un nmero negativo o cero.
Pag.29
Pseudocdigo
Inicio
contador
0
Leer (numero)
Mientras numero > 0 hacer
contador
contador+1
Leer (numero)
Fin_Mientras
Escribir('El nmero de enteros positivos es : ', contador)
Fin
Diagrama de Flujo
Pag.30
Pseudocdigo en Ingls
Repeat
<acciones>
:
Until <condicin>
Pseudocdigo en
For variable (v)= vi To vf
<acciones>
Donde:
v: Variable ndice
vi, vf: Valores inicial y final de la variable
Diagrama de Flujo de la estructura Desde/Para
Pag.32
LENGUAJE DE PROGRAMACIN C
2.1 HISTORIA DE C
En 1970 Ken Thompson de los laboratorios Bell se haba propuesto desarrollar un
compilador para el lenguaje Fortran que corra en la primera versin del sistema
operativo UNIX tomando como referencia el lenguaje BCPL; el resultado fue el
lenguaje B (orientado a palabras) que resulto adecuado para la programacin de
software de sistemas. Este lenguaje tuvo la desventaja de producir programas
relativamente lentos.
En 1971 Dennis Ritchie, con base en el lenguaje B desarroll NB que luego cambio su
nombre por C; en un principio sirvi para mejorar el sistema UNIX por lo que se le
considera su lenguaje nativo. Su diseo incluye una sintaxis simplificada, la aritmtica
de direcciones de memoria (permite al programador manipular bits, bytes y direcciones
de memoria) y el concepto de apuntador; adems, al ser diseado para mejorar el
software de sistemas, se busco que generase cdigos eficientes y uno portabilidad
total, es decir el que pudiese correr en cualquier mquina. Logrados los objetivos
anteriores, C se convirti en el lenguaje preferido de los programadores profesionales.
En 1980 Bjarne Stroustrup de los laboratorios Bell de Murray Hill, New Jersey,
inspirado en el lenguaje Simula67 adiciono las caractersticas de la programacin
orientada a objetos (incluyendo la ventaja de una biblioteca de funciones orientada a
objetos) y lo denomino C con clases. Para 1983 dicha denominacin cambio a la de
C++. Con este nuevo enfoque surge la nueva metodologa que aumenta las
posibilidades de la programacin bajo nuevos conceptos.
Pag.33
Pag.34
2.3 Compiladores de C
Pag.35
Pag.36
Pag.37
devuelve
la
funcin
2.6 Identificadores
Los identificadores son nombres dados a constantes, variables, tipos, funciones y
etiquetas de un programa.
2.7.1.1
Pag.38
2.7.1.2
Tipo de Variable
Carcter
Nmeros Enteros
Entero corto
Entero largo
Palabra clave
Char
Int
Short
Long
Bytes Requeridos
1
2
1
4
Nmeros en Punto
flotante
float
double
1.7X10 -308 a
1.7X10 +308
Doble largo
long double
3.4 X10-4932 a
1.1X10+4932
2.7.1.3
Rango
0 a 255
-32767 a 32767
-128 a 127
-2,147,483,648 a
-2,147,483,647
6 dgitos de precisin
3.4X10-38 a
3.4X10+38
Declaracin de Variables
Antes de ser utilizada una variable en C, esta debe ser declarada. Una declaracin de
variable le informa al compilador el nombre y tipo de la variable y opcionalmente inicia
la variable a un valor especifico.
Tipo Nombre de variable ,Nombre de Variable,:
Ejemplo.
Int contador;
Int numero, suma, inicio;
double porcentaje;
2.7.1.4
Inicializacin de Variables.
2.7.2 Constantes
Recordemos que el valor de una constante no puede ser cambiado durante la
ejecucin del programa. El C tiene dos tipos de constantes.
Pag.39
2.7.2.1
Constantes Literales.
2.7.2.2
Constantes simblicas
Una constante simblica es una constante que est representada por un nombre
(identificador). Cada vez que se necesite el valor de la constante en el programa se
usa su nombre.
2.7.2.3
Declaracin de Constantes
Las constante se pueden definir de dos maneras, por medio de la directiva #define o
la palabra clave const. Por conveniencia los nombres de las constantes se escriben en
mayscula.
2.7.2.3.2 Const
La palabra clave const es otra manera de definer una constante, con la diferencia que
esta si reserva espacio en memoria para almacenar su valor. Su sintaxis es la
siguiente.
Const tipo de variable nombre de variable;
Const Int contador =100;
Const Float PI=3.1416;
Const long deuda =120000,
Pag.40
=
3;
2.8.2 Expresiones
Las expresiones son variables y constantes conectadas por operadores por ejemplo:
3+5
Var * 3
2.8.3 Operadores
Un operador es un smbolo que le da instrucciones al C para que ejecute alguna
operacin o accin, en uno o ms operandos. Los operadores en C se agrupan en
varias categoras.
2.8.3.1
Operador de asignacin
2.8.3.2
Operadores matemticos.
Smbolo
++
Decremento
--
++X;
Pag.41
Accin
Incrementa al operando en
1
Decrementa el operando en
1
Ejemplo
++x, x++
--x,x--
--Y;
Son equivalentes a
x=x+1
y=y-1;
Cuando se usan en modo prefijo, los operadores de incremento y decremento
modifican a su operando antes de que sea usado y en modo prefijo modifican a su
operando despus de que sea usado.
Ejemplo.
X=10;
Y=x++;
Despus de que estos enunciados se ejecutan x tiene el valor de 11 y y tiene el valor
de 10: el valor de x fue asignado a y y luego fue incrementado. Por el contrario, los
enunciados
X=10;
Y=++x;
Da como resultado que tanto y como x tienen el valor de 11: x fue incrementado y
luego fue asignado a y.
Smbolo
+
Accin
Suma sus dos operadores
Ejemplo
X+y
Resta
X-Y
Multiplicacin
X*y
Divisin
Modulo
Precedencia relativa
1
2
3
Ejemplo 12%5*2
2.8.3.3
Operadores de Relacin
Operador
Igual
Smbolo
==
Mayor que
>
Menor que
<
>=
Menor o igual a
<=
Diferente
!=
2.8.3.4
Pregunta
Es el Primer
operando igual que el
segundo?
Es el operando
mayor que el
segundo?
Es el operando
menor que el
segundo?
Es el operando
mayor que o igual al
segundo?
Es el operando
Menor que o igual al
segundo?
Es el operando
mayor que el
segundo?
Ejemplo
X==y
X>y
X<y
X>=y
X<=y
X!=y
Operadores lgicos
Operador
Smbolo
Ejemplo
&&
||
Exp1 || Exp2
No
!exp1
Precedencia
No
&&
||
%d, x);
Significado
%c
Un solo carcter
%d
Entero decimal
%f
Float, double
%s
Cadena de caracteres
%u
Pag.44
2.10.1
Estructuras condicionales
2.10.1.1
El Enunciado IF
Num=num*2;
Printf (El numero es
2.10.1.2
%d, num);
El enunciado IF.Then..Else
IF anidados.
If(expresin)
Sentencia1;
Else if (expresin)
Sentencia 2;
Else
Sentencia3;
Ejemplo: Disea un programa en C que lea la edad de una persona, si la edad es
menor que 18, entonces que imprima menor de edad, de lo contrario si es menor que
65 entonces que imprima Adulto, si pasa los 65 entonces que imprima Anciano.
If(edad<18)
Printf(Menor de edad);
Else if(edad<65)
Printf(Adulto);
Else
Printf(Anciano);
2.10.1.3
EL enunciado Switch
sentencia1;
case expr_cte2:
sentencia2;
case expr_cte3:
sentencia3;
default:
sentencia;
}
Se selecciona a partir de la evaluacin de una nica expresin.
void main()
{
int nota;
printf(Calificacin: );
scanf(%d, ¬a);
switch (nota) {
case 0:
case 1:
case 2:
case 3:
case 4:
printf(Suspenso);
break;
case 5:
case 6:
printf(Aprobado);
break;
case 7:
case 8:
printf(Notable);
break;
case 9:
printf(Sobresaliente);
break;
case 10:
printf(Matrcula);
break;
default:
printf(Error);
}
}
Pag.47
2.10.2
Estructuras ciclicas
2.10.2.1
El enunciado For
2.11 FUNCIONES
Pag.48
2.-No)
2.-No)
Una funcin es una seccin de cdigo de C que tiene un nombre independiente, que
ejecuta una tarea especfica y opcionalmente regresa un valor al programa que la
llama.
2.11.1
Prototipo de Funcin
2.11.2
Definicin de Funcin
2.11.3
2.11.4
Llamado de funciones
2.11.5
Paso de Argumentos
Para pasar argumentos de una funcin se enlista entre parntesis a continuacin del
nombre. LA cantidad de argumentos y el tipo de cada uno de ellos deben coincidir con
los parmetros del encabezado y prototipo de funcin
#include <stdio.h>
Float suma (float, float);
Pag.49
Prototipo de Funcion
Void()
{
Float x,y,resultado ;
Printf (Escribe el primer valor);
Scanf(%f,&x);
Printf (Escribe el segundo valor);
Scanf(%f,&y);
resultado=suma(x,y);
Llamada a Funcion y
printf(El resultado de la suma es %f, resultado);
paso de argumentos
}
Float suma (float a, float b)
Encabezado de
{
funcion
Float resultado;
resultado=a+b;
return(resultado);
Sentencia return para
}
regreso de resultado
Escriba un encabezado de funcin llamada hazlo ( ), que tome tres argumentos de tipo
char y regrese un tipo float al programa que la llama.
Escriba una funcin que reciba dos nmeros como argumentos y regrese el valor de
su producto
Escriba una funcin que reciba dos nmeros como argumentos, La funcin debe dividir
el primer nmero entre el segundo. No divida cuando el segundo nmero es cero.
Escribe un programa que use una funcin para encontrar el promedio de cinco valores
tipo float tecleados por el usuario.
2.12 Arreglos
Un arreglo es una coleccin ordenada de elementos de un mismo tipo. Ordenada
significa que cada elemento tiene una ubicacin determinada dentro del arreglo y
debemos conocerla para accederlo.
Un arreglo puede tener una o varias dimensiones. A los arreglos unidimensionales se
les conocen como vectores y a los bidimensionales como matrices.
2.12.1
Pag.50
tipo puede ser cualquier tipo de dato (int, float, char, etc.).
2.12.1.1
Inicializar un arreglo
Posiciones 0 1 2 3 4 5 6
Contenido
F u l a n o \0
2.12.1.2
Asignacin de un arreglo:
nombre_variable[ndice] = valor
Esta instruccin asigna el valor a la posicin ndice del arreglo. El ndice debe ser una
expresin del tipo entero en el rango [0, longitud-1].
Acceso al contenido de un arreglo:
nombre_variable[ndice] es valor del tipo <tipo> que puede ser asignado a una
variable, o pasado como parmetro, imprimirlo, etc. Aqu tambin vale la aclaracin de
que el ndice debe estar dentro del rango de definicin del arreglo, C++ no chequear
que esto sea cierto y devolver lo contenido en la posicin de memoria
correspondiente a un arreglo de mayor longitud, el dato obtenido de esta manera es
basura.
EJEMPLO:
El siguiente programa realiza la lectura de 10 datos y calcula la suma de los mismos:
#include <stdio.h>
main()
Pag.51
{
int i;
int sum;
int x[10];
sum=0;
for (i=0; i<10; i++)
{
printf (INTRODUCE EL DATO % d ,
i);
2.12.2
2.12.2.1
Definicin
Pag.52
tipo puede ser cualquier tipo de dato (int, float, char, etc.).
3. Hacer un programa que lea 25 valores enteros en una tabla de 5 por 5, y que
despus muestre la tabla y las sumas de cada fila y de cada columna. Procura que la
salida
sea
clara.
4. Escribir un programa que lea un arreglo de cualquier tipo (entero, flotante, char), y
revise el arreglo para encontrar un valor en particular digitado por el usuario, la salida
es
la
posicin
del
arreglo
en
que
se
encuentra.
5. Leer un texto, un carcter a la vez desde la entrada estndar (que es el teclado), e
imprimirlo en forma invertida. Leer hasta que se encuentre un final-de-datos (teclear
CONTROL-Z
para
generarlo).
6. Escribir un programa para leer un texto hasta el fin-de-datos, y mostrar informacin
del texto , es decir nmero de palabras, longitud de las palabras, etc.
Pag.54
2.13 REGISTROS
2.13.1
CONCEPTOS GENERALES
2.13.1.1
CONCEPTO DE CAMPO
2.13.1.2
CONCEPTO DE REGISTRO
2.13.2
Pag.55
DEFINICION
2.13.2.1
2.13.2.2
DEFINICION DE CAMPOS
DEFINICION DE REGISTROS
Ejemplo:
struct Registro {
int a;
float b;
unsigned int c;
unsigned int d;
};
Esto permite agrupar un conjunto de variables en una nica estructura. Para crear
una variable de este tipo, bastar con hacer referencia a esta estructura. Las variables
o campos de esta estructura se referencian utilizando un punto.
MANIPULACION
MANIPULACION DE CAMPOS
MANIPULACION DE REGISTROS
Pag.56
=
=
=
=
-10;
20.3;
15;
Registro.c * 2;
Es posible cargar una estructura con un valor inicial. Por ejemplo, en el caso anterior
podra escribirse:
void main (void)
{
struct Registro Reg = {-10, 20.3, 15, 15*2};
struct Registro Reg2;
Reg2 = Reg;
variable */
}
No existe ninguna funcin que imprima el contenido de un registro. Para ello debe
definirse una funcin que lo haga.
2.13.3
Enumeraciones
Pag.57
JUEVES,
VIERNES,
SABADO = 10 /* Repito un valor ya utilizado */
};
En este caso, tanto SABADO como DOMINGO tendrn el valor 10, LUNES tendr el
11, MARTES el 12, MIERCOLES el 15, JUEVES el 16 y VIERNES 17.
Si bien una variable de tipo enum almacenar un entero no est permitido asignarle
directamente valores de este tipo. Por ejemplo, el cdigo:
Dia = 15;
2.13.4
Uniones
Una unin es una agrupacin de variables bajo una nica denominacin, pero en la
cual todas ellas comparten una misma zona de memoria. Segn como se la acceda,
dicha zona de memoria ser utilizada para almacenar un tipo de dato diferente.
Veamos un ejemplo:
Ejemplo : Uniones
union MiUnion{
char c;
int n;
float f;
double d;
};
void main(void)
{
MiUnion u;
u.d = 10.0 / 3.0;
printf ("u como double = %f\n", u.d);
printf ("u como float = %f\n", u.f);
Pag.58
Este ejemplo es correcto. Sin embargo no debe leerse nunca una variable de una
forma diferente a como fue escrita, por ejemplo, si u se escribe como int no debe
leerse nunca como double. Las uniones son utilizadas principalmente para almacenar
datos particulares de un tipo de dato ms general. En C++ este problema se resuelve
de una forma diferente, con el concepto de herencia que se ver ms adelante, razn
por la cual las uniones son rara vez utilizadas.
Para terminar con el tema, veamos un par de ejemplos, el los que se utilicen
estructuras, enumeraciones y uniones:
Pag.59
double x,y,z;
double vx,vy,vz;
};
};
struct Edificio
{
double x,y;
TipoDureza Dureza;
}
};
2.13.5
Pueden definirse tipos de datos o nuevos nombres para los ya existentes usando la
palabra reservada typedef. Esta se utiliza de la siguiente forma:
typedef definicin_del_tipo nuevo_nombre_del_tipo;
Por ejemplo, si se quisiese llamar byte al tipo de dato unsigned char, debera escribir:
typedef unsigned char byte;
Tambin podra utilizar typedef para abreviar el nombre de una estructura. Por
ejemplo, en ejemplo de la seccin anterior, donde se defina el tipo de dato struct
Registro, podra abreviar estas dos palabras en una sla escribiendo:
struct Registro {
int a;
float b;
unsigned int c;
unsigned int d;
};
typedef struct Registro TRegistro;
Pag.60
2.13.6
a = -1;
b = a;
a = 20 / 3;
b = a;
Pag.61
En este caso a recibir en valor 6.66666, y b este valor, pero con la parte decimal
truncada a 0, es decir, 6.
La mayora de los compiladores emiten mensajes de advertencia cuando se realizan
operaciones entre datos de distinto tipo, y lo correcto es no hacer esto. Para realizar
operaciones entre datos de distinto tipo, debe realizarse una conversin de tipo. Esto
se hace encerrando entre parntesis el tipo de dato al que se quiere convertir. Esto se
conoce con el nombre de cast, y la operacin de realizar esta conversin con el
nombre de casting. Por ejemplo, en los casos anteriores se tendra:
{
int a;
unsigned int b;
float c;
a = -1;
b = (unsigned int) a;
c = (float) a;
return retult;
return retult;
Notar la forma en que se realiz la operacin. En primer lugar se convirti cada una de
las tres variables a un entero de mayor precisin, luego se efectu la suma de las tres
y la divisin por 3. Finalmente se convirti el resultado en un entero de 8 bits y se lo
copi en la variable result.
2.13.7
Ejercicios
1 - Defina un tipo de dato complejo, que almacene dos enteros llamados Real e Imag.
2 - Defina dos funciones que tomen un par de datos de tipo complejo y devuelvan su
suma y diferencia, respectivamente.
3 - Escriba una funcin que devuelva la parte real de un nmero complejo, convertida a
punto flotante.
Pag.63
2.14 ARCHIVOS
2.14.1
CONCEPTOS GENERALES
CAMPO
REGISTRO
ARCHIVO
este sistema, combinado con algo de memoria RAM, proporciona un acceso muy
prximo al de los discos duros.
2.14.2
Clasificacin de Archivos
En cuanto al tipo de acceso, en C y C++ podemos clasificar los archivos segn varias
categoras:
Dependiendo de la direccin del flujo de datos:
De entrada: los datos se leen por el programa desde el archivo.
De salida: los datos se escriben por el programa hacia el archivo.
De entrada/salida: los datos pueden se escritos o ledos.
Dependiendo del tipo de valores permitidos a cada byte:
De texto: slo estn permitidos ciertos rangos de valores para cada byte.
Algunos bytes tienen un significado especial, por ejemplo, el valor hexadecimal
0x1A marca el fin de fichero. Si abrimos un archivo en modo texto, no ser
posible leer ms all de un byte con ese valor, aunque el fichero sea ms largo.
Binarios: estn permitidos todos lo valores para cada byte. En estos archivos
el final del fichero se detecta de otro modo, dependiendo del soporte y del
sistema operativo. La mayora de las veces se hace guardando la longitud del
fichero. Cuando queramos almacenar valores enteros, o en coma flotante, o
imgenes, etc, deberemos usar este tipo de archivos.
Segn el tipo de acceso:
Archivos secuenciales: imitan el modo de acceso de los antiguos ficheros
secuenciales almacenados en cintas magnticas y
Archivos de acceso aleatorio: permiten acceder a cualquier punto de ellos
para realizar lecturas y/o escrituras.
Segn la longitud de registro:
Longitud variable: en realidad, en este tipo de archivos no tiene sentido
hablar de longitud de registro, podemos considerar cada byte como un registro.
Tambin puede suceder que nuestra aplicacin conozca el tipo y longitud de
cada dato almacenado en el archivo, y lea o escriba los bytes necesarios en
cada ocasin. Otro caso es cuando se usa una marca para el final de registro,
por ejemplo, en ficheros de texto se usa el carcter de retorno de lnea para
eso. En estos casos cada registro es de longitud diferente.
Longitud constante: en estos archivos los datos se almacenan en forma de
registro de tamao constante. En C usaremos estructuras para definir los
registros. C dispone de funciones de librera adecuadas para manejar este tipo
de ficheros.
Mixtos: en ocasiones pueden crearse archivos que combinen los dos tipos de
registros, por ejemplo, dBASE usa registros de longitud constante, pero aade
un registro especial de cabecera al principio para definir, entre otras cosas, el
tamao y el tipo de los registros.
Pag.65
r
w
a
rb
wb
ab
r+
w+
a+
rb+
wb+
ab+
nombre_archiv
o
modo
Pag.66
Ejemplo:
Para abrir un nuevo archivo llamado alumnos en el cual slo se realizara
escritura de texto, se deben escribir las siguientes sentencias:
FILE *pfArch;
pfArch = fopen(alumnos, w);
Para realizar una apertura en la cual se desee leer el contenido se tendr:
Por ejemplo, para cerrar el archivo del ejemplo anterior basta con escribir:
fclose(pfArch);
2.14.3
Existen diversas funciones que nos permiten escribir o leer un archivo que ha
sido abierto con anterioridad. Las funciones putc() y fputc() son equivalentes, con
ellas se puede escribir un carcter en un archivo. Su funcin prototipo es:
Pag.67
#include <conio.h>
#ifndef SALIDA
#define SALIDA'@'
#endif
void main(void)
{
FILE *pfArchivo;
char szLinea[80];
char szArchivo[12];
register int iContador;
/* Pide el nombre del szArchivo a crear */
printf("\n Digite el nombre del szArchivo: ");
gets(szArchivo);
if (strlen(szArchivo) == 0)
{
printf("\n Se omitio nombre del Archivo");
}
else
{
/* Creacion del szArchivo */
pfArchivo=fopen(szArchivo,"w");
if ( pfArchivo != NULL )
{
/* Si la creacion fue exitosa captura una szLinea de texto a la vez */
/*clrscr();*/
szLinea[0]='\0';
printf("\n @ Termina captura\n Capturando...\n");
/* Mientras no se de caracter de salida */
while (szLinea[0] != SALIDA)
{
gets(szLinea);
iContador=0;
while (szLinea[iContador] != '\0'&& szLinea[0] != SALIDA)
{
/* Guarda un caracter a la vez */
fputc(szLinea[iContador],pfArchivo);
iContador++;
}
fputc('\n',pfArchivo);
}
/* Cierra el szArchivo */
fclose(pfArchivo);
}
else
{
printf("\n No fue posible realizar la apertura");
}
}
}
Pag.68
2.14.4
Teniendo en cuenta que los registros empiezan a contarse desde el cero, para hacer
una lectura del registro nmero 6 usaremos:
fseek(fichero, 5*sizeof(stRegistro), SEEK_SET);
fread(®, sizeof(stRegistro), 1, fichero);
Pag.69
2.14.5
2.14.6
del fichero
en registros
Borrar registros
Si el campo Valido tiene un valor prefijado, por ejemplo 'S' o ' ', el registro es
vlido. Si tiene un valor prefijado, por ejemplo 'N' o '*', el registro ser invlido o se
considerar borrado.
De este modo, para borrar un registro slo tienes que cambiar el valor de ese
campo.
Pero hay que tener en cuenta que ser el programa el encargado de tratar los
registros del modo adecuado dependiendo del valor del campo Valido, el hecho de
marcar un registro no lo borra fsicamente.
Si se quiere elaborar ms, se puede mantener un fichero auxiliar con la lista de
los registros borrados. Esto tiene un doble propsito:
o
o
Que se pueda disear una funcin para sustituir a fseek() de modo que
se tengan en cuenta los registros marcados.
Que al insertar nuevos registros, se puedan sobrescribir los
anteriormente marcados como borrados, si existe alguno.
2. Hacer una copia del fichero en otro fichero, pero sin copiar el registro que se
quiere borrar. Este sistema es ms tedioso y lento, y requiere cerrar el fichero y
Pag.70
2.14.7
Ejemplo:
Pag.71
Mostrar(®);
break;
case '3': // Eliminar registro
system("cls");
printf("Eliminar registro: ");
numero = LeeNumero();
fseek(fa, numero*sizeof(struct stRegistro), SEEK_SET);
fread(®, sizeof(struct stRegistro), 1, fa);
reg.valido = 'N';
fseek(fa, numero*sizeof(struct stRegistro), SEEK_SET);
fwrite(®, sizeof(struct stRegistro), 1, fa);
break;
case '4': // Mostrar todo
rewind(fa);
numero = 0;
system("cls");
printf("Nombre
Datos\n");
while(fread(®, sizeof(struct stRegistro), 1, fa))
Listar(numero++, ®);
system("PAUSE");
break;
case '5': // Eliminar marcados
Empaquetar(&fa);
break;
}
} while(opcion != '0');
fclose(fa);
return 0;
Pag.72
Pag.73
2.15 APUNTADORES
Los punteros proporcionan la mayor parte de la potencia al C y C++, y marcan
la principal diferencia con otros lenguajes de programacin. Una buena comprensin y
un buen dominio de los punteros pondr en tus manos una herramienta de gran
potencia. Un conocimiento mediocre o incompleto te impedir desarrollar programas
eficaces.
La memoria RAM de un ordenador est compuesta por unidades bsicas
llamadas bits. Cada bit slo puede tomar dos valores, normalmente denominados alto
y bajo, 1 y 0. Pero trabajar con bits no es prctico, y por eso se agrupan. Cada grupo
de 8 bits forma un byte u octeto. En realidad el microprocesador, y por lo tanto nuestro
programa, slo puede manejar directamente bytes o grupos de dos o cuatro bytes.
Para acceder a los bits hay que acceder antes a los bytes. Y aqu llegamos al quid,
cada byte tiene una direccin, llamada normalmente direccin de memoria.
La unidad de informacin bsica es la palabra, dependiendo del tipo de
microprocesador una palabra puede estar compuesta por dos, cuatro, ocho o diecisis
bytes. Hablaremos en estos casos de plataformas de 16, 32, 64 128 bits. Se habla
indistintamente de direcciones de memoria, aunque las palabras sean de distinta
longitud. Cada direccin de memoria contiene siempre un byte. Lo que suceder
cuando las palabras sean de 32 bits es que accederemos a posiciones de memoria
que sern mltiplos de 4.
Un puntero es un tipo especial de variable que contiene, ni ms ni menos
que, una direccin de memoria.
Por supuesto, a partir de esa direccin de memoria puede haber cualquier tipo
de objeto: un char, un int, un float, un array, una estructura, una funcin u otro puntero.
Intentemos ver con mayor claridad el funcionamiento de los punteros. Podemos
considerar la memoria del ordenador como un gran array, de modo que podemos
acceder a cada celda de memoria a travs de un ndice. Podemos considerar que la
primera posicin del array es la 0 celda[0].
Si usamos una variable para almacenar el ndice, por ejemplo, ndice=0,
entonces celda[0] == celda[ndice]. Prescindiendo de la notacin de los arrays, el
ndice se comporta exactamente igual que un puntero.
El puntero ndice podra tener por ejemplo, el valor 3, en ese caso, *ndice
tendra el valor 'valor3'.
Las celdas de memoria existirn independientemente del valor de ndice, o
incluso de la existencia de ndice, por lo tanto, la existencia del puntero no implica
nada ms que eso, pero no que el valor de la direccin que contiene sea un valor
vlido de memoria.
Dentro del array de celdas de memoria existirn zonas que contendrn
programas y datos, tanto del usuario como del propio sistema operativo o de otros
programas, el sistema operativo se encarga de gestionar esa memoria, prohibiendo o
protegiendo determinadas zonas.
Pag.74
2.15.1
Declaracin de punteros.
Una variable puntero se declara como todas las variables. Debe ser del mismo
tipo que la variable apuntada. Su identificador va precedido de un asterisco (*):
int *punt;
*punt es una variable puntero que apunta a otra variable que contiene un dato de tipo
entero.
char *car:
Es un puntero a variable de tipo carcter.
Como pasa con todas las variables en C++, cuando se declaran slo se
reserva espacio para almacenarlas, pero no se asigna ningn valor inicial, el contenido
de la variable permanecer sin cambios, de modo que el valor inicial del puntero ser
aleatorio e indeterminado. Debemos suponer que contiene una direccin no vlida.
Si "punt" apunta a una variable de tipo "int", "*punt" ser el contenido de esa
variable, pero no olvides que "*punt" es un operador aplicado a una variable de tipo
"puntero a int", es decir "*punt" es una expresin, no una variable.
2.15.2
Pag.75
2.15.3
2.15.4
Existe una equivalencia casi total entre arrays y punteros. Cuando declaramos
un array estamos haciendo varias cosas a la vez:
Declaramos un puntero del mismo tipo que los elementos del array, y que
apunta al primer elemento del array.
Reservamos memoria para todos los elementos del array. Los elementos de un
array se almacenan internamente en el ordenador en posiciones consecutivas
de la memoria.
Pag.76
Ejemplo:
int vector[10];
int *puntero;
puntero = vector; /* Equivale a puntero = &vector[0];
*puntero++; /* Equivale a vector[0]++; */
puntero++; /* puntero equivale a &vector[1] */
2.15.5
Aunque no son muchas las operaciones que se pueden hacer con los punteros, cada
una tiene sus peculiaridades.
Pag.77
2.15.6
Asignacin.
2.15.7
Operaciones aritmticas.
Tambin hemos visto como afectan a los punteros las operaciones de suma
con enteros. Las restas con enteros operan de modo anlogo. Pero, qu significan
las operaciones de suma y resta entre punteros?, por ejemplo:
int vector[10];
int *p, *q;
p = vector; /* Equivale a p = &vector[0]; */
q = &vector[4]; /* apuntamos al 5 elemento */
printf(%u, q-p);
El resultado ser 4, que es la "distancia" entre ambos punteros. Normalmente este tipo
de operaciones slo tendr sentido entre punteros que apunten a elementos del
mismo array. La suma de punteros no est permitida.
Pag.78
#include <stdio.h>
#include <conio.h>
char cad[20]="Hola Buenos Dias\n";
char *punt; //declaracion de puntero.
void main(void)
{
//inicializacin de variable
punt=cad; //asignacion de direccion al puntero.
clrscr();
printf("a = %s", cad); //imprimo valor de variable
printf("\n&a = %x", cad); //imprimo direccin variable apuntada (en hexadecimal)
printf("\npunt = %x ", punt); //imprimo la direccin guardada (la variable apuntada)
printf("\n*punt = %s", punt); //imprimo el contenido de la direccin apuntada.
printf("\nTamao puntero %d Bytes", sizeof(punt));
getch();
}
#include <stdio.h>
#include <conio.h>
void main()
{
char carac='A', *r;
int a=12,b=45;
int *p, *q;
clrscr();
printf("Direccin de a=%p\n", &a); printf("Direccin de b=%p\n", &b);
printf("a = %d b = %d\n", a, b); printf("Direccin de caract = %p\n", &carac);
printf("carac = %c\n", carac); printf("Valor ASCII de carac = %d\n", carac);
printf("Direccin de p = %p\n", &p);
printf("Direccin de q = %p\n", &q);
printf("Direccin de r = %p\n", &r);
p = &a;
q = &b;
r = &carac;
printf("El puntero p apunta a la direccin: %p\n", p);
printf("Y su contenido es: %d\n", *p);
printf("El puntero q apunta a la direccin: %p\n", q);
printf("Y su contenido es: %d\n", *q);
printf("El puntero r apunta a la direccin: %p\n", r);
printf("Y el contenido de *r es: %d\n", *r);
printf("Como caracter ASCII *r contiene: %c\n", *r);
getch();
}
Pag.79
#include <conio.h>
#include <stdio.h>
void main()
{
int mat[] = {1,2,3,4}, *pmat, i;
clrscr();
printf("\Empleamos notacin decimal\n");
printf("Hacemos que el puntero seale al primer elemento del array: pmat = mat");
pmat = mat;
//pmat=&mat[0]; //ES LO MISMO QUE pmat =mat
printf("\nComprobamos los valores: ");
printf("\nDireccin de inicio del array: mat = %u", &mat[0]);
getch();
printf("\nDireccin de pmat: &pmat = %u", &pmat);
getch();
printf("\nImprimimos las direcciones de memoria:\n");
for(i=0; i<4; i++)
{
printf("\n&mat[%u] = %u (pmat+%u) = %u ", i, &mat[i], i, (pmat+i));
printf(" mat[%u] = %u *(pat+%u) = %u" , i, mat[i], i, *(pmat+i));
}
getch();
}
Pag.80
BIBLIOGRAFA
Algoritmos y Programacin
Cristian Prez Berro
Nueva librera, 2007
Introduccin a la programacin en C
Marco A. Pea Basurto, Jos M. Cela Espn
Edicions UPC, 2000
Curso prctico de programacin en C y C++
Pag.81