P07arrInt.
cpp
1) Objetivo.
Opera arreglos enteros. Ejm: Lee un arreglo de 2x5 elementos y lo imprime en orden
inverso.
2) Interface de usuario. Se refiere a un esquema que ilustra lo que sale en la pantalla
o monitor, al momento de la ejecución del programa.
3) Diagramas de flujo.
main
Ent(Ax[][5]) Proc(Ay[][5])
limPant 1 (80-strlen(T1))/2,12
Ent(Arr) T1
(80-strlen(T1))/2,1)
i=4,ii=0;ii<5;ii++,i--
T1 Proc(Arr)
(80-strlen(T1))/2,2) j=4,jj=0;jj<5;jj++,j--
opc=Sal()
i=0;i<5;i++ SI 6+jj*14,14+ii
opc=='n'
j=0;j<5;j++ E[i+1][j+1]: Ay[i][j]
fin
6+j*14,4+i
E[i+1][j+1]: fin
Ax[i][j]
SI
!(Ax[i][j]>=-30000
&&Ax[i][j]<=3000
Sal()
0)
fin
ir((80-strlen(T1)-1)/2,20)
T1
s
c=tolower(c)
SI
!(c=='s'||c=='n') fin
4) Codificación.
/* [Link]
Opera arreglos enteros
*/
#include"gotoxy.h"
//#include<cctype>
#include<cstring>
#include<iostream>
#include<conio.h> //para el getch
using namespace std;
void Ent(int Aint[][5]);
void Proc(int Aint[][5]);
char Sal();
void main(void){
int Arr[5][5];
char opc;
while(1){
Ent(Arr);
Proc(Arr);
opc=Sal();
if(opc=='n') break;
}
return 0;
}
void Ent(int Ax[][5]){
int i,j;
char T1[]="[Link] Manipulaci¢n de Arreglos Enteros";
char T2[]="Valores entre -30000 y 30000 inclusive";
system("cls"); //clrscr();
gotoxy((80-strlen(T1))/2,1);cout<<T1;
gotoxy((80-strlen(T2))/2,2);cout<<T2;
for(i=0;i<5;i++){
for(j=0;j<5;j++){
do{
gotoxy(6+j*14,4+i);
cout<<"E["<<i+1<<"]["<<j+1<<"]:";
cin>>Ax[i][j];
}while(!(Ax[i][j]>=-30000&&Ax[i][j]<=30000));
}
}
}
void Proc(int Ay[][5]){
int i,j,ii,jj;
char T1[]="Valores impresos en orden inverso";
gotoxy((80-strlen(T1))/2,12);cout<<T1;
for(i=4,ii=0;ii<5;ii++,i--){
for(j=4,jj=0;jj<5;jj++,j--){
gotoxy(6+jj*14,14+ii);
cout<<"E["<<i+1<<"]["<<j+1<<"]:"<<Ay[i][j];
}
}
}
char Sal(){
char c;
char T1[]="Otro Proceso (s/n)?: ";
do{
gotoxy((80-strlen(T1)-1)/2,20);
cout<<T1;
//cin>>c;
c=getch();
c=tolower(c);
}while(!(c=='n'||c=='s'));
return c;
}
5) Requerimientos:
Enviar al eMail correspondiente del grupo:
1 Archivo tipo “.c” con el código del programa (copia de la codificación del punto 4).
2 Imagen de la pantalla con la ejecución del programa. La captura de una pantalla
se obtiene al digitar simultáneamente las teclas “Windows” e “ImpPt”; el archivo con
la imagen se encuentra en el directorio …\Pictures\CapturaDePantalla (una
aproximación, depende del S.O. instalado y el equipo).
Es necesario crear una Carpeta o Directorio en el equipo del alumno con el nombre
“POO”. En ese directorio guardar todos los archivos del curso. Este ejercicio debe
generar: Archivo Fuente (….cpp, Archivo Objeto (….o), Archivo ejecutable (….exe),
pueden guardar adicionalmente el archivo enviado por WhatsApp (P…..pdf).
6) Explicación:
Línea 1/3: Comentario, delimitado por “/*” y “*/" El equipo no lo considera, sirve
únicamente para información para el usuario.
Líneas siguientes: Directiva al compilador. Incluye en el programa la librería
“iostream” en donde se encuentra la información para operar instrucciones de
entrada/salida. Está #include"gotoxy.h" (Librería donde se encuentra la instrucción
“gotoxy(valX, valY) que sirve para posesionarse en la pantalla con esos valores);
esta librería no es de codeBloks y se proporciona en el curso, se debe guardar en
la carpeta donde están los programas fuente y en el “include” se delimita por
comillas.
using namespace std;: Necesario para “codeBlocks”. Esta plataforma puede operar
para otras aplicaciones. Para operar con CPP.
Siguen los “Prototipos de Función”.
Encabezado de la función principal. Ahí se inicia la ejecución del programa. Indica
que al final debe regresar un valor entero (int).
Al inicio del programa se deben definir las variables que existen en el programa, y
que tipo de variable. En este caso, opc char.
Se llaman de manera secuencial las funciones Ent(Arr); Proc(Arr); opc=Sal();. Lo
anterior dentro de while(1) para repetir el proceso; esto se hace cuando opc que
regresa la función Sal() tiene un valor de ‘s’, cuando el valor es ´n´ con break sale
de while y termina el proceso.
Después del código de “main”, viene el código de las funciones, de acuerdo al
“prototipo”, pero dándole nombre a las variables que vienen como parámetros.
Similar a main, se definen variables locales a la función para realizar la tarea, cuando
sea necesario.
Función “Ent(Arr[][5])”. Inicio de un proceso, limpia pantalla e imprime los letreros T1
y T2. Por medio de dos for se controlan las coordenadas de los elementos del
arreglo (de dos dimensiones -fila y columna-, se trata de una matriz); dentro de un
ciclo iterativo (do / while) lee el elemento (i,j) de la matriz y chaca que sea un valor
correcto, si no lo es regresa a leer nuevamente el número. Se hace la observación
de que la matriz “Arr” llega a la función sin datos (basura) y regresa con la
información.
Función “Proc(Ay[][5])”. Imprime la matriz en orden inverso. Se realiza con dos for
variando el índice de mas a menos. Se utilizan otros índices para controlar la
posición de la impresión.
Función “char Sal()”, regresa el valor de la variable ‘c’ que debe ser ‘s’ o ‘n’. esto se
lleva a cabo por medio de la crítica dentro de un do/while. Y previamente
convirtiendo a minúsculas la letra alimentada.