Fundamentos de Programación

Xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx – xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Continuación de Capítulo 2

CAPITULO 2
ENTRADA Y SALIDA ESTÁNDAR
El proceso de entrada obtiene datos de algún medio externo (por ejemplo, del
teclado o de un fichero en disco) y los envía al ordenador para que sean
procesados por un programa. Cuando se introduce un dato, se almacena en una
variable en memoria. Esto quiere decir que habrá que utilizar variables en
cualquier proceso de un programa.

La operación de salida envía una copia de los datos que hay en la memoria del
ordenador a otro lugar; por ejemplo, los visualiza en el monitor, los escribe por
la impresora o los guarda en un fichero en disco. La operación de salida no borra
los datos de la memoria ni cambia la forma en la que están almacenados.
Simplemente hace una copia de los mismos para enviarlos a otro lugar.

En este capítulo estudiaremos, además de la sentencia de asignación, las

funciones de la biblioteca de lenguaje C que permiten realizar operaciones de
entrada y de salida sobre los dispositivos estándar del ordenador; esto es,
funciones para introducir datos desde el teclado y funciones para visualizar datos
por el monitor.

XXXXXXXXXXXXXXXXX -------------- XXXXXXXXXXXXXXXXXX

Continuacion de Funciones

Funciones
Una función es una colección de sentencias que ejecutan una tarea específica. En un
programa C se distinguen dos clases de funciones, las funciones definidas por el usuario y
las funciones de biblioteca. En C, la definición de una función nunca puede contener a la
definición de otra función.

Conversión de un algoritmo a función: en el lenguaje C se conoce como funciones, aquellos

trozos de códigos utilizados para dividir un programa en subprogramas, con el objetivo de
que cada bloque o función realice una tarea específica. Es decir; a medida que los programas
crecen en tamaño y dificultad, el programador debe dividirlos en secciones más pequeñas
o módulos, denominadas funciones. De ahí el nombre de programación estructurada o

Fundamentos de Programación | Ing. Patricio Vinueza

modular. Esta estructura permite tanto al programador como al usuario seguir los pasos en
la ejecución de un programa para revisar y corregir errores.

PAPEL DE LAS FUNCIONES.

1. Modularidad: un programa por extenso que sea, es más fácil y agradable
manipularlo cuando se ha dividido en varios módulos o funciones.
2. Facilidad de seguimiento: las funciones permiten ahorrar tiempo al programador
cuando se trata de buscar errores o cuando se quiere depurar el programa.
3. Reutilización del código: sí una función requiere utilizarse más de una vez en el
mismo programa, no se necesita volver a escribir su código (definición de la función).
Basta hacer el llamado a partir de su nombre que le identifica.

Para construir una función de debe tener en cuenta:

 Qué hace exactamente la función (tarea específica).
 El nombre de la función
 Qué datos necesita la función (parámetros formales).
 Qué tipo de dato o valor devuelve (o que resultados debe producir)

Sí se encuentra que en una función hay involucrada más de una tarea, debe subdividir en
dos o más funciones según el caso. En las funciones es importante declarar las variables y
estas pueden ser locales o globales.

Ámbito y Alcance de la Declaración de Variables

Variables locales: estas, solo pueden ser utilizadas únicamente en la función que hayan sido
declaradas.

Variables globales: las variables globales se crean durante la ejecución del programa, y son
globales porque son llamadas, leídas, modificadas, etc. Desde cualquier función y se definen
por lo general antes del programa principal (main).

También se definen fuera de cualquier bloque de instrucciones. Estas variables pueden ser
utilizadas a partir de su definición en cualquier parte del programa.

Fundamentos de Programación | Ing. Patricio Vinueza

Por ejemplo:
#include <stdio.h>
int a; //variable global

int main (void)

{
int p = 3 ; //variable local
a = p;
printf("%5d %5d\n", a, p);
}//fin programa

También se puede definir en forma explícita dentro de un bloque de instrucciones, como se

muestra a continuación:

int a; //variable global

void main (void)

{
int p = 3;
extern int a; //declaración explícita
a = p;
printf("%5d %5d\n", a, p);
}//fin programa

int a; //variable global

void main (void)

{
int p = 3;
extern int a; //variable local
a = p;
printf("%5d %5d\n", a, p);
}//fin programa

Fundamentos de Programación | Ing. Patricio Vinueza

El ámbito de las variables globales se puede apreciar a continuación:

La sintaxis de una función es la siguiente:

[Tipo de retorno] Nombre_de_la_función ([Declaración de Parámetros])

{
Instrucciones;
……
……
[return expr;]
}//fin función

Donde:
tipo_de_retorno: es el tipo de dato que devolverá esa función, que puede ser real, entero,
o tipo void (es decir que no devolverá ningún valor).
nombre_de_la_función: es el identificador o el nombre que se le da a una función.
Declaración de Parámetros: los parámetros que recibe la función y pueden existir funciones
que no reciban parámetros. Los parámetros de una función no son más que
variables locales que reciben un valor.

Fundamentos de Programación | Ing. Patricio Vinueza

De omitirse el tipo de retorno, la función deberá devolver un valor de tipo int . La cláusula
return expr; permite devolver el resultado de la función al módulo que la invocó, expr es
una expresión aritmética cuyo resultado será valor devuelto.

Entre abrir y cerrar {}, se encuentran las instrucciones o lo que queremos que haga la
función; al final antes de cerrar con llave debemos colocar una instrucción return, el cual
devolverá un valor específico; si la función es de tipo void no devuelve ningún valor
específico, debido a que esta instrucción reconoce todo tipo de dato.

Las funciones pueden ser colocadas en cualquier orden dentro del programa, pero si se van
a invocar antes de su declaración, se deberá colocar el "prototipo" de la función al inicio del
programa. El "prototipo no es más que el encabezado de la función, el cual termina con un
";".

TIPOS DE FUNCIONES.

Una función es un bloque de código dentro de un programa que se encarga de una tarea
específica. El programa puede tener muchas funciones y no puede faltar la función principal
main(). Entonces un programa, está constituido por más de una función, las llamadas a la
misma pueden realizarse desde cualquier parte del programa y no solo una vez, se pueden
llamar muchas veces y empiezan a ejecutarse las acciones que están escritas en código.

Los tipos de funciones son de acuerdo al tipo de dato que manejan como:

 Funciones que no devuelven ningún valor (void)

 Funciones que devuelven un valor entero (obligado debe tener return)
 Funciones que devuelven un valor real (obligado debe tener return )
 Funciones recursivas (obligado debe tener return)
 Funciones en las que usamos un menú

DECLARACIÓN DE UNA FUNCIÓN.

Una función en C, se declara antes de ser utilizada por el programa principal (main()) y se
declaran después de invocar las librerías. El prototipo de una función es su cabecera
terminada en punto y coma (;), como se muestra en el siguiente ejemplo:

/* suma de los n primeros números enteros */

#include<conio.h>
#include <stdio.h>
int suma(int n); // Declaro la función antes de main( ) y debe llevar (;)

Fundamentos de Programación | Ing. Patricio Vinueza

int main() //programa principal
{
int sum,n;
printf("entre el valor de n: " );
scanf("%d",&n);
sum= suma(n); // aquí llamo la función suma()
printf("la suma de los n primeros numeros enteros es: %d" ,sum); //salida
getch();
} //fin main

int suma(int n) // definición de la función sin el (;) y va después del programa principal
{
int i,sum=0;
for(i=1; i<=n; i++)
sum+=i;
return(sum); //return 6
} //fin suma

SALIDA:
entre el valor de n: 4
la suma de los n primeros numeros enteros es: 10

Fundamentos de Programación | Ing. Patricio Vinueza

continua…….

Variables Automáticas y Estáticas

Las variables automáticas son aquellas variables que se definen dentro de un

bloque de instrucciones { ... }, su nombre es debido a que se crean cuando se
declara la variable y se destruyen cuando se sale del bloque.

Las variables automáticas se pueden ser definidas en cualquier parte del

programa.

Así:

int main ()
{
int a, b = 7; //variables automáticas, sólo se pueden usar dentro de la
//función main.
a=b-7;

float p; //variable automática, no se puede hacer en C estandar

p=a*10; // pero si en C++.
while (a>5)
{

}
...
}//fin programa

int f(void)
{ int x; //variable automática, sólo se pueden usar dentro de la función f.
x = a; //ERROR: no puede usas la variable a dentro de la función f.
...
return 10;
}

Fundamentos de Programación | Ing. Patricio Vinueza

Se puede hacer también lo siguiente:
a
b
int main ()
{ 10 3
int a=0, b = 5;
while (b>3)
f
{
int f = 5; //variable local al bloque;
a = a+f;
printf("a= %d\n",a);
b--;
} a= 5
b = f; //ERROR: no puede usar la variable f aquí a= 10
}//fin programa

Observe el siguiente ejemplo:

b f
int main ()
{
int b = 7;
int f = 5;

while (b>3)
{
f *= 10; f=50
printf("f= %d\n", f); f=50
b--; f=50
} f=50
}

El programa imprime 4 veces 50 y no 50, 500, 5000 y 50000.

Las variables estáticas se crean la primera vez que se ingresa al bloque, pero
no se destruyen, permanecen definidas en la memoria hasta que se acabe el
programa, su valor se mantiene. Sin embargo el ámbito de esta variable se limita
al bloque en el que fue definida.

Sintaxis:

static Tipo Lista de variables;

Fundamentos de Programación | Ing. Patricio Vinueza

Observe el siguiente ejemplo:
b
int main ()
{
int b = 7;
while (b>3) static f
{
static int f = 5; f= 50
f *= 10; f=500
printf("f= %d \n", f); f=5000
b--; f=50000
}
f++; //error
}//fin del programa

El programa imprime 4 veces 50 y no 50, 500, 5000 y 50000.

Ejemplo:

#include <stdio.h>
void muestra (int a)
{
static int b=1;
b += a;
printf("a= %5d b= %5d\n", a, b);
}
int main ()
{
int a;
for (a=0; a<4; a++)
muestra (a);
} 3

Inicialización de variables

Cuando una variable no se inicializa explícitamente, se garantiza que las

variables externas (globales) y estáticas se inicializan con cero. Por otro lado,
las variables automáticas y los datos de tipo registro (las que se verán más
adelante) no se inicializan, tienen valores iniciales indefinidos (basura) hasta que
se le asigne un valor explícitamente.

Cuando se inicializa explícitamente una variable, las variables externas y

estáticas sólo se pueden inicializar con expresiones constantes, esto es:

Fundamentos de Programación | Ing. Patricio Vinueza

static int i = 0;
static char tab = '\t';
extern long dia = 24L * 60L * 60L; //segundos

Las variables automáticas y de tipo registro se pueden inicializar con cualquier

expresión, estas expresiones pueden contener valores constantes, variables que
tenga valores previamente definidos, incluso llamadas a funciones.

Ejemplo:

int función x (int a, int n)

{
int menor = 0;
int mayor = n-1;
int peor = menor/abs(a) * mayor;
}

#include <stdio.h>
int producto(int A, int B);

int main()
{
int A, B,resultado;
do{
printf("Ingrese dos n%cmeros # # (Enter) \nPara finalizar digite
9999\n",163); A B
scanf("%d %d",&A ,&B);
resultado=0; 3 2
if (A!=9999 && B!=9999)
{
resultado = producto(A,B,5,8); //llamando a la función
producto(3) //llamando a función con el argumento 3 y 2

printf(" A B PRODUCTO\n");
printf("%10d %10d %10d\n",A,B,resultado);
}
}while (A!=9999 && B!=9999);
}//fin programa

argumento 3 2

Fundamentos de Programación | Ing. Patricio Vinueza

 mama papa
int producto(int mama, int papa) parámetros por valor 2
3
{
int total,cont,negativo;
if (mama>0 && papa>0)
negativo=0;
if (A<0 && B>0)
{
negativo=1; A=A*(-1);
}
if (A>0 && B<0)
{
negativo=1; B=B*(-1);
}
if (A<0 && B<0)
{
negativo=0;A=A*(-1);B=B*(-1);
}
for (total=0,cont=1;cont<=A;cont++)
{
total=total+B;

if (negativo==0)
return total;
else
return total*(-1);
} //fin de la funcion

Declaración de una función otros aspectos

La declaración de una función, también conocida como prototipo de la función, indica

cuántos parámetros tiene la función y de qué tipo son, así como el tipo del valor retornado.
Su sintaxis es:

tipo-resultado nombre-función ([lista de parámetros]);

Fundamentos de Programación | Ing. Patricio Vinueza

El prototipo de una función es una plantilla que se utiliza para asegurar que una sentencia
de invocación escrita antes de la definición de la función, es correcta: esto es, que son
especificados los argumentos adecuados y que el valor retornado se trata correctamente.

Este chequeo de tipos y número de argumentos permite detectar durante la compilación si

se ha cometido algún error. Por ejemplo, la siguiente sentencia declara la función convertir
para indicar que cuando sea invocada tiene que recibir un argumento entero y que cuando
finalice su ejecución, retornará un valor real.
float convertir(int e);

En conclusión, la declaración de una función da características de la misma, pero no define

el proceso que realiza.

Una función puede ser declarada implícitamente o explícitamente. La declaración implícita

se da cuando la función es llamada y no existe una declaración previa (prototipo de la
función). En este caso, C, por defecto, construye una función prototipo. Esto obliga a que la
función se la defina o desarrolle antes del main. Por ello, se recomienda realizar siempre
una declaración explícita de la función.

La declaración explícita, especifica el número y el tipo de los argumentos de la función, así

como el tipo del valor retomado.

La lista de parámetros normalmente consiste en una lista de identificadores con sus tipos,
separados por comas. En el caso de que se trate del prototipo de una función, se pueden
omitir los identificadores. Por ejemplo:

float funcion_x(int , float , char );

En cambio, si se especifican, su ámbito queda restringido a la propia declaración; esto es,

no son accesibles en otra parte. Por ejemplo, en la declaración siguiente, a, b y c no son
accesibles en ninguna otra parte.

float funcion_x(int a, float b, char e);

De lo expuesto se deduce que los identificadores utilizados en la declaración de la función

y los utilizados después en la definición de la misma función no necesariamente tienen que
ser los mismos.

Para asegurar la portabilidad de los programas, se puede utilizar el tipo void para especificar
que una función no acepta argumentos, ya que, a diferencia de C++, en el lenguaje C
estándar la ausencia de parámetros y la no especificación de void indica cualquier número

Fundamentos de Programación | Ing. Patricio Vinueza

y tipo de argumentos. Según esto, las declaraciones siguientes tienen la misma validez,
aunque con significados diferentes.

float fnEscribir(void); /* función sin parámetros*/

float fnEscribir(); /* función con cualquier número y tipo de parámetros*/

Las declaraciones de las funciones pertenecientes a la biblioteca estándar de C, como printf,

son proporcionadas por los ficheros de cabecera o ficheros .h. Por eso, cuando un programa
utiliza, por ejemplo, la función printf observará que se incluye el fichero de cabecera stdio.h.

#include <stdio.h>

Al especificar la sintaxis de las funciones de la biblioteca de C, también se indica el fichero

de cabecera donde está declarada.

Definición de una función

La definición de una función consta de una cabecera de función y del cuerpo de la función
encerrado entre llaves.

tipo-resultado nombre-función ([parámetros formales])

{

declaraciones de variables locales;

sentencias;
[return [(]expresión[)] ];
}

Las variables declaradas en el cuerpo de la función son locales y por definición solamente
son accesibles dentro del mismo.

El tipo del resultado especifica qué tipo de datos retorna la función. Este, puede ser
cualquier tipo fundamental, o tipo definido por el usuario, pero no puede ser un array o una
función. Si no se especifica, se supone que es int. El resultado de una función es devuelto a
la sentencia de llamada, por medio de la sentencia:
return [()expresión[));

Esta sentencia puede ser o no la última y puede aparecer más de una vez en el cuerpo de la
función. En el caso de que la función no retorne un valor, se puede omitir o especificar
simplemente return. Por ejemplo,

Fundamentos de Programación | Ing. Patricio Vinueza

 void fnEscribir()
{
// …
return;
}

Los parámetros formales de una función son las variables que reciben los valores de los
argumentos especificados en la llamada a la función. Consisten en una lista de
identificadores con sus tipos, separados por comas. A continuación puede ver un ejemplo:

float convertir(int gcent) /* cabecera de la función*/

{ /* cuerpo de la función*/
float gfahr;
gfahr = (float)9 / (float)5 * gcent + 32;
return (gfahr); /* valor retornado*/
}

Llamada a una función

Para ejecutar una función hay que llamarla. La llamada a una función consta del nombre de
la misma y de una lista de argumentos, denominados parámetros actuales, encerrados
entre paréntesis y separados por comas. Por ejemplo:

/* Se llama a la función convertir*/

GradosFahrenheit = convertir(nGradosCentigrados);

Pasando argumentos a las funciones

Cuando se llama a una función, el valor del primer argumento actual es pasado al primer
parámetro formal, el valor del segundo argumento actual es pasado al segundo parámetro
formal y así sucesivamente. Por defecto, todos los argumentos, excepto los arrays, son
pasados por valor. Esto significa que a la función se pasa una copia del valor del argumento,
no su dirección. Esto hace que la función invocada, no pueda alterar las variables que
contienen los valores pasados.

En el ejemplo anterior, cuando se llama a la función convertir, el parámetro formal gcent

recibe el valor del parámetro actual nGradosCentigrados.

En el siguiente ejemplo, puede observar que la función main llama a la función intercambio
y le pasa los argumentos a y b. La función intercambio almacena en x el valor de a y en y el

Fundamentos de Programación | Ing. Patricio Vinueza

valor de b. Esto significa que los datos a y b se han duplicado. Esto es, ocurren las siguientes
asignaciones:

x=a
y=b
20 30
a b

20 30
x y

Los parámetros formales x e y son variables locales a la función intercambio, por lo tanto
sólo son accesibles dentro de la propia función. Esto significa que las variables locales se
crean cuando se ejecuta la función y se destruyen cuando finaliza la ejecución de la función.

* - Paso de parámetros por valor*/

#include <stdio.h>
void intercambio(int , int); /* prototipo de la función*/
int main ()
{
int a= 20, b = 30;
intercambio(a, b); /*a y b son pasados por valor*/
printf ( "a es %d y b es %d\n", a, b); // se ve en pantalla a es 20 y b es 30
}

20 30

void intercambio(int x, int y)

{
int z = x;
x = y;
y = z;
}

Después de ejecutarse la función intercambio el valor de y ha sido copiado en x y el valor

de x ha sido copiado en y. Lo importante, es que vea que estas operaciones no afectan a los
valores de a y de b.

Fundamentos de Programación | Ing. Patricio Vinueza

 20 30
a b

20 20 30
z x y

Parámetros por dirección

Operador dirección-de

El operador & ( dirección de) da la dirección de su variable. Por ejemplo, 27894

a
int a = 7; // la variable entera 'a' almacena el valor 7 a7

printf("dirección de memoria= %p, dato= %d\n", &a, a);

printf(“%d”,a); // el valor que muestra es 7 27895

printf(“%p”,&a); //el valor que muestra 11862

El resultado desde el punto de vista gráfico puede verlo en la. figura siguiente. La figura
representa un segmento de memoria de n bytes. En este segmento localizamos el entero 7
de dos bytes de longitud, en la dirección 13162. La variable a representa al valor 7 y &a
(dirección de a; esto es, donde se localiza a) es 13162.
13162

7
a
16456
a
int a;
int *aucas; 12

a = 10;
aucas = 12; //esto es error aucas
aucas = &a; esto es correcto 16456

printf(“%d”,a); //el valor a mostrar es 10

printf(“%p”,&a); //se mostrara 16456
printf(“%p”,aucas) //se mostrara 16456
printf(“%d”,*aucas); //se muestra 10

Fundamentos de Programación | Ing. Patricio Vinueza

*aucas = 12;

Fundamentos de Programación | Ing. Patricio Vinueza

& operador de dirección
* operador de indireccion

Operador de indirección

El operador *(indirección) accede a un valor indirectamente a través de un puntero. El

resultado es el valor direccionado (apuntado) por el operando.

Un puntero es una variable capaz de contener una dirección de memoria que indica dónde
se localiza un objeto de un tipo especificado (por ejemplo, un entero). La sintaxis para
definir un puntero es:

tipo *identificador;

donde tipo es el tipo del objeto apuntado e identificador el nombre del puntero.

El siguiente ejemplo declara un puntero px a un valor entero x y después asigna este valor
al entero y.
px x y
7 7
int main()
{
int *px, x = 7, y= 0; // px es un puntero a un valor entero
px = &x; // en el puntero px se almacena la dirección de x
y= *px; //a la variable y se le asigna el valor localizado en la dirección
// almacenada en px
} x
maria
char c;
int x; 15
int *maria;
char *pedro;

x=15;
maria = 7; //error
maria = &x; esto es valido
pedro = &x; error es error

Fundamentos de Programación | Ing. Patricio Vinueza

 x
maria
int x; 15
int *maria;
x=15;
maria = &x;

printf(“%d”,x); en pantalla se verá el 15

printf(“%d”,*maria); en pantalla se verá el 15

Suponiendo que la dirección de x es 13162, el resultado expresado de una forma gráfica es

el siguiente:
13162

13162

13162 7 7

px x y

Apunta

Fundamentos de Programación | Ing. Patricio Vinueza

Lo que indica que el contenido de px (*px) es 7. La sentencia y = *px se lee "y igual al
contenido de px". De una forma más explícita diríamos "y igual al contenido de la dirección
dada por px".

Si lo que se desea es alterar los contenidos de los argumentos especificados en la llamada,

entonces hay que pasar dichos argumentos por referencia. Esto es, a la función se le pasa
la dirección de cada argumento y no su valor, lo que exige que los parámetros formales
correspondientes sean punteros. Para pasar la dirección de un argumento, utilizaremos el
operador &. Por ejemplo:

/* Paso de parámetros por referencia*/

#include <stdio.h>
void intercambio(int *x, int *y); /* prototipo de la función*/
void main ()
{
int a= 20, b = 30;
intercambio(&a, &b); /*a y b son pasados por referencia de memoria o por la
dirección de memoria*/
printf("a es %d y bes %d\n", a, b);
}

void intercambio(int *x, int *y)

{
int z = *x; // z = contenido de la dirección X
*x = *y; // contenido de X = contenido de y
*y = z ; //contenido de y = z
}
En el ejemplo expuesto podemos ver que la función intercambio tiene dos parámetros x e
y de tipo puntero a un entero, que reciben las direcciones de a y de b, respectivamente.
Esto quiere decir que al modificar el contenido de las direcciones x e y, indirectamente
estamos modificando los valores a y b. Recordar la definición de puntero y las definiciones
de los operadores de indirección (*) y dirección-de ( & ).

La explicación gráfica del ejemplo que acabamos de ver es la siguiente:

1. La función main define las variables a y b y llama a la función intercambio pasando

las direcciones de dichas variables como argumento. Supongamos que las
direcciones en memoria de estas variables son 16382 y 16384, respectivamente.

Fundamentos de Programación | Ing. Patricio Vinueza

 16382 16384

20 30
a b

2. Cuando se llama a la función intercambio el valor del primer parámetro actual es

pasado al primer parámetro formal y el valor del segundo parámetro actual es
pasado al segundo parámetro formal. Esto es,
x = &a
y= &b

Los parámetros formales son variables locales a la función que se crean en el

instante en el que ésta es llamada. Según esto,

16382 16384
x y

3. Ahora x apunta al dato a; esto es, el valor de x especifica el lugar donde se localiza
el dato a dentro de la memoria. Análogamente, diremos que y apunta al dato b.

16382 16384
x y

20 30
a b

Observe que *x hace referencia al mismo dato de memoria que a y que *y hace
referencia al mismo dato de memoria que b.

4. A continuación se ejecutan las sentencias:

int z = *x; // se asigna a la variable z el valor de a

*x = *y; // se asigna a la variable a el valor de b
*y = z ; // se asigna a la variable bel valor de z

Fundamentos de Programación | Ing. Patricio Vinueza

 20 16382 16384
z x y

30 20
a b

Cuando la función intercambio finaliza, los valores de a y b han sido intercambiados y las
variables x e y, por el hecho de ser locales, son destruidas.

Por lo tanto, pasar parámetros por referencia a una función es hacer que la función acceda
indirectamente a las variables pasadas. A diferencia de cuando se pasan los parámetros por
valor, no hay duplicidad de datos.

Cuando se trate de funciones de la biblioteca de C, también se le presentarán ambos casos.

Por ejemplo, suponga que desea escribir un programa que lea dos valores a y b y que escriba
la suma de ambos. La solución es la siguiente:

//Sumar dos valores

#include <stdio.h>
int main ()
{
int a= 0, b = 0, s = 0;
printf ( "Ingrese valores de a y b: ”);
scanf("%d %d", &a, &b); // leer desde el teclado a y b
s = a + b;
printf("La suma es %d\n", s);
}

La ejecución de este programa puede ser así:

Ingrese valores de a y b: 10 20
La suma es 30

Fundamentos de Programación | Ing. Patricio Vinueza

//Sumar dos valores por medio de una funcion
#include <stdio.h>
int suma(int , int );
int main ()
{
int a= 0, b = 0, s = 0;
printf ( "Ingrese valores de a y b: ”);
scanf("%d %d", &a, &b); // leer desde el teclado a y b
s = suma(a,b);
printf("La suma es %d\n", s);
}
int suma(int x, int y )
{
return x + y;
}

//Sumar dos valores por medio de una función, la función no devuelve nada y el resultado
se regresará en un tercer parámetro por dirección

#include <stdio.h>
void suma(int , int , int *);
int main ()
{
int a= 0, b = 0, s = 0;
printf ( "Ingrese valores de a y b: ”);
scanf("%d %d", &a, &b); // leer desde el teclado a y b
suma(a,b, &s);
printf("La suma es %d\n", s);
}
void suma(int x, int y, int *z )
{
*z = x + y;
}

Fundamentos de Programación | Ing. Patricio Vinueza

Tarea 12 Problemas Propuestos

Elabore en Lenguaje según se le indique de cada uno de los siguientes problemas

y codifiquelos en DEV C++, Enviar archivos fuente en una sola carpeta
comprimido.

Ejercicio 1

Elaborar una función que reciba como argumento un dato de tipo float y devuelva
tres variables: la primera que almacene la parte entera del número, la segunda
que almacene como entero la parte decimal del número y la última que almacene
el número de decimales que contiene el dato recibido por la función.

En el programa se lee el dato de tipo float e imprime los resultados obtenidos

de la función.

Ejercicio 2

Elaborar una función que reciba en una variable entera un número n, y devuelva
en otra variable la palabra "verdadero" si el número recibido es primo, caso
contrario devuelva la palabra "falso".

En el programa leer el valor de n e indicar con un mensaje apropiado si n es

primo o no.

Ejercicio 3

Realizar un programa que escriba el triángulo de Pascal. La profundidad del

triángulo está determinada por el valor n leído desde teclado. Por ejemplo, si el
valor leído n es 4, el triángulo de Pascal debe imprimirse de la siguiente manera:

1
1 1
1 2 1
1 3 3 1

Nota: El triángulo de Pascal anterior, es equivalente a:

Fundamentos de Programación | Ing. Patricio Vinueza

Ejercicio 4

Realizar un menú con las siguientes opciones.

a) Una función entera Celsius() que regresa el equivalente Celsius de una

temperatura en Fahrenheit.

b) Una función entera Fahrenheit() que regresa el equivalente en Fahrenheit

de una temperatura en Celsius.

c) Utilizar ambas funciones para escribir un programa que imprima tablas

mostrando los equivalentes Fahrenheit de todas las temperaturas Celsius
desde 0 hasta 100 grados, y los equivalentes Celsius de todas las
temperaturas Fahrenheit entre 32 y 212 grados. Imprimir las salidas en
un formato tabular nítido, que minimice el número de líneas de salida.

Programa de conversión de Temperaturas

Menú Principal
1. Convertir de Fahrenheit a Celsius
2. Convertir de Celsius a Fahrenheit
3. Mostrar Tablas
a. Tabla de Celsius entre 0 y 100 a Fahrenheit
b. Tabla de Fahrenheit entre 32 y 212 a Celsius
c. Regresar al menú principal
4. Salir del Programa

Ingrese su opción: 1

Convertir de Fahrenheit a Celsius

Ingrese un valor Fahrenheit: 56
El equivalente en Celsius es: xxx

Presione una tecla para continuar…

Fundamentos de Programación | Ing. Patricio Vinueza