Transcript si - UPC

Computación y Programación
Fundamentos de Informática
Josefina Sierra Santibáñez
[email protected]
1
Objetivos
Introducción a la programación
– Entender y construir algoritmos (lenguaje semi-formal).
– Conocer conceptos importantes de programación: tipos de datos,
expresiones, instrucciones, estructuras de datos y funciones.
– Algoritmos de búsqueda, recorrido, ordenación y cálculos
matemáticos.
– Fundamentos de la programación en C.
2
Funcionamiento
• Clases de teoría:
– Presentar conceptos y metodología de programación. Explicar su
representación en lenguaje algorítmico y en C.
– Ilustrarlos con ejemplos de algoritmos en lenguaje algorítmico y
con ejercicios.
• Clases de problemas y laboratorio:
– Presentar ejemplos de programas C en los que se utilicen los
conceptos de programación vistos en clase de teoría.
– Realizar ejercicios de programación en C de algoritmos vistos
en clase de teoría o propuestos como ejercicios.
3
Programa
1.
2.
Introducción
Conceptos básicos
1.
2.
3.
Acciones y funciones
1.
2.
4.
Concepto y operaciones asociadas (búsqueda y recorrido)
Ejercicios de secuencias
Matrices o tablas
1.
2.
6.
Declaración, definición, llamada y paso de parámetros
Ejercicios de acciones y funciones
Secuencias
1.
2.
5.
Tipos de datos básicos, variables, constantes y expresiones
Asignación y composición secuencial, condicional e iterativa
Vectores, matrices y operaciones asociadas
Ejercicios de vectores y matrices
Ordenación
1.
2.
Algoritmos de ordenación
Ejercicios de ordenación
4
Programa
7.
Estructuras o tuplas
1.
2.
3.
8.
9.
Definición y operaciones asociadas
Tablas de estructuras
Ejercicios de estructuras
Algoritmos numéricos
Diseño descendente
5
Evaluación
• Calificación global
– G = 0.45*Teoría + 0.45*Práctica + 0.1*Proyecto
• Se realizarán dos exámenes: un parcial y un final
– Teoría = 0.3*Parcial Teoría + 0.7*Final Teoría
– Práctica = 0.3*Parcial Práctica + 0.7*Final Práctica
• El proyecto de programación es un trabajo individual que
se evaluará generalmente mediante preguntas del examen
final (y excepcionalmente mediante una entrevista).
6
Consultas
• Martes y Miércoles de 11:00 a 12:00 y de 14:00 a
16:00 en el despacho 322 de la ETSEIT.
• Para realizar consultas en otro horario podéis
enviar un mensaje de correo electrónico a:
[email protected]
7
Material de Apoyo
Página de Internet de la asignatura:
http://www.lsi.upc.es/~fietseit/fi.html
–
–
–
–
–
–
Bibliografía básica
Entorno de programación Dev C++
Apuntes de la asignatura
Normas de evaluación
Funcionamiento de la asignatura
Programa detallado
8
Preguntas
9
1.1.- Algoritmo
Concepto de algoritmo:
Sucesión explícita de reglas para resolver correctamente un problema
genérico bien definido en un número finito de pasos.
Aspectos básicos a tener presentes a la hora de redactar un algoritmo:
• Explícito: Formal y sin ambigüedades.
• Genérico: Problema cuyos datos son generales.
• Bien definido: Problema perfectamente caracterizado.
• Correcto: Que funcione en todos los casos.
• Número finito de pasos: Debe terminar.
10
Estructura de un algoritmo:
algoritmo nombre
constantes (valores fijos)
datos
tipos (nuevos dominios de datos)
variables
cuerpo
(datos)
(instrucciones)
falgoritmo
acciones y funciones auxiliares
11
Son de un tipo
Datos
• Simple:
entero, real, booleano, carácter
[dominio + operaciones]
• Compuesto:
tupla, tabla
[constructores + funciones de
acceso]
Tienen un nombre (identificador)
Pueden ser
• Constantes: valor fijo
[Literales: constantes predefinidas]
• Variables
Los datos se deben declarar con todos estos atributos (excepto los literales).
Un dato contiene siempre un valor de su tipo.
12
Comunicarse con el exterior
[lectura y escritura]
Modificar el contenido de los datos
[asignación]
Instrucciones
Controlar el orden de
ejecución
• Secuenciación
• Condicional
• Iteración
Agrupar sucesiones de instrucciones en bloques
independientes [acciones y funciones]
13
1.2.- Variables
Definición: una variable es un dato cuyo valor puede cambiar durante la ejecución
de un algoritmo.
Para asignar un valor a una variable se utiliza el operador de asignación “:=”.
Ejemplos: x := 3.0; y := x + 2.1; y := 3*x + 2; ... [x, y son variables]
Tipos básicos de datos son:
real
3.0, -2.1, ...
entero
-3, +10, …
carácter
’a’, ’b’, ’F’, ’4’, ’.’, ...
booleano
VERDADERO, FALSO
Definición de una variable en un algoritmo:
algoritmo nombre_algoritmo
var n: entero; x, y: real; c: carácter; b: booleano fvar
n:=3; x:=2.3; c:=’w’; b:=VERDADERO; y:=-5.0;
...
falgoritmo
14
Lectura de datos
algoritmo leer_variables
var n: entero; x: real; c: carácter; b: booleano fvar
LeerEntero(n); LeerReal(x);
LeerCarácter(c); LeerBooleano(b);
...
falgoritmo
Notación alternativa:
algoritmo leer_variables
var n: entero; x: real; c: carácter; b: booleano fvar
n:=LeerEntero( ); x:=LeerReal( );
c:=LeerCarácter( ); b:=LeerBooleano( );
...
falgoritmo
15
Si n es entera, x es real y realizamos la asignación n:=x, la variable n toma
como valor la parte entera de x.
Se pueden transformar los valores de las variables de un tipo a otro.
algoritmo
var x: real; n: entero; c: carácter fvar
...
x := 65.2
[x <- 65.2]
n := DeRealAEntero(x)
[n <- 65]
c := DeEnteroACarácter(n)
[c <- “carácter correspondiente al número 65 en el código
de ASCII, esto es, la
letra mayúscula ‘A’.”]
...
falgoritmo
Análogamente se pueden realizar los siguientes cambios de tipos
carácter  entero  real
16
1.3.- Constantes
Definición: una constante es un dato que representa un valor fijo de un tipo determinado que no se puede modificar.
Ejemplo:
algoritmo
const Pi: real = 3.1415926535897932385 fconst
var x, y: real fvar
...
x := Pi*Pi;
y := 3*Pi;
...
falgoritmo
17
1.4.- Tipos y operaciones
Definición: conjunto de valores (dominio) y operaciones aplicables.
Tipos básicos: booleano, entero, real y carácter.
• Tipo de datos booleano: Valores: {V, F}. Operadores: y, o, no, =, 
• Tipo de datos entero:
Valores: los enteros, {-MaxEnt, ..., -3, -2, -1, 0, 1, 2, 3, ..., MaxEnt }
Operadores (binarios):
+:
entero + entero  entero
x
r
y
q
-:
*:
(división entera) div:
(resto) mod:
=:

<:
>:


entero - entero  entero
entero * entero  entero
entero div entero  entero
entero mod entero  entero
entero = entero  booleano
entero  entero  booleano
entero < entero  booleano
entero > entero  booleano
entero  entero  booleano
entero  entero  booleano
x div y = q
x mod y = r
y * q + r = x
0  r < |y|
18
• Tipo de datos real.
Valores: los reales, {-MaxReal, ... , -MinReal, 0, MinReal ,…, MaxReal}
Operadores (binarios):
+:
-:
*:
/:
=:

<:
>:


real + real  real
real - real  real
real * real  real
real / real  real
real = real  booleano
real  real  booleano
real < real  booleano
real > real  booleano
real  real  booleano
real  real  booleano
• Tipo de datos carácter. Valores: los caracteres,
{’?’, ’^’, ’#’, ’&’, ..., ’A’, ’B’, …, ’Z’, …,
’a’, ’b’, …, ’z’, …, ’0’, ’1’, ’2’, …, ’9’, …, ’+’, ’-’, ... }
Operadores (binarios): =, : carácter = carácter  booleano
...
• Más adelante veremos algunos tipos compuestos: tablas y tuplas.
19
1.5.- Expresiones
Definición:
Una variable es una expresión.
Una constante es una expresión.
Si E es una expresión, (E) es una expresión.
Si E1, E2, ..., En son expresiones y f una función, f(E1, E2, ..., En) es una expresión
Los tipos de las expresiones tienen que ser coherentes.
Las prioridades de los operadores se utilizan para evaluar correctamente las
expresiones: se aplica la regla asociativa de izquierda a derecha y, en caso de duda, se
ponen paréntesis.
Operadores utilizados más frecuentemente ordenados de mayor a menor prioridad:
., [ ]
-, no
*, /, div, mod
+, <, >, 
y, o
(acceso a tuplas y tablas)
(cambio de signo y negación lógica) [unarios]
(operadores multiplicativos)
(operadores aditivos)
(operadores relacionales)
(y, o lógicos)
20
• Ejemplos
Sean i=3, j=16, x=3.5, y=2 y b=FALSO, entonces
(x+y)*y = (3.5+2.0)*2.0
= (5.5)*2.0
= 11.0
( j div i )  5 y b
=
=
=
=
( 16 div 3 )  5 y FALSO
( 5 )  5 y FALSO
VERDADERO y FALSO
FALSO
Hay que tener en cuenta los errores que se pueden producir en tiempo
de ejecución:
• Dividir por 0: cuando utilicemos los operadores div, mod, y /.
• Problemas de precisión con los reales
21
• Ejemplos. Sean i, j y k variables o constantes enteras, x, y y z variables o
constantes reales, a, b y c variables o constantes booleanas.
34.0 es una expresión real
x es una expresión real
x+y es una expresión real
(x+y) es una expresión real
(x+y)*x es una expresión real
(x+y)*x < 24 es una expresión booleana
28 es una expresión entera
i es una expresión entera
i mod j es una expresión entera
(i mod j) es una expresión entera
(i mod j) = k es una expresión booleana
(x+y) * x > 34 y (i mod j) = k es una expresión booleana
((x+y) * x > 34 y (i mod j) = k) es una expresión booleana
no((x+y) * x > 34 y (i mod j) = k) es una expresión booleana
RealAEntero(x) es una expresión entera
RealAEntero(LeerReal(x))+Pi es una expresión real
22
MaxEnt+MaxEnt es una expresión entera (error de compilación)
1.6.- Instrucciones
Lectura (ya lo hemos visto) y Escritura
• Lectura: establece el valor de una variable a través de un dispositivo de entrada.
• Escritura: permite comunicar el valor de una expresión a través de un dispositivo
de salida.
algoritmo ejemplo
var n: entero; x: real; c: carácter; fvar
LeerEntero(n); EscribirEntero(n);
LeerReal(x); EscribirReal(x);
LeerCarácter(c); EscribirCarácter(c)
falgoritmo
La notación anterior se puede simplificar utilizando las instrucciones leer(variable),
escribir(variable), así como instrucciones de lectura y escritura múltiple. También
se pueden escribir mensajes de texto, siempre que éstos se escriban entre comillas.
algoritmo ejemplo
var n: entero; x: real; c: carácter; fvar
escribir(“Introduzca un entero, un real y un carácter:”);
23
leer(n, x, c); escribir(n, x, c)
falgoritmo
Asignación
variable := expresión
[la variable toma el valor de la expresión]
Ejemplos.
n := 1 (entero); x := 9.8 (real);
c := ’e’ (carácter); b := VERDADERO (booleano);
Notas: El tipo de la variable y el de la expresión deben de ser iguales.
El valor que tenía la variable antes de la asignación se pierde.
Las variables cuando se declaran no tienen ningún valor concreto.
Siempre que trabajemos con una variable debemos darle un valor
inicial. Este proceso se denomina “inicialición de las variables”.
Secuenciación
Cuando tengamos más de una instrucción, utilizaremos la instrucción de
secuenciación. Las distintas instrucciones se separan con el signo “ ; “.
instrucción_1; instrucción_2; ... ; instrucción_k; ... ; instrucción_n
En este caso la instrucción_k no se ejecuta hasta que termina la ejecución24
de las k-1 instrucciones anteriores.
Instrucción condicional o alternativa (si … entonces … si no … fsi)
si expresión_booleana entonces
instrucciones_V
si no
instrucciones_F
[instrucciones que se ejecutan si la
expresión booleana es verdadera]
[instrucciones que se ejecutan si la
expresión booleana es falsa (opcional)]
fsi
Cuando hay varias condiciones se puede utilizar el siguiente esquema:
si
expresión_booleana_1  instrucciones_1
expresión_booleana_2  instrucciones_2
...
expresión_booleana_n  instrucciones_n
fsi
25
Ejemplo. Calcular el máximo de dos números dados.
algoritmo máximo
var x, y: real fvar
(* Declaración de variables *)
LeerReal(x);
(* Instrucción de lectura *)
LeerReal(y)
(* Instrucción de lectura *)
si (x  y) entonces (* Instrucción alternativa *)
EscribirReal(x) (* Instrucción de escritura *)
si no
EscribirReal(y) (* Instrucción de escritura *)
fsi
falgoritmo
Ejemplo. Calcular el máximo de dos números teniendo en cuenta si son iguales.
algoritmo máximo=
var x, y: real fvar
LeerReal(x); LeerReal(y)
si
(x > y)  EscribirReal(x)
(x < y)  EscribirReal(y)
(x = y)  EscribirCadenadeCarateres(“Son iguales.”)
fsi
26
falgoritmo
Ejercicio 3. Determinar las raíces de una ecuación de segundo grado
• Las raíces de la ecuación de segundo grado ax2+bx+c=0 se obtienen mediante la
fórmula
x=(-b  (b2-4ac)1/2)  2a
• Esta expresión para x se obtiene
1. sustituyendo x por t-(b/2a) en la ecuación ax2+bx+c=0
2. despejando t
3. calculando el valor de x a partir del valor de t.
27
algoritmo raíces de ecuación de segundo grado
var a, b, c, x, y, aux: real fvar
Escribir (“Introducir los coeficientes de mayor a menor grado, i.e., a, b y c
tales que la ecuación es ax^2+bx+c=0:”);
LeerReal(a); LeerReal(b); LeerReal(c); aux := b2 - 4ac;
si
a = 0 y b = 0 —> Escribir(“No es una ecuación.”);
a = 0 y b  0 —> Escribir(“Ecuacion de primer grado con raiz:”);
x := -c/b; EscribirReal(x);
aux > 0 —> Escribir(“Tiene dos raices reales distintas:”);
x := (- b + aux 1/2 ) / 2a ; y := (- b - aux 1/2 ) / 2a;
EscribirReal(x) ; EscribirReal(y)
aux = 0 —> Escribir(“Tiene dos raices reales iguales:”);
x := - b / 2a ; y := x; EscribirReal(x)
aux < 0 —> Escribir(“Tiene dos raices complejas:”);
aux := (-aux) 1/2 ;
EscribirReal(-b/2a); EscribirCadenadeCaracteres(“+i”); EscribirReal(|aux/2a|) ;
EscribirCadenadeCaracteres(“\n”);
EscribirReal(-b/2a); EscribirCadenadeCaracteres(“-i”); EscribirReal(|aux/2a|)
fsi
falgoritmo
28
Instrucción iterativa (mientras … hacer … fmientras)
mientras expresión_booleana hacer
instrucciones
fmientras
Notas:
• Mientras la expresión_booleana sea cierta, las instrucciones se ejecutan.
• Cuando la expresión_booleana deja de ser cierta entonces la instrucción
iterativa se acaba.
• Si la expresión_booleana es inicialmente falsa la instrucción iterativa no
hace nada.
• Hay que asegurarse de que las instrucciones modifiquen los valores de las
variables que forman parte de la expresión_booleana de manera que la
instrucción iterativa termine en un número finito de pasos.
29
Ejemplo. El algoritmo de Euclides sirve para calcular el máximo común divisor
(m.c.d.) de dos números positivos. Dados dos números enteros positivos:
1. Se calcula el resto r de dividir el número mayor de los dos x por el menor y.
2. Si r es 0, entonces y es el máximo común divisor.
3. Si r no es 0, entonces se asigna a x el antiguo valor de y, se asigna a y el valor
de r, y se repite todo el proceso.
Ejemplo: x=49, y=42, r=7  x=42, y=7, r=0  7 es el m.c.d. de 49 y 42.
algoritmo Euclides
var x, y, r: entero; fvar
LeerEntero(x); LeerEntero(y);
si y>0 y x>0 entonces
r:= x mod y;
mientras (r ≠ 0) hacer
x:=y ; y:=r; r:= x mod y;
fmientras
Escribir(“El maximo común divisor es “); Escribir(y);
fsi
falgoritmo
31
Instrucción iterativa (para … hasta … hacer ... fpara)
para variable := valor_inicial hasta valor_final hacer
instrucciones
fpara
En la definición anterior el valor asignado inicialmente a la variable se incrementa
en una unidad en cada iteración. También se puede incluir un valor con la opción
paso que permite especificar la cantidad en la que se quiere incrementar el valor
de la variable en cada interacción.
para variable := valor_inicial hasta valor_final paso incremento hacer
instrucciones
fpara
Ejemplo. Escribir los números pares del 1 al 100.
algoritmo pares
var n: entero fvar
para n:= 2 hasta 100 paso 2 hacer
EscribirEntero(n);
fpara
falgoritmo
(* Declaración de variables *)
(* Instrucción iterativa *)
(* Instrucción de escritura *)
32
algoritmo Suma lista N
cons N: entero = 10; fcons
var i: entero; número, suma: real fvar
suma := 0.0;
para i:=1 hasta N hacer
Escribir(“Introduzca un número: “);
Leer(número);
suma := suma+número;
fpara
Escribir(“La suma de los números introducidos es “);
Escribir(suma);
falgoritmo
algoritmo Producto lista N
cons N: entero = 5; fcons
var i: entero; número, producto: real fvar
producto := 1.0;
para i:=1 hasta N hacer
Escribir(“Introduzca un número: “);
Leer(número);
producto := producto*número;
fpara
Escribir(“El producto de los números introducidos es “);
Escribir(producto);
falgoritmo
Ejercicio 1. Calcular el factorial de un número introducido por el
usuario.
algoritmo factorial
var n, i, resultado: entero; fvar
Escribir(“Introduzca un número positivo: “);
LeerEntero(n);
resultado := 1;
si (n > 1) entonces
para i := 2 hasta n hacer
resultado := resultado*i;
fpara
fsi
Escribir(“El factorial de “); Escribir(n);
Escribir(“ es “); Escribir(resultado);
falgoritmo
Ejercicio 2. Calcula la suma de los dígitos de un número.
algoritmo Suma dígitos de un número
var número, suma, aux: entero fvar
suma := 0;
Escribir(“Introduzca un número entero positivo: “);
Leer(número);
aux := número;
mientras número ≠ 0 hacer
suma := suma + (número mod 10);
número := número div 10;
fmientras
Escribir(“La suma de los dígitos de “);
Escribir(aux);
Escribir(“ es “);
Escribir(suma);
falgoritmo
Ejercicio 3. Determinar si un número es primo.
Un número n es primo si es mayor que 1 y sólo es divisible por sí mismo y la unidad.
algoritmo primo
var n, i: entero; primo: booleano fvar
Escribir(“Introduzca un número entero positivo: “); LeerEntero(n);
si (n = 1) entonces primo := F
si no
primo :=V; i := 2;
mientras primo y i ≤ n-1 hacer
si (n mod i) = 0 entonces
primo := F;
si no
i:= i+1;
fsi
fmientras
fsi
si primo entonces
Escribir(n); Escribir(“ es primo.”)
si no
Escribir(n); Escribir(“ no es primo.”)
fsi
falgoritmo
Ejercicio 4. Determinar si un número es primo.
Un número n es primo si es mayor que 1 y sólo es divisible por sí mismo y la unidad.
Para determinarlo comprobamos que n no es par y que no es divisible por los impares
comprendidos entre 3 y n(1/2).
algoritmo primo
var n, i: entero; primo: booleano fvar
Escribir(“Introduzca un número entero: “); LeerEntero(n);
si (n = 1) o ((n mod 2) = 0 y n ≠ 2) entonces primo := F
si no
primo :=V; i := 3;
mientras primo y i2 ≤ n hacer
si (n mod i) = 0 entonces
primo := F;
si no
i:= i+2;
fsi
fmientras
fsi
si primo entonces
Escribir(n); Escribir(“ es primo.”)
si no
Escribir(n); Escribir(“ no es primo.”)
fsi
falgoritmo
Ejercicio 5. Escribir los n primeros números de la sucesión de Fibonacci.
La sucesión de Fibonacci viene definida por las siguientes reglas:
•
fib[0]=0
•
fib[1]=1
•
fib[i]=fib[i-1]+fib[i-2], para i>1.
algoritmo Fibonacci
var n, último, penúltimo, aux, i: entero fvar
Escribir(“Introduzca un número: “); LeerEntero(n);
penúltimo:=0; último:=1;
para i:=0 hasta n-1 hacer
EscribirEntero(penúltimo);
aux:=último; último:=último+penúltimo; penúltimo := aux;
fpara
falgoritmo
Estructura de un programa C
algoritmo nombre
inclusiones
constantes
constantes
tipos
tipos
variables
prototipos
instrucciones
int main (void) {
falgoritmo
variables
acciones y funciones auxiliares
instrucciones
}
acciones y funciones auxiliares
archivo nombre.cpp
A lo largo del curso iremos viendo cómo se traduce cada parte del algoritmo.
Hay que respetar el orden de aparición de las distintas partes que aparecen en esta transparencia.
Las inclusiones son referencias a archivos que tienen información auxiliar.
Los prototipos son declaraciones de las acciones y funciones auxiliares (no deben olvidarse).
int, main y void son palabras clave, hay que escribirlas tal y como aparecen en la transparencia.
45
Constantes
Cada constante se define en una línea diferente de la forma
nombre: tipo = valor
-->
#define nombre valor
Ejemplo:
const
pi: real = 3.1415926
#define pi 3.1415926
Terminador: carácter = ‘\0'
#define Terminador ‘\0'
fconst
46
Declaración de variables
Las declaraciones de las variables de un algoritmo se traducen indicando en
primer lugar el tipo traducido y en segundo lugar el nombre de la variable.
var nombre: tipo fvar

tipo-traducido nombre;
Los tipos básicos se traducen del modo siguiente:
entero --> int
real --> double o float
carácter --> char
booleano --> bool
[En C++, false, true]
Ejemplo:
var
fvar
suma: entero;
int suma;
x, y: real
double x, y;
letra: carácter
char letra;
primo: booleano
bool primo;
47
Tabla resumen de los operadores del lenguaje C
• Aritméticos: + (suma), - (cambio de signo), - (resta), * (producto), / (división),
% (módulo)
• Lógicos: && (conjunción, “y”), || (disyunción, “o”), ! (negación, “no”)
• Relacionales: == (igualdad), != (desigualdad), <, >, <=, >= (comparaciones)
• Cambio de tipo: (tipo), donde (tipo) puede ser int, double, float o char
(double) n
convierte el valor de n a real de doble precisión
• Prioridad de evaluación: operadores ordenados de mayor a menor.
– Operadores unarios: - (cambio de signo), !, (tipo)
– Operadores multiplicativos: *, /, %
– Operadores aditivos: +, - (resta)
– Operadores de comparación: <, <=, >, >=
– Operadores de igualdad: ==, !=
– Conjunción: &&
– Disyunción: ||
• A igual prioridad la regla asociativa se aplica de izquierda a derecha.
48
Instrucciones de entrada, salida y asignación
La instrucción de entrada habitual se traduce del modo siguiente:
Leer(var)

cin >> var;
puede tener varios argumentos cin >> var_1 >> var_2 >> ... >> var_n;
La instrucción de salida habitual se traduce del modo siguiente:
Escribir(expr)

cout << expr;
puede tener varios argumentos cout << expr_1 << ... << expr_n;
cout << endl; produce un salto de línea
La instrucción de asignación se traduce del modo siguiente:
var := expr

var = expr;
49
Instrucción condicional IF
si expr entonces
instrucciones_V
si no
instrucciones_F
fsi
En C la expresión se escribe entre paréntesis y las instrucciones de los casos V
(verdadero) y F (falso) entre llaves.
if (expr) {
instrucciones_V
} else {
instrucciones_F
}
50
Instrucción condicional ELSE IF
si
expresión_booleana_1  instrucciones_1
expresión_booleana_2  instrucciones_2
...
expresión_booleana_n  instrucciones_n
fsi
if (expresión_booleana_1) {
instrucciones_1
} else if (expresión_booleana_2) {
instrucciones_2
....
} else {
instrucciones_n
}
51
Instrucción Iterativa WHILE
mientras expr hacer
instrucciones
fmientras
En C la expresión se escribe entre paréntesis y las instrucciones entre llaves.
while (expr) {
instrucciones
}
52
Instrucción iterativa FOR
En notación algorítmica se escribe
para var := valor_inicial hasta valor_final paso incremento hacer
instrucciones
fpara
En C se escribe
for (var = valor_inicial ; var <= valor_final ; var = var + incremento) {
instrucciones
}
53
En general la instrucción iterativa for
for (expr1; expr2 ; expr3) {
instrucciones
}
equivale a
expr1;
while (expr2) {
instrucciones;
expr3;
}
54
Comentarios
Tanto en los programas como en los algoritmos deben aparecer comentarios explicativos. En C los comentarios se escriben así (pueden ocupar varias líneas):
/* Esto es un comentario. */
Indentación
Se suelen dejar espacios en blanco al comienzo de la línea para reflejar la estructura lógica de un programa.
También se dejan dos líneas en blanco para separar unidades lógicas diferentes de un programa. Por ejemplo, para separar las inclusiones de las constantes, o las distintas funciones.
Identificadores
Los nombres de las constantes, variables y funciones deben ser autoexplicativos (e.g., Par, SumaTotal o Resultado).
55