Breve descripción del uso de Funciones en Lenguaje C

1. UNIVERSIDAD TÉCNICA DE
AMBATO
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

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 2
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.
3
¿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. 4
– 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);
5
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 6
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 7
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. 8
– 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 9
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 10
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, 11
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(); 12
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:nn", sum);
} /*Fin de la funci¢n suma*/
void mayor(int a, int b)
{
if(a==b)
printf("Son igualesnn");
else
{
if(a>b)
printf("El valor de a es mayor que el de bnn");
else
printf("El valor de b es mayor que el de ann");
}
}
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: 13
/* 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. 14
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 %dnn", factorial (num));

15. printf("¨Desea Realizar otro calculo?Si=1 y No=0n");
scanf("%d", &ban);
}
getch();
return 0;
}
int factorial (int num)
{
int sum=1, i;
for(i=2; i<=num; i++) 15
{
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 %ldnn", base, exponente, potencia(base,exponente));
getch();
return 0; 16
}
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.
17
 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
{ 18
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
19
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
20
#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 21
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
22
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).
23
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
} 24
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; 25
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;
26
}
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/
27