Teoria de Orejas PDF

PROGRAMACION DIGITAL - CB412 - CICLO 2014-1 1
UNIVERSIDAD NACIONAL DE INGENIERIA

FACULTAD DE INGENIERIA CIVIL
PROGRAMACION DIGITAL
LABORATORIOS
CICLO 2014-1
WILFREDO CUPE ROMÁN

COMPETENCIAS DEL CURSO

1. Diseña programas para procesar datos, la generación de
información y su interpretación.
2. Razona, planea y construye una secuencia lógica de procesos
utilizando estructuras de selección e iteración.
3. Conoce nuevas técnicas y herramientas que permita su
aplicación en la solución de problemas.
4. Conoce y utiliza un lenguaje de programación a través de
prácticas de edición y ejecución de programas estructurados.
5. Comprende el comportamiento de otros programas de
cómputo durante su utilización.
Las competencias 3, 4 y 5 se desarrollarán en las sesiones de
Laboratorio
Laboratorio N°1
Objetivos
1. Utilizar el PSeInt para la creación y ejecución
de Diagramas de Flujo.
2. Conocer las facilidades del PSeInt para la
Ejecución Paso a Paso, Prueba de Escritorio y
Exportación a C.
3. Utilizar el DEV C++ para la Depuración de la
codificación en C.
Entorno del PSeInt

MENU
HERRAMIENTAS
AREA DE COMANDOS
TRABAJO
LINEA DE
ESTADO
Creación de Diagramas de Flujo
AREA DE COMANDOS
TRABAJO
Creación de Diagramas de Flujo

Operadores y Funciones
Ejecución del Diagrama de Flujo

Ejecución del Diagrama de Flujo

Ejecución paso a paso
Permite realizar un seguimiento más detallado de

la ejecución del diagrama de flujo, observando en
tiempo real las instrucciones y el orden en que se
ejecutan.
También se puede observar el contenido de
variables o expresiones durante el proceso.


Prueba de Escritorio
Permite configurar una tabla con un conjunto de

variables o expresiones para que sean evaluadas
en cada paso de la ejecución paso a paso y
registradas en dicha tabla automáticamente para
analizar luego la evolución de los datos y el
diagrama de flujo.
Prueba de Escritorio
Exportación a C
Entorno del DEV C++

MENU
HERRAMIENTAS
AREA DE
TRABAJO
LINEA DE
ESTADO
Menu File (Archivo)
Nuevo  Archivo Fuente

Proyecto
Abrir Proyecto o Archivo…
Abrir Archivo Reciente
Grabar
Grabar Como…
Grabar Todo
Cerrar
Cerrar Todo
Propiedades
Importar
Exportar
Imprimir…
Configura Impresión
Salir
Menu Execute (Ejecutar)
Compilar
Compila el archivo actual
Ejecutar
Parámetros…
Compilar y Ejecutar
Reconstruir Todo
Revisar Sintáxis
Limpiar Resultados
Análisis de Perfil
Reiniciar ejecución del programa
Lenguaje de Programación C
Un programa está constituido por un conjunto de

instrucciones que se ejecutan de modo
secuencial.
El ANSI C es un lenguaje de alto nivel, es decir
está mucho más cerca del lenguaje natural.
El C++ puede ser considerado como una
extensión del C.
ANSI: American National Standards Institute

Ejemplo de Programa 1
/*Mayor de tres numeros*/ Comentario
#include<stdio.h> Directiva de Preprocesador.

main() { Se incluye en el programa la librería de
Función Principal funciones estándar de Entrada/Salida
int a,b,c,mayor,suma;
printf("Ingrese 3 datos\n");
scanf("%d",&a); scanf("%d",&b); scanf("%d",&c);
if (a>b)
mayor=a;
else
mayor=b;
if (c>mayor)
mayor=c;
printf("El mayor valor: %d\n",mayor);
suma=a+b+c;
printf("suma: %d\n",suma);
}
Compilación (Execute  Compile)
El compilador traduce el programa a lenguaje de

máquina y verifica la sintáxis.
El programa está almacenado en el archivo
fuente.
El resultado de este proceso de compilación es
un archivo objeto, con la extensión .obj.
Archivo Fuente COMPILACION Archivo Objeto
LAB1.C
El linker enlaza todos los archivos compilados

(archivo objeto y librerias pre-compiladas) y crea
un archivo .exe ejecutable.
Archivo Objeto
Archivo
ENLACE
Ejecutable
Librerias
Pre-compiladas LAB1.EXE

La ventana de Progreso de Compilación mostrará
los Errores y Warnings del programa:
Ejecución (Execute  Run)
El archivo ejecutable es independiente del DEV.

Errores
Errores de Sintáxis
Errores de Ejecución
Errores Lógicos
Errores de Sintáxis
Los errores de sintaxis, o sintácticos, ocurren

cuando el programador escribe código que no va
de acuerdo a las reglas de escritura del lenguaje
de programación. Por ejemplo, la instrucción:
prrintf( "\n Hola mundo " );
La sentencia correcta debe ser:
printf( "\n Hola mundo " );
Los errores de sintaxis se detectan en el proceso

de compilación.
Errores de Ejecución
Se producen cuando la computadora no puede

ejecutar alguna instrucción de forma correcta.
Por ejemplo, la instrucción:
c = 15 / 0; /*No tiene errores de sintaxis*/
Producirá un error de ejecución, ya que,

matemáticamente, no se puede dividir entre
cero.
Errores Lógicos
Ocurren a causa de una lógica equivocada, los

resultados obtenidos no son los esperados.
Por ejemplo, si en vez de la instrucción:
a = b + c;
el alumno hubiera escrito:
a = b * c;
Se producirá un error lógico, para descubrirlo se
deberá analizar los resultados del programa.
Laboratorio N° 2
Funciones Salida Entrada

de por por
Operadores
Entrada / Pantalla: Teclado:
Salida printf scanf
Funciones de Entrada / Salida
Permiten a un programa recibir y enviar datos al

exterior.
Para su utilización en ANSI C, es necesario incluir
al comienzo del programa el archivo stdio.h con la
sentencia:
#include<stdio.h>
donde stdio proviene de standard-input-output.

Salida por Pantalla: printf
Imprime en la unidad de salida estándar (monitor)

texto, constantes y variables que se especifiquen.
printf(“cadena de formato”, expresión);
• Especificadores de Formato • Constante

• Especificadores Adicionales • Variable
• Secuencias de Escape
• Texto
Especificadores de Formato
Especificadores de Tipo de la expresión

Formato
%c Caracter
%d Entero
%ld Entero largo
%f Punto Flotante
%lf Doble Precisión
%s Cadena de Caracteres
Especificadores de Formato
Especificadores Efecto
Adicionales
Ancho Justifica a la derecha
.Precisión Redondea al n° de decimales
- Justifica a la izquierda
0 Llena con ceros según el ancho
Secuencias de Escape
Secuencia Efecto
de Escape
\n Salto de línea
\t Tabulador
\r Retorno de carro
\’ Comilla simple
\” Doble comilla
\\ Diagonal
Entrada por Teclado: scanf
Lee datos de la entrada estándar (teclado).
scanf(“cadena de formato”, &variable);

Similar a printf
• Especificadores de Formato
• Secuencias de Escape
• Texto
Ejemplo Inicio
b  12
Escribir
b
c  24.3
Escribir
c
Fin
Comentario
/*Ejemplo printf*/
#include<stdio.h> Directiva de Preprocesador.
Se incluye la librería de funciones
int main() estándar de Entrada/Salida
{ Función Principal
int b;
Declaración de Variables
float c;
b=12; Escritura en pantalla
printf("Ejemplo de printf\n");
printf("b=%5d\n",b);
c=24.3;
printf("c=%7.1f\n",c);
system("pause"); Pausa en la ejecución
}
Ejemplo1.-
Ejemplo2.-
Inicio
Leer
a, b, c
Escribir
a, b, c
Fin
/*Ejemplo printf y scanf*/

#include<stdio.h>
int main()
Escritura en pantalla
{
char a; int b; float c;
printf("Ejemplo de printf y scanf\n");
printf("Ingrese letra : "); scanf("%c",&a);
printf("Ingrese entero : "); scanf("%d",&b);
printf("Ingrese decimal: "); scanf("%f",&c);
printf("a=%5c\n",a);
printf("b=%5d\n",b); Lectura por teclado
printf("c=%7.1f\n",c);
system("pause");
}
Ejemplo2.-
Ejemplo3.-
Inicio
Leer
x, y
Escribir
x, y
Fin
/*Ejemplo printf y scanf*/

#include<stdio.h>
int main()
{
int x,y;
printf("Ingrese Punto : ");
scanf("%d,%d",&x,&y);
printf("x=%4d\n",x);
printf("y=%4d\n",y);
system("pause");
}
Ejemplo3.-
Operadores
Son signos especiales que indican determinadas

operaciones a realizar con las variables y/o
constantes.
Aritméticos
De asignación
Incrementales
Relacionales
Lógicos
Primarios
Operadores
Aritméticos Lógicos
+ Suma && Y
- Resta || O
* Multiplicación ! Negación
/ División
% Resto división entera Primarios
() Llamada función
Incrementales [] Indice de arreglo
++ Incremento en 1 . Miembro estructura
-- Decremento en 1
Operadores
De Asignación Relacionales
= Asignación simple == Igual que
+= Asignación suma < Menor que
-= Asignación resta > Mayor que
*= Asignación <= Menor o igual que
multiplicación >= Mayor o igual que
/= Asignación división != No igual que
%= Asignación resto
Inicio
Ejemplo4.-
Leer
x, y
xx+5
yy+1
z  resto entero(x/y)
Escribir
x, y, z
Fin
/*Ejemplo de printf, scanf y operadores*/

#include<stdio.h>
int main()
{ int x,y,z;
printf("Ingrese Punto : ");
scanf("%d,%d",&x,&y);
x=x+5; //incrementa x en 5
y++; //incrementa y en 1
z=x%y; //resto entero de x entre y
printf("x=%4d\n",x);
printf("y=%4d\n",y);
printf("z=%4d\n",z);
system("pause");
}
Ejemplo4.-
Laboratorio N° 3
Funciones Funciones Trigonométricas

Matemáticas
Potencias
Logaritmos
Raíz cuadrada
Valor Absoluto
Redondeo de decimales
Funciones Hiperbólicas
Funciones Matemáticas
El ANSI C tiene una biblioteca estándar de

funciones matemáticas.
Se debe incluir al comienzo del programa el
archivo math.h con la sentencia:
#include<math.h>
Funciones Trigonométricas
Función Descripción
double sin(double x) Seno(x), x en radianes
double cos(double x) Coseno(x)
double tan(double x) Tangente(x)
double asin(double x) arco seno(x) en radianes
double acos(double x) arco coseno(x)
double atan(double x) arco tangente(x)
Tipo del valor devuelto Argumento o parámetro

Potencias y Logaritmos
double pow(double x, Devuelve el valor de xy
double y)
double exp(double x) Devuelve el valor de ex
double log(double x) logaritmo neperiano de x
double log10(double x) logaritmo decimal de x

Raíz Cuadrada, Valor Absoluto, Redondeo de

Decimales
double sqrt(double x) Devuelve x (x positivo)
double abs(int x) Devuelve |x| (entero x)
double fabs(double x) Devuelve |x| (double x)
double ceil(double x) Redondea x hacia arriba al
entero mas cercano
double floor(double x) Redondea x hacia abajo al
entero mas cercano
Funciones hiperbólicas
double sinh(double x) seno hiperbólico(x), x en
radianes
double cosh(double x) coseno hiperbólico(x)
double tanh(double x) tangente hiperbólica(x)

Ejercicio1
Dados dos puntos A(xa, ya) y B(xb, yb), calcular la
longitud de la línea AB.
B(xb, yb)
longitud  xa  xb2  ya  yb2

A(xa, ya)
Inicio
Leer
xa, ya, xb, yb
longitud  xa  xb2  ya  yb2

Escribir
longitud
Fin
/*Distancia entre dos puntos*/

#include<stdio.h>
#include<math.h>
int main()
{float xa,ya,xb,yb;
double longitud;
printf("Distancia entre dos puntos\n");
printf("Punto A: ");
scanf("%f,%f",&xa,&ya);
printf("Punto B: ");
scanf("%f,%f",&xb,&yb);
longitud=sqrt(pow(xa-xb,2)+pow(ya-yb,2));
printf("Longitud = %.3lf",longitud);
system("pause");
}
Ejercicio2
Dados la hipotenusa y un cateto de un triángulo
rectángulo, calcular el ángulo que forman y el otro
cateto.
a
c=?
ang=?
b
Inicio
Leer
a, b
c  a2  b2
ang  arcocosenob/a*180 / 3.141592
angm (ang - ang ) * 60
Escribir
c, ang , angm
Fin
/*Calcula cateto y angulo interno*/

#include<stdio.h>
#include<math.h>
#define PI 3.141592
int main()
{double a,b,c,ang,angm;
printf("Calcula cateto y angulo interno\n");
printf("a: "); scanf("%lf",&a);
printf("b: "); scanf("%lf",&b);
c=sqrt(pow(a,2)-pow(b,2));
ang=acos(b/a)*180/PI;
printf("Cateto = %.2lf\n",c);
angm=(ang-floor(ang))*60;
printf("Angulo = %.0lf%c %.2lf\’\n",
floor(ang),248,angm);
system("pause");
}
• Evaluar la función:
f ( x)  seno( x)  e cos(x )
x 2
Inicio
Leer
x
f  seno(x) ecos(x)  x 2
Escribir
f
Fin
/*Evalua Formula*/
#include<stdio.h>
#include<math.h>
int main()
{
float x;
double f;
printf("Evalua Formula\n");
printf("x: ");
scanf("%f",&x);
f=fabs(sin(x)-exp(cos(x)))+floor(pow(x,2));
printf("f(%.3f) = %.4lf",x,f);
system("pause");
}
Laboratorio N° 4
Sentencias Sentencia if
Condicionales de
Control de Flujo
Sentencia if … else
Sentencia if … else múltiple
Sentencia switch
Sentencias Condicionales de Control de Flujo
Modifican el flujo secuencial en la ejecución del

programa.
Se denominan Condicionales o Bifurcaciones y
permiten elegir entre dos o más opciones según
ciertas condiciones.
En las condiciones se utilizarán:

Operadores relacionales : >, <, >=, <=, ==, !=
Operadores lógicos : &&, ||, !
Sentencia if
Permite ejecutar o no una sentencia simple o

compuesta según se cumpla o no una
determinada condición.
~
F
if(expresion) expresión
sentencia; V
sentencia
La sentencia compuesta
forma un bloque { … }
~
Sentencia if
Ejm: ~
F
if (nota>=10) nota10
printf(“Aprobado”); V
Esc
“Aprobado”
~
Permite realizar una bifurcación, ejecutando una

parte u otra del programa, según se cumpla o no
una determinada condición.
~
if(expresion) V F
expresión
sent1;
else
sent2; sent1 sent2
~
Ejm: ~
V F
nota10
Esc Esc
“Aprobado” “Desaprobado”
if (nota>=10)
~
printf(“Aprobado”);
else
printf(“Desaprobado”);
Permite realizar una ramificación múltiple

bifurcación, ejecutando una parte u otra del
programa, según se cumpla una entre n
condiciones.

if(expr1) ~
sent1; V F
expr1
else if(expr2)
sent2; sent1 V
expr2
F
else if(expr3)
sent2 V F
sent3; expr3
else if(…) …
… sent3 sentn
[else
sentn;]
~

~
V F
10nota 20
Esc V F
“Aprobado” 10> nota6
Esc V F
“Desaprobado” 6> nota 0
Esc Esc
“Reprobado” “Nota no Válida”
~
Ejm:
if(nota>=10 && nota<=20)

printf(“Aprobado”);
else if(nota>=6 && nota<10)
printf(“Desaprobado”);
else if(nota>=0 && nota<6)
printf(“Reprobado”);
else
printf(“Nota no válida”);
Sentencia switch
Alternativa múltiple, permite seleccionar, por

medio de una expresión, un bloque de sentencias
a ejecutar entre n posibles.
El resultado de evaluar la expresión debe ser un
valor perteneciente a un tipo de dato finito y
ordenado, es decir, entero, lógico, carácter,
enumerado o subrango.
Sentencia switch
switch(expr) {
case cte1:
sent1; ~
break; expr
cte1 cte2 cten default
case cte2:
sent2;
break; sent
sent1 sent2 … sentn
…
case cten:
sentn; ~
break;
[default:
sent;]
}
Sentencia switch
~
3 4 lados 5 default
Esc Esc Esc Esc

“Triángulo” “Cuadrado” “Pentágono” “Otro”
~
Sentencia switch
Ejemplo:
switch(lados) {
case 3:
printf(“Triángulo”);
break;
case 4:
printf(“Cuadrado”);
break;
case 5:
printf(“Pentágono”);
break;
default:
printf(“Otro”);
}
Ejercicios
• Dados tres números, determinar el mayor valor
de los tres.
• Escribir un programa que presente en pantalla un
menú de opciones:
Opciones
1.- Triángulo
2.- Cuadrado
3.- Pentágono
Ingresar opción:
• Ingresar la opción y mostrar un mensaje con la

opción que fue elegida.
Ejercicios
• Ingresar la opción y mostrar un mensaje con la
opción que fue elegida.
• Ingresar por teclado las notas del examen
parcial, final y promedio de prácticas de un
alumno de programación digital. Calcular su
promedio y determinar si está aprobado,
desaprobado o reprobado.
UNIVERSIDAD NACIONAL DE INGENIERIA

FACULTAD DE INGENIERIA CIVIL
PROGRAMACION DIGITAL
GUIA DE LABORATORIO
CICLO 2013-2
Laboratorio N° 5
Sentencias Repetitivas Sentencia while

de Control de Flujo
Sentencia do … while
Sentencia for
Sentencias Repetitivas de Control de Flujo
Modifican el flujo secuencial en la ejecución del

programa.
Se denominan Bucles y permiten repetir la
ejecución de unos procesos un determinado
número de veces o hasta que se cumpla una
condición de tipo lógico o aritmético.
Sentencia while
Permite ejecutar repetidamente una sentencia o

bloque de sentencias, mientras se cumpla una
determinada condición.
~
F
expresión
while (expresion)
V
sentencia;
sentencia
~
Ejemplo
Escribir un programa que permita ingresar

sucesivamente notas por teclado, verificando que
sean notas válidas.
El programa terminará cuando se ingrese una
nota no válida.
Dar como respuesta el promedio de las notas
ingresadas con dos decimales.
Inicio
suma  0 
conta  0 prom  suma/conta
Leer Escribir
nota prom
F Fin
0 nota 20
V
suma  suma + nota
conta  conta + 1
Leer
nota

Ejemplo
Calcular el MCD de dos números utilizando el

algoritmo de Euclides.
Por ejemplo para 2366 y 273:
El MCD es 91
Sentencia do … while
Análoga a while, con la diferencia de que la

evaluación de la condición se realiza al final del
bucle, después de haber ejecutado al menos una
vez las sentencias. ~
do sentencia
sentencia;
while (expresion); V
expresión
F
~
Ejemplo
Realizar un programa que encuentre el valor de e

con un error menor a 10-4, dado que el valor del
exponencial para un valor de x se puede expresar
mediante la serie:
ex=1+x+x2/2!+x3/3!+…..
Inicio
serie  0 
error  1 Escribir
serie
conta  0
Fin
Leer
x
serie  serie + error
conta  conta + 1
error  error * x / conta
V
|error| > 10-4
F

Sentencia for
Permite repetir una sentencia o bloque de

sentencias, mientras se cumple una determinada
condición.
Sentencia for
for(inicial; expr; increm)

sentencia;
~
Inicial; expr; increm
sentencia
~
Ejemplo
Ejemplo
Dados n números ingresados por teclado, escribir

un programa que permita determinar el mayor y el
menor de los n números.
Inicio
Leer  
n,num
menor  num F
num > mayor
mayor  num
V
mayor  num
i  2..n
Leer
num
Escribir
F
num < menor mayor,menor
V Fin
menor  num
 
Laboratorio N° 6
Arreglo Lineal
Variable
y Ejercicios
Subindicada
Bidimensional
Variable Subindicada
Es una variable que almacena un conjunto de valores del

mismo tipo de dato.
Cada valor del conjunto se identifica con un subíndice
entero (0, 1, 2,…).
También se le denomina arreglo.
Tipos:
• Arreglo Lineal: un solo subíndice (vector)*

• Arreglo Bidimensional: dos subíndices (matriz)
• Arreglo Multidimensional: tres o mas subíndices
* Una cadena de caracteres equivale a un arreglo lineal de caracteres.

Arreglo Lineal
Tiene un solo subíndice.
Declaración: tipo nombre_arreglo[N° elementos];
Ejemplo: int x[50];
x[0] x[1] x[2] … x[49]
subíndice
50 elementos
Arreglo Lineal
Lectura y Escritura:
scanf(“formato”,&elemento[i-ésimo]);
printf(“formato”,elemento[i-ésimo]);
~
Ejemplo: Leer
scanf(“%d”, &x[i]); xi
~
~
printf(“%d”, x[i]); Escribir
xi
Ejercicio1
Dado un arreglo de n elementos, determinar la media

y la desviación estándar.
Entradas Salidas
N media
xi (i 1..N) desv
Diagrama PSeInt
Codificación C
/*Obtiene la media y desviacion de n números x*/
#include<stdio.h>
#include<math.h>
int main()
{ int n,i; double s=0,x[100],media,d=0,desv;
printf("Ingrese n:" ); scanf("%d",&n);
for (i=1;i<=n;i++) {
printf("x%d: ",i); scanf("%lf",&x[i]);
s=s+x[i];
}
media=s/n;
for (i=1;i<=n;i++) {
d=d+(x[i]-media)*(x[i]-media);
}
desv=sqrt(d/(n-1));
printf("Media = %8.2lf\nDesviacion = %8.2lf\n",media,desv);
system("pause");
}
Ejecución
Ingrese n:6
x1: 4
x2: 1
x3: 11
x4: 13
x5: 2
x6: 7
Media = 6.33
Desviacion = 4.89
Presione una tecla para continuar . . .
Ejercicio2
Dado un arreglo de N elementos, determinar cual es

el valor que más veces se repite y cuántas veces se
presenta.
x1 x2 x3 x4 … xN
…
Entradas Salidas
N moda
xi (i 1..N) vecesmoda
Diagrama PSeInt
Codificación C
/*Obtiene la(s) moda(s) de n números enteros x*/
#include<stdio.h>
int main()
{ int i,j,k=0,n,x[100],moda[100],vecesmoda=1,veces;
printf("Ingrese n:" ); scanf("%d",&n);
for(i=1;i<=n;i++)
{ printf("x%d: ",i); scanf("%d",&x[i]);
}
for(i=1;i<=n;i++)
{ veces=1;
for(j=i+1;j<=n;j++)
if(x[i]==x[j]) veces++;
if(veces>vecesmoda) {
k=1;
vecesmoda=veces;
moda[k]=x[i];
}
else
if(veces==vecesmoda) {
k++;
moda[k]=x[i];
}
}
if(k*vecesmoda<n)
for(i=1;i<=k;i++)
printf("La moda %d se repite %d
veces\n",moda[i], vecesmoda);
else printf("No hay moda\n");
system("pause");
}
Ejecución
Ingrese n:13
x1: 9
x2: 8
x3: 7
x4: 1
x5: 4
x6: 9
x7: 5
x8: 4
x9: 1
x10: 5
x11: 9
x12: 1
x13: 5
La moda 9 se repite 3 veces
Ejercicio3
Dadas las matrices A y B de m*n, se pide sumarlas

utilizando arreglos lineales.
 A1 A2 ... An   B1 B2 ... Bn 
   
 An 1 An  2 ... A2 n   Bn 1 Bn  2 ... B2 n 
 ...   
... ... ... ... ... ... ...
 Ak   Bk 
 A( m 1) n 1 A( m 1) n  2 ... Amn  m*n  B( m 1) n 1 B( m 1) n  2 ... Bmn  m*n

k#col+(#fila-1)*n Entradas Salidas k#col+(#fila-1)*n

m, n Ci (i 1..m*n)
Ai (i 1..m*n)
Bi (i 1..m*n)
Diagrama PSeInt
Codificación C
/*suma de matrices A(m*n) y B(m*n) usando
arreglos lineales*/
#include<stdio.h>
int main()
{ int i,j,k,m,n;
float A[100],B[100],C[100];
printf("Nro filas: "); scanf("%d",&m);
printf("Nro columnas: "); scanf("%d",&n);
printf("A:\n");
for(i=1;i<=m*n;i++) scanf("%f",&A[i]);
printf("B:\n");
for(i=1;i<=m*n;i++) scanf("%f",&B[i]);
printf("C:\n");
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{ k=j+(i-1)*n;
C[k]=A[k]+B[k];
printf("%8.1f",C[k]);
}
printf("\n");
}
system("pause");
}
Ejecución
Nro filas: 3
Nro columnas: 4
A:
9 3 8 1
8 6 4 0
5 2 3 4
B:
5 7 2 3
9 6 1 1
4 9 3 7
C:
14.0 10.0 10.0 4.0
17.0 12.0 5.0 1.0
9.0 11.0 6.0 11.0
Arreglo Bidimensional
Tiene dos subíndices.
Declaración:
tipo nombre_matriz[N°filas][N°columnas];
Ejemplo: int x[20][30];
col 0 col 1 col 2 … col 29

   
fila 0  x[0][0] x[0][1] x[0][2] … x[0][29]
fila 1  x[1][0] x[1][1] x[1][2] … x[1][29] 20
… … … … … … filas
fila 19  x[19][0] x[19][1] x[19][2] … x[19][29]
30 columnas
Arreglo Bidimensional
Lectura y Escritura:
scanf("formato",&matriz[fila-ésima][col-ésima]);
printf("formato",matriz[fila-ésima][col-ésima]);
~
Ejemplo:
scanf("%d", &x[i][j]); Leer
xi,j
~
~
printf("%d", x[i][j]); Escribir
xi,j
Laboratorio N° 7
Archivo
Archivo Tipo Texto Definición
Uso 1. Declarar variable FILE
2. Abrir el Archivo
3. Leer y/o Escribir
4. Cerrar el Archivo
Fin de Archivo
Archivo
Empleado para almacenar información de manera

permanente.
Ejemplo: LAB7.C, DATOS.TXT, PLANO.DWG
Tipos:
• Texto : Conjunto de caracteres ASCII

Cada grupo de 8bits corresponde a 1
byte o 1 carácter.
• Binario : Conjunto de bits de longitud variable.
Tabla ASCII
Fuente: http://www.elcodigoascii.com.ar/
Archivo Tipo Texto
Esta formado por un conjunto de caracteres ASCII

organizados secuencialmente.
Utilizamos el archivo para entrada y/o salida del
programa.
Archivo de Archivo de
Datos Programa Resultados
ENTRADA SALIDA
Pasos a seguir:
1. Declarar variable FILE
2. Abrir el archivo
4. Cerrar el archivo
1. Declarar variable FILE
FILE *var_archi;
Donde:
FILE Tipo especial de dato, establece un área de

memoria temporal de transferencia (Buffer)
entre el programa y el archivo.
var_archi Variable (puntero), indica el inicio del Buffer.
var_archi
Programa Buffer Archivo

2. Abrir el Archivo
var_archi=fopen(archivo, modo);
Donde:
fopen Conecta el archivo físico con el programa.

archivo Nombre del archivo (cadena de caracteres)
Ejm: En diagrama de flujo:
“DATOS.TXT” var_archi  fopen(archivo, modo)

“SALIDA.TXT”
“E:\\DATOS.TXT”
“E:\\CARPETA\\SALIDA.TXT”
2. Abrir el Archivo
var_archi=fopen(archivo, modo);
Donde:
modo Forma en que se utilizará el archivo.
Modo Apertura Descripción
“r” Abre un Archivo para lectura (ENTRADA)
“w” Crea un Archivo para escritura (SALIDA)
“a” Abre un Archivo para añadir al final (SALIDA)
“r+” Abre un Archivo para lectura/escritura
“w+” Crea un Archivo para lectura/escritura
“a+” Abre o crea un Archivo para añadir al final
fscanf(var_archi, “formato”, &variable);
Donde:
fscanf Lee la variable desde el archivo según el
formato.
~
Leer (var_archi)
variable
~
fprintf(var_archi, “formato”, expresión);
Donde:
fprintf Escribe la expresión al archivo según el
formato.
~
Escribir (var_archi)
expresión
~
4. Cerrar el Archivo
fclose(var_archi);
fcloseall();
Donde:
fclose Cierra el archivo.
fcloseall Cierra todos los archivos abiertos.
fclose(var_archi) fcloseall( )
Ejercicio1
Escribir un programa que escriba en un archivo una

pirámide como el de la figura. El dato del programa
será la altura de la pirámide. Por ejemplo:
h= 5
Piramide.txt
*
***
*****
*******
*********
Fin de Archivo
Todo archivo tiene un inicio y un fin: EOF (End Of File)

inicio
Archivo
EOF
La función feof determina si se ha alcanzado el EOF.

Fin de Archivo aplicado a archivos de lectura
feof(var_archi) será Verdadero si se alcanzó el EOF y

será Falso si aún no se alcanza.
inicio
Archivo
de
Lectura
EOF
!feof(var_archi) será Verdadero mientras no se alcance
el EOF.
negación
Lectura del archivo usando while con !feof()

~
F
!feof(var_archi)
V
sentencias
~
while(!feof(var_archi)){
//Sentencias de Lectura
…
}
Lectura del archivo usando for con !feof()

~
Inicial; !feof(var_archi); increm
sentencia
~
for(Inicial; !feof(var_archi); increm){
//Sentencias de Lectura
…
}
Ejercicio2
Un archivo contiene las coordenadas (x, y) de los

puntos de una poligonal cerrada. Determinar si es
una poligonal cóncava o convexa. No se conoce la
cantidad de puntos. Por ejemplo:
Poligonal.txt
10,13
11,6
20,12
17,21
9,23
5,16
Ejercicio3
Un archivo contiene una matriz por filas y columnas.

Usando un arreglo lineal leer la matriz y escribir la
transpuesta en otro archivo. El orden de la matriz no
es dato. Por ejemplo:
Matriz.txt Matrizt.txt
9 3 8 1 9 8 5
8 6 4 0 3 6 2
5 2 3 4 8 4 3
… 1 0 4
…
Laboratorio N° 8
Función
Parámetros pasados Declaración

por valor
Llamado
Definición
Función
Un programa grande o complejo se puede dividir en

una serie de módulos más pequeños y manejables. A
cada módulo se le llama función.
FUNCION 1
DIVIDIR FUNCION 2
PROGRAMA
FUNCION 3
La función es una parte o módulo del programa que

realiza una tarea muy concreta.
Paso de Parámetros
Los parámetros son las variables que la función

necesita conocer para realizar su tarea.
Hay dos tipos de paso de parámetros:
1. Por Valor : Se pasa una copia del valor del

parámetro (el original no cambia)
2. Por Referencia: Se pasa la dirección en memoria
del parámetro (el original cambia)
Los arreglos son siempre pasa-
dos por referencia.
Parámetros pasados por Valor
Por ejemplo la función Valor(x,…):
Definición
Valor(x)
…
z=Valor(x,…); …
Valor : nombre de la función

x,… : parámetros
Parámetros pasados por Referencia
Por ejemplo la función Referencia(*x,…):
Definición
Referencia(*x)
…
z=Referencia(&x,…); …
Referencia : nombre de la función

x,… : parámetros
Valor Retornado
Valor que retorna la función con la sentencia return.
Si la función no retorna ningún valor, el tipo de la

función será void (vacío)
Pasos para utilizar Funciones
Para utilizar funciones en nuestro programa se deben

seguir los siguientes pasos:
1. Declaración
2. Llamado 1. Declaración
3. Definición
2. Llamado
3. Definición
Parámetros Pasados por Valor
Pasamos por VALOR cuando se pasa una copia del

parámetro actual.
El parámetro actual no será modificado por la función.
Llamado: Declaración y
parámetro_actual Definición:
parámetro_formal
parámetro formal
Memoria de la
Función
1. Declaración
tipo funcion(parámetros formales);
Donde:
tipo : tipo de dato del valor retornado por la

función
función : Nombre de la función
Parámetros : Declaración de los parámetros formales de
formales la función
2. Llamado
variable = funcion(parámetros actuales);
Donde:
variable : Variable donde se asigna el valor retornado

por la función (opcional)
parámetros : Listado de los parámetros actuales de la
función
3. Definición
tipo funcion(parámetros formales)

{
…
}
Donde:
tipo : tipo de dato del valor retornado por la
función
Parámetros : Declaración de los parámetros formales de
formales la función
Ejemplo1
Definir una función que evalúe el polinomio:

P(x) = anxn + an-1xn-1 + … + a2x2+a1x+a0
Planteamiento
¿Que parámetros necesita la función?
a0..n por referencia (arreglo float)
n por valor (int)
x por valor (float)
¿La función retorna un valor?
Si, retorna el polinomio evaluado en x.
tipo double
Codificación1
double poli(float a[50], int n, float x)

{ double p=0; int i;
for(i=n; i>=0; i--)
p=p*x+a[i];
return p;
}
Ejemplo2
Definir una función que dado un ángulo en grados y

minutos, retorne el ángulo en radianes.
Planteamiento
grad por valor (int)
min por valor (int)
Si, retorna el ángulo en radianes.
tipo double
Codificación2
double grad_a_rad(int grad, int min)

{ double ang;
ang=(grad+min/60.0)*PI/180;
return ang;
}
Ejemplo3
Definir una función que retorne la cantidad de filas

que hay en un archivo tipo texto.
Planteamiento
ninguno

Si, retorna la cantidad de filas.
tipo int
Codificación3
int num_filas()
{ FILE *g; int conta=0; char car;
g=fopen("DATOS.TXT","r");
while(!feof(g)){
fscanf(g,"%c",&car);
if(car=='\n') conta++;
}
fclose(g);
return conta+1;
}
Ejemplo4
Definir una función que escriba en pantalla la longitud

de una poligonal cerrada de n puntos (x, y)
Planteamiento
n por valor (int)
x1..n por referencia (arreglo float)
y1..n por referencia (arreglo float)
Si, retorna la longitud de la poligonal.
tipo double
Codificación4
void longitud_poli(float x[50], float

y[50], int n)
{ double lon=0; int i;
x[n+1]=x[n]; y[n+1]=y[n];
for(i=1; i<=n; i++)
lon=lon+sqrt(pow(x[i]-x[i+1],2) +
pow(y[i]-y[i+1],2));
printf("Longitud = %.3lf\n",lon);
}
Laboratorio N° 9
Función
Parámetros pasados Declaración

por referencia
Llamado
Definición
Parámetros pasados por Referencia
Por ejemplo la función Referencia(*x,…):
Definición
Referencia(*x)
…
z=Referencia(&x,…); …
Referencia : nombre de la función

x,… : parámetros
Parámetros Pasados por Referencia
Pasamos por REFERENCIA cuando el parámetro es

modificado en la función.
Si el parámetro no es modificado lo pasamos por VALOR.
Llamado Declaración y
Definición
*parámetro_formal
&parámetro_actual
parámetro_actual
Memoria de
la función
1. Declaración
tipo funcion(*parámetros formales);
Donde:
tipo : tipo de dato del valor retornado por la función
Parámetros : Declaración de los parámetros formales de la
formales función como punteros
2. Llamado
variable = funcion(&parámetros actuales);
Donde:
variable : Variable donde se asigna el valor retornado
por la función (opcional)
parámetros : Listado de los parámetros actuales de la
función pasando la dirección en memoria
3. Definición
tipo funcion(*parámetros formales)

{
…
}
Donde:
tipo : tipo de dato del valor retornado por la función

Parámetros : Declaración de los parámetros formales de la
formales función como punteros
Ejercicio1
Diseñar una función que lea un vector de n

elementos.
Planteamiento
x por referencia (arreglo float)
*n por referencia (int)
No, n y x se retornan como parámetros por
referencia.
tipo void
Diagrama de Flujo1
DEFINICION
lee_vector(x, *n) Inicio
LLAMADO
Leer lee_vector(x, &n)
*n
i  1..*n i  1..n
Leer Escribir
xi xi
Fin Fin
Ejercicio2
Diseñar una función que intercambie el contenido

completo de dos vectores de n decimales.
Planteamiento
x por referencia (arreglo float)
y por referencia (arreglo float)
n por valor (int)
No, x e y se retornan como parámetros por
referencia.
tipo void
Diagrama de Flujo2
Inicio
LLAMADO
DEFINICION
lee_vector(x, &n)
intercambio(x, y, n)
LLAMADO
i  1..n lee_vector(y, &n)

LLAMADO
t  xi intercambio(x, y, n)
xi  yi
i  1..n
yi  t
Escribir
xi , yi
Fin
Fin
Ejercicio3
Diseñar una función que lea una matriz de orden m*n.
Planteamiento
A por referencia (arreglo bidimensional float)
*m por referencia (int)
*n por referencia (int)
No, A, m y n se retornan como parámetros por
referencia
tipo void
Diagrama de Flujo3
DEFINICION
lee_matriz(A, *m, *n) Inicio
LLAMADO
Leer lee_matriz(A, &m, &n)
*m , *n
i  1..*m i  1..m
j  1..*n j  1..n
Leer Escribir
Ai j Ai j
Fin Fin
Ejercicio4
Diseñar una función que multiplique dos matrices

A(m*n) y B(n*p).
Planteamiento
A por referencia (arreglo bidimensional float)
B por referencia (arreglo bidimensional float)
C por referencia (arreglo bidimensional float)
m, n, p por valor (int)
No, C se retorna como parámetro por referencia
tipo void
Inicio
Diagrama de Flujo4 LLAMADO
DEFINICION
multiplica(A,B,C,m,n,p) lee_matriz(A,&m,&n)
LLAMADO
i  1..m lee_matriz(B,&n,&p)
LLAMADO
j  1..p multiplica(A,B,C,m,n,p)
Ci j  0
i  1..m
k  1..n
j  1..n
Ci j  Ci j + Ai k* Bk j
Escribir
Ci j
Fin Fin
Laboratorio N° 10
Recursividad
Función Recursiva Declaración
Llamado
Definición
Función Recursiva
Una Función es recursiva cuando se llama a si

misma.
Por ejemplo, el factorial de n se puede calcular con

una función recursiva:
n * fact(n  1) n  0
fact(n)  
 1 n0
Ejercicio1
Calcular xn en forma recursiva, x decimal y n entero
positivo
 x * pot ( x, n  1) n  0
pot ( x, n)  
 1 n0
Planteamiento
x por valor (float)
n por valor (int)
Si, retorna xn.
tipo double
Diagrama Potencia
DEFINICION FUNCION PRINCIPAL
pot(x,n) Inicio
V F Leer
LLAMADO n>0
RECURSIVO x, n
LLAMADO
p  x*pot(x,n-1) p1
p  pot(x,n)
return p Escribir
p
Fin
Fin
Ejercicio2
Calcular en forma recursiva el máximo común divisor de
dos números
mcd (b, a%b) a%b  0
mcd (a, b)  
 b a%b  0
Planteamiento
a por valor (int)
b por valor (int)
Si, retorna el MCD de a y b.
tipo int
Diagrama MCD
DEFINICION FUNCION PRINCIPAL
mcd(a,b) Inicio
V F Leer
LLAMADO a%b>0
RECURSIVO a, b
LLAMADO
m  mcd(b,a%b) mb
m  mcd(a,b)
return m Escribir
m
Fin
Fin
Laboratorio N° 11
Cadenas de Caracteres Definición
Funciones Principales
Cadenas de Caracteres
Una cadena es un arreglo de caracteres.
Declaración:
char cadena[#carac]=“valor inicial”;
Ej:
char cad[30]=“Hola Mundo\n”;
cad: H o l a M u n d o \n \0
0 1 2 3 4 5 6 7 8 9 10 11
12 caracteres
El carácter nulo (‘\0’) indica el final de la cadena.
Una constante cadena se encierra entre dobles comillas.
~
Lectura de Cadenas Leer
cad
Lee hasta encontrar espacio o salto de línea.
~
char cad[30];
scanf("%s", cad); //por teclado, sin &
fscanf(g,"%s", cad); //de archivo, sin &
Lee hasta encontrar salto de línea

char cad[30];
gets(cad); //por teclado
fgets(cad,#caracteres,g); //de archivo
~
Escritura de Cadenas
Escribir
cad
char car[30];
~
printf("%s", cad); //en pantalla
fprintf(h,"%s", cad); //en archivo
Funciones de Cadenas
Se debe incluir en el programa: #include<string.h>
strlen(cad) Retorna la longitud de cad. No se
cuenta el nulo.
strcpy(cad1, cad2) Copia cad2 en cad1.
strcat(cad1, cad2) Une cad1 con cad2.

strcmp(cad1, cad2) Compara cad1 con cad2.
<0 si cad1<cad2
Retorna =0 si cad1=cad2
>0 si cad1>cad2
Ejemplo con Funciones de Cadenas

#include<stdio.h>
#include<string.h>
int main()
{char ap[50],no[50],apn[100]; int n;
printf("Apellidos: "); gets(ap);
printf("Nombres: "); gets(no);
strcpy(apn,ap); strcat(apn," ");
strcat(apn,no);
printf("%s %d caracteres\n",apn, strlen(apn));
n=strcmp(ap,no);
if(n>0) printf("%s>%s\n",ap,no);
else if(n<0) printf("%s<%s\n",ap,no);
else printf("%s=%s\n",ap,no);//n=0
system("pause");
}
Ejecución
Apellidos: PEREZ LOPEZ

Nombres: JUAN CARLOS
PEREZ LOPEZ JUAN CARLOS 23 caracteres
PEREZ LOPEZ>JUAN CARLOS
Ejercicio1
Dada una cadena leída por teclado, determinar si es

palíndroma (un palíndromo es una palabra que se lee
igual en dos sentidos, Ejemplo: arepera, Ana, etc.).
cad: a r e p … … … … … e r a \0
0 1 2 3 … i n-i-1 n-3 n-2 n-1 n
n=?
i=0,1,…,?
Solución1
cad: a r e p … … … … … e r a \0
0 1 2 3 … i n-i-1 n-3 n-2 n-1 n
n caracteres
…
conta=0 //cuenta letras diferentes
n = strlen(cad);
for(i=0;i<=(n-1)/2;i++)
if(cad[i]!=cad[n-i-1])
conta++;
…
Ejercicio2
Leer una frase y visualizar cada palabra seguida del

número de letras que la componen. Por ejemplo:
Estas fiestas pascuas tome con moderación
Se mostraría:
Estas 5
fiestas 7
pascuas 7
tome 4
con 3
moderación 10
20 car.
Solución2
Frase: Estas fiestas pascuas tome con moderación

Primero la frase se guarda en un archivo:
Frase.txt
Estas fiestas pascuas tome con moderación
Luego se lee del archivo palabra por palabra:

while(!feof(g)){
fscanf(g,"%s", cad);
printf("%-20s %d\n",cad, strlen(cad));
}
…
Ejercicios Propuestos
• Dada una cadena leída por teclado, convertir las letras

minúsculas a mayúsculas.
• Dada una cadena leída por teclado, invertir el orden de

las letras de cada palabra.
• Dado un archivo, leer por teclado una cadena y

determinar cuantas veces se repite la cadena en el
archivo.
• Dado un archivo, leer por teclado dos cadenas, buscar la

primera cadena en el archivo y reemplazarla por la
segunda cadena.
Laboratorio N° 12
Estructuras o Registros Definición
Tipos Simples y
Estructurados
Estructuras o Registros
Una estructura es un tipo de datos especial

utilizada para guardar información que contiene
diferentes tipos de datos.
Una estructura (Registro) es un tipo de dato
especial, que está compuesto por elementos
denominados campos, cada uno de los cuales
puede ser de un tipo de dato diferente.
Definición de la Estructura
La estructura se define con un alias y se declara la

variable.
struct alias alias

{tipo1 campo1;
tipo2 campo2;
… … campo1 campo2 …
} variable;
Es posible definir la estructura sin alias y declarar la

variable.
struct variable
{tipo1 campo1;
tipo2 campo2;
} variable;
Se puede utilizar el alias para declarar la variable

en otra sentencia.
struct alias alias

{tipo1 campo1;
tipo2 campo2;
};
struct alias variable;

Ejemplo
struct datos datos
{char coda[11];
char apenom[40];
int credap;
coda apenom credap prom
float prom;
};
struct datos alu1, alu2;

Acceso a los campos de una Estructura
Para acceder a la información guardada en una

estructura, podemos hacer uso de dos operadores:
1.-El operador punto (.)
variable.campo
2.-El operador puntero flecha (->)
variable_puntero->campo
Acceso a los campos de una Estructura
Ejemplos:
strcpy(alu1.coda, “20130001A”);
strcpy(alu1.apenom, “Perez-Manuel”);
alu1.credap=100;
alu1.prom=15.6;
Para utilizar el operador flecha, debemos hacer uso

de punteros.
struct datos *ptr;
ptr=&alu1;
strcpy(ptr->coda, “20130001A”);
ptr->credap=100;
Asignación directa
Dos variables estructura del mismo tipo pueden

asignarse directamente.
struct datos alu1, alu2;
…
alu2=alu1;
Lectura y Escritura
Es campo por campo, utilizando el operador punto.
scanf(“%s”,alu1.coda);
gets(alu1.apenom);
scanf(“%d %f”,&alu1.credap, &alu1.prom);
Arreglo de Estructuras
struct alias arreglo[#elementos];
xi
coda apenom credap prom
struct datos x[50];

…
scanf(“%s”,x[i].coda);
gets(x[i].apenom);
scanf(“%d %f”,&x[i].credap, &x[i].prom);
Ejercicio1
Leer por teclado la siguiente información de n

alumnos:
• Código
• Apellidos y Nombres
• Créditos Aprobados
• Promedio
Guardar lo leído en un archivo. Utilizar un arreglo
de estructuras.
Codificación1
/*Ejemplo con registros o estructuras*/
#include<stdio.h>
struct datos //1:Definicion
{char coda[11]; char apenom[40];
int credap; float prom;
}; //Aqui punto y coma
int main()
{ //2: Declaracion de variable
struct datos x[50]; int i,n; FILE *g;
printf("n: "); scanf("%d",&n);
for(i=1;i<=n;i++){
printf("Alumno%d\n",i);
printf("Promedio: "); scanf("%f",&x[i].prom);
printf("Codigo: "); scanf("%s",x[i].coda);
getchar(); //Para el salto de linea
printf("Apellidos y Nombres: "); gets(x[i].apenom);

printf("Creditos: "); scanf("%d",&x[i].credap);
}
g=fopen("ALUMNOS.TXT","w");
for(i=1;i<=n;i++){
fprintf(g,"%s ",x[i].coda);
fprintf(g,"%-40s",x[i].apenom);
fprintf(g,"%05.2f ",x[i].prom);
fprintf(g,"%d\n",x[i].credap);
}
fclose(g);
system("pause");
}
Ejecución1
n: 5
Alumno1
Promedio: 15.8
Codigo: 20120101A
Apellidos y Nombres: PEREZ LOPEZ JUAN CARLOS
Creditos: 120
Alumno2
Promedio: 10.9
Codigo: 20100101B
Apellidos y Nombres: RAMOS ESTRADA KEVIN FAUSTO
Creditos: 100
Alumno3
Promedio: 14.6
Codigo: 20110101C
Apellidos y Nombres: SANTIAGO LLEELLISH JOSE
Creditos: 200
Alumno4
Promedio: 13.7
Codigo: 20100101D
Apellidos y Nombres: OTERO MONTEZA ALEXANDER
Creditos: 190
Alumno5
Promedio: 19.9
Codigo: 20130101E
Apellidos y Nombres: MOYA CAHUANA CARLOS ARTURO
Creditos: 200
ALUMNOS.TXT
20120101A PEREZ LOPEZ JUAN CARLOS 15.80 120

20100101B RAMOS ESTRADA KEVIN FAUSTO 10.90 100
20110101C SANTIAGO LLEELLISH JOSE 14.60 200
20100101D OTERO MONTEZA ALEXANDER 13.70 190
20130101E MOYA CAHUANA CARLOS ARTURO 19.90 200
40 car.
Laboratorio N° 13
Punteros Definición
Aritmética de Punteros
Aplicaciones

Teoria de Orejas PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Teoria de Orejas PDF

Uploaded by

Copyright:

Available Formats

PROGRAMACION DIGITAL - CB412 - CICLO 2014-1 1

UNIVERSIDAD NACIONAL DE INGENIERIA

WILFREDO CUPE ROMÁN

COMPETENCIAS DEL CURSO

Entorno del PSeInt

Creación de Diagramas de Flujo

Creación de Diagramas de Flujo

Ejecución del Diagrama de Flujo

Ejecución del Diagrama de Flujo

Ejecución paso a paso

Permite realizar un seguimiento más detallado de

Ejecución paso a paso

Ejecución paso a paso

Permite configurar una tabla con un conjunto de

Entorno del DEV C++

Menu File (Archivo)

Nuevo  Archivo Fuente

Menu Execute (Ejecutar)

Un programa está constituido por un conjunto de

ANSI: American National Standards Institute

#include<stdio.h> Directiva de Preprocesador.

Compilación (Execute  Compile)

El compilador traduce el programa a lenguaje de

Archivo Fuente COMPILACION Archivo Objeto

Compilación (Execute  Compile)

El linker enlaza todos los archivos compilados

Compilación (Execute  Compile)

Ejecución (Execute  Run)

El archivo ejecutable es independiente del DEV.

Los errores de sintaxis, o sintácticos, ocurren

Los errores de sintaxis se detectan en el proceso

Se producen cuando la computadora no puede

c = 15 / 0; /*No tiene errores de sintaxis*/

Producirá un error de ejecución, ya que,

Ocurren a causa de una lógica equivocada, los

Funciones Salida Entrada

Funciones de Entrada / Salida

Permiten a un programa recibir y enviar datos al

donde stdio proviene de standard-input-output.

Salida por Pantalla: printf

Imprime en la unidad de salida estándar (monitor)

printf(“cadena de formato”, expresión);

• Especificadores de Formato • Constante

Especificadores de Tipo de la expresión

Entrada por Teclado: scanf

Lee datos de la entrada estándar (teclado).

scanf(“cadena de formato”, &variable);

/*Ejemplo printf y scanf*/

/*Ejemplo printf y scanf*/

Son signos especiales que indican determinadas

/*Ejemplo de printf, scanf y operadores*/

Funciones Funciones Trigonométricas

El ANSI C tiene una biblioteca estándar de

Tipo del valor devuelto Argumento o parámetro

Tipo del valor devuelto Argumento o parámetro

Raíz Cuadrada, Valor Absoluto, Redondeo de

Tipo del valor devuelto Argumento o parámetro

longitud  xa  xb2  ya  yb2

longitud  xa  xb2  ya  yb2

/*Distancia entre dos puntos*/

ang  arcocosenob/a*180 / 3.141592

angm (ang - ang ) * 60

/*Calcula cateto y angulo interno*/

c = 15 / 0; /No tiene errores de sintaxis/

/Ejemplo printf y scanf/

/Ejemplo printf y scanf/

/Ejemplo de printf, scanf y operadores/

/Distancia entre dos puntos/

/Calcula cateto y angulo interno/

k#col+(#fila-1)n Entradas Salidas k#col+(#fila-1)n