FACULTAD DE CIENCIAS HUMANAS Y DE LA

EDUCACIÓN

CARRERA DE DOCENCIA EN INFORMÁTICA

PROGRAMACIÓN II ELEMENTO 4

ESTUDIANTE:

Amancha Lagla María Elena

TERCERO “U” INFORMÁTICA

ENERO

2012

UNIVERSIDAD TÉCNICA DE

AMBATO

2

INDICE

1. FUNDAMENTACIÓN TEÓRICA _________________________________________ 3

FUNCIONES EN LENGUAJE C _____________________________________________ 3

¿QUÉ SON? Y ¿PARA QUÉ SIRVEN LAS FUNCIONES? _______________________________ 3

DEFINICIÓN _______________________________________________________________ 3

DIFERENCIA ENTRE EL PROGRAMA Y LAS FUNCIONES ______________________________ 4

CONCEPTOS BÁSICOS _______________________________________________________ 4

DECLARACIONES DE FUNCIONES ______________________________________________ 5

IMPLEMENTACIÓN DE FUNCIONES _____________________________________________ 5

SINTAXIS: _________________________________________________________________ 5

¿CÓMO RETORNAR? ________________________________________________________ 7

USO DE FUNCIONES _________________________________________________________ 8

LLAMADAS A FUNCIONES ____________________________________________________ 8

PASOS PARA LLAMAR A UNA FUNCIÓN _________________________________________ 9

SINTAXIS: _________________________________________________________________ 9

FUNCIONES SIN ARGUMENTOS_______________________________________________ 10

FUNCIONES DEFINIDAS POR EL USUARIO EN C __________________________________ 10

FUNCIONES ANIDADAS _____________________________________________________ 12

RECURSIVIDAD ____________________________________________________________ 12

PASO DE VECTORES COMO PARÁMETROS A FUNCIONES __________________________ 13

2. APLICACIONES ____________________________________________________ 17

APLICACIÓN Nº 1 __________________________________________________________ 17

APLICACIÓN Nº 2: _________________________________________________________ 19

PROGRAMA TOMADO EN EXAMEN ___________________________________________ 22

3.- BIBLIOGRAFÍA _____________________________________________________ 27

3

1. FUNDAMENTACIÓN TEÓRICA

FUNCIONES EN LENGUAJE C

La modularización, es una técnica usada por los programadores para hacer sus

códigos más cortos, ya que consiste en reducir un gran problema complejo, en

pequeños problemitas más sencillos, concentrándose en la solución por separado,

de cada uno de ellos.

¿QUÉ SON? Y ¿PARA QUÉ SIRVEN LAS FUNCIONES?

Son un grupo de sentencias bajo el mismo nombre que realizan una tarea

específica.

Sirven para facilitar la resolución de problemas mediante la aplicación del

paradigma “Dividir y Conquistar”.

DEFINICIÓN

En C, se conocen como funciones aquellos trozos de códigos utilizados para dividir

un programa con el objetivo que, cada bloque realice una tarea determinada.

En las funciones juegan un papel muy importe las variables, ya que como se ha dicho

estas pueden ser locales o globales.

Variables Globales: Estas se crean durante toda la ejecución del programa, y

son globales, ya que pueden ser llamadas, leídas, modificadas, etc; desde cualquier

función. Se definen antes del main( ).

Variables Locales: Estas, pueden ser utilizadas únicamente en la función que

hayan sido declaradas.

Las funciones son porciones de código que devuelven un valor.

Permiten descomponer el programa en módulos que se llaman entre ellos.

En C no existe diferencia entre funciones y procedimientos: a todas las subrutinas se

las llama funciones.

4

La definición de una función especifica lo siguiente:

nombre de la función

número de argumentos que lleva y tipo de cada uno de ellos

tipo de datos que devuelve

Cuerpo de la función (el código que ejecuta)

DIFERENCIA ENTRE EL PROGRAMA Y LAS FUNCIONES

• Las funciones y los programas se parecen mucho, pero difieren:

– Los programas son usados por un usuario externo.

– Las funciones son utilizadas por un programador.

– El usuario del programa “Hola Mundo” no conoce que es la función

printf.

– El programador que usa printf no siempre conocerá explícitamente

como ésta hace para mostrar información en pantalla.

– El programador que escribió printf conoce exactamente su

funcionamiento interno.

CONCEPTOS BÁSICOS

• Función

– Grupo de sentencias bajo el mismo nombre que realizan una tarea

específica.

• Llamada a una función

– Ejecuta el grupo de sentencias de una función.

• Retorno

– Una vez “llamada” la función, esta hace su trabajo, y regresa al mismo

punto donde fue llamada.

• Vamos a conocer tres cosas muy importantes sobre las funciones:

– ¿Cómo se declaran?

– ¿Cómo se implementan?, y

– ¿Cómo se usan?

5

DECLARACIONES DE FUNCIONES

• De forma similar a las variables, las funciones deben ser declaradas:

• La forma de declarar una función es siguiendo la forma predefinida:

• Por ejemplo:

int potencia(int base, int exponente);

float farenheitACelsius(double celsius);

IMPLEMENTACIÓN DE FUNCIONES

SINTAXIS:

La sintaxis de una función es la siguiente:

Tipo_de_datos nombre_de_la_funcion(tipo y nombre de argumentos)

{

acciones

}

donde:

Tipo_de_datos: Es el tipo de dato que devolverá esa función, que puede ser

real, entera, o tipo void(es decir que no devolverá ningún valor).

6

Nombre_de_la_funcion: Es el identificador que le damos a nuestra función,

la cual debe cumplir las reglas que definimos en un principio para los

identificadores.

Tipo y nombre de argumentos: son los parámetros que recibe la función. Los

argumentos de una función no son más que variables locales que reciben un

valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden

existir funciones que no reciban argumentos.

Acciones: Constituye el conjunto de acciones, de sentencias que cumplirá la

función, cuando sea ejecutada. Entre ellas están:

1. Asignaciones

2. Lecturas

3. Impresiones

4. Cálculos, etc

Una función, termina con la llave de cerrar, pero antes de esta llave,

debemos colocarle la instrucción return, con la cual devolverá un valor específico.

Es necesario recalcar que si la función no devuelve ningún valor, es decir, es tipo

void, no tiene que ir la sentencia return, ya que de lo contrario, nos dará un error.

Cada función debe ser declarada. Su forma general es:tipo nombre_función (lista de

tipos (y nombres) de los argumentos); Si una función va usar argumentos, debe

declarar variables que acepten los valores de los argumentos. Estas variables se

llaman parámetros formales de la función y se comportan como variables locales

dentro de la función, creándose al entrar en la función y destruyéndose al salir. La

declaración de parámetros aparece después del nombre de la función al definirla.

Los parámetros formales tienen que ser del mismo tipo que los argumentos usados

al llamar una función (el compilador no dará error pero los resultados serán

inesperados).

Al igual que con variables locales, se pueden hacer asignaciones a los parámetros de

una función o usarlos en cualquier expresión válida. Se pueden usar como cualquier

otra variable.

Una función es visible para ella misma y otras funciones desde el momento en que

se define. Es visible para el propio cuerpo de la función, es decir, la recursividad está

permitida. El código de una función es privado a esa función y sólo se puede acceder

a él mediante una llamada a esa función. Las variables definidas dentro de una

función son locales (a no ser que las definamos globales) por lo que no conservan su

7

valor de una llamada a otra (excepto si se declaran como static, entonces el

compilador no las destruye y almacena su valor para la próxima llamada, aunque la

variable tiene limitado el ámbito al interior de la función).

En C, todas las funciones están al mismo nivel, es decir, no se puede definir una

función dentro de otra función. Esto es por lo que C no es técnicamente un lenguaje

estructurado por bloques.

El código de una función es privado a esa función y sólo se puede acceder a él

mediante una llamada a esa función. Las variables definidas dentro de una función

son locales (a no ser que las definamos globales) por lo que no conservan su valor

de una llamada a otra (excepto si se declaran como static, entonces el compilador

no las destruye y almacena su valor para la próxima llamada, aunque la variable

tiene limitado el ámbito al interior de la función).

Las funciones son siempre globales, esto es, no se permite declarar una función

dentro de otra.

Las funciones son visibles sólo después de que se han declarado.

Se pueden declarar funciones, especificando sólo su formato, pero no su cuerpo:

int suma ( int a, int b );

lo anterior es una declaración de la función suma, que queda disponible para su uso,

a pesar de no haber sido definido su cuerpo.

La declaración de una función de esta forma se llama prototipo.

Es buena práctica declarar al comienzo del programa los prototipos de las funciones

que vamos a definir, incluyendo comentarios sobre su finalidad.

¿CÓMO RETORNAR?

• Si la función debe generar un valor, lo retornará usando la sentencia return

dentro del cuerpo de la función.

• La forma de usarla es:

return (variable o expresión que se debe retornar);

• Esto especifica que la función debe terminar, retornando el valor calculado.

• Hay funciones que no retornan datos, en este caso, se puede usar return, pero

sin mencionar una expresión.

8

return;

USO DE FUNCIONES

• Como las funciones siempre retornan un valor, el uso de una función consiste

en utilizar el valor de retorno.

• Se lo puede hacer de dos formas:

– Almacenar el valor de retorno en una variable que deberá ser del

mismo tipo de dato que el tipo de dato de retorno de la función.

– Utilizar el valor de retorno en una expresión.

LLAMADAS A FUNCIONES

Las funciones son llamadas para su ejecución desde cualquier parte del código,

teniendo en cuenta que antes deben haber sido declaradas (y por supuesto

definidas).

La llamada de una función se produce mediante el uso de su nombre en una

sentencia, pasando una lista de argumentos que deben coincidir en número y tipo

con los especificados en la declaración (en otro caso se produciría una conversión

de tipos o resultados inesperados). Llamadas por valor y por referencia En general,

se pueden pasar argumentos a las funciones de dos formas, por valor y por

referencia.

La llamada por valor copia el valor de un argumento en el parámetro formal de la

función. De esta forma, los cambios en los parámetros de la función no afectan a las

variables que se usan en la llamada (es la llamada más usual, es decir, en general no

se pueden alterar las variables usadas para llamar a la función).

La llamada por referencia copia la dirección del argumento en el parámetro. Dentro

de la función se usa la dirección para acceder al argumento usado, significando que

los cambios hechos a los parámetros afectan a la variable usada en la llamada.

Es posible simular una llamada por referencia pasando un puntero al argumento,

entonces, al pasar la dirección, es posible cambiar el valor de la variable usada en la

llamada.

9

PASOS PARA LLAMAR A UNA FUNCIÓN

• Se evalúan las expresiones enviadas como argumentos.

• El valor de cada argumento es copiado en orden en cada parámetro

correspondiente de la función llamada.

• Se ejecutan una a una las sentencias del cuerpo de la función hasta que

aparece la sentencia return.

• Se evalúa la expresión de la sentencia return.

• El programa que llamó a la función continúa, reemplazando en el lugar de la

llamada, el valor retornado

SINTAXIS:

La sintaxis de una función es la siguiente:

Tipo_de_datos nombre_de_la_funcion(tipo y nombre de argumentos)

{

acciones

}

10

donde:

Tipo_de_datos: Es el tipo de dato que devolverá esa función, que puede ser

real, entera, o tipo void(es decir que no devolverá ningún valor).

Nombre_de_la_funcion: Es el identificador que le damos a nuestra función,

la cual debe cumplir las reglas que definimos en un principio para los

identificadores.

Tipo y nombre de argumentos: son los parámetros que recibe la función. Los

argumentos de una función no son más que variables locales que reciben un

valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden

existir funciones que no reciban argumentos.

Acciones: Constituye el conjunto de acciones, de sentencias que cumplirá la

función, cuando sea ejecutada. Entre ellas están:

1. Asignaciones

2. Lecturas

3. Impresiones

4. Cálculos, etc

Una función, termina con la llave de cerrar, pero antes de esta llave,

debemos colocarle la instrucción return, con la cual devolverá un valor específico.

Es necesario recalcar que si la función no devuelve ningún valor, es decir, es tipo

void, no tiene que ir la sentencia return, ya que de lo contrario, nos dará un error.

FUNCIONES SIN ARGUMENTOS

Se declaran con void entre paréntesis (sólo en C).

int fecha (void)

{ ... }

Se las llama así:

dato = fecha();

es decir, siempre hay que escribir los paréntesis aunque no haya argumentos.

En C++ se declaran sólo con los paréntesis, sin el void.

FUNCIONES DEFINIDAS POR EL USUARIO EN C

Una función, como ya se ha dicho, es un bloque de código dentro del programa que

se encarga de realizar una tarea determinada. Por lo tanto un programa en c debe

11

constar de una o más funciones, y por supuesto no puede faltar la función principal

main().

Un viejo adagio dice: Separa y vencerás, lo cual se acopla perfectamente cuando

tenemos un programa que es bastante grande; podemos separarlos en pequeños

subprogramas (funciones), y concentrarnos en la solución por separados de cada

uno de ellos y así resolver un gran problemas, en unos cuantos problemitas más

pequeños.

Si un programa, está constituido por más de una función, las llamadas a la misma,

pueden realizarse desde cualquier parte del programa, y la definición de ellas debe

ser independiente unas de otras.

Por lo tanto sería un grave error el tratar de definir una función dentro de otra.

Una función puede ser llamada desde cualquier parte del programa no sólo una vez,

y cuando es llamada, empieza a ejecutar las acciones que están escritas en código.

Ejemplos:

1. Funciones que no devuelven ningún valor

2. Funciones que devuelven un valor entero

3. Funciones que devuelven un valor Real

4. Funciones combinadas

5. Funciones en las que usamos Menú.

1. Funciones que no devuelven ningún valor.

Cómo se ha dicho las funciones pueden o no devolver algún valor, para mi parecer,

este tipo de funciones son las más sencillas, ya que cuando se llama la función, esta

realiza lecturas, asignaciones, cálculos o impresiones, finaliza la ejecución de la

función y el programa continúa normalmente.

Ejemplo 5.1

Diseñe un programa que dados dos números enteros determine la suma y cuál de

ellos es mayor, usando dos funciones diferentes.

#include <stdio.h>

#include <conio.h>

void suma (int a, int b); /*Declaración de la función*/

void mayor (int a, int b); /*Tipo de dato, nombre de la funci¢n y el tipo y nombre de

los argumentos*/

main()

12

{

int a, b;

printf("Ingrese el valor de a:\n");

scanf("%d", &a);

printf("Ingrese el valor de b:\n");

scanf("%d", &b);

suma(a,b); /*Llamado de la funci¢n*/

mayor(a,b); /*Unicamente el nombre de la funci¢n y de los par metros*/

getch();

return 0;

}

void suma(int a, int b) /*Definici¢n de la funci¢n*/

{ /*Abrimos llaves al inicio de la definici¢n*/

int sum; /*Declaraci¢n de las variables locales*/

sum=a+b;

printf("El valor de la suma es %d:\n\n", sum);

} /*Fin de la funci¢n suma*/

void mayor(int a, int b)

{

if(a==b)

printf("Son iguales\n\n");

else

{

if(a>b)

printf("El valor de a es mayor que el de b\n\n");

else

printf("El valor de b es mayor que el de a\n\n");

}

}

FUNCIONES ANIDADAS

En C no se pueden declarar funciones dentro de otras (funciones anidadas o

locales). Todas las funciones son globales.

RECURSIVIDAD

Se permite hacer llamadas recursivas:

13

float factorial (int n)

{

if (n<=1) return 1.0;

else return n*factorial(n-1);

}

PASO DE VECTORES COMO PARÁMETROS A FUNCIONES

La aritmética de punteros permite trabajar con vectores pasados como parámetros

a funciones en forma de punteros:

/* Rellena de ceros los "n_elem"

primeros elementos de "vector"

*/

void rellena_de_ceros ( int n_elem, int* vector )

{

int i;

for ( i=0; i<n_elem; i++ )

*(vector++) = 0; /* operador de post-incremento */

}

main()

{

int ejemplo [300];

int otro_vector [100];

/* pasa la dirección del vector "ejemplo" */

rellena_de_ceros ( 300, ejemplo );

/* rellena los elems. del 150 al 199 */

rellena_de_ceros ( 50, otro_vector+150 );

}

2. Funciones que devuelven un valor entero

Las funciones que devuelven algún valor, se les llama PROTOTIPOS DE FUNCIONES:

Antes de usar una función C debe tener conocimiento acerca del tipo de dato que

regresara y el tipo de los

parámetros que la función espera.

El estándar ANSI de C introdujo una nueva (mejor) forma de hacer lo anterior

respecto a las versiones previas

14

de C.

La importancia de usar prototipos de funciones es la siguiente:

Se hace el código mas estructurado y por lo tanto, más fácil de leer.

Se permite al compilador de C revisar la sintaxis de las funciones llamadas.

Lo anterior es hecho, dependiendo del alcance de la función. Básicamente si

una función ha sido definida antes de que sea usada (o llamada), entonces se puede

usar la función sin problemas.

Si no es así, entonces la función se debe declarar. La declaración

simplemente maneja el tipo de dato que la función regresa y el tipo de parámetros

usados por la función.

Es una práctica usual y conveniente escribir el prototipo de todas las

funciones al principio del programa, sin embargo esto no es estrictamente

necesario.

Para declarar un prototipo de una función se indicara el tipo de dato que

regresará la función, el nombre de la función y entre paréntesis la lista del tipo de

los parámetros de acuerdo al orden que aparecen en la definición de la función. Por

ejemplo:

int longcad(int n); Lo anterior declara una función llamada longcad que regresa un

valor entero y acepta otro valor entero como parámetro.

Ejemplo 5.3

Diseñe un programa, que dado un número entero y mayor que cero, muestre

su factorial. (El factorial de 5 es 120; 5x4x3x2x1=120)

#include <stdio.h>

#include <conio.h>

int factorial (int num);

main()

{

int num, ban=1;

clrscr();

while(ban==1)

{

printf("Ingrese el valor del n£mero por favor:\n");

scanf("%d", &num);

while(num<0)

{

printf("ERROR, el valor del n£mero debe ser mayor que cero:\n");

scanf("%d", &num);

}

printf("El valor del factorial es %d\n\n", factorial (num));

15

printf("¨Desea Realizar otro calculo?Si=1 y No=0\n");

scanf("%d", &ban);

}

getch();

return 0;

}

int factorial (int num)

{

int sum=1, i;

for(i=2; i<=num; i++)

{

sum=sum*i;

}

return (sum);

}

Explicación:

Quizá, lo único nuevo, e importante de explicar, radica en la llamada y la

definición de la función. Cuando una función nos devolverá un valor entero, al

identificador de dicha función debe precederle el tipo de dato. En el lugar, donde

llamamos la función, es que aparecerá el valor que nos devuelva, como valor de

retorno. En nuestro ejemplo, en una impresión. Y al momento de definirla, no se

nos debe olvidar, colocarle la sentencia return(); ya que, mediante esta declaratoria,

está retornando el valor calculado.

Pero, que sucede cuando se está trabajando, con valores bastante grandes, al

utilizar solamente el int, se producirá un error lógico; ya que como valor de retorno

podría ser un cero o una cifra negativa. Por tanto debemos usar el tipo de dato

“long int”.

Ejemplo 5.4

Diseñe un programa, que dada una cifra entera y mayor que cero, sea

elevada a una potencia introducida por el usuario, la cual. (Ejemplo: 5^2=25).

#include <stdio.h>

#include <conio.h>

long int potencia (int base, int exponente);

main()

{

int base, exponente;

clrscr();

printf("La Base es:\n");

scanf("%d", &base);

16

while (base<0)

{

printf("ERROR, el dato debe ser mayor que cero:\n");

scanf("%d", &base);

}

printf("El Exponente es:\n");

scanf("%d", &exponente);

printf("%d ^ %d es %ld\n\n", base, exponente, potencia(base,exponente));

getch();

return 0;

}

long int potencia (int base, int exponente)

{

long int sum=0, i,x;

for(i=1; i<exponente; i++)

{

x=base*base;

sum=sum+x;

}

return (sum);

}

Este método es un poco complejo y puede realizarse de manera más fácil,

haciendo uso de las funciones predefinidas en C, de las cuales hablaremos a

continuación.

17

2. APLICACIONES

APLICACIÓN Nº 1

Enunciado

Diseñe un programa en el que se genera una matriz de las

dimensiones de límite cuya diagonal principalcontenga los números

pares y en la diagonal secundaria contenga losnúmeros imparesel

resto de posiciones de la matriz sean rellenados con ceros.

Análisis

El presente programa usa funciones, para ello primeramente

declaramos las variables globales que nos servirán para todo el

programa estas variables globales van colocadas debajo del ingreso de

librerías y antes de la declaración de la primera función. En este caso mi

primera función es void borde(), abrimos llaves y allí está el detalle del

borde que se genera, para terminar la función cerramos la llave. Luego

tenemos la función ingreso, donde van los for que me ayudan a generar

o lectura de la matriz y el ingreso del límite que se caracteriza por

poseer en su sentencia scanf("%d",&l), a través de ello ingreso el límite de

mi vector con el cual se generará unamatriz cuadrática del orden del

límite.

Como requisito para que se imprima la diagonal principal tenemos que

los subíndices i == j, y con dos lazos for se imprime la matriz, con la

condición if (i==j), designamos solo la diagonal principal en la que

deben insertarse los numero pares, en la diagonal secundaria los

impares y cerramos el programa al final con la función principal y

haciendo el llamad a cada una de las funciones insertadas, así como;

borde(), ingreso().

Desarrollo

# include<conio.h> //ingreso de librerías # include<stdio.h> int i, j, fil, col,x,y,l,f,c,op; //declaración de variables globales y de matrices int matriz[10][10]; void borde() //function borde { for(i=2;i<=80;i++) //diseño del borde { textcolor(11); gotoxy(i,2);cprintf("*"); gotoxy(i,45);cprintf("*"); } for(i=2;i<=45;i++) {

18

gotoxy(2,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } void ingreso() //function ingreso { clrscr(); textcolor(11); gotoxy(15,5);cprintf("INGRESO LIMITE: ");scanf("%d",&l); //lee datos desde teclado for(f=1;f<=l;f++) //dos lazos for para ingreso de matriz { for(c=1;c<=l;c++) { matriz[f][c]=0; gotoxy(f*3+8,c*2+8);cprintf("%d", matriz[f][c]); //impresión de matriz[f][c] } } x=2; for(f=1;f<=l;f++) //lazos for para la impresión de matriz { for(c=1;c<=l;c++) { if(f==c) //condición para elegir diagonal primaria { matriz[f][c]=x; x=x+2; //x será el número par que se imprimirá en diagonal principal } gotoxy(f*3+8,c*2+8);cprintf("%d", matriz[f][c]); } } x=1; //variables auxiliaries y=l; for(f=1;f<=l;f++) //lazo for para impresión de diagonal secundaria { matriz[y][f]=x; gotoxy(y*3+8,f*2+8);printf("%d", matriz[y][f]); //visualización de valores enteros en diagonal secundaria que son los impares x=x+2; //determinan el valor impar y=y-1; } } void main() //Se inicializa el programa principal { borde(l); //se llama a la función borde do { clrscr(); //borrado de pantalla ingreso(); //se llama a la función ingreso de matriz gotoxy(20,23);printf("Presione 1 para continuar y 0 para salir: ");scanf("%d",&op); // bucle do/while para elección de salir o no del programa

19

} while(op==1); getch(); } //cierre del programa general

Ejecución del programa

APLICACIÓN Nº 2:

Enunciado

Diseñe un programa que realice el producto de matrices, en

donde se visualice las matrices 1 y 2 y la matriz resultante.

Análisis

Ingreso de librerías conocidas, declaración de variables globales y de

matrices, primera función, void borde, se detalla la operación que

20

desplegará el borde. Función void ingreso donde ingresaremos las

matrices y sus elementos por teclado.

Función producto donde se realiza la operación de las mismas, se imprimen

tres matrices.

Función main llama a todas las funciones existentes: borde(), ingreso() ,

producto() y las titulaciones, se cierra el lazo do/while y se cierra el

programa principal.

Desarrollo

#include<stdio.h> //inclusión de librerías #include<conio.h> int l,c,c1,c2,f,f1,f2,k,i,j,op,a; //declaración de variables globales int matriz1[10][10],matriz2[10][10],matriz3[10][10]; void borde() //función borde { for(i=1;i<=25;i++) //lazos for para desplegar el borde en sus cuatro lados { gotoxy(1,i);printf("@",i); gotoxy(80,i);printf("@",i); } for(i=1;i<=80;i++) { gotoxy(i,2);printf("@",i); gotoxy(i,25);printf("@",i); } } void ingreso() //función ingreso de matrices { for(i=1;i<=l;i++) { for(j=1;j<=l;j++) { gotoxy(c,f);scanf("%d",&matriz1[i][j]); //lectura de datos ingresados por teclado c=c+5; } c=5; f=f+1; } for(i=1;i<=l;i++) //lazos for para la impresión de la matriz { for(j=1;j<=l;j++) { gotoxy(c1,f1);scanf("%d",&matriz2[i][j]); //posicionamiento e impresión de la matriz c1=c1+5; } c1=25;

21

f1=f1+1; }} void producto() //función que realice el producto de las matrices { for(i=1;i<=l;i++) //lazos para la impresión de la matriz resultante { for(j=1;j<=l;j++) { matriz3[i][j]=0; for(k=1;k<=l;k++) { matriz3[i][j]=matriz3[i][j]+matriz1[i][k]*matriz2[k][j]; //operación de matrices }}} for(i=1;i<=l;i++) { for(k=1;k<=l;k++) { gotoxy(c2,f2);printf("%d",matriz3[i][k]); //impresión de matriz con dos for c2=c2+4; } c2=42; f2=f2+1; }} void main() //function principal { do { clrscr(); //borrado de pantalla borde(); //llamado a la función borde c=5; c1=25; c2=42; f=10; f1=10; f2=10; gotoxy(28,3);printf("PRODUCTO DE MATRICES"); //leyendas o titulaciones gotoxy(10,5);printf("INGRESE UN LIMITE ");scanf("%d",&l); gotoxy(5,7);printf("MATRIZ1"); gotoxy(25,7);printf("MATRIZ2"); gotoxy(40,7);printf("MATRIZ RESULTANTE"); ingreso(); //llamado a función ingreso producto(); //llamado a función producto gotoxy(8,20);printf("seleccione 1 para continuar y 0 para salir ");scanf("%d",&op); } while(op==1); //cierre de lazo do/while getch(); } //cierre del programa general

22

Ejecución del programa

PROGRAMA TOMADO EN EXAMEN

Enunciado

Diseñe un programa utilizando Matrices y Funciones que permita: 1.- Ingresar n elementos en una matriz con datos entre 5 y 35, excluyendo las diagonales principal y secundaria, en dónde la

diagonal principal se llena con la serie del Fibonnaci y la diagonal secundaria con el factorial de los números ascendentes iniciando en

3. Recorra la matriz y guarde los datos de la diagonal principal en las posiciones pares del vector y los datos de la diagonal segundaria en

las posiciones impares del vector. Presente como resultado el vector origen resultante y el mismo

vector preséntelo impreso en forma descendente.

Análisis

Declaramos variables, y librerías, de tipo entero, dentro del programa

principal, colocamos el diseño del borde con lazos for. Posicionamos

rotulación, a través de scanf leemos dato de límite que nos dará la pauta de

la matriz a generarse. Se lee datos desde teclado pero validados entre 5 y

35 por medio de un do/ while cuya condición sería: while(matriz[i][j]<5||

23

matriz[i][j]>35); ingresamos matriz, con la sentencia if logramos escoger

solo la diagonal principal de la matriz e imprimir en ella la serie fibonacci.

Por otro lado, en la diagonal secundaria se imprimirá el factorial que

empiece en 3.

Los datos de las diagonales tanto primaria como secundaria son llevados a

dos vectores, previamente declarados. Cada vector utiliza un lazo for para

la impresión o visualización de los datos.

En un nuevo vector tomamos el índice y lo condicionamos para que en las

posiciones pares se imprima la serie fibonacci y en las posiciones impares

los números de factorial:if(k%2==0).

Con un nuevo lazo for podemos imprimir el vector resultante.

Se cierra el bucle do While externo y se cierra el programa principal.

Desarrollo

#include <conio.h> //inclusión de librerías #include <stdio.h> voidmain() //inicia programa principal { int vector[10],d,a,b,c,vm1[10],matriz[10][10],matriz1[10][10], vp[10]; intaux,op,i,j,limite,col=10,fil=10,k; //declaración de variables enteras, vectores y matrices do{ //abre lazo do clrscr(); //borrado de pantalla textcolor(11); clrscr(); for(i=1; i<=80;i++) //diseño de borde { gotoxy(i,1);cprintf("*"); gotoxy(i,4);cprintf("*"); gotoxy(i,20);cprintf("*"); } for(i=1; i<=20;i++) { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } textcolor(10); gotoxy(33,3);cprintf("EXAMEN"); //titulación textcolor(27); gotoxy(19,6);cprintf("INGRESE EL LIMITE :==> ");scanf("%d",&limite); textcolor(14); gotoxy(10,9);cprintf("MAT. ENTRADA"); gotoxy(35,9);cprintf("D.PRINC. D. SEC."); fil=11; //inicialización de filas y columnas col=10; for(i=1;i<=limite;i++)

24

{ for(j=1;j<=limite;j++) { do{ gotoxy(col,fil); scanf(" "); gotoxy(col,fil);scanf("%d",&matriz[i][j]); //lectura de una matriz por teclado } while(matriz[i][j]<5|| matriz[i][j]>35); //cierre de lazo while para validación de datos de entrada col=col+5; //avance en columnas } col=10; fil=fil+1; //avance en filas } col=35; fil=11; for(i=1;i<=limite;i++) { for(j=1;j<=limite;j++) { gotoxy(col,fil);printf("%d",matriz[i][j]);//impresión de matriz con dos for col=col+5; //posicionamiento en columna } fil=fil+1; //avance en filas col=35; } col=35; //inicio de filas y columnas fil=11; textcolor(5); a=0; b=1; c=0; for(i=1;i<=limite;i++) { for(j=1;j<=limite;j++) { if (i==j) //condición para escoger solo diagonal principal { a=b; //programa para fibonacci b=c; c=a+b; matriz[i][j]=c; gotoxy(col,fil);cprintf("%d",matriz[i][j]); //impresión de matriz textcolor(5); gotoxy(53,9);printf("Vec.Fibo."); vm1[j]=matriz[i][j]; //valores Fibonacci a vector

25

gotoxy(57,fil);cprintf("%d",vm1[j]); //impresión de vector Fibonacci } } fil=fil+1; //avance de filas y columna col=col+5; } col=55; fil=11; aux=limite; textcolor(25); d=3; for(i=1;i<=limite;i++) //for para impresión de vector factorial { d=d*i; //programa para factorial gotoxy(col-=5,fil);cprintf("%d",d); textcolor(25); gotoxy(63,9);printf("Vec.Fact."); vm1[j]=d; gotoxy(65,fil);cprintf("%d",vm1[j]); //impresión de vector de factorial aux=aux-1; // fil=fil+1; } fil=10; for ( i=limite-1;i>=0;i--) { textcolor(12); gotoxy(45,fil+1);printf("%d",vm1[j]); //en diagonal secundaria fil=fil+1; } //textcolor(12); fil=10; k=0; vm1[j]=matriz[i][j]; //for(k=1;k<=j;k++) //{ if(k%2==0) //condición para las posiciones pares { matriz[i][j]=vp[k]; vp[k]=vm1[j]; // vp[1]=1; // vp[2]=3; for(k=1;k<=j;k++) { gotoxy(70,fil);printf("%d",vp[k]); //impresión de vector posiciones pares }

26

} else { vp[k]=d; for(k=1;k<=j;k++) { gotoxy(74,fil);printf("%d", vp[k]); //impresión de posiciones impares fil=fil+1; } k=k+1; } textcolor(7); gotoxy(5,23);cprintf("Presione 1 para continuar,0 parasalir");scanf("%d",&op); } while(op==1); //cierre de lazo while para salir o no del programa getch(); } //fin de programa principal.

Ejecución del programa

27

3.- BIBLIOGRAFÍA

Apuntes teoría Programación U.T.A.

http://programandoenc.over-blog.es/article-32481588.html

http://www.slideshare.net/gugaslide/funciones-lenguaje-c-presentation

http://www.monografias.com/trabajos4/lenguajec/lenguajec.shtml

http://sopa.dis.ulpgc.es/so/cpp/intro_c/