Gua 2 de programacin en Lenguaje C

Tipos de Datos Estructurados en C

ARREGLOS
Un arreglo es una estructura de datos esttica formada por una coleccin o conjunto fijo de
elementos o componentes del mismo tipo.
Se define esttica porque el tamao de dicha estructura se especifica al declararla y una vez
establecido este tamao, ya no puede ser modificado durante la ejecucin del programa.
En C se puede trabajar con los siguientes tipos de arreglos:
- Arreglos Unidimensionales o Lineales (Vectores)
- Arreglos Multidimensionales.
A continuacin se ver cada uno de ellos.
ARREGLOS UNIDIMENSIONALES O LINEALES (VECTORES):
Es un conjunto de elementos representados en forma lineal, en el cual existe una nica fila y N
nmero de columnas.
Declaracin de un Arreglo Unidimensional:
Al declarar un arreglo se define el tipo de componente, nombre del arreglo y el tamao (tambin
llamado orden del arreglo) encerrado entre corchetes.
Sintaxis:
<tipo> <variable> [<dimensin>];
En donde, <tipo> es el tipo de dato de los elementos del arreglo (ejemplo: int, float, char),
<variable> es el nombre de la variable tipo arreglo a declarar; <dimensin> es el tamao del arreglo
que especifica la cantidad de elementos.
Ejemplo:
int notas[5];
El ejemplo anterior declara la variable notas como un arreglo de 5 elementos de tipo int.
Para una mejor comprensin, grficamente, podramos verlo de la siguiente forma:
0
1
2
3
4
notas
Cada elemento del arreglo tiene un subndice o posicin que permite acceder directamente a un
elemento. Los subndices en lenguaje C empiezan en 0 (cero) y terminan en n-1, donde n es el tamao
del arreglo. Es decir, si el arreglo notas tiene un tamao 5, el primer elemento del arreglo est en la
posicin 0 y el ltimo elemento est en la posicin 4.
Ejemplo:
char nombres[20];
El ejemplo anterior declara un string de tamao 20, que es un arreglo de 20 caracteres.
Ejemplo:
#define MAX 10
float sueldos[MAX];
El ejemplo anterior declara la variable sueldos como un arreglo de 10 elementos de tipo float.
Se utiliz la directiva #define para definir un nombre simblico (MAX) para el tamao del arreglo (10).
Observe que esta instruccin no finaliza con punto y coma (;).
Ejemplo:

#define CINCO 5
int num[CINCO] = {12, 24, 2, 41, 7};
En el ejemplo anterior se ha inicializado un arreglo al momento de declararlo (normalmente para
arreglos pequeos).
Acceder a un elemento del Arreglo:
Cada elemento del arreglo puede ser accedido directamente colocando el nombre del arreglo,
seguido por el subndice (o posicin) encerrado entre corchetes.
Ejemplo:
notas[0] = 18;
En el ejemplo anterior, se asigna el valor 18 al arreglo notas en la posicin 0, es decir, el primer
elemento del arreglo notas es un 18.
Los elementos de un arreglo pueden leerse, asignarse, imprimirse y/o formar parte de una
expresin, siempre que se indique el subndice.
Ejercicio N 1:
Declare un arreglo de cinco elementos llamado tabla. Cargarlo con los nmeros del 1 al 5 y mostrarlo.
#include <stdio.h>
#include <conio.h>
#define MAX 5
main()
{
int tabla[MAX];
int i;
clrscr(); /* Limpia la pantalla */
for (i = 0; i < MAX; i++)
tabla[i] = i + 1;
printf ("Los elementos de la tabla son: \n");
for (i = 0; i < MAX; i++)
printf ("%d ", tabla[i]);

printf ("\n");
printf ("Presione Enter, para salir...");
return;

getche();

Nota: En el ejercicio anterior se pudo haber inicializado el arreglo al momento de declararlo.

int tabla[MAX] = {1, 2, 3, 4, 5};
Ejercicio N 2:
Leer 10 nmeros enteros en un arreglo. Imprimir los elementos que sean nmeros impares.
#include <stdio.h>
#include <conio.h>
#define MAX 10
main()
{
int num[MAX], i;
clrscr(); /* Limpia la pantalla */
for (i = 0; i < MAX; i++)

{
printf ("Introduzca un numero entero: ");
scanf ("%d", &num[i]);
}
printf ("Los numeros impares son: \n");
for (i = 0; i < MAX; i++)
{
if ((num[i] % 2) != 0)
/* si el resto no es cero */
printf ("%d ", num[i]);
}
printf ("\n");
printf ("Presione Enter, para salir...");
return;

getche();

}
Ejercicio N 3:
Leer 5 nmeros enteros en un arreglo. Se pide:
a) Mostrar el arreglo.
b) Invertir el arreglo y mostrarlo.
#include <stdio.h>
#include <conio.h>
#define MAX 5
main()
{
int arreglo[MAX], i, primer, ultimo, aux;
clrscr(); /* Limpia la pantalla */
for (i = 0; i <= (MAX-1); i++)
{
printf ("Introduzca un numero entero: ");
scanf ("%d", &arreglo[i]);
}
printf ("El arreglo original es: \n");
for (i = 0; i <= (MAX-1); i++)
printf ("%d ", arreglo[i]);
printf ("\n");
/* invertir arreglo */
primer = 0;
ultimo = MAX-1;
while (primer <= ultimo)
{
aux = arreglo[primer];
/* intercambiar valores */
arreglo[primer] = arreglo[ultimo];
arreglo[ultimo] = aux;
primer++;
ultimo--;
}
printf ("El arreglo invertido es: \n");
for (i = 0; i <= (MAX-1); i++)
printf ("%d ", arreglo[i]);

printf ("\n");
printf ("Presione Enter, para salir...");
return;

getche();

}
Ejercicio N 4:
Leer un texto en un arreglo. El final del texto se indica con el smbolo $. Calcular la cantidad de vocales
en el texto.
#include <stdio.h>
#include <conio.h>
#define MAX 100
main()
{
char texto[MAX];
int k, cont;
clrscr(); /* Limpia la pantalla */
printf ("Introduzca un texto terminando con el caracter $: \n");
k=-1;
do
{
k++;
texto[k] = getche();
} while (texto[k] != '$');
printf ("\n");
cont=0; k=0;
while (texto[k] != '$')
{
if (toupper(texto[k]) == 'A' || toupper(texto[k]) == 'E' || \
toupper(texto[k]) == 'I' || toupper(texto[k]) == 'O' || \
toupper(texto[k]) == 'U' || toupper(texto[k]) == 'E')
cont++;
k++;
}
printf ("La cantidad de vocales es: %d \n", cont);
printf ("Presione Enter, para salir..."); getche();
return;

}
Nota: Recuerde que la funcin toupper() retorna la mayscula de un carcter alfabtico.
Ejercicio N 5:
Leer una palabra en un arreglo de caracteres (una letra en cada posicin). Verifique si la palabra es un
palndrome (al inverso se lee igual). Ejemplo: AREPERA.
#include <stdio.h>
#include <conio.h>
#define MAX 20
#define VERDADERO 1
#define FALSO 0
main()
{
char palabra[MAX], caracter;
int cont, i, es_palindrome;
clrscr(); /* Limpia la pantalla */
printf ("Introduzca una palabra: ");
cont=-1;
do

{
cont++;
palabra[cont] = getche();
} while (palabra[cont] != '\r');
printf ("\n");
es_palindrome = FALSO;
i=0; cont--;
while (i <= cont)
{
if (palabra[i] == palabra[cont])
es_palindrome = VERDADERO;
i++;
cont--;
}
if (es_palindrome)
printf ("Es un Palindrome. \n");
else
printf ("No es un Palindrome. \n");
printf ("Presione Enter, para salir...");
return;

getche();

}
Nota: El programa anterior lee caracteres hasta que se introduce el carcter '\r' que es la tecla Enter.
Ejercicio N 6:
Declare un arreglo de diez elementos que contenga apellidos. Indique cuntos apellidos tienen ms de
seis letras.
#include <stdio.h>
#include <conio.h>
#define MAX 10
#define VEINTE 20

/* tamao del arreglo */

/* tamao del string */

main()
{
char apellidos[MAX][VEINTE];
int i, cont;
clrscr(); /* Limpia la pantalla */
for (i = 0; i <= (MAX-1); i++)
{
printf("Introduzca apellido: ");
scanf ("%s", apellidos[i]);
}
cont=0;
for (i = 0; i <= (MAX-1); i++)
if (strlen(apellidos[i]) > 6)
cont++;

/* si longitud del string > 6 */

printf ("Los apellidos con mas de seis letras son: %d \n", cont);
printf ("Presione Enter, para salir..."); getche();
return;

Nota: El programa anterior declara un arreglo de cadenas. El primer subndice en la declaracin

corresponde al tamao del arreglo, y el segundo subndice corresponde al tamao de las cadenas que va
a contener el arreglo. Esta declaracin tambin corresponde a un arreglo bidimensional.

Ejercicio N 7:
Leer las notas de 8 alumnos, en un arreglo. Calcular: la cantidad de aprobados y la nota Promedio.
#include <stdio.h>
#include <conio.h>
#define MAX 8
main()
{
int notas[MAX];
int i, contAp, acumNota;
float promedio;
clrscr(); /* Limpia la pantalla */
for (i = 0; i < MAX; i++)
{
printf ("Introduzca Nota: ");
scanf ("%d", &notas[i]);
}
contAp = 0;
acumNota = 0;
for (i = 0; i < MAX; i++)
{
if (notas[i] >= 12)
contAp++;
acumNota = acumNota + notas[i];
}
promedio = (float) acumNota / MAX;
printf ("La cantidad de aprobados es: %d \n", contAp);
printf ("La nota promedio es: %.2f \n", promedio);
printf ("Presione Enter, para salir...");
return;

getche();

}
Ejercicios propuestos:
T01.- Leer 10 enteros en un arreglo. Sustituir cada elemento del arreglo por su raz cuadrada e imprimir
el arreglo.
T02.- Leer 5 enteros en un arreglo. Se pide: a) mostrar el arreglo original: b) rotar los elementos una
posicin a la derecha (el ltimo al primero) y mostrarlo.
T03.- Se tienen tres arreglos: A, B y C, de 5 enteros cada uno. Cargar (leer) los dos primeros arreglos y
asignar a C la suma de A y B.
T04.- Se tiene un arreglo de 10 posiciones. Leer los valores (enteros) de manera que los nmeros pares
se introducen de izquierda a derecha en el arreglo, y los impares de derecha a izquierda.
T05.- Se tienen cuatro arreglos llamados: N1, N2, Operador y Respuesta, de 5 posiciones cada uno.
Leer enteros en N1 y N2; leer caracteres operadores (+, -, * /) en el arreglo Operador. Asigne el
resultado de la operacin N1 operador N2 al arreglo Respuesta. Mostrar el arreglo Respuesta.
T06.- Leer diez caracteres (entre letras y espacios en blanco) en un vector. Se pide compactar el
arreglo, mover las letras a la izquierda, de manera que los espacios en blanco ( ) queden al final, a la
derecha.
T07.- Leer 20 nmeros enteros en un arreglo. Indique cul es el nmero que ms se repite.
ARREGLOS MULTIDIMENSIONALES:

Los arreglos que hemos visto hasta ahora, se llaman unidimensionales o vectores. Como se
explic, los elementos de un arreglo pueden ser de cualquier tipo (int, char, string, etc.), siempre que
todos los elementos del arreglo sean del mismo tipo.
Podemos definir arreglos cuyos elementos sean otros arreglos. Un arreglo cuyos elementos sean
arreglos unidimensionales se llama arreglo de dos dimensiones o bidimensional. Igualmente, se pueden
definir arreglos tridimensionales, y as sucesivamente.
Cabe destacar, que los arreglos de dimensin mayor que tres son desechados, generalmente,
por los programadores, ya que son ms difciles de visualizar y por lo tanto de manejar.
Un arreglo bidimensional es llamado matriz.
A continuacin se ver dos tipos de arreglos multidimensionales:
- Arreglos Bidimensionales o Matrices
- Arreglos Tridimensionales.
ARREGLOS BIDIMENSIONALES O MATRICES:
Es un conjunto de elementos representados en M nmero de filas y N nmero de columnas.
Declaracin de un Arreglo Bidimensional:
Al declarar un arreglo bidimensional se define el tipo de componente, el nombre del arreglo y su
tamao (filas y columnas) encerrados entre corchetes.
Sintaxis:
<tipo> <variable> [<dimensin1>][<dimensin2>];
En donde, <tipo> es el tipo de dato de los elementos del arreglo (ejemplo: int, float, char y
otros); <variable> es el nombre del arreglo a declarar; <dimensin1> y <dimensin2> representan el
tamao del arreglo, especificando un rango ordinal para las filas y otro rango ordinal para las columnas
(encerrados entre corchetes).
Ejemplo:
int notas[3][5];
El ejemplo anterior declara la variable notas como un arreglo de 3 filas por 5 columnas (3x5), es
decir 15 elementos de tipo int.
Para una mejor comprensin, grficamente, podramos verlo de la siguiente forma:
0
notas

4 (columnas)

0
1

(filas) 2
Cada elemento del arreglo tiene una posicin referida por dos subndices (fila, columna) que
permite acceder directamente a un elemento. Estos subndices estn definidos entre corchetes.
Los subndices en lenguaje C empiezan en 0 (cero) y terminan en n-1, donde n es el tamao de
la fila o columna del arreglo. Es decir, si el arreglo notas tiene un tamao 3x5, el primer elemento del
arreglo est en la posicin [0][0] y el ltimo elemento est en la posicin [2][4].
Ejemplo:
char letras [4][7];
Ejemplo:
#define MAXF 4
#define MAXC 10
int edades[MAXF][MAXC];
Ejemplo:
int num[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
En el ejemplo anterior se ha inicializado un arreglo al momento de declararlo. Los cuatro
primeros elementos (1,2,3,4) corresponden a la primera fila; los cuatro siguientes elementos
(5,6,7,8) a la segunda fila; y los cuatro ltimos elementos (9,10,11,12) a la tercera fila.

El siguiente ejemplo es equivalente al anterior:

Ejemplo:
int num[3][4] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} };
Acceder a un elemento de la Matriz:
Cada elemento de una matriz puede ser accedido directamente colocando el nombre de la
variable tipo arreglo, seguido por los subndices de fila y columna encerrados entre corchetes.
Ejemplo:
notas [0][2] = 17;
En el ejemplo anterior, se asigna el valor 17 a la matriz notas en la posicin, fila 0, columna 2;
es decir, el elemento que est en la primera fila con la tercera columna es 17.
Ejercicio N 8:
Declare una matriz de 3 filas y 5 columnas que contenga edades. Se pide:
a) Leer las edades (por filas).
b) Mostrar la matriz (imprimir las edades) por filas.
c) Mostrar la matriz (imprimir las edades) por columnas.
#include <stdio.h>
#include <conio.h>
#define MAXF 3
#define MAXC 5
main()
{
int edades[MAXF][MAXC];
int i, j;
clrscr(); /* Limpia la pantalla */
/* Cargar por filas */
for (i = 0; i < MAXF; i++)
for (j = 0; j < MAXC; j++)
{
printf("Introduzca una Edad: ");
scanf ("%d", &edades[i][j]);
}
/* Mostrar por filas */
for (i = 0; i < MAXF; i++)
{
for (j = 0; j < MAXC; j++)
printf("%d ", edades[i][j]);
printf ("\n");
}
/* Mostrar por columnas */
for (j = 0; j < MAXC; j++)
{
for (i = 0; i < MAXF; i++)
printf("%d ", edades[i][j]);
printf ("\n");
}

printf ("Presione Enter, para salir...");

return;

getche();

Ejercicio N 9:
Leer enteros en una matriz de 3x3. Indique si la matriz es simtrica (todo nij = nji)

#include <stdio.h>
#include <conio.h>
#define MAX 3
#define VERDADERO 1
#define FALSO 0
main()
{
int num[MAX][MAX];
int i, j, es_simetrica;
clrscr(); /* Limpia la pantalla */
/* Cargar por filas */
for (i = 0; i < MAX; i++)
for (j = 0; j < MAX; j++)
{
printf("Introduzca el entero de fila %d columna %d: ", i, j);
scanf ("%d", &num[i][j]);
}
/* Verificar si es Matriz simetrica */
es_simetrica = VERDADERO;
for (i = 0; i < MAX; i++)
for (j = 0; j < MAX; j++)
if (num[i][j] != num[j][i])
es_simetrica = FALSO;
if (es_simetrica == VERDADERO)
printf("La Matriz es simetrica. \n");
else
printf("La Matriz NO es simetrica. \n");
printf ("Presione Enter, para salir...");
return;

getche();

}
Ejercicio N 10:
Leer enteros en dos matrices: A (2x3) y B (3x4). Calcular la multiplicacin de matrices A y B en la matriz
C (2x4). Debe aplicar los conocimientos de matemticas sobre matrices.
#include <stdio.h>
#include <conio.h>
#define DOS 2
#define TRES 3
#define CUATRO 4
main()
{
int a[DOS][TRES], b[TRES][CUATRO], c[DOS][CUATRO];
int i, j, k, acum;
clrscr(); /* Limpia la pantalla */
/* Cargar matriz A por filas */
printf("Datos de la matriz A \n");
for (i = 0; i < DOS; i++)
for (j = 0; j < TRES; j++)
{
printf("Introduzca el entero de fila %d columna %d: ", i, j);
scanf ("%d", &a[i][j]);
}

/* Cargar matriz B por filas */

printf("Datos de la matriz B \n");
for (j = 0; j < TRES; j++)
for (k = 0; k < CUATRO; k++)
{
printf("Introduzca el entero de fila %d columna %d: ", j, k);
scanf ("%d", &b[j][k]);
}
/* Resolver multiplicacion de A x B en C */
for (i = 0; i < DOS; i++)
for (k = 0; k < CUATRO; k++)
{
acum = 0;
for (j = 0; j < TRES; j++)
acum = acum + a[i][j] * b[j][k];
c[i][k] = acum;
}
/* Mostrar matriz C por filas */
printf("Datos de la matriz C \n");
for (i = 0; i < DOS; i++)
{
for (k = 0; k < CUATRO; k++)
printf("%d ", c[i][k]);
printf ("\n");
}
printf ("Presione Enter, para salir...");
return;

getche();

}
Ejercicio N 11:
Leer las notas de 4 asignaturas de 5 alumnos, en una matriz (4x5). Se pide:
a) Leer las notas por asignatura (por filas).
b) Calcular la cantidad de aprobados por asignatura (por filas).
c) Calcular la nota promedio por alumno (por columnas).
d) Calcular la nota mayor (de todas).
#include <stdio.h>
#include <conio.h>
#define MAXF 4
#define MAXC 5
main()
{
int notas[MAXF][MAXC];
int i, j, contap, acumn, mayor;
float prom;
clrscr(); /* Limpia la pantalla */
/* Cargar por filas */
for (i=0; i<MAXF; i++)
/* ciclo de las filas (asignaturas) */
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (alumnos) */
{
printf ("Introduzca nota en asignatura %d de alumno %d: ", i, j);
scanf ("%d", &notas[i][j]);
}
/* Calcular cantidad de aprobados por asignatura (por filas) */
for (i=0; i<MAXF; i++)
/* ciclo de las filas (asignaturas) */
{
contap=0;
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (alumnos) */

if (notas[i][j] >= 12)

contap++;
printf("La cantidad de aprobados en asignatura %d es: %d\n", i, contap);
}
/* Calcular nota promedio por alumno (por columnas) */
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (alumnos) */
{
acumn=0;
for (i=0; i<MAXF; i++)
/* ciclo de las filas (asignaturas) */
acumn = acumn + notas[i][j];
prom = (float) acumn / MAXF;
printf("El promedio de nota del alumno %d es: %.1f\n", j, prom);
}
/* Calcular la nota mayor (de todas) */
mayor=0;
for (i=0; i<MAXF; i++)
/* ciclo de las filas (asignaturas) */
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (alumnos) */
if (notas[i][j] > mayor)
mayor = notas[i][j];
printf("La nota mayor general es: %d\n", mayor);
printf ("Presione Enter, para salir...");
return;

getche();

}
ARREGLOS TRIDIMENSIONALES:
Es un conjunto de elementos representados en tres dimensiones: filas, columnas y profundidad.
Declaracin de un Arreglo Tridimensional:
Al declarar un arreglo tridimensional se define su nombre, el tamao (ndice de filas, ndice de
columnas e ndice de profundidad) encerrado entre corchetes, y el tipo de componente.
Sintaxis:
<tipo> <variable> [<dimensin1>][<dimensin2>][<dimensin3>];
En donde, <tipo> es el tipo de dato de los elementos del arreglo (ejemplo: int, float, char y
otros). <variable> es el nombre de la variable arreglo a declarar; <dimensin1>, <dimensin2> y
<dimensin3> representan el tamao del arreglo, especificando el tamao para las filas, para las
columnas y la profundidad (encerrados entre corchetes).
Ejemplo:
float sueldos [3][5][2];
El ejemplo anterior declara la variable sueldos como un arreglo de 3 filas, por 5 columnas, por 2
de profundidad (orden 3x5x2), es decir 30 elementos de tipo real.
Para una mejor comprensin, grficamente, podramos verlo de la siguiente forma:
0
(Profundidad)

4 (columnas)

0
sueldos

0
1

(filas) 2
Cada elemento del arreglo tiene una posicin referenciada por tres subndices (filas, columnas,
profundidad) que permite acceder directamente a un elemento. Estos ndices estn definidos de 0 a n-1,
donde n es el tamao de una dimensin.

Ejemplo:
#define MAXF 4
#define MAXC 8
#define MAXP 3
int edades[MAXF][MAXC][MAXP];
Ejemplo:
char letras[3][3][2];
Acceder a un elemento del Arreglo Tridimensional:
Cada elemento de un arreglo tridimensional puede ser accedido directamente colocando el
nombre de la variable tipo arreglo, seguido por los subndices encerrados entre corchetes.
Ejemplo:
sueldos [0][4][1] = 0.0;
En el ejemplo anterior, se asigna el valor real 0.0 al arreglo sueldos en la posicin, fila 0,
columna 4, profundidad 1; es decir, al elemento que est en la primera fila con la quinta columna de
profundidad 1 es 0.0.
Ejercicio N 12:
Leer las ventas de 3 vendedores de 5 artculos en 2 ciudades en un arreglo (3x5x2). Calcular:
a) La suma de las ventas por vendedor.
b) La suma de las ventas por artculo.
c) La suma de las ventas por ciudad.
#include <stdio.h>
#include <conio.h>
#define MAXF 3
#define MAXC 5
#define MAXP 2
main()
{
float ventas[MAXF][MAXC][MAXP], acum;
int i, j, k;
clrscr(); /* Limpia la pantalla */
/* Cargar por filas */
printf ("Introduzca las ventas de: \n");
for (i=0; i<MAXF; i++)
/* ciclo de las filas (vendedores) */
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (articulos) */
for (k=0; k<MAXP; k++)
/* ciclo de la profundidad (ciudades) */
{
printf ("vendedor:%d articulo:%d ciudad:%d: ", i, j, k);
scanf ("%f", &ventas[i][j][k]);
}
/* Calcular suma de las ventas por vendedor (por filas) */
for (i=0; i<MAXF; i++)
/* ciclo de las filas (vendedores) */
{
acum=0;
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (articulos) */
for (k=0; k<MAXP; k++)
/* ciclo de la profundidad (ciudades) */
acum = acum + ventas[i][j][k];
printf("La suma de las ventas del vendedor: %d es: %.2f\n", i, acum);
}
/* Calcular suma de las ventas por articulo (por columnas) */
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (articulos) */

acum=0;
for (i=0; i<MAXF; i++)
/* ciclo de las filas (vendedores) */
for (k=0; k<MAXP; k++)
/* ciclo de la profundidad (ciudades) */
acum = acum + ventas[i][j][k];
printf("La suma de las ventas del articulo: %d es: %.2f\n", j, acum);

/* Calcular suma de las ventas por ciudad (por profundidad) */

for (k=0; k<MAXP; k++)
/* ciclo de la profundidad (ciudades) */
{
acum=0;
for (i=0; i<MAXF; i++)
/* ciclo de las filas (vendedores) */
for (j=0; j<MAXC; j++)
/* ciclo de las columnas (articulos) */
acum = acum + ventas[i][j][k];
printf("La suma de las ventas de la ciudad: %d es: %.2f\n", k, acum);
}

printf ("Presione Enter, para salir...");

return;

getche();

EJERCICIO CON TRES ARREGLOS

Ejercicio N 13:
Leer Nombre, Edad y Sexo de 5 personas, en tres arreglos. Realice:
a) Blanquear o limpiar los arreglos.
b) Leer datos de entrada (Nombre, edad y sexo de las 5 personas)
c) Calcular la suma de las edades de los varones.
d) Calcular la edad mayor.
e) Nombre de la persona con edad menor.
#include <stdio.h>
#include <conio.h>
#define MAX 5
main()
{
char
int
char
int
char

nombre[MAX][20];
edad[MAX];
sexo[MAX];
i, acumEdHom, mayor, menor;
nombreAux[20];

clrscr(); /* Limpia la pantalla */

for (i = 0; i < MAX; i++)
{
strcpy (nombre [i], " ");
edad [i] = 0;
sexo [i] = ' ';
}
for (i = 0; i < MAX; i++)
{
printf ("Introduzca Nombre: ");
printf ("Introduzca Edad: ");
printf ("Introduzca Sexo (F/M): ");
printf ("\n");
}
acumEdHom = 0; mayor = 0; menor = 200;

scanf ("%s", nombre[i]);

scanf ("%d", &edad [i]);
sexo[i] = getche();

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

{
if (sexo [i] == 'M' || sexo [i] == 'm')
acumEdHom = acumEdHom + edad [i];
if (edad [i] > mayor)
mayor = edad [i];
if (edad [i] < menor)
{
menor = edad [i];
strcpy (nombreAux, nombre [i]);
}
}
printf ("La edad mayor es: %d \n", mayor);
printf ("La suma de las edades de los varones es: %d \n", acumEdHom);
printf ("El nombre de la persona con edad menor es: %s \n", nombreAux);
printf ("Presione Enter, para salir...");
return;

getche();

}
ESTRUCTURAS
Anteriormente, se discuti el concepto de arreglos, los cuales agrupaban elementos del mismo
tipo. Una Estructura es capaz de manejar mltiples elementos de datos los cuales pueden ser de
diferentes tipos, usando un nico identificador que los agrupe a todos.
Una Estructura se puede tratar como un todo o individualmente.
Una Estructura es una estructura de datos compuesta de un nmero fijo de componentes
llamados miembros, donde cada miembro viene definido por un tipo y un identificador.
Declaracin de una Estructura:
Se puede declarar una estructura al definir un nombre (identificador), y sus miembros (con su tipo
y nombre).
Sintaxis:
struct <nombre de la estructura> {
<tipo> <miembro1>;
<tipo> <miembro2>;
...
<tipo> <miembroN>;
};
En donde, <nombre de la estructura> es el nombre de la estructura que se declara;
<miembro1>, <miembro2>, <miembroN> son los nombres de los miembros o datos que va a contener
la estructura; y <tipo> es el tipo de dato de cada miembro definido (ejemplo: int, float, char, arreglos).
Ejemplo:
struct registro {
char nombre[20];
int
edad;
float sueldo;
};
Nota: El ejemplo anterior slo define una estructura. Ninguna variable est declarada all.
Para declarar variables de tipo estructura, se puede usar la siguiente declaracin:
Ejemplo:
struct registro empleado, persona;
El ejemplo anterior declara las variables empleado y persona de tipo estructura registro que
contiene tres (3) miembros: nombre, edad y sueldo.

Tambin podemos definir las variables al momento de declarar la estructura:

Ejemplo:
struct registro {
char nombre[20];
int
edad;
float sueldo;
} empleado, persona;
Ejemplo:
struct fecha {
int dia;
int mes;
int anio;
} fecha_nac, fecha_ingr, fecha_jubila;
El ejemplo anterior declara tres variables de tipo estructura fecha. Observe que los miembros
pueden ser del miso tipo.
Acceder a un miembro de una Estructura:
Cada elemento (o miembro) de la estructura puede ser accedido directamente colocando el
nombre de la variable tipo estructura, seguido de un punto (.) y el identificador del miembro.
Ejemplo:
empleado.edad = 19;
scanf ("%f", &empleado.sueldo);
En el ejemplo anterior, se asigna el valor 19 al miembro edad, y se lee (con scanf) el miembro
sueldo de la variable empleado.
Los miembros de una estructura pueden leerse, asignarse, imprimirse y/o formar parte de una
expresin, siempre que se indique el nombre de la variable estructura, seguido de un punto y el
identificador del miembro.
Nota: No se puede leer o imprimir una estructura sin definir un miembro. Sin embargo, podemos utilizar
el nombre de la variable estructura como parmetro en una funcin.
Ejercicio N 14:
Leer Apellido, Edad y Sexo de 5 alumnos. Calcular: a) Edad menor; b) Promedio de Edad de los varones.
Utilice una estructura.
#include <stdio.h>
#include <conio.h>
main()
{
struct registro {
char apellido[20];
int edad;
char sexo;
} alumno;
int i, menor, acumedV, contV;
float promedV;
clrscr(); /* Limpia la pantalla */
menor=200; acumedV=0; contV=0;
for (i = 0; i < 5; i++)
{
printf("Introduzca Apellido: ");
printf("Introduzca Edad: ");

scanf ("%s", alumno.apellido);

scanf ("%d", &alumno.edad);

printf("Introduzca Sexo (F/M): "); alumno.sexo = getche();

printf("\n");

if (alumno.edad < menor)

menor = alumno.edad;
if (alumno.sexo == 'M' || alumno.sexo == 'm')
{
acumedV = acumedV + alumno.edad;
contV = contV + 1;
}

if (contV > 0)
/* verifica que el divisor no sea cero */
promedV = (float) acumedV / contV;
else
promedV = 0.0;
printf ("La edad menor es: %d \n", menor);
printf ("La edad promedio de los varones es: %.1f \n", promedV);

printf ("Presione Enter, para salir...");

return;

getche();

ESTRUCTURA DE ESTRUCTURAS
En C se pueden definir estructuras como miembros de otra estructura.
Ejemplo:
struct fecha {
int dia;
int mes;
int anio;
};
struct registro {
char nombre[20];
char direccion[50];
float sueldo;
struct fecha fecha_nac;
} persona;
El ejemplo anterior declara la variable estructura persona con cuatro (4) miembros: nombre,
direccion, sueldo y fecha_nac; donde fecha_nac es de tipo estructura con tres (3) miembros:
dia, mes y anio.
Acceder a un miembro Estructura de una Estructura:
Ya sabemos, que cada elemento (o miembro) de una estructura puede ser accedido directamente
colocando el nombre de la variable estructura, seguido de un punto (.) y el identificador del miembro.
Ejemplo:
strcpy (persona.nombre, "Ernesto");
strcpy (persona.direccin, "Urb. El Pedregal");
persona.sueldo
= 800000.0;
persona.fecha_nac.dia = 16;
persona.fecha_nac.mes = 9;
persona.fecha_nac.anio = 1967;
Ejercicio N 15:
Leer Nombre y tres Notas (matemticas, programacin y arquitectura) de cuatro estudiantes. Calcular la
nota promedio de cada asignatura. Utilice una estructura cuyos miembros sean el nombre y una
estructura con las tres notas del alumno.

#include <stdio.h>
#include <conio.h>
main()
{
struct tipo_nota {
int matema;
int progra;
int arquit;
};
struct tipo_alumno {
char nombre[20];
struct tipo_nota nota;
} alumno;
int i, acumMat=0, acumPro=0, acumArq=0;
float promMat, promPro, promArq;
clrscr(); /* Limpia la pantalla */
for (i = 0; i < 4; i++)
{
printf("Introduzca Nombre: ");
scanf ("%s", alumno.nombre);
printf("Introduzca Nota de Matemticas: ");
scanf ("%d", &alumno.nota.matema);
printf("Introduzca Nota de Programacin: ");
scanf ("%d", &alumno.nota.progra);
printf("Introduzca Nota de Arquitectura: ");
scanf ("%d", &alumno.nota.arquit);
acumMat = acumMat + alumno.nota.matema;
acumPro = acumPro + alumno.nota.progra;
acumArq = acumArq + alumno.nota.arquit;
}
promMat = (float) acumMat / 4;
promPro = (float) acumPro / 4;
promArq = (float) acumArq / 4;
printf ("La nota promedio de Matemticas es: %.1f \n", promMat);
printf ("La nota promedio de Programacin es: %.1f \n", promPro);
printf ("La nota promedio de Arquitectura es: %.1f \n", promArq);

printf ("Presione Enter, para salir...");

return;

getche();

ARREGLO DE ESTRUCTURAS
Un arreglo de estructuras es simplemente un arreglo cuyos elementos son estructuras.
Ejemplo:
struct registro {
char apellido[20];
int edad;
char sexo;
} alumnos[15];
El ejemplo anterior define un arreglo llamado alumnos de quince (15) elementos; donde cada
elemento es una estructura que contiene los miembros: apellido, edad y sexo. Es decir, un arreglo de
quince estructuras.

Acceder a un miembro del Arreglo de Estructuras:

Cada miembro del arreglo de estructuras puede ser accedido directamente colocando: el nombre
del arreglo; seguido por el ndice (o posicin) encerrado entre corchetes; un punto (.); seguido por el
nombre del miembro.
Ejemplo:
alumnos[2].edad = 19;
En el ejemplo anterior, se hace referencia al arreglo llamado alumnos en la posicin 2, es decir,
el segundo elemento del arreglo (que es una estructura) en el miembro edad, asignndole el valor 19.
Es decir, al miembro edad en la segunda posicin del arreglo alumnos se le asigna el valor 19.
Ejercicio N 16:
Leer Nombre, Nota y Sexo de 6 alumnos, en un arreglo de estructuras. Realice:
a) Calcular la cantidad de varones y de hembras.
b) Nombre del alumno con nota mayor.
#include <stdio.h>
#include <conio.h>
#define MAX 6
main()
{
struct tipo_alumno {
char nombre[20];
int nota;
char sexo;
} alumnos[MAX];
int i, contF=0, contM=0, mayor=0;
char nombreAux[20];
clrscr(); /* Limpia la pantalla */
for (i = 0; i < MAX; i++)
{
printf("Introduzca Nombre del alumno %d : ", i+1);
scanf ("%s", alumnos[i].nombre);
printf("Introduzca Nota del alumno %d : ", i+1);
scanf ("%d", &alumnos[i].nota);
printf("Introduzca Sexo (F/M) del alumno %d : ", i+1);
fflush (stdin);
scanf ("%c", &alumnos[i].sexo);
}
for (i = 0; i < MAX; i++)
{
if (alumnos[i].sexo == 'F' || alumnos[i].sexo == 'f')
contF = contF + 1;
else
contM = contM + 1;
if (alumnos[i].nota > mayor)
{
mayor = alumnos[i].nota;
strcpy (nombreAux, alumnos[i].nombre);
}
}
printf ("La cantidad de varones es: %d \n", contM);
printf ("La cantidad de hembras es: %d \n", contF);
printf ("El alumno con nota mayor es: %s \n", nombreAux);

printf ("Presione una tecla, para salir...");

return;

getche();

}
Ejercicio propuesto:
T08.- Leer Marca, Tipo (Auto o Camioneta) y Precio de 5 automviles, en un arreglo de estructuras.
Realice:
a) Calcular el Precio promedio de los Autos y de las Camionetas.
b) Marca del automvil ms econmico.
UNIONES
Las Uniones son similares a las estructuras. Tambin contienen miembros cuyos tipos de dato
pueden ser diferentes. En una Unin los miembros comparten el mismo espacio de memoria, es decir
slo un miembro se usa bajo una condicin.
Sintaxis:
union <nombre de la unin> {
<tipo> <miembro1>;
<tipo> <miembro2>;
...
<tipo> <miembroN>;
};
Ejemplo:
union tipo_ocupacion {
char empresa[20];
int
curso;
} ocupacion;
En el ejemplo anterior, se ha declarado una variable ocupacion tipo unin. Se podra utilizar
esta unin en una aplicacin de acuerdo a una condicin, si la persona trabaja se guarda el nombre de la
empresa, si estudia se guarda el curso. Se usa un solo miembro.
La razn principal para el uso de una Unin es ahorrar espacio en memoria.
Los miembros de una unin pueden ser de cualquier tipo de datos, arreglos o estructuras.
Al usar el operador punto (.) se hace referencia a cualquier miembro de la unin (como en las
estructuras).
Ejemplo:
ocupacion.empresa
TIPOS DE DATOS DEFINIDOS POR EL USUARIO
C permite a los usuarios definir sus propios tipos de datos. La sentencia typedef permite a los
usuarios definir nuevos tipos de datos que son equivalentes a los tipos de datos existentes.
Sintaxis:
typedef <tipo existente> <nuevo tipo>;
En donde, <tipo existente> se refiere a cualquier tipo de dato estndar (int, char, float)
u otros tipos de datos (arreglos, estructuras) definidos por el usuario previamente, que estn disponibles.
<nuevo tipo> es un nuevo nombre que se ha dado a un tipo de dato estndar o definido
previamente por el usuario.
Ejemplo:
typedef char caracter;
caracter letra;
caracter apellido[20];

/* definicin del tipo */

/* declaracin de variables */

En el ejemplo anterior, se ha definido el tipo caracter que es equivalente a char. La variable

letra est declarada de tipo caracter (equivalente a char). Tambin se declar la cadena apellido
(que es un arreglo de veinte elementos de tipo caracter.
Ejemplo:
typedef int entero;
entero num1, num2;
entero edades[10];

/* definicin del tipo */

/* declaracin de variables */

En el ejemplo anterior, se ha definido el tipo entero que es equivalente a int. Las variables
num1 y num2 estn declaradas de tipo entero (equivalente a int). Tambin se declar el arreglo
edades de diez elementos de tipo entero (equivalente a int).
Ejemplo:
typedef int tipoarreglo[10];
tipoarreglo edades;
En el ejemplo anterior, tambin se declar un arreglo edades de diez elementos de tipo entero
(equivalente a int). Es parecido al otro ejemplo.
Ejemplo con estructura:
typedef struct {
char nombre[30];
int
altura;
float peso;
} tipo_reg;
tipo_reg estudiante;
tipo_reg alumnos[8]

/* definicin del tipo estructura */

/* declaracin de variables */

En el ejemplo anterior, se ha definido el tipo estructura tipo_reg, y se declar la variable

estudiante (tipo estructura tipo_reg). Tambin se declar la variable alumnos que es un arreglo de
estructuras.
La ventaja de usar la sentencia typedef es que hace las declaraciones ms legibles. Adems,
no se necesita escribir struct repetidas veces cuando se referencia a una estructura.
MODULARIDAD
Una forma de enfocar la solucin a un problema es dividir ste en partes ms pequeas o
subproblemas, lo cual es un principio primordial en la solucin de problemas de programacin.
Frecuentemente un conjunto de instrucciones deben repetirse varias veces a lo largo de un
programa, lo cual implica que tenga que escribir este bloque tantas veces como sea necesario.
Al aplicar la filosofa de Divide y vencers, se reduce la complejidad global del problema,
disminuye el nmero de lneas de instruccin y el programa es ms claro. Este es el principio de la
Modularidad.
En C podemos utilizar las funciones para dividir un programa en partes ms pequeas.
FUNCIONES
Una funcin es un subprograma que contiene un conjunto de instrucciones que realizan una tarea
especfica. Un programa en C es realmente una coleccin de una o ms funciones. El main es, en
efecto, una funcin. Todos los programas en C deben tener una funcin main. La ejecucin de un
programa en C inicia con la ejecucin de la funcin main.
El lenguaje C soporta algunas funciones incorporadas (aquellas que son parte de la librera
estndar de C). Ejemplos de funciones incorporadas son: clrscr, printf, scanf, toupper, sqrt.
Las funciones definidas por el usuario son aquellas que son diseadas y escritas por el
programador para un uso especfico en las aplicaciones.
Una funcin toma cero o ms entradas (tambin denominadas parmetros o argumentos).

Ejemplo:
clrscr();
printf("Introduzca nota: ");

/* no toma entradas */
/* s utiliza un parmetro */

Una funcin retorna un solo valor (aunque algunas no retornan valor alguno).
Ejemplo:
clrscr();
/* no retorna valor */
raiz = sqrt(num);
/* s retorna valor */
Al ejecutarse las instrucciones de una funcin, sta define o genera un valor. Este valor que se
genera se dice que es: el valor de la funcin o el valor que retorna la funcin.
Este valor generado por la funcin debe ser de un tipo definido (ejemplo: int, char, float), por
lo tanto, la funcin debe ser declarada con ese tipo de dato.
En otras palabras, al llamar a una funcin (por su nombre), est retornar un valor que puede
ser asignado a una variable (del mismo tipo) o ser usado en una expresin (de ese tipo). Es decir, una
funcin puede ser asignada a una variable (del mismo tipo) o ser usada en una expresin (de ese tipo).
Una funcin tiene dos conceptos asociados:
A.- Declaracin de una Funcin.
B.- Llamada de una Funcin.
A.- Declaracin de una Funcin: Al declarar una funcin se debe definir el nombre de la funcin, los
parmetros (si los tiene) y el tipo de valor a retornar (que es el tipo de la funcin).
Estructura de una Funcin:
Una funcin en C tiene dos partes:
1. ENCABEZADO DE LA FUNCION
2. CUERPO DE LA FUNCION
1.- ENCABEZADO DE LA FUNCION: Constituye la identificacin de la funcin. Aqu se define: el tipo
del valor a ser retornado, el nombre de la funcin, el conjunto de entradas o parmetros (si los tiene)
separados por comas.
Sintaxis:
<tipo de dato> <nombre> (<tipo> arg1, <tipo> arg2, ...)
En donde, <tipo de dato> es el tipo del valor a retornar (llamado tambin el tipo de la funcin)
(ejemplo: int, float, char y otros). <nombre> es el nombre de la funcin que se est declarando;
luego, entre parntesis se especifica cada parmetro con su tipo, separados por comas.
Ejemplo:
int
calcular_suma (int n1, int n2)
Ejemplo:
float calcular_promedio (int x, int y, int z)
Ejemplo:
char leer_caracter ()
Si la funcin no retorna valor se indica el tipo de la funcin como void.
Ejemplo:

void

mostrar_datos (int edad, float sueldo, char, sexo)

Si se omite el tipo de dato de la funcin, C asume que es de tipo int por defecto. Sin embrago,
nunca se debe omitir, ya que no se considera un buen estilo de programacin.
2.- CUERPO DE LA FUNCION: Este bloque se encierra entre llave ({ }) y est compuesto por el conjunto
de declaraciones de variables locales y las instrucciones que ejecutar la funcin, al ser llamada.
Adems, una funcin debe tener la sentencia return seguido por el valor o expresin que ser
retornado. Si la funcin no retorna valor (funcin tipo void) no necesita la sentencia return, sin
embargo, es prudente escribir la sentencia return.

Ejemplo:

int calcular_suma (int n1, int n2)

{
int salida;
salida = n1 + n2;
return (salida);
}

/*encabezado de la funcin */

En el ejemplo anterior, en el cuerpo de la funcin (encerrado entre llaves) se ha declarado una

variable local con el nombre salida, la cual sirve para guardar el clculo realizado. La sentencia
return retornar el valor de la variable local salida. Observe que la variable salida debe ser del
mismo tipo que el tipo de la funcin (int).
Ejemplo:

int calcular_suma (int n1, int n2)

{
return (n1 + n2);
}

/*encabezado de la funcin */

El ejemplo anterior es similar al otro, pero ms directo.

B.- Llamada de una Funcin: Una funcin, previamente declarada, puede ser llamada (o invocada o
activada), con el nombre de la funcin (y sus parmetros, si los tiene) desde la funcin main o cualquier
otra funcin.
La llamada de una funcin consiste en ejecutar las instrucciones implcitas en esa funcin. Si la
funcin retorna un valor, puede ser asignado a una variable o ser utilizado directamente en una expresin
o funcin (en la llamada)
La llamada de una funcin se realiza escribiendo el nombre de la funcin y los parmetros entre
parntesis (si existen).
La declaracin de la funcin y la llamada deben tener el mismo nmero de parmetros, en el
mismo orden.
Ejemplo:
suma = calcular_suma(num1, num2);
Ejemplo:
printf ("La suma es: %d", calcular_suma(num1, num2));
Ejemplo:
promedio = calcular_suma(num1, num2) / 3;
Ejemplo:
printf ("El promedio es: %f", calcular_suma(num1, num2)/3);
-------- o -------Ejemplo:
int calcular_suma (int n1, int n2)
{
int salida;
salida = n1 + n2;
return (salida);
}
main()
{
int num1, num2, suma;
num1 = 3; num2 = 5;
suma = calcular_suma (num1, num2);
printf ("La suma es: %d", suma);
return;
}

/*llamada a la funcin*/

Conceptos:
Variables Globales: Son las variables declaradas fuera de cualquier funcin. Debido a la naturaleza de
su declaracin (global) pueden ser utilizadas en cualquier funcin definida que est escrita ms abajo de
la declaracin de estas variables. El valor de una variable global (extern) puede ser leda, comparada,
modificada y/o mostrada en cualquiera de estas funciones.

Variables Locales: Son las variables declaradas en una funcin. Debido a la naturaleza de su
declaracin (local) pueden ser utilizadas nicamente en la funcin donde fue declarada.
Las variables locales no son reconocidas en otra funcin distinta a aquella donde fue declarada.
Las variables locales son creadas al momento de llamar a la funcin (donde fue declarada). Al
terminar la ejecucin de la funcin (donde fue declarada) la variable local se pierde.
Ejercicio N 17:
Leer un nmero entero, calcular su mitad. Hacer el programa sin funciones y luego con funciones.
#include <stdio.h>
#include <conio.h>
void main()
{
int numero;
float mitad;
clrscr();

/* Limpia la pantalla */

printf("Introduzca un numero entero: ");

scanf ("%d", &numero);
mitad = (float) numero / 2;
printf ("La mitad de %d es: %.1f \n", numero, mitad);
printf ("Presione Enter, para salir...");
return;

getche();

}
Nota: Podemos crear tres funciones: lectura, calculo y mostrar.
#include <stdio.h>
#include <conio.h>
int lectura ()
/*declaracin de la funcin lectura*/
{
int num;
printf("Introduzca un numero entero: ");
scanf ("%d", &num);
return (num);
}
/*========================================================*/
float calculo (int n)
/*declaracin de la funcin calculo*/
{
float salida;
salida = (float) n / 2;
return (salida);
}
/*========================================================*/
void mostrar (int num, float mitad)
/*declaracin de funcin mostrar*/
{
printf ("La mitad de %d es: %.1f \n", num, mitad);
return;
}
/*========================================================*/
void main()
{
int numero;
float mitad;

clrscr(); /* Limpia la pantalla */

numero = lectura();
/*llamada a la funcin lectura*/
mitad = calculo(numero);
/*llamada a la funcin calcular*/
mostrar(numero, mitad);
/*llamada a la funcin mostrar*/
printf ("Presione Enter, para salir...");
return;

getche();

}
Ejercicio N 18:
Leer tres notas y calcular la nota promedio. Hacer el programa sin funciones y luego con funciones.
#include <stdio.h>
#include <conio.h>
void main()
{
int nota1, nota2, nota3;
float promedio;
clrscr(); /* Limpia la pantalla */
printf("Introduzca la primera nota: "); scanf ("%d", &nota1);
printf("Introduzca la segunda nota: "); scanf ("%d", &nota2);
printf("Introduzca la tercera nota: "); scanf ("%d", &nota3);
promedio = (float) (nota1 + nota2 + nota3) / 3;
printf ("La Nota promedio es: %.1f \n", promedio);

printf ("Presione Enter, para salir...");

return;

getche();

Nota: Podemos crear dos funciones: calcular y mostrar.

#include <stdio.h>
#include <conio.h>
float calcular (int n1, int n2, int n3)
/*declaracin de la funcin */
{
float prom;
prom = (float) (n1 + n2 + n3) / 3;
return (prom);
}
/*========================================================*/
void mostrar (float promed)
/*declaracin de la funcin */
{
printf ("La Nota promedio es: %.1f \n", promed);
return;
}
/*========================================================*/
void main()
{
int nota1, nota2, nota3;
float promedio;
clrscr(); /* Limpia la pantalla */
printf("Introduzca la primera nota: "); scanf ("%d", &nota1);
printf("Introduzca la segunda nota: "); scanf ("%d", &nota2);
printf("Introduzca la tercera nota: "); scanf ("%d", &nota3);

promedio = calcular(nota1, nota2, nota3);

/*llamada a funcin calcular*/

mostrar(promedio);

/*llamada a funcin mostrar*/

printf ("Presione Enter, para salir...");

return;

getche();

}
Ejercicio N 19:
Leer un nmero entero positivo e indique si es un nmero primo. Programar con funciones.
#include <stdio.h>
#include <conio.h>
#define VERDADERO 1
#define FALSO 0
int es_primo (int num)
{
int i, cont;
cont=0;
for (i=1; i<=num; i++)
if (num % i == 0)
cont++;

/* declaracin de la funcin es_primo */

/* si el residuo == 0 */

if (cont <= 2)
return (VERDADERO);
else
return (FALSO);
}
/*========================================================*/
void main()
{
int numero;
float mitad;
clrscr(); /* Limpia la pantalla */
printf("Introduzca un nmero entero positivo: ");
scanf ("%d", &numero);
if (es_primo(numero) == VERDADERO)
/*llamada a la funcin es_primo*/
printf ("El numero %d SI es primo \n", numero);
else
printf ("El numero %d NO es primo \n", numero);
printf ("Presione Enter, para salir...");
return;

getche();

}
Nota: En el ejercicio anterior, la funcin es_primo tiene dos sentencias return. Se puede escribir una
o ms sentencias return en una funcin. Adems, se hizo la llamada a la funcin en la expresin de la
instruccin selectiva if.
Prototipos de funciones
Hasta ahora todas las funciones definidas por el programador estn escritas antes de la funcin
main. El compilador necesita tener definidas las funciones hechas por el programador antes que la
funcin main. Esto se llama enfoque bottom-up (de abajo-hacia arriba) de solucin de problemas.

Existe otro enfoque para resolver problemas, denominado enfoque top-down (de arriba-hacia
abajo). En este mtodo, la funcin main aparece delante de todas las funciones definidas por el usuario.
Para que el compilador est informado de estas funciones, se utilizan los prototipos de funciones.
Los prototipos de funcin se especifican al comienzo de un programa en C, antes de la funcin
main, y corresponden a los encabezados de las funciones, finalizadas con punto y coma (;),
Ejemplo:
int funcion_1 (int a);
int funcion_2 (int b);
void main()
{
...
}
int funcion_1 (int a)
{
...
}
int funcion_2 (int b)
{
...
}

/*prototipo de funcion*/
/*prototipo de funcion*/

/*declaracin de funcion*/

/*declaracin de funcion*/

Ejercicio N 20:
Leer dos nmeros enteros. Calcular el mayor. Programar con funciones y sus prototipos.
#include <stdio.h>
#include <conio.h>
int el_mayor (int n1, int n2);
/* prototipo de la funcin el_mayor */
void mostrar (int may);
/* prototipo de la funcin mostrar */
/*========================================================*/
void main()
{
int num1, num2, mayor;
clrscr(); /* Limpia la pantalla */
printf("Introduzca el primer numero entero: ");
printf("Introduzca el segundo numero entero: ");
mayor = el_mayor (num1, num2);
mostrar(mayor);

scanf ("%d", &num1);

scanf ("%d", &num2);

/*llamada a la funcin el_mayor*/

/*llamada a la funcin mostrar*/

printf ("Presione Enter, para salir...");

return;

getche();

}
/*========================================================*/
int el_mayor (int n1, int n2)
/*declaracin de la funcin el_mayor*/
{
int mayor = 0;
if (n1 > n2)
mayor = n1;
else
mayor = n2;
return (mayor);

}
/*========================================================*/
void mostrar (int may)
/*declaracin de la funcin mostrar*/

{
printf ("El numero mayor es: %d \n", may);
return;
}
Clases de Almacenamiento
Al declarar una variable en C se especifica su tipo y el nombre (ejemplo: int num). Junto con el
tipo de dato se puede especificar una clase de almacenamiento en la definicin.
Las clases de almacenamiento se usan en C para definir la visibilidad (o alcance) y el tiempo de
vida de las variables. La clase de almacenamiento ayuda a entender cmo C trata las variables definidas
dentro y fuera de una funcin.
C tiene las siguientes clases de almacenamiento:
A.- automatic
B.- register
C.- static
D.- extern
A.- Clase de almacenamiento automatic: Todas las variables definidas dentro de una funcin,
llamadas variables locales, por defecto corresponden a la clase de almacenamiento automatic.
Ejemplo:
int funcion_x ()
{
int i;
...
}
En el ejemplo anterior, la variable i es una variable automatic. Opcionalmente, se puede usar
la palabra reservada auto al declarar una variable local (como: auto int i;).
Las variables automatic definidas dentro de una funcin, obtiene el espacio de memoria
asignado slo cuando se invoca la funcin. El compilador libera el espacio tan pronto como la funcin
retorna.
B.- Clase de almacenamiento register: La clase de almacenamiento register asigna memoria en
los registros de alta velocidad del CPU. El compilador asigna memoria en estos registros si estn
disponibles, sino trata estas variables como variables automatic.
Ejemplo:
int funcion_1 (register int a)
{
register int i;
...
}
Slo las variables locales (automatic) y los argumentos se pueden definir como variables
register.
C.- Clase de almacenamiento static: La clase de almacenamiento static le informa al compilador
que los valores almacenados en las variables estn disponibles entre llamadas a funciones. Es decir,
estas variables no pierden sus datos cuando la funcin retorna.
Por ejemplo, si dentro de una funcin se declara una variable static y se le asigna el valor 10,
el valor 10 se retiene cuando la funcin es llamada nuevamente. Cualquier cambio que se haga durante
una invocacin ser retenido durante la prxima invocacin.
Ejemplo:
int generar ()
{
static int cont = 0;
return ++cont;

}
Las variables definidas como static son inicializadas cuando la funcin se llama la primera vez.
Las llamadas subsecuentes a la funcin no inicializan la variable.
D.- Clase de almacenamiento extern: Las variables globales, cuya definicin est fuera de cualquier
funcin pertenecen a la clase de almacenamiento extern. Estas variables son visibles a travs del
programa, a partir del punto en que son definidas hasta el final del mbito establecido para ellas.
Cualquier cambio que se haga a estos valores afectan al resto del programa.
Ejemplo:
int k;
void func_a ()
{
...
}
Ejercicios propuestos:
T09.- Leer un nmero entero positivo. Calcular el Factorial (Ejemplo: 5! = 5 * 4 * 3 * 2 * 1 = 120).
T10.- Leer la hora de inicio (hora y minutos) y la hora final (hora y minutos) de la ejecucin de una tarea.
Calcular cuntas horas y minutos se tard esa tarea.
T11.- Leer un precio al detal y un precio al mayor de un artculo. Calcular el porcentaje de descuento.
T12.- Para practicar realice algunos ejercicios de la Gua 1 de Programacin en Lenguaje C, con
funciones.
T13.- Leer un nmero y calcular el cubo de ese nmero (n 3).
T14.- Leer el precio de un artculo. Calcular su Precio final, sabiendo que se ofrece un descuento de Bs.
2000 a los artculos con precio entre Bs. 5000 y Bs. 10000; y un descuento del 10% a los artculos cuyo
precio es mayor a Bs. 10000.
PUNTEROS
Un puntero es una variable en C que representa una direccin de un elemento de datos en la
memoria. Un puntero apunta a una direccin en la memoria donde un elemento de dato (int, float,
char, arreglo o estructura) se puede encontrar.
Operador &:
El operador & es el operador de referencia o direccin de.
Supongamos que se declara una variable num de tipo int, inicializada con el valor 5, y esta
variable se encuentra actualmente en la direccin de memoria: 43267.
Ejemplo:
int num = 5;
printf ("%d \n", num);
/*se imprime el contenido: 5*/
printf ("%u \n", &num);
/*se imprime la direccin: 43267*/
Se ha utilizado el especificador %u que significa un entero sin signo, ya que las direcciones son
siempre positivas.
Para que una variable contenga una direccin de memoria se debe declarar como variable
puntero de la siguiente manera:
<tipo de dato> *<variable puntero>;
El <tipo de dato> se refiere al tipo de dato de la variable a apuntar, y la <variable
puntero> es el nombre de la variable puntero que se est declarando.
Ejemplo:
int num = 5;
/*se declara num de tipo int con el valor: 5*/
int *direc;
/*se declara direc de tipo puntero a un int*/
direc = &num;
/*se asigna la direccin de num al puntero direc*/
printf ("%d \n", num);
/*se imprime el contenido de num: 5*/

printf ("%u \n", &num);

printf ("%u \n", direc);

/*se imprime la direccin de num: 43267*/

/*se imprime el contenido de direc: 43267*/

Operador *:
El operador * es el operador de indireccin o de desreferencia. El operador de indireccin
provee el contenido de la direccin a la que apunta. El siguiente ejemplo es continuacin del anterior.
Ejemplo:
printf ("%d \n", *direc); /*se imprime el contenido de la direccin*/
/*apuntada por direc (43267) que es: 5*/
Grficamente, se puede representar:
Nombre de la variable
Contenido

num

direc

43267

Direccin de memoria
43267
52134
Se puede inicializar una variable puntero en la misma declaracin, como en el siguiente ejemplo:
Ejemplo:
float monto = 3.5;
/*inicializa monto con: 3.5*/
float *apunt = &monto;
/*inicializa apunt con dir de monto: 22222*/
printf ("%.1f \n", monto); /*se imprime el contenido de monto: 3.5*/
printf ("%u \n", &monto);
/*se imprime la direccin de monto: 22222*/
printf ("%u \n", apunt);
/*se imprime el contenido de apunt: 22222*/
printf ("%.f \n", *apunt); /*se imprime el contenido de la direccin*/
/*apuntada por apunt (22222) que es: 3.5*/
Las direcciones de memoria en los ejemplos son inventadas, ya que estas son asignadas al
momento de la ejecucin del programa..
Uso de Punteros para pasar Parmetros a Funciones
Se usan punteros como argumento cuando se desea pasar un parmetro por referencia. Antes
de entrar en materia, revisemos algunos conceptos referentes a parmetros.
Parmetro: Los parmetros son identificadores que sirven de enlace entre una funcin y otra funcin que
la llama permitiendo el traspaso de informacin entre ambos.
Los parmetros sirven para enviar valores a una funcin.
Tipos de Parmetros:
1.- Parmetros Formales:
1.1.- Parmetros Formales por Valor.
1.2.- Parmetros Formales por Referencia (Variable).
2.- Parmetros Actuales.
1.- Parmetros Formales: Son los que se encuentran en el encabezado de una funcin encerrados entre
parntesis. Aqu se declaran los parmetros.
Ejemplo:
int calculo (<parmetros formales>)
Se debe especificar el tipo de dato de cada parmetro. Para separar los parmetros se usan
comas (,).
Los parmetro formales pueden ser de dos tipos: Parmetros Formales por Valor y Parmetros
Formales por Referencia (Variable).
1.1.- Parmetros Formales por Valor: Ellos se encuentran en el encabezado de una funcin. Son los
llamados parmetros de Entrada, porque introducen un valor a la funcin.

Estos parmetros reciben un valor enviado por la llamada de la funcin. No obstante, estos
parmetros no retornan un valor a la llamada de la funcin. Aunque el valor del parmetro por Valor sea
modificado dentro de la funcin, este valor no ser retornado a la llamada.
Cuando se pasa un parmetro por Valor a una funcin, se hace una copia del elemento de dato
dentro de la funcin. De manera que si se modifica este elemento de dato, es la copia dentro de la
funcin la que es modificada y no la usada en la llamada.
Ejemplo:
int calculo (int a, int b)
1.2.- Parmetros Formales por Referencia (Variable): Ellos se encuentran en el encabezado de la
funcin. Son los llamados parmetros de Salida, o de Entrada/Salida, porque pueden introducir un valor
a la funcin, pero su valor ser modificado en la funcin y es retornado a la llamada modificado.
Para pasar un parmetro por referencia a una funcin se debe enviar la direccin de la variable.
Es decir, en la llamada a la funcin se especifica como parmetro la direccin de la variable.
Ejemplo:
calcular (a, b, &x, &y);
/*llamada a la funcin*/
En el ejemplo anterior se invoca la funcin calcular y se enva como parmetro la direccin de
x y la direccin de y, con el operador &. Ambos, son pasados por Referencia y pueden ser modificados
en la funcin.
Veamos el siguiente ejemplo de encabezado de la funcin calcular:
Ejemplo:

void calcular (int a, int b, int *x, int *y)

En el ejemplo anterior, la funcin calcular tiene definidos los parmetros x e y como

parmetros por Referencia. Ambos contienen las direcciones enviadas en la llamada a la funcin. En
otras palabras, x e y son punteros ya que contienen direcciones de memoria. En el ejemplo, x e y
pueden ser modificados y enviados de vuelta a la llamada.
2.- Parmetros Actuales: Son los que se encuentran en las llamadas de las funciones.
parmetros son variables o direcciones de memoria (punteros) que se envan a la funcin.
Ejemplo:

Estos

calculos (n1, n2, &y);

Nota: El nmero de parmetros actuales debe de coincidir con el nmero de parmetros formales.
Nota: El orden de los parmetros, determina el orden de correspondencia entre los parmetros de la
funcin (Formales ) y los parmetros de la llamada (Actuales).
Es decir, el primer parmetro de la funcin siempre corresponder al primer parmetro de la
llamada; el segundo parmetro de la funcin corresponder al segundo parmetro de la llamada; y as
sucesivamente. Por lo tanto, el nmero de parmetros actuales debe de coincidir con el nmero de
parmetros formales.
Nota: El nombre de los parmetros formales de una funcin, no necesariamente deben ser los mismos
de los parmetro actuales en la llamada. Recuerde que la correspondencia entre ellos est determinada
por el orden en que se escriben, no por su nombre.
Nota: Cada parmetro Formal debe tener el mismo tipo de su parmetro Actual correspondiente.
Resumiendo, si se desea pasar un parmetro que no sea modificado en la funcin se enva
simplemente la variable o un valor (parmetro por Valor). En cambio, si se desea pasar un parmetro
que retorne modificado, entonces se debe enviar la direccin de la variable (parmetro por referencia).
Ejercicio N 21:
Leer dos nmeros enteros. Escriba una funcin que intercambie ambos valores.
#include <stdio.h>
#include <conio.h>
void intercambiar (int *x, int *y);
/* prototipo de la funcin */
/*========================================================*/
void main()
{

int num1, num2;

clrscr(); /* Limpia la pantalla */
printf("Introduzca el primer numero entero: ");
printf("Introduzca el segundo numero entero: ");

scanf ("%d", &num1);

scanf ("%d", &num2);

printf ("El primer numero es: %d y el segundo es: %d \n", num1, num2);
printf ("Al intercambiarlos... \n");
intercambiar (&num1, &num2);
/* llamada a la funcin */
printf ("El primer numero es: %d y el segundo es: %d \n", num1, num2);
printf ("Presione Enter, para salir...");
return;

getche();

}
/*========================================================*/
void intercambiar (int *x, int *y)
/*declaracin de la funcin*/
{
int temp;
temp = *x;
*x = *y;
*y = temp;
return;

/* el contenido de x se mueve a temp */

/* el contenido de y se mueve a x */
/* el contenido de temp se mueve a y */

}
Nota: Dentro de una funcin los parmetros por referencia se deben utilizar precedidos por el operador *.
Ejercicio N 22:
Leer un nmero entero. Escriba una funcin que calcule el cubo y la mitad del nmero ledo.
#include <stdio.h>
#include <conio.h>
void calcular (int num, int *cubo, float *mitad);
/* prototipo funcin */
/*========================================================*/
void main()
{
int numero, cubo;
float mitad;
clrscr(); /* Limpia la pantalla */
printf("Introduzca un numero entero: ");

scanf ("%d", &numero);

calcular (numero, &cubo, &mitad);

/* llamada a la funcin */
printf ("El cubo del numero %d es: %d \n", numero, cubo);
printf ("La mitad del numero %d es: %.2f \n", numero, mitad);
printf ("Presione Enter, para salir...");
return;

getche();

}
/*========================================================*/
void calcular (int num, int *cubo, float *mitad)
/* declara funcin */
{
*cubo = num * num * num;
*mitad = (float) num / 2;
return;

Cabe destacar, que cuando se utiliza la funcin scanf las variables a leer (de tipo int, float y
char) deben estar precedidas por el operador &. Esto se debe a que son parmetros por referencia y se
debe enviar su direccin. Sin embargo, cuando se leen cadenas (string) no se antepone el operador &.
Ejemplo:
char nombre[20];
int edad;
scanf ("%s", nombre);
/*lee una cadena (arreglo de char) sin &*/
scanf ("%d", &edad);
/*lee un entero (int)*/
Una cadena es un arreglo de char. Una variable de tipo arreglo es un apuntador que contiene la
direccin del primer elemento en el arreglo (es un puntero). Pero, cuando usamos el nombre del arreglo
seguido de una posicin (entre corchetes) hacemos referencia a un contenido (no una direccin).
A continuacin se explica la forma de pasar un arreglo como parmetro.
Arreglos como Parmetros a Funciones
El punto importante a notar aqu es que en C los arreglos se pasan a las funciones slo como
referencias. El nombre del arreglo contiene la direccin base, la cual es la direccin del primer elemento
del arreglo. Esta direccin base se pasa a la funcin. De manera que cualquier modificacin que se
haga en la funcin a un arreglo se refleja en la funcin que la invoc.
Pasar Arreglos como Parmetro:
Ya sabemos que para pasar un parmetro por referencia a una funcin se debe enviar la
direccin de la variable. En el caso de los arreglos, el nombre de la variable tipo arreglo contiene o
apunta al primer elemento del arreglo.
En la llamada a la funcin se especifica como parmetro el nombre del arreglo (su direccin).
Ejemplo:
calculos (cadena);
/*llamada a la funcin*/
En el ejemplo anterior se invoca la funcin calculos y se enva como parmetro el arreglo de
nombre cadena. No se requiere anteponer el operador &.
Veamos los siguientes ejemplos de encabezado para la funcin calculos:
Ejemplo:
int calculos (char *palabra)
Ejemplo:
int calculos (char palabra[])
Ejemplo:
int calculos (char palabra[MAX])
En los ejemplos anteriores, la funcin calculos tiene definido palabra como parmetro por
Referencia. Se puede anteponer *, o colocar los corchetes ([]) especificando o no el tamao.
Ejercicio N 23:
Leer dos cadenas (string). Escriba una funcin que intercambie ambas cadenas.
#include <stdio.h>
#include <conio.h>
#include <string.h>
void intercambiar (char *tira1, char *tira2);
/* prototipo de funcin */
/*========================================================*/
void main()
{
char cadena1[20], cadena2[20];
clrscr(); /* Limpia la pantalla */
printf ("Introduzca primer String: "); scanf("%s", cadena1);
printf ("Introduzca segundo String: "); scanf("%s", cadena2);
printf ("Primera cadena: %s - Segunda cadena: %s \n", cadena1, cadena2);
printf ("Al intercambiarlos... \n");
intercambiar (cadena1, cadena2);
/* llamada a la funcin */
printf ("Primera cadena: %s - Segunda cadena: %s \n", cadena1, cadena2);
printf ("Pulse una tecla para salir...");

getche();

return;
}
/*========================================================*/
void intercambiar (char *tira1, char *tira2)
/*declaracion de funcin*/
{
char temp[20];
strcpy (temp, tira1);
strcpy (tira1, tira2);
strcpy (tira2, temp);
return;

/* intercambiar tira1 y tira2 */

}
Nota: Observe que dentro de la funcin intercambiar, tira1 y tira2 no estn precedidos de *.
Ejercicio N 24:
Leer 5 enteros en un arreglo A. Escriba una funcin que retorne otro arreglo B con los elementos del
arreglo A invertidos.
#include <stdio.h>
#include <conio.h>
#define MAX 5
void lectura (int *arreglo);
/*prototipo de funcin*/
void invertir (const int *arregA, int *arregB);
/*prototipo de funcin*/
void mostrar (const int *arreglo);
/*prototipo de funcin*/
/*========================================================*/
void main()
{
int A[MAX], B[MAX];
clrscr(); /* Limpia la pantalla */
lectura (A);
printf ("El arreglo originales: \n");
mostrar (A);
invertir (A, B);
printf ("El arreglo invertido es: \n");
mostrar (B);

/* llamada a la funcin */
/* llamada a la funcin */
/* llamada a la funcin */

printf ("Pulse una tecla para salir...");

return;

/* llamada a la funcin */
getche();

}
/*========================================================*/
void lectura (int *arreglo)
/*declaracin de funcin*/
{
int i;
for (i = 0; i <= (MAX-1); i++)
{
printf ("Introduzca un numero entero: ");
scanf ("%d", &arreglo[i]);
}
return;
}
/*========================================================*/
void invertir (const int *arregA, int *arregB)
/*declaracin de funcin*/
{
int i, j;
j = MAX-1;
for (i=0; i<=MAX; i++)
{
arregB[i] = arregA[j];

j--;
}
return;
}
/*========================================================*/
void mostrar (const int *arreglo)
/*declaracin de funcin*/
{
int i;
for (i = 0; i <= (MAX-1); i++)
printf ("%d ", arreglo[i]);
printf ("\n");
return;
}
Nota: Dentro de la funcin lectura se utiliza el operador & cuando se lee con scanf. Esto se debe a
que se est leyendo un elemento (int) del arreglo.
Nota: Si se desea que la direccin del arreglo no sea modificada cuando se pasa como parmetro, se
utiliza la palabra reservada const para indicar que el puntero se declara como una constante. Esto se
aplica tambin a las estructuras que se pasan como parmetros.
Ejercicio N 25:
Leer enteros en una Matriz de 2x3. Escriba una funcin que aumente en dos (sume dos) a cada
elemento de la matriz.
#include <stdio.h>
#include <stdio.h>
#include <conio.h>
#define MAXF 2
#define MAXC 3
/*========================================================*/
void lectura (int matriz[MAXF][MAXC])
/*declaracin de funcin*/
{
int i,j;
for (i = 0; i < MAXF; i++)
for (j = 0; j < MAXC; j++)
{
printf ("Introduzca un numero entero: ");
scanf ("%d", &matriz[i][j]);
}
return;

}
/*========================================================*/
void aumentar (int matriz[MAXF][MAXC])
/*declaracin de funcin*/
{
int i,j;
for (i = 0; i < MAXF; i++)
for (j = 0; j < MAXC; j++)
matriz[i][j] = matriz[i][j] + 2;
return;

}
/*========================================================*/
void mostrar (const int matriz[MAXF][MAXC])
/*declaracin de funcin*/
{
int i,j;
for (i = 0; i < MAXF; i++)
{
for (j = 0; j < MAXC; j++)

printf ("%d ", matriz[i][j]);

printf ("\n");

}
return;

}
/*========================================================*/
void main()
{
int matriz[MAXF][MAXC];
clrscr(); /* Limpia la pantalla */
lectura (matriz);

/* llamada a la funcin */

printf ("El arreglo original es: \n");

mostrar (matriz);
/* llamada a la funcin */
aumentar (matriz);
printf ("El arreglo mas 2 es: \n");
mostrar (matriz);

/* llamada a la funcin */
/* llamada a la funcin */

printf ("Pulse una tecla para salir...");

return;

getche();

}
Nota: Un arreglo bidimensional (matriz) se pasa como parmetro por referencia especificando, en el
encabezado de la funcin, el tamao de la matriz (ejemplo: int matriz[MAXF][MAXC]).
Ejercicio N 26:
Leer cinco apellidos (en minscula) en un arreglo. Escriba una funcin que convierta a mayscula los
apellidos del arreglo. Este es un arreglo de string o arreglo bidimensional de char.
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#define MAX 5
#define VEINTE 20
/*========================================================*/
void lectura (char apellidos[MAX][VEINTE])
/*declaracin de funcin*/
{
int i;
for (i = 0; i < MAX; i++)
{
printf ("Introduzca un apellido: ");
}
return;

scanf ("%s", apellidos[i]);

}
/*========================================================*/
void mayuscula (char apellidos[MAX][VEINTE])
/*declaracin de funcin*/
{
int i,j, longitud;
for (i = 0; i < MAX; i++)
{
longitud = strlen(apellidos[i]);
for (j=0; j<longitud; j++)
apellidos[i][j] = toupper(apellidos[i][j]);
}
return;
}
/*========================================================*/

void mostrar (const char apellidos[MAX][VEINTE]) /*declaracin de funcin*/

{
int i;
for (i = 0; i < MAX; i++)
printf ("%s \n", apellidos[i]);
return;
}
/*========================================================*/
void main()
{
char apellidos[MAX][VEINTE];
clrscr(); /* Limpia la pantalla */
lectura (apellidos);

/* llamada a la funcin */

printf ("El arreglo original es: \n");

mostrar (apellidos);

/* llamada a la funcin */

mayuscula (apellidos);
printf ("El arreglo en mayscula: \n");
mostrar (apellidos);

/* llamada a la funcin */

printf ("Pulse una tecla para salir...");

return;

/* llamada a la funcin */
getche();

}
/*========================================================*/
Puntero a Estructura
Se puede tambin tener punteros apuntando a estructuras. El siguiente ejemplo muestra como
declarar un puntero a estructura y acceder los miembros de la estructura con el operador ->.
Ejemplo:
struct tipo_alum {
char nombre[20];
int
edad;
float peso;
};

/*declara la estructura tipo_alum*/

struct tipo_alum alumno = {"Nancy", 18, 63.5}; /*inicializa alumno*/

struct tipo_alum *apunt;
/*declara apunt tipo puntero*/
apunt = &alumno;

/*asigna la direccin de alumno a apunt*/

printf ("%s \n",

alumno.nombre);
printf ("%d \n",
alumno.edad);
printf ("%.2f \n", alumno.peso);

/* imprime: Nancy */
/* imprime: 18
*/
/* imprime: 63.50 */

printf ("%s \n",

apunt->nombre);
printf ("%d \n",
apunt->edad);
printf ("%.2f \n", apunt->peso);

/* imprime: Nancy */
/* imprime: 18
*/
/* imprime: 63.50 */

El siguiente es otro ejemplo de declaracin de puntero, usando la sentencia typedef para

declarar la estructura:
Ejemplo:
typedef struct {
char nombre[20];
int
edad;
float peso;
} tipo_alum;
/*declara el tipo estructura: tipo_alum*/
tipo_alum alumno = {"Nancy", 18, 63.5};

/*inicializa alumno*/

tipo_alum *apunt;
apunt = &alumno;

/*declara apunt tipo puntero*/

/*asigna la direccin de alumno a apunt*/

printf ("%s \n",

alumno.nombre);
printf ("%d \n",
alumno.edad);
printf ("%.2f \n", alumno.peso);

/* imprime: Nancy */
/* imprime: 18
*/
/* imprime: 63.50 */

printf ("%s \n",

apunt->nombre);
printf ("%d \n",
apunt->edad);
printf ("%.2f \n", apunt->peso);

/* imprime: Nancy */
/* imprime: 18
*/
/* imprime: 63.50 */

Estructuras como Parmetros a Funciones

Podemos pasar una estructura como parmetro por valor o por referencia a una funcin. Si se
desea pasar la estructura por referencia (para modificar su contenido) se debe enviar la direccin de la
variable (estructura). Es decir, en la llamada a la funcin se especifica como parmetro la direccin de la
variable.
Ejemplo:
lectura (&reg);
/*llamada a la funcin*/
En el ejemplo anterior se invoca la funcin lectura y se enva como parmetro la direccin de
reg con el operador &. La estructura reg es pasada por Referencia y puede ser modificada en la funcin.
Veamos el siguiente ejemplo de encabezado de la funcin lectura:
Ejemplo:

void lectura (tipo_reg *reg)

En el ejemplo anterior, la funcin lectura tiene definido el parmetro reg como parmetro por
Referencia. Este contiene la direccin enviada en la llamada a la funcin. En otras palabras, reg es un
puntero ya que contiene una direccin de memoria.
Cuando se utiliza una funcin con una estructura como parmetro por referencia, se tiene un
puntero apuntando a una estructura. Dentro de la funcin, para acceder a los miembros de una
estructura se debe usar el operador ->, en lugar del punto (.).
Ejemplo:
printf ("%s \n", reg->nombre);
Ejercicio N 27:
Declare una estructura llamada reg con los miembros: nombre, edad y sexo. Escriba una funcin
inicializar que retorne los datos: Tamara, 18, F. Escriba una funcin de lectura pasando la estructura
como parmetro por referencia (su direccin). Muestre los datos inicializados y los ledos.
#include <stdio.h>
#include <conio.h>
typedef struct registro {
char nombre[20];
int edad;
char sexo;
} tipo_reg;

/*definicin de estructura*/

/*========================================================*/
tipo_reg inicializar ()
/*declaracin de funcin*/
{
tipo_reg regis;
strcpy (regis.nombre, "Tamara");
regis.edad = 18;
regis.sexo = 'F';
return (regis);
}
/*========================================================*/
void lectura (tipo_reg *reg)
/*declaracin de funcin*/

{
printf("Introduzca Nombre del empleado: "); scanf ("%s", reg->nombre);
printf("Introduzca edad del empleado: ");
scanf ("%d", &reg->edad);
printf("Introduzca sexo [F/M] del empleado: "); reg->sexo = getche();
printf("\n");
return;

}
/*========================================================*/
void mostrar (tipo_reg reg)
/*declaracin de funcin*/
{
printf("Nombre del empleado: %s \n", reg.nombre);
printf("Edad del empleado: %d \n", reg.edad);
printf("Sexo del empleado: %c \n", reg.sexo);
return;
}
/*========================================================*/
void main()
{
tipo_reg reg;
/*declaracin de variable estructura*/
clrscr(); /* Limpia la pantalla */
reg = inicializar();
mostrar (reg);

/* llamada a la funcin */
/* llamada a la funcin */

lectura (&reg);
mostrar (reg);

/* llamada a la funcin */
/* llamada a la funcin */

printf ("Presione Enter, para salir...");

return;

getche();

}
/*========================================================*/
Nota: La funcin inicializar retorna el registro inicializado. La funcin lectura pasa la estructura
como parmetro por referencia (un apuntador). La funcin mostrar pasa la estructura por valor.
Arreglo de Estructuras como Parmetro a Funciones
Podemos pasar un arreglo de estructuras como parmetro solo por referencia a una funcin. De
la misma forma en que se pasan los arreglos a una funcin.
Cuando se invoca la funcin se enva como parmetro el arreglo (sin anteponer el operador &).
Ejemplo:
lectura (arreglo);
El encabezado de la funcin debe especificar el arreglo como parmetro por referencia. Se
puede anteponer *, o colocar los corchetes ([]) especificando o no el tamao.
Ejemplo:
Ejemplo:
Ejemplo:

void lectura (tipo_struct

void lectura (tipo_struct
void lectura (tipo_struct

*arreglo)
arreglo[])
arreglo[MAX])

Ejercicio N 28:
Declare un arreglo de tres elementos tipo estructura cuyos miembros son: apellido, edad y sexo. Escriba
una funcin de lectura y una funcin para mostrar los datos.
#include <stdio.h>
#include <conio.h>
#define MAX 3
typedef struct registro {
char apellido[20];

/*definicin de estructura*/

int edad;
char sexo;
} tipo_persona;
/*========================================================*/
void lectura (tipo_persona persona[MAX])
/*declaracin de funcin*/
{
int i;
for (i=0; i<MAX; i++)
{
printf("Introduzca Apellido: "); scanf ("%s", persona[i].apellido);
printf("Introduzca edad
: "); scanf ("%d", &persona[i].edad);
printf("Introduzca Sexo F/M: "); persona[i].sexo = getche();
printf("\n");
}
return;
}
/*========================================================*/
void mostrar (tipo_persona *persona)
/*declaracin de funcin*/
{
int i;
for (i=0; i<MAX; i++)
{
printf("Apellido del empleado: %s \n", persona[i].apellido);
printf("Edad del empleado
: %d \n", persona[i].edad);
printf("Sexo del empleado
: %c \n", persona[i].sexo);
}
return;

}
/*========================================================*/
void main()
{
tipo_persona persona[MAX];
/*declaracin de variable estructura*/
clrscr(); /* Limpia la pantalla */
lectura (persona);
mostrar (persona);
printf ("Presione Enter, para salir...");
return;

/* llamada a la funcin */
/* llamada a la funcin */
getche();

}
/*========================================================*/
Nota: La funcin lectura declara el arreglo persona como parmetro con los corchetes
(persona[MAX]). La funcin mostrar declara el arreglo persona como parmetro anteponiendo *
(*persona). Se puede usar cualquiera de las dos formas para pasar como parmetro por referencia.
Puntero a Funcin
Una funcin en C no es una variable. Sin embargo, se trata como tal. Es posible definir punteros
a a una funcin la cual puede ser colocada en arreglos, pasada a funciones y retornar de las funciones.
El uso tpico de un puntero a una funcin radica en el hecho que una funcin misma puede ser
pasada como parmetro a otra funcin.
A continuacin se muestra un ejemplo de declaracin y uso de un puntero a funcin:
Ejemplo:
int cuadrado (int x)
/*declaracin de la funcin cuadrado*/
{
return (x * x);
}

...
int num=5, cuad=0;
int (*fptero)(int);

/*definicin de dos variables: num y cuad*/

/*declaracin de fptero (puntero a funcin)*/

fptero = cuadrado;

/*asignar una funcin al puntero fptero */

cuad = cuadrado(num);
cuad = fptero(num);

/*llamada a la funcin cuadrado*/

/*llamada a la funcin cuadrado a travs
del puntero fptero)*/
-------- o --------

Ejercicio N 29:
Leer un nmero entero. Escriba una funcin que calcule el cuadrado. Haga la llamada a la funcin por
su nombre y luego por un puntero a funcin. Debe crear un puntero a funcin.
#include <stdio.h>
#include <conio.h>
int
{

cuadrado (int x)

return (x * x);
}
/*========================================================*/
void main()
{
int num, cuad;
int (*fptero)(int);
/*declaracin de fptero (puntero a funcin)*/
clrscr(); /* Limpia la pantalla */
printf ("Introduzca un numero entero:");
fptero = cuadrado;

scanf ("%d", &num);

/*asignar funcin cuadrado al puntero fptero*/

cuad = cuadrado(num);
printf ("numero:%d \n", num);
printf ("cuadrado:%d \n", cuad);

/*llamada a funcin cuadrado*/

cuad = fptero(num);
printf ("numero:%d \n", num);
printf ("cuadrado:%d \n", cuad);

/*llamada a funcin por el puntero*/

printf ("Pulse una tecla para salir...");

return;

getche();

}
Ejercicio N 30:
Se tiene una funcin llamada cuadrado que recibe un entero (int) y retorna su cuadrado. Adems hay
otra funcin generarTabla que crea una tabla de dos columnas, la primera con los nmeros del 1 al 10,
y la segunda con los valores asociados (cuadrado). La funcin generarTabla recibir la funcin
(cuadrada) a ser llamada, como un parmetro.
#include <stdio.h>
#include <conio.h>
void generarTabla (int (*fptro)(int));
/*prototipo de funcin*/
int cuadrado (int x);
/*prototipo de funcin*/
/*========================================================*/
void main()
{
clrscr(); /* Limpia la pantalla */
generarTabla (cuadrado);
/* llamada a la funcin */

printf ("Pulse una tecla para salir...");

return;

getche();

}
/*========================================================*/
void generarTabla (int (*fptro)(int))
/*declaracin de funcin*/
{
int i;
for (i = 1; i <= 10; i++)
{
printf ("numero:%d \t cuadrado:%d \n", i, (*fptro)(i));
}
return;
}
/*========================================================*/
int cuadrado (int x)
/*declaracin de funcin*/
{
int cuad = 0;
cuad = x * x;
return (cuad);
}