Programación Imperativa
La
programación imperativa, en
contraposición a la programación declarativa
es un paradigma de programación
que describe la programación en términos del estado del programa y sentencias
que cambian dicho estado. Los programas imperativos son un conjunto de
instrucciones que le indican al computador cómo realizar una tarea.
La
implementación de hardware de la mayoría de computadores es
imperativa; prácticamente todo el hardware de los computadores está diseñado
para ejecutar código de máquina, que es
nativo al computador, escrito en una forma imperativa. Esto se debe a que el
hardware de los computadores implementa el paradigma de las Máquinas de Turing. Desde
esta perspectiva de bajo nivel, el estilo del programa está definido por los
contenidos de la memoria, y las sentencias son instrucciones en el lenguaje de
máquina nativo del computador (por ejemplo el lenguaje ensamblador).
Los
lenguajes imperativos de alto nivel usan variables y sentencias más complejas, pero aún siguen el mismo
paradigma. Las recetas y las listas de revisión de procesos, a pesar de no ser
programas de computadora, son también conceptos familiares similares en estilo
a la programación imperativa; cada paso es una instrucción, y el mundo físico
guarda el estado (Zoom).
Los
primeros lenguajes imperativos fueron los lenguajes de máquina de los
computadores originales. En estos lenguajes, las instrucciones fueron muy
simples, lo cual hizo la implementación de hardware fácil, pero obstruyendo la
creación de programas complejos. Fortran, cuyo desarrollo fue iniciado en 1954
por John Backus en IBM, fue el primer gran lenguaje de
programación en superar los obstáculos presentados por el código de máquina en
la creación de programas complejos.
Las
acciones principales que componen este paradigma son la asignación, selección e
iteración.
Asignación: un valor o un conjunto de ellos operados
por operandos (expresiones) son almacenados en variables. Las variables
representan contenedores de memoria para datos. La asignación es la
representación más pura de la secuencialidad. Ejemplos:
Var
Iva:
real
Cedula:
entero
Sexo:
carácter
Iva
← 0.12
Cedula
← 12345678
Sexo
← 'm'
Como
se puede ver, la variable con identificador "iva" recibe el valor
0.12, la variable con identificador "cedula" el valor 12345678, y la
variable con identificador "sexo" recibe el valor 'm'. La asignación
fomenta la sencuencialidad, puesto que expresiones evaluadas se almacenan en
variables, que sirven como nuevos operandos para nuevas expresiones o como
salidas finales del programa.
Estructuras Selectivas: permiten que una acción
se lleve a cabo bajo una toma de decisión explicita. Crean caminos o
bifurcaciones para la secuencialidad del paradigma imperativo. Una selección
puede crear dos o más alternativas para la ejecución secuencial, pero siempre,
llevando a cabo una y solo una de ellas en un momento determinado. Una
selección múltiple crea un árbol donde las ramificaciones representan las
alternativas.
Selección simple: la toma de decisiones, basada en una
condición, genera dos posibles alternativas de ejecución secuencial. La primera
se lleva a cabo cuando la evaluación de la condición es cierta, y la segunda
cuando la evaluación es falsa (este caso es opcional)
Si
(condición) entonces
accion1
Sino
accion2
Finsi
Selección múltiple: permiten establecer múltiples alternativas
ante bien sea el valor de una variable especifica establecer un conjunto de
selecciones cada una con una condición diferente.
Var
Día:
carácter
Selección
(día)
Caso
'1': escribir (“Hoy es lunes”)
Caso
'2': escribir (“Hoy es martes”)
Caso
'3': escribir (“Hoy es miércoles”)
Caso
'4': escribir (“Hoy es jueves”)
Caso
'5': escribir (“Hoy es viernes”)
Finseleccion
Estructuras Iterativas: permiten establecer
ciclos de ejecución para la secuencialidad. Establecen repetición de acciones,
y la culminación del ciclo puede ocurrir mediante el manejo de índices de ciclo
(cuando el índice alcance el valor tope definido) o mediante el cumplimiento de
una condición (ejecutar acciones “mientras” la condición siga siendo verdadera
o ejecutar acciones “hasta” que la condición se haga verdadera).
Bajo el manejo de índices de control de ciclo: el valor índice
incrementa por cada iteración hasta alcanzar el valor tope. Se usa cuando se
conoce a exactitud la cantidad de iteraciones.
Para
i ← 1 hasta 10 hacer
//acciones
finpar
Bajo el manejo de condiciones (caso mientras): establece que las
acciones se realizan siempre y cuando se cumpla la condición inicial del ciclo,
esto establece que es posible que la secuencialidad no de paso al ciclo si en
primera instancia la condición no se cumple. Se usa cuando se desconoce la
cantidad de iteraciones (la evaluación de la condición se ejecuta primero).
Mientras
(condición) hacer
//acciones
Finmientras
Bajo el manejo de condiciones (caso repetir): establece que las
acciones se realizan hasta que la condición sea verdadera o hasta que sea falsa
(en el caso del pseudocodigo hasta que sea verdadera). Se usa cuando se
desconoce la cantidad de iteraciones.
Repetir
//acciones
Hasta
(condición)
Ejemplos Programados (Lenguaje C)
/*
* Prime Number Generator: genera numeros primos hasta el numero indicado como
* parametro. Si el numero indicado como parametro de entrada no es primo,
* entonces genera la secuencia hasta el ultimo numero primo encontrado antes
* de llegar al numero top.
*/
void PrimeNumbers(int top){
int i,flag,number,j=1;
//Iteración de tipo indexada
for(j=2;j<=top;j++){
//Asignaciones
i=2;
flag=1;
number=j;
//Iteración con condicion mientras
while((i<=number-1)&&(flag==1)){
//Seleccion
if(number%i==0){
flag=0;
}
else{
i++;
}
}
if(flag==1){
printf("%d ",number);
}
}
printf("\n\n");
}
* Prime Number Generator: genera numeros primos hasta el numero indicado como
* parametro. Si el numero indicado como parametro de entrada no es primo,
* entonces genera la secuencia hasta el ultimo numero primo encontrado antes
* de llegar al numero top.
*/
void PrimeNumbers(int top){
int i,flag,number,j=1;
//Iteración de tipo indexada
for(j=2;j<=top;j++){
//Asignaciones
i=2;
flag=1;
number=j;
//Iteración con condicion mientras
while((i<=number-1)&&(flag==1)){
//Seleccion
if(number%i==0){
flag=0;
}
else{
i++;
}
}
if(flag==1){
printf("%d ",number);
}
}
printf("\n\n");
}
/* Busqueda del mayor/menor: recibe un arreglo, su tamaño y el tipo de
busqueda, y retorna el elemento mayor o menor de la colección según sea
el caso. Los valores aceptados para el tipo de busqueda son las cadenas:
"mayor" o "menor". El modulo debe permitir que las cadenas esten en
mayusculas o minusculas.
* Se ha usado: recorrido de vectores, cadenas y operaciones sobre ellas,
* constantes simbolicas, busqueda secuencial, manejo de mayusculas y
* minusculas en strings, iteracion con indice, seleccion simple.
*/
float BiggerorSmaller(float *array, int size, char *searchtype){
int i;
char aux[100];
float menor=0,mayor=0;
strcpy(aux,searchtype);
for(i=0;i<strlen(aux);i++){
aux[i]=tolower(aux[i]);
}
if((strcmp(aux,"mayor")==0)||(strcmp(aux,"menor")==0)){
if(strcmp(aux,"mayor")==0){
mayor=FLT_MIN;
for(i=0;i<size;i++){
if(array[i]>mayor){
mayor=array[i];
}
}
return mayor;
}
else{
menor=FLT_MAX;
for(i=0;i<size;i++){
if(array[i]<menor){
menor=array[i];
}
}
return menor;
}
}
else{
printf("ERROR: LOS VALORES ACEPTADOS SON MAYOR O MENOR EN EL STRING\n\n");
return -1;
}
}
busqueda, y retorna el elemento mayor o menor de la colección según sea
el caso. Los valores aceptados para el tipo de busqueda son las cadenas:
"mayor" o "menor". El modulo debe permitir que las cadenas esten en
mayusculas o minusculas.
* Se ha usado: recorrido de vectores, cadenas y operaciones sobre ellas,
* constantes simbolicas, busqueda secuencial, manejo de mayusculas y
* minusculas en strings, iteracion con indice, seleccion simple.
*/
float BiggerorSmaller(float *array, int size, char *searchtype){
int i;
char aux[100];
float menor=0,mayor=0;
strcpy(aux,searchtype);
for(i=0;i<strlen(aux);i++){
aux[i]=tolower(aux[i]);
}
if((strcmp(aux,"mayor")==0)||(strcmp(aux,"menor")==0)){
if(strcmp(aux,"mayor")==0){
mayor=FLT_MIN;
for(i=0;i<size;i++){
if(array[i]>mayor){
mayor=array[i];
}
}
return mayor;
}
else{
menor=FLT_MAX;
for(i=0;i<size;i++){
if(array[i]<menor){
menor=array[i];
}
}
return menor;
}
}
else{
printf("ERROR: LOS VALORES ACEPTADOS SON MAYOR O MENOR EN EL STRING\n\n");
return -1;
}
}
/* Suma generalizada: recibe un arreglo y retorna el valor de la sumatoria
de cada uno de sus elementos
* Se ha usado: recorrido de vectores, iteracion con indices, contadores.
*/
float SumaGeneralizada(float *array, int size){
int i;
float sumatoria;
for(i=0;i<size;i++){
sumatoria=sumatoria+array[i];
}
return sumatoria;
}
de cada uno de sus elementos
* Se ha usado: recorrido de vectores, iteracion con indices, contadores.
*/
float SumaGeneralizada(float *array, int size){
int i;
float sumatoria;
for(i=0;i<size;i++){
sumatoria=sumatoria+array[i];
}
return sumatoria;
}
que bibliotecas utilizaron para el ejemplo
ResponderEliminar