Fases del Desarrollo de Software
Fase de definición
Analizamos el problema a resolver.
- Análisis del problema.
- Diseño y verificación del algoritmo.
Fase de desarrollo
Creamos el/los programas y la documentación asociada a ellos.
- Codificación en un lenguaje de programación.
- Compilación y enlazado.
- Pruebas y depuración.
- Documentación.
Detalles de las Fases
1. Análisis del Problema
El objetivo es determinar qué ha de hacer el programa. En esta fase se estudiarán los datos de entrada necesarios, el tratamiento que van a sufrir esos datos y los datos de salida.
2. Diseño del Algoritmo
Se detalla la secuencia de pasos (algoritmo) a seguir para la resolución del problema. El algoritmo es una secuencia de pasos a seguir para llevar a cabo la resolución de un problema. Debe cumplir:
- Ser definido.
- Ser preciso: Debe estar compuesto por una secuencia finita de operaciones.
- Ser finito: Debe acabar en un número finito de pasos.
Dos maneras de representarlo: Métodos informales y métodos formales (Pseudocódigo) y Diagramas de flujo.
4. Compilación
El programa fuente es traducido por:
- Un intérprete: toma el programa fuente sentencia a sentencia (de una en una), la analiza y la interpreta produciéndose su ejecución.
- Un compilador: traduce el programa fuente a lenguaje máquina, generando el denominado programa objeto. (Análisis del programa fuente, Errores: El proceso de compilación no continúa, Advertencias sobre la traducción del código).
5. Tipos de Errores
Hay dos tipos de errores:
- Errores de ejecución: el programa «se para» repentinamente sin llegar al final.
- Errores lógicos: el programa se ejecuta hasta el final pero da resultados incorrectos.
6. Documentación
La documentación técnica para el mantenimiento del programa puede dividirse en interna (se incluye en el código del programa fuente) y externa (se realizará en ficheros distintos al programa fuente).
El Preprocesador en C
El preprocesador es un componente característico del lenguaje C que no existe en otros lenguajes de programación. Actúa sobre el programa fuente antes de que empiece la compilación. Es responsable de:
- Eliminar los comentarios.
- Interpretar las directivas.
Generalidades de C
- Los programas fuentes en C se guardan en ficheros de texto con extensión ‘.c’.
- Es sensible a mayúsculas y minúsculas.
- Se permiten comentarios de texto multilínea, son eliminados por el preprocesador y no se pueden anidar.
- Las palabras reservadas son componentes léxicos predefinidos por el lenguaje y que tienen un significado especial para el compilador.
- Un identificador es un nombre que puede elegir libremente el programador para referirse a distintos elementos dentro del programa como variables, constantes.
- Al declarar una variable estamos determinando:
- Su representación en memoria.
- El conjunto de valores posibles.
- Las operaciones permitidas.
- La forma de realizar las operaciones.
- En la propia declaración, será posible determinar:
- La clase de localización en memoria.
- El ámbito de existencia.
Ejemplos de Código en C
Ejemplo 1: Bucle de Salida
/* Petición de una nueva ejecución */
do {
printf("\n\nSalir del programa (S/N)?: ");
fflush(stdin); /* Vaciado del buffer de teclado */
scanf("%c", &terminar);
terminar = toupper(terminar);
} while (terminar != 'S' && terminar != 'N');
system("cls"); /* Borrado de la pantalla */
} while (toupper(terminar) != 'S');
Ejemplo 2: Cálculo de Matriz Producto
filP = filA;
colP = colB;
/* Se calcula la matriz producto */
for (f = 0; f < filA; f++) {
for (c = 0; c < colB; c++) {
matrizP[f][c] = 0;
for (j = 0; j < colA; j++) {
matrizP[f][c] = matrizP[f][c] + (matrizA[f][j] * matrizB[j][c]);
}
}
}
Ejemplo 3: Punteros y Matrices
int mat[4] = {10, 20, 30, 40};
int *pt;
/* mat = %p = ff30 */
/* mat + 1 = %p = ff34 */
/* mat + 1 = &mat[0] */
/* *mat = 20 => mat[0] + 1 */
/* Si hacemos pt = mat */
/* *pt = mat[0] = 10 */
Ejemplo 4: Acceso a Elementos de una Matriz
void main(void) {
int f, c;
double mt[FIL][COL];
for (f = 0; f < FIL; f++) {
for (c = 0; c < COL; c++) {
/* &mt[f][c] = *(mt + f) + c */
}
}
/* **mat = mat[0][0] */
/* *(*mat + 1) = mat[0][1] */
/* **(mat + 1) = mat[1][0] */
/* *(*(mat + 1) + 1) = mat[1][1] */
/* *(*(mat + 1) + 2) = mat[1][2] */
}
Ejemplo 5: Producto de Dos Matrices
/* Prototipos */
void presentacion(void);
void modulo_principal(void);
void leer_matriz(long (*)[COL], int, int);
void escribir_matriz(long (*)[COL], int, int);
void producto_matriz(long (*)[COL], int, int, long (*)[COL], int, long (*)[COL]);
int main(void) {
char respuesta;
system("cls");
presentacion();
do {
printf("\n");
modulo_principal();
printf("\n");
do {
printf("¿Otra ejecución (S/N)?: ");
fflush(stdin); /* Limpia el buffer de teclado */
respuesta = toupper(getchar());
} while (respuesta != 'S' && respuesta != 'N');
} while (respuesta != 'N');
return 0;
} /* Fin del main */
void presentacion(void) {
puts("Programa para realizar el producto de dos matrices de enteros");
puts("-------------------------------------------------------------");
}
void modulo_principal(void) {
long matrizA[FIL][COL]; /* matriz a */
long matrizB[FIL][COL]; /* matriz b */
long matrizP[FIL][COL]; /* matriz producto */
int filA, colA; /* filas, columnas efectivas matriz a */
int filB, colB; /* filas, columnas efectivas matriz b */
int filP, colP; /* filas, columnas efectivas matriz producto */
int f, c; /* índices para recorrido matriz */
int j;
/* Se lee del número de filas de la primera matriz (A) */
do {
printf("¿Número filas matriz A (máx. %d)?: ", FIL);
scanf("%d", &filA);
} while ((filA <= 0) || (filA > FIL));
/* Se lee el número de columnas de la primera matriz (A) */
do {
printf("¿Número columnas matriz A (máx. %d)?: ", COL);
scanf("%d", &colA);
} while ((colA <= 0) || (colA > COL));
/* filas segunda = columnas primera */
filB = colA;
/* Se lee el número de columnas de la segunda matriz (B) */
do {
printf("¿Número columnas matriz B (máx. %d)?: ", COL);
scanf("%d", &colB);
} while ((colB <= 0) || (colB > COL));
/* Se introducen desde teclado las dos matrices A y B */
printf("Introduzca la matriz A:\n");
leer_matriz(matrizA, filA, colA);
printf("Introduzca la matriz B:\n");
leer_matriz(matrizB, filB, colB);
/* Tamaño de la matriz producto:
Número de filas de la de la primera matriz.
Número de columnas de la segunda matriz. */
filP = filA;
colP = colB;
/* Se calcula la matriz producto */
producto_matriz(matrizA, filA, colA, matrizB, colB, matrizP);
/* Se presentan matrices introducidas y la matriz producto */
printf("\nMatriz A:\n");
escribir_matriz(matrizA, filA, colA);
printf("\nMatriz B:\n");
escribir_matriz(matrizB, filB, colB);
printf("\nMatriz Producto:\n");
escribir_matriz(matrizP, filP, colP);
}
void leer_matriz(long (*ma)[COL], int filas, int columnas) {
/* Se solicita la matriz por filas */
int f, c;
for (f = 0; f < filas; f++) {
for (c = 0; c < columnas; c++) {
printf("Elemento (%d, %d)=> ", f + 1, c + 1);
scanf("%ld", &ma[f][c]);
}
}
}
void escribir_matriz(long (*ma)[COL], int filas, int columnas) {
/* Se escribe la matriz por filas */
int f, c;
for (f = 0; f < filas; f++) {
for (c = 0; c < columnas; c++) {
printf("%5ld", ma[f][c]);
}
printf("\n");
}
}
void producto_matriz(long (*ma)[COL], int f_a, int c_a, long (*mb)[COL], int c_b, long (*mp)[COL]) {
int f, c, j;
for (f = 0; f < f_a; f++) {
for (c = 0; c < c_b; c++) {
mp[f][c] = 0;
for (j = 0; j < c_a; j++) {
mp[f][c] = mp[f][c] + (ma[f][j] * mb[j][c]);
}
}
}
}
Ejemplo 6: Cálculo de Puntos de Silla
#include
#include
#include
#define FIL 25
#define COL 25
/* Prototipos */
void presentacion(void);
void modulo_principal(void);
void leer_matriz(long (*)[COL], int, int);
void escribir_matriz(long (*)[COL], int, int);
void puntosdesilla(long (*)[COL], int, int, int *);
int main(void) {
char respuesta;
system("cls");
presentacion();
do {
printf("\n");
modulo_principal();
printf("\n");
do {
printf("¿Otra ejecución (S/N)?: ");
fflush(stdin); /* Limpia el buffer de teclado */
respuesta = toupper(getchar());
} while (respuesta != 'S' && respuesta != 'N');
} while (respuesta != 'N');
return 0;
} /* Fin del main */
void presentacion(void) {
puts("Programa para calcular los puntos de silla de una matriz");
puts("--------------------------------------------------------");
puts("Determina un único punto de silla por fila.");
puts("La matriz no debe tener elementos repetidos.");
puts("");
}
void modulo_principal(void) {
long matrizA[FIL][COL]; /* matriz */
int filA, colA; /* filas, columnas efectivas matriz */
int lista_ps[FIL]; /* vector con los puntos de silla */
int f, c; /* índices para recorrido matriz */
int total_puntos; /* Número total de puntos de silla */
/* Se lee del número de filas y columnas de la primera matriz */
do {
printf("¿Número filas matriz (máx. %d)?: ", FIL);
scanf("%d", &filA);
} while ((filA <= 0) || (filA > FIL));
do {
printf("¿Número columnas matriz (máx. %d)?: ", COL);
scanf("%d", &colA);
} while ((colA <= 0) || (colA > COL));
printf("Introduzca la matriz:\n");
leer_matriz(matrizA, filA, colA);
puntosdesilla(matrizA, filA, colA, lista_ps);
printf("\nMatriz:\n");
escribir_matriz(matrizA, filA, colA);
printf("\nPuntos de silla:\n");
total_puntos = 0;
for (f = 0; f < filA; f++) {
if (lista_ps[f] != -1) {
total_puntos++;
printf("Punto de silla en [%02d][%02d] con valor %6ld \n", f, lista_ps[f], matrizA[f][lista_ps[f]]);
}
}
if (total_puntos)
printf("Número total de puntos de silla: %d\n", total_puntos);
else
printf("La matriz no tiene puntos de silla\n");
}
void leer_matriz(long (*ma)[COL], int filas, int columnas) {
/* Se solicita la matriz por filas */
int f, c;
for (f = 0; f < filas; f++) {
for (c = 0; c < columnas; c++) {
printf("Elemento (%d, %d)=> ", f + 1, c + 1);
scanf("%ld", &ma[f][c]);
}
}
}
void escribir_matriz(long (*ma)[COL], int filas, int columnas) {
/* Se escribe la matriz por filas */
int f, c;
for (f = 0; f < filas; f++) {
for (c = 0; c < columnas; c++) {
printf("%5ld", ma[f][c]);
}
printf("\n");
}
}
void puntosdesilla(long (*ma)[COL], int filas, int columnas, int *ps) {
/* La longitud de ps debe ser el número de filas de ma */
int f, f2, c; /* Para recorrido matriz */
int menorf; /* Determina el menor elemento de la fila */
int cm; /* Determina la columna de menorf */
int flag_ps; /* Flag para determinar si el punto es silla */
for (f = 0; f < filas; f++) { /* (1) Recorrido por filas */
menorf = ma[f][0];
cm = 0;
for (c = 1; c < columnas; c++) {
if (menorf > ma[f][c]) {
menorf = ma[f][c];
cm = c;
}
}
/* Ha quedado determinado el menor de la fila f */
/* La columna del menorf es mc */
/* Recorremos la columna cm hasta que encontrar */
/* un valor mayor que menorf. Si fuera así, el */
/* el punto menorf en la fila f, no es de silla */
flag_ps = 1;
f2 = 0;
while (flag_ps && f2 < filas) {
flag_ps = menorf >= ma[f2][cm];
f2++;
}
if (flag_ps)
ps[f] = cm; /* Si el punto de la fila f es de silla, */
else
ps[f] = -1; /* su columna es cm. Si no es de silla. */
/* Si no es de silla informamos -1 como */
/* número de columna */
} /* Fin de (1) */
}