Overblog Seguir este blog
Administration Create my blog
17 mayo 2010 1 17 /05 /mayo /2010 23:55

Instalación de la librería

  1. Descomprime el archivo en cualquier directorio y verás que aparece el fichero conio-2.0-1mol.DevPak, le das doble click y se te presenta una pantalla como la siguiente:
  2. c1.png

  3. Le das click al botón Install y empezará el proceso de instalación

    Una vez terminada la instalación se presentan la siguiente pantalla indicandonos que le proceso ha sido exitoso. Click en Finish y terminamos esta parte.

 

c2.png


Configuración de la librería

1. Ahora vamos a configurar la librería para poder usarla, para ello abre el compilador y ve a Herramientas -> Opciones del compilador, en la ficha Compilador activa la casilla Añadir estos comandos a la línea de comandos del linker y el cuadro que está debajo escribe -lconio (Ojo: la primera letra es: ele), puedes fijarte en la siguiente pantalla:



Una vez hecho esto pulsa el botón Aceptar para guardar los cambios

c3.png

 

Prueba de la librería

  1. Abre el compilador, vas a Archivo -> Nuevo -> Proyecto y en la pestaña Basic seleccionas Console Application y das click en Aceptar:

    c4.png



  2. Selecciona en donde quieres guardar el archivo del proyecto y se te presentará a continuación un código de ejemplo. Reemplaza todo el código escrito por el siguiente:

#include <stdio.h>
#include <conio2.h>

int main()
{
     clrscr();
     gotoxy(20,40);
     printf("Hola, esto es un mensaja de prueba");
     getch();
     return 0;
}

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
17 mayo 2010 1 17 /05 /mayo /2010 23:47

Buenas.

 

Se presenta Link para descargar libreria conio 2.0, a fin de utilizarla para emplear funciones manejables por ella.

 

http://www.filestube.com/32739d215693f27b03ea,g/conio-2-0-1mol-DevPak.html

Repost 0
Published by Prof.Luis Eduardo Aponte
Comenta este artículo
15 mayo 2010 6 15 /05 /mayo /2010 16:23

Para el Desarrollo del Proyecto se deben seguir las siguientes pautas:

 

1. Formar equipo de 04 o 05 personas.

2. Ubicar Problematica Real.

3. Para programar y dar solucion a tal problematica se debe considerar las siguientes herramientas de programacion:

a) Estructuras de Decision ( para generar contraseña y crear menu de opciones)

b) Estructuras Repetitivas.

c) Estructuras de Registros.

d) Estructuras de Datos (Arreglos Unidimensionales y Bidimensionales).

e)Direccionamiento de los elementos en pantalla (Uso de Gotoxy)

f)Archivos

 

Observaciones.

 

1.El programa debe comenzar con la solicitud de una contraseña para iniciar las opciones del menu del programa.

2. Se debe procurar tener las opciones de registro de datos, busquedas varias y eliminacion de los mismos.

3. Debe ser una problematica compleja y original.

4. El dia de la Exposicion del Proyecto se evaluaran los siguientes aspectos:

 

-Exposicion Individual (Dominio del tema, Uso de Recurso)

-Informe Descriptivo (Incluye las Fases )  y Codigo Fuente del Programa

-Publicidad

-Logistica

 

Ponderacion 30%

Repost 0
Published by Prof.Luis Eduardo Aponte
Comenta este artículo
29 marzo 2010 1 29 /03 /marzo /2010 15:48
Buenos Dias. Saludos.

Les presento el link de lapagina para que descarguen el software para realizar y validar los Diagramas de Flujo de los ploblemas planteados.

http://dfd.programas-gratis.net/

Estamos en Contacto.

Prof. & Lic. Luis E. Aponte I.



Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
5 febrero 2010 5 05 /02 /febrero /2010 02:54

Arrays de Estructuras

Los ejemplos de estructuras que hemos visto hasta el momento, sólo podemos manejar un conjunto de datos a la vez, o podemos declarar varias variables para manejar, por ejemplo, los datos de 5 alumnos de una institución.

Sin embargo, al igual que los tipos int, float... en c, podemos crear arrays con estructuras.

Por ejemplo, supongamos que ya tenemos declarada una estructura llamada datos, que contiene los datos personales de alumnos de cierta institución, y queremos guardar los datos de 100 alumnos, no necesitamos de crear 100 variables de tipo estructura, sino que hacemos esta declaratoria:

struct datos alumnos[100];

 

Ejemplo 3.

Una biblioteca, desea tener un registro de los libros que en ella se encuentran, se sabe que existe un número no mayor a 100 libros, y que los datos que se necesitan registrar son: el nombre del autor, el título del libro y las existencias del mismo. Diseñe una estructura que sea capaz de guardar esa información y luego mandarla a impresión.

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#define N 100

struct info_libro

{

    char autor[20];

    char titulo[30];

    int num_ejemplares;

};

main()

{

   struct info_libro libro[N];

   int i=0;

   clrscr();

   printf("\t\tPROGRAMA QUE CONTROLA UN INVENTARIO DE LIBROS\n\n\n");

 

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

   {

            printf("Ingrese los datos del libro %d\n",i);

      printf("Nombre del autor: ");

      scanf("%s", &libro[i].autor);

      printf("El titulo del libro es: ");

      scanf("%s", &libro[i].titulo);

      printf("Las existencias de este libro son:\n");

      scanf("%d", &libro[i].num_ejemplares);

   }

   clrscr();

   printf("\t\t\tLOS DATOS SON LOS SIGUIENTES:\n\n\n");

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

   {

      printf("********************************************\n");

      printf("Autor: %s\n", libro[i].autor);

      printf("Titulo: %s\n", libro[i].titulo);

      printf("Existencias: %d\n", libro[i].num_ejemplares);

   }

   getch();

   return 0;

 

}

 

Lo más resaltante que, debo rescatar es que, a diferencia de los vectores y las matrices, las estructuras no identifican su primer elemento con cero, sino con el número uno, es por ello que nuestro contador, inicia con ese número, además que, para diferenciar un registro por otro, debemos incluir siempre el subíndice, [i].

Estructuras y Funciones

Cuando hacemos uso de funciones y de estructuras, debemos tener en cuenta la forma correcta, de cómo enviarle a la función el parámetro deseado, y con las estructuras, no es la excepción, por ejemplo:

 

/*declaración de la estructura*/

struct info_libro

{

    char autor[20];

    char titulo[30];

    int num_ejemplares;

};

 

/*declaración de las funciones */

void impresión (struct info_libro *ptr);

void impresión1 (struct info_libro p);

 

/*definición de la estructura*/

struct info_libro libros;

 

/*llamado de la funcion: envío por referencia*/

impresión(&libros);

 

/*¨llamado de la función: envío por valor*/

impresión (libros);

 

Uso del typedef

Un operador typedef permite al programador crear un sinónimo de tipo definido por el usuario o de un tipo ya exitente. La sintaxis es la siguiente:

 

typedef tipo_de_dato nuevotipodedato;

 

A partir de la declaración hecha por el typedef se puede hacer uso del nuevo sinónimo del tipo de dato para definir variables, en general donde se utilizan los tipos de datos.

Veamos un ejemplo donde matemos dos pájaros de un solo tiro, es decir donde se muestren el uso de funciones y el typedef.

Ejemplo 4.

Un médico almacena la siguiente información de sus paciente en un array de registros (como mucho habrá 100 pacientes): Nombre, teléfono, dirección, y si tiene alergias. Escribir un programa con las siguientes opciones (todas ellas diben realizarse con funciones):

a) Introducir los datos interactivamente. Para saber que ya no se van a introducir más pacientes, el usuario introducirá un 0 al solicitarle el número de teléfono del paciente.

b) Imprimir por pantalla toda la información.

c) Listar todos los pacientes con alergias.
d) Crear una lista con el índice de todos los pacientes que sean de la Comunidad de Madrid (su teléfono comienza por el prefijo 91).
e) Salir.

 #include <stdlib.h>  
 #include <conio.h>  
 #include <stdio.h>  
 #include <string.h>  
   
 #define TAM_NOM 31  
 #define TAM_DIR 41  
 #define TAM_ALE 71  
 #define TAM_PAC 100  
   
 typedef struct { 
  char nombre[TAM_NOM]; 
  double telefono; 
  char direccion[TAM_DIR]; 
  char alergias[TAM_ALE]; 
 } reg_paciente; 
   
 void tecla(); 
 char menu(); 
 void leerdatos(reg_paciente *pacientes, int *tamano); 
 void hayalergias(reg_paciente *pacientes, int tamano); 
 void imprimirtodos(reg_paciente *pacientes, int tamano); 
 void telefono91(reg_paciente *pacientes, int tamano); 
   
 void main() 
 { 
  char opcion; 
  int tamano; 
  reg_paciente pacientes[TAM_PAC]; 
   
  system("color f0"); 
  printf("\n\n\n\n\n\n\n\n\n\t\t\tINICIO DEL PROGRAMA\n\n\n\n\n\n\n\n"); 
  tecla(); 
  leerdatos(pacientes,&tamano); 
  do { 
  opcion=menu(); 
  switch(opcion) { 
  case '1':  
  imprimirtodos(pacientes,tamano); 
  break; 
  case '2':  
  hayalergias(pacientes,tamano); 
  break; 
  case '3':  
  telefono91(pacientes,tamano); 
  break; 
  case '4':  
  leerdatos(pacientes,&tamano); 
  break; 
  case '0': 
  printf("\nSaliendo..."); 
  break; 
  } 
  tecla(); 
  } while (opcion!='0'); 
  printf("\n\n\n\n\n\n\n\t\t\tFIN DEL PROGRAMA\n\n\n\n\n\n\n"); 
  tecla(); 
 } 
   
 void tecla() 
 { 
  printf("\nPresiona cualquier tecla para continuar "); 
  getch(); 
  clrscr(); 
  return; 
 } 
   
 void leerdatos(reg_paciente *pacientes, int *tamano) 
 { 
  char buffer[15]; 
  int i; 
   
  for (i=0;i<TAM_PAC;i++) { 
  printf("\n\n\n****PACIENTE NUMERO %2d****",i+1); 
  printf("\nIntroduzca el nombre (no m…s de %d caracteres)\n\t",TAM_NOM-1); 
  do { 
  gets(pacientes[i].nombre); 
  } while (strlen(pacientes[i].nombre)==0); 
  printf("\nIntroduzca su tel‚fono (o 0 o cualquier letra para no introducir m…s datos)\n\t"); 
  do { 
  gets(buffer); 
  } while (strlen(buffer)==0); 
  pacientes[i].telefono=atof(buffer); 
  if (pacientes[i].telefono==0) { 
  *tamano=i; 
  break; 
  } 
  printf("\nIntroduzca la direccion (no m…s de %d caracteres)\n\t",TAM_DIR-1); 
  do { 
  gets(pacientes[i].direccion); 
  } while (strlen(pacientes[i].direccion)==0); 
  printf("\nIntroduzca la descripcion de la alergias (no m…s de %d caracteres)\n",TAM_ALE-1); 
  printf("\n****Escriba \"NO\" si el paciente no tiene ninguna alergia****\n\t"); 
  do { 
  gets(pacientes[i].alergias); 
  } while (strlen(pacientes[i].alergias)==0); 
   
  } 
  return; 
 } 
   
 char menu() 
 { 
  char respuesta; 
  printf("\n\n\n\n\tMENU DEL PROGRAMA"); 
  printf("\n1.- Imprimir en la pantalla toda la informacion"); 
  printf("\n2.- Listar los pacientes con alergias"); 
  printf("\n3.- Crear una lista de los pacientes con el telefono 91-XXXXXXX"); 
  printf("\n4.- Crear una lista nueva de pacientes"); 
  printf("\n0.- Salir del programa.\n"); 
  do { 
  respuesta=getch(); 
  } while (respuesta<'0' || respuesta>'9'); 
  return respuesta; 
 } 
   
   
 void imprimirtodos(reg_paciente *pacientes, int tamano) 
 { 
  int i,contimpresos=0; 
  printf("\n\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); 
  if (tamano>0) { 
  for (i=0;i<tamano;i++) { 
  printf("\n\tÛÛ%5d\t%20s\t\t%9.0f\tÛÛ",i+1,pacientes[i].nombre,pacientes[i].telefono); 
  printf("\n\tÛÛ\t%40s\tÛÛ",pacientes[i].direccion); 
  printf("\n\tÛÛ\t%40s\tÛÛ",pacientes[i].alergias); 
  contimpresos++;/*CUENTA EL NUMERO DE LOS QUE SE VAN IMPRIMENDO*/ 
  if ((contimpresos)%10==0) { 
  printf("\n\tÛÛ *** Presione cualquier tecla para continuar. *** ÛÛ"); 
  getch(); 
  } 
  } 
  } 
  if (contimpresos==0) printf("\nÛÛ\t No hay ningun dato que mostrar en la pantalla.\t ÛÛ"); 
  printf("\n\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); 
  return; 
 } 
   
   
 void telefono91(reg_paciente *pacientes, int tamano) 
 { 
  int i,contimpresos=0; 
  printf("\n\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); 
  if (tamano>0) { 
  for (i=0;i<tamano;i++) { 
  if (pacientes[i].telefono>=910000000 && pacientes[i].telefono<920000000) { 
  printf("\n\tÛÛ%5d\t%20s\t\t%9.0f\tÛÛ",i+1,pacientes[i].nombre,pacientes[i].telefono); 
  printf("\n\tÛÛ\t%40s\tÛÛ",pacientes[i].direccion); 
  printf("\n\tÛÛ\t%40s\tÛÛ",pacientes[i].alergias); 
  contimpresos++;/*CUENTA EL NUMERO DE LOS QUE SE VAN IMPRIMENDO*/ 
  if ((contimpresos)%10==0) { 
   printf("\n\tÛÛ *** Presione cualquier tecla para continuar. *** ÛÛ"); 
  getch(); 
  } 
  } 
  } 
  } 
  if (contimpresos==0) printf("\nÛÛ\t No hay ningun dato que mostrar en la pantalla.\t ÛÛ"); 
  printf("\n\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); 
  return; 
 } 
   
 void hayalergias(reg_paciente *pacientes, int tamano) 
 { 
  int i,contimpresos=0; 
  printf("\n\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); 
  if (tamano>0) { 
  for (i=0;i<tamano;i++) { 
  if (strcmp(pacientes[i].alergias,"NO")!=0 && strcmp(pacientes[i].alergias,"no")!=0 && strcmp(pacientes[i].alergias,"No")!=0) { 
  printf("\n\tÛÛ%5d\t%20s\t\t%9.0f\tÛÛ",i+1,pacientes[i].nombre,pacientes[i].telefono); 
  printf("\n\tÛÛ\t%40s\tÛÛ",pacientes[i].direccion); 
  printf("\n\tÛÛ\t%40s\tÛÛ",pacientes[i].alergias); 
  contimpresos++;/*CUENTA EL NUMERO DE LOS QUE SE VAN IMPRIMENDO*/ 
  if ((contimpresos)%10==0) { 
   printf("\n\tÛÛ *** Presione cualquier tecla para continuar. *** ÛÛ"); 
  getch(); 
  } 
  } 
  } 
  } 
  if (contimpresos==0) printf("\nÛÛ\t No hay ningun dato que mostrar en la pantalla.\t ÛÛ"); 
  printf("\n\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); 
  return; 
 } 

 

Repost 0
Published by Prof.Luis Eduardo Aponte
Comenta este artículo
5 febrero 2010 5 05 /02 /febrero /2010 02:48

Los Arrays, son un ejemplo de estructuras (de tipo homogéneo), sin embargo, éste tipo de estructuras posee una gran limitante, puesto que, sólo admite datos del mismo tipo (entero, flotante, carácter); las estructuras que vamos a estudiar,  están compuestas por un grupo de variables, no necesariamente del mismo tipo, en las cuales, podemos almacenar diferente información (en cuanto a tipo), pero referente a un mismo tópico.


Por ejemplo, en nuestro carnet de identidad, del colegio, de la universidad, aparecen muchos datos acerca de nosotros.


                Nombres, apellidos, edad, dirección, fecha de nacimiento, grado, sección, ciclo...


Estos datos, son de diferente tipo, pero, en C, podemos almacenarlos utilizando un tipo de dato registro al que llamamos Estructura.


Por tanto, una estructura es una colección de una o más tipos de elementos denominados miembros, cada uno de los cuales puede ser de un tipo de dato diferente.

 

          Es ello que radica la importancia de las estructuras, porque nos ahora tiempo además que las estructuras son una herramienta importante para la creación de programas potentes y bases de datos.

 

Declaración de una Estructura

Como toda variable, en C, debemos declarar una estructura para poder hacer uso de ella, y la forma de hacerlo es la siguiente:

struct <nombre de la estructura>

{

            <tipo de dato del miembro1> <nombre del miembro 1>;

            <tipo de dato del miembro 2> <nombre de miembro 2>:

            ...

            <tipo de dato del miembro n> <nombre del miembro n>;

}

 

Por ejemplo, para los datos anteriores, la forma de declararla sería la siguiente:

 

struct datos

{

            char nombre[30];

            char apellido[20];

            int edad;

            char dirección[100];

            char fecha_nac[8];

};

 

Definición de variables del tipo estructura

Al igual que las funciones, las estructuras son declaradas y definidas; en la declaración es que, le estamos indicando al compilador que las variables de tipo datos estarán compuestas por los elementos, tales como nombre, apellido etc; pero además, debemos definir variables que, serán de ese tipo. Así como en alguna parte de C, están declarados los tipos de datos char, int, float; así también nosotros debemos definir las estructuras. Y cuando en el main, definimos las variables que serán del tipo int, del tipo float o del tipo char, de igual manera, debemos definir que variables serán del tipo de la estructura que hemos creado. Para ello existen dos procedimientos:


  1. listar las variables inmediantamente después de cerrar la llave de la estructura
  2. Listar las variables que serpán del tipo estructura creadas, inmeditamente después del identificador de la estructura; en la zona de declaraciones del programa.

 

Ejemplo:

1. struct datos

{

            char nombre[30];

            char apellido[20];

            int edad;

            char dirección[100];

            char fecha_nac[8];

} alumno1, alumno2, alumno3;

 

2. struct datos alumno1, alumno2, alumno3;

 

Si por algún caso, los datos de las tres variables, fuesen los mismos, podemos asignar los valores de ésta forma:

Alumno1=alumno2;

Alumno3=alumno2;

 

O también:

Alumno1=alumno3=alumno2;

 

Ya que, al contener los mismos miembros, es como si se tratacen de datos tipo int, float o char, por consiguiente podemos hacer las asignaciones anteriores.

Una estructura la podemos inicializar así:


struct datos

{

            char nombre[30];

            char apellido[20];

            int edad;

            char dirección[100];

            char fecha_nac[8];

}alumno1 = {“Manuel”,

                         “Ortez”,

                         20,

                         “San Salvador, El Salvador”,

                         “27/04/86”,

                        };

 

o también así:

struct datos alumno2={“Carolina”,

                                “Pelayo”,

                                   20,

                                   “San Salvador, El Salvador”,

                                   “14/05/86”,

                              };

El tamaño de una estructura es determinado de forma muy simple, consiste en sumar, el tamaño de todos los miembros, para nuestro caso particular, el tamaño (en bytes) de la estructura datos sería:

 

Ciertamente que, este proceso, lo podemos simplificar utilizando la sentencia:

 

Sizeof(datos);

Cuyo resultado será: 160.

 

Acceso a una estructura.


Para acceder a una estructura, o bién a la información guardada en ella, podemos hacer uso de dos nuevos amigos:

  1. El operador punto (.)
  2. El operador puntero –flecha- (->)

Por ejemplo:

Alumno1.nombre=”Manuel”;

Strcpy(alumno1.apellido, “Ortez”);

 

Para utilizar el operador flecha, debemos hacer uso de punteros (y creíste que ya nos habíamos olvidado de los punteros verdad?).

Por ejemplo, si tenemos un puntero a una estructura:

.struct datos *ptr;

ptr=&alumno1;

ptr->edad=20;

 

Ejemplo 1.


Diseñe un programa que guarde los datos de dos cd.


#include <stdio.h>

#include <conio.h>

/*declracion de la estructura*/

struct datos_cd                                                         

{

    char titulo[20];

    float precio;

    char fecha[8];

};

main()

{

   /*definicion de las variables estructuras*/

   struct datos_cd cd1, cd2;

   struct datos_cd *ptr;

   int tam;

   ptr=&cd2; /*asignacion de la direccion de cd2 al puntero*/

   clrscr();

   /*leemos los datos, usando el operador punto*/

   printf("Introduzca el t¡tulo del primer cd:\n");

   scanf("%s", &cd1.titulo);

   printf("Introduzca el precio del cd1:\n");

   scanf("%f", &cd1.precio);

   printf("Ahora, la fecha de edicion (dd/mm/aa/):\n");

   scanf("%s", &cd1.fecha);

      printf("Introduzca el t¡tulo del segundo cd:\n");

   scanf("%s", &cd2.titulo);

   printf("Introduzca el precio del cd2:\n");

   scanf("%f", &cd2.precio);

   printf("Ahora, la fecha de edicion (dd/mm/aa/):\n");

   scanf("%s", &cd2.fecha);

   clrscr();

   printf("\t\t\tAhora vamos a imprimir los valores guardados:\n\n");

   printf("********************Datos del CD1*************************\n");

   printf("Titulo %s \n", cd1.titulo);

   printf("Precio %.2f\n", cd1.precio);

   printf("Fecha %s\n", cd1.fecha);

   printf("**********************************************************\n\n");

     printf("********************Datos del CD2*************************\n");

   printf("Titulo %s\n", ptr->titulo);

   printf("Precio %.2f\n", ptr->precio);

   printf("Fecha %s\n", ptr->fecha);

   printf("**********************************************************\n\n");

   printf("El tama¤o de la estructura es %d bytes\n\n", sizeof(datos_cd));

   getch();

   return 0;

}

 

Estructuras Anidadas

Al igual que los ciclos, las decisiones, las expresiones, etc, las estructuras también pueden estar dentro de otras, a esto es que se le llama estructuras anidadas.

Supongamos que tenemos dos estructuras siguientes:

stuct empleado

{

            char nom[30];

            char puesto[10];

            int edad;

            float sueldo;

            char municipio[20];

            char ciudad[10];

            char dirección[50];

};

 

struct cliente

{

            char nom[30];

            char fecha_deuda[8];

            float saldo;

            char municipio[20];

            char ciudad[10];

            char dirección[50];

};

 

Observamos que, en ambas estructuras, hay fatos que se repiten, los cuales los podríamos ubicar en otra structura, así:

struct direc

{

char municipio[20];

            char ciudad[10];

            char dirección[50];

};

 

por tanto, las estructuras de empleado y cliente, sería de la siguiente forma:

stuct empleado

{

            char nom[30];

            char puesto[10];

            int edad;

            float sueldo;

            struct direc direc_empleado;

};

 

struct cliente

{

            char nom[30];

            char fecha_deuda[8];

            float saldo;

            struct direc direc_cliente;

};

 

En C, podemos definir una estructura dentro de otra estructura, claro siempre y cuando la declaración de ésta, haya sido previo.


Ejemplo 2.


Se desea diseñar una estructura que contenga la información de operaciones financieras. Esta estructura debe contar con un número de cuenta, una cantidad de dinero, el tipo de operación (deposito=0, retiro de fondos=1, puesta al dia=2 o estado de cuenta=3) y la fecha y hora en que la operaciópn se ha realizado.

#include <stdio.h>

#include <conio.h>

#include <dos.h>

/*declaracion de las estructuras*/

struct fecha

{

    unsigned int mes, dia, anyo;

};

struct tiempo

{

    unsigned int horas, minutos;

};

struct registro_operacion

{

   long numero_cuenta;

   float cantidad;

   int tipo_operacion;

   struct fecha f;

   struct tiempo t;

};

struct registro_operacion entrada();

main()

{

    struct registro_operacion w;

    w=entrada();

    printf("\n\n operacion realizada\n");

    printf("\t%ld\n", w.numero_cuenta);

    /*ATENCION: note, la forma en la que llamamos a los miembros

      de una estructura anidada*/

    printf("\t%d-%d-%d\n", w.f.dia, w.f.mes, w.f.anyo);

    printf("\t%d:%d\n", w.t.horas, w.t.minutos);

    getch();

    return 0;

 

}

struct registro_operacion entrada()

{

    struct time t;

    struct date d;

    struct registro_operacion una;

    printf("\nNumero de cuenta:\n");

    scanf("%ld", &una.numero_cuenta);

    puts("\nTipo de Operacion:\n");

    puts("Deposito (0)");

    puts("Retirada de Fondos (1)");

    puts("Puesta al Dia (2)");

    puts("Estado de Cuenta (3)");

    scanf("%d", &una.tipo_operacion);

    /*fecha y tiempo del sistema*/

    gettime(&t);

    una.t.horas=t.ti_hour;

    una.t.minutos=t.ti_min;

    getdate(&d);

    una.f.anyo=d.da_year;

    una.f.mes=d.da_mon;

    una.f.dia=d.da_day;

    return una;

}

 

Explicación

A fin de realizar el acceso correcto a los campos día, mes y año, así como el tiempo (la hora y los minutos) en que se efectuó la operación, se define una estructura fecha y una estructura tiempo. La estructura registro_operación tiene como miembro una variable (un campo) de tipo fecha, otra variable de tipo tiempo y otras variables para representar los otros campos. La estructura de tipo operación se hace con una variable entera. A continuación se declara tipos, se escribe una función que lee una operación financiera y devuelve la operación leída. La fecha y hora es capturada del sistema.

 

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
5 febrero 2010 5 05 /02 /febrero /2010 02:43
Arreglos de Caracteres.

Son arreglos que almacenan datos de tipo texto. Requieren la incorporacion de la libreria <string.h>.


Funciones de manejo de cadenas


Existen unas cuantas funciones el la biblioteca estándar de C para el manejo de cadenas:

 

strlen

strcpy

strcat

sprintf

strcmp


Para usar estas funciones hay que añadir la directiva:

 

    #include <string.h>

 

 

 

strlen


Esta función nos devuelve el número de caracteres que tiene la cadena (sin contar el '\0').

 

 

#include <stdio.h>

#include <string.h>

 

int main()

     {

     char texto[]="Gorka";

     int longitud;

 

     longitud = strlen(texto);

     printf( "La cadena \"%s\" tiene %i caracteres.\n", texto, longitud );

     }

Crea tus propias funciones: Vamos a ver cómo se haría esta función si no dispusiéramos de ella. Si no te enteras cómo funciona consulta Recorrer cadenas con punteros.

 

#include <stdio.h>

#include <string.h>

 

int main()

     {

     char texto[]="Gorka";

     char *p;

     int longitud=0;

 

     p = texto;

     while (*p!='\0')

          {

          longitud++;

          printf( "%c\n", *p ); /* Mostramos la letra actual */

          p++;                  /* Vamos a la siguiente letra */

          }

     printf( "La cadena \"%s\" tiene %i caracteres.\n", texto, longitud );

     }

 

Para medir la longitud de la cadena usamos un puntero para recorrerla (el puntero p). Hacemos que p apunte a texto. Luego entramos en un bucle while. La condición del bucle comprueba si se ha llegado al fin de cadena ('\0'). Si no es así suma 1 a longitud, muestra la letra por pantalla e incrementa el puntero en 1 (con esto pasamos a la siguiente letra).

 

 

 

strcpy


     #include <string.h>

 

     char *strcpy(char *cadena1, const char *cadena2);

 

Copia el contenido de cadena2 en cadena1. cadena2 puede ser una variable o una cadena directa (por ejemplo "hola"). Debemos tener cuidado de que la cadena destino (cadena1) tenga espacio suficiente para albergar a la cadena origen (cadena2).

 

#include <stdio.h>

#include <string.h>

 

int main()

     {

     char textocurso[] = "Este es un curso de C.";

     char destino[50];

 

     strcpy( destino, textocurso );

     printf( "Valor final: %s\n", destino );

     }

 

Vamos a ver otro ejemplo en el que la cadena destino es una cadena constante ("Este es un curso de C") y no una variable. Además en este ejemplo vemos que la cadena origen es sustituida por la cadena destino totalmete. Si la cadena origen es más larga que la destino, se eliminan las letras adicionales.

 

#include <stdio.h>

#include <string.h>

 

int main()

     {

     char destino[50] = "Esto no es un curso de HTML sino un curso de C.";

 

     printf( "%s\n", destino );

     strcpy( destino, "Este es un curso de C." );

     printf( "%s\n", destino );

     }

 

 

 

strcat


     #include <string.h>

 

     char *strcat(char *cadena1, const char *cadena2);

 

Copia la cadena2 al final de la cadena1.

 

#include <stdio.h>

#include <string.h>

 

int main()

     {

     char nombre_completo[50];

     char nombre[]="Gorka";

     char apellido[]="Urrutia";

 

     strcpy( nombre_completo, nombre );

     strcat( nombre_completo, " " );

     strcat( nombre_completo, apellido );

     printf( "El nombre completo es: %s.\n", nombre_completo );

     }

 

Como siempre tenemos que asegurarnos que la variable en la que metemos las demás cadenas tenga el tamaño suficiente. Con la primera línea metemos el nombre en nombre_completo. Usamos strcpy para asegurarnos de que queda borrado cualquier dato anterior. Luego usamos un strcat para añadir un espacio y finalmente metemos el apellido.

 

 

 

sprintf

     #include <stdio.h>

 

     int sprintf(char *destino, const char *format, ...);

 

Funciona de manera similar a printf, pero en vez de mostrar el texto en la pantalla lo guarda en una variable (destino). El valor que devuelve (int) es el número de caracteres guardados en la variable destino.

 

Con sprintf podemos repetir el ejemplo de strcat de manera más sencilla:

 

#include <stdio.h>

#include <string.h>

 

int main()

     {

     char nombre_completo[50];

     char nombre[]="Gorka";

     char apellido[]="Urrutia";

 

     sprintf( nombre_completo, "%s %s", nombre, apellido );

     printf( "El nombre completo es: %s.\n", nombre_completo );

     }

 

Se puede aplicar a sprintf todo lo que valía para printf.

 

 

strcmp

     #include <string.h>

 

     int strcmp(const char *cadena1, const char *cadena2);

 

Compara cadena1 y cadena2. Si son iguales devuelve 0. Un número negativo si cadena1 va antes que cadena2 y un número positivo si es al revés:

 

cadena1 == cadena2 -> 0

cadena1 > cadena2 -> número negativo

cadena1 < cadena2 -> número positivo


#include <stdio.h>

#include <string.h>

 

int main()

     {

     char nombre1[]="Gorka";

     char nombre2[]="Pedro";

 

     printf( "%i", strcmp(nombre1,nombre2));

     }

 


 

 

toupper() y tolower() - Convertir a mayúsculas y minúsculas

 

La función tolower() nos permite convertir una cadena a minúsculas:

 

char *tolower( char *cadena );

toupper cumple la función contraria, convierte la cadena a mayúsculas:

 

char *toupper( char *cadena );

Repost 0
Published by Prof.Luis Eduardo Aponte
Comenta este artículo
5 febrero 2010 5 05 /02 /febrero /2010 02:36

Matrices

Las matrices se declaran de forma análoga, con corchetes independientes para cada subíndice. La forma general de la declaración es:

tipo nombre[numero_filas][numero_columnas]; donde tanto las filas como las columnas se numeran también a partir de 0. La forma de acceder a los elementos de la matriz es utilizando su nombre, seguido de las expresiones enteras correspondientes a los dos subíndices, entre corchetes.

En C tanto los vectores como las matrices admiten los tipos de las variables escalares (char, int, long, float, double, etc.), Las matrices en C se almacenan por filas, en posiciones consecutivas de memoria. En cierta forma, una matriz se puede ver como un vector de vectores-fila. Si una matriz tiene N filas (numeradas de 0 a N-1) y M columnas (numeradas de 0 a la M-1), el elemento (i, j) ocupa el lugar: posición_elemento(0, 0) + i * M + j

A esta fórmula se le llama fórmula de direccionamiento de la matriz.

 

Ejemplo

Diseñe un  programa que lea un matriz de 6*6 y luego determine la suma de cada una de las filas y la almacene en un vector llamado suma.

#include <stdio.h>

#include <conio.h>

#define F 6

#define C 6

main()

   {

      int matriz[F][C], i,j, vector [F]={0,0,0,0,0,0};

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

             for(j=0; j<C; j++)

                 {

                        printf("Ingrese el elemento F=%d y Columna=%d de la matriz:\n", i,j);

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

                        vector[i]=vector[i]+matriz[i][j];

                 }

      printf("La Matriz generada es:\n\n");

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

      {

             for(j=0; j<C; j++)

                 {

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

                 }

             printf("\n");

      }

      printf("Y el vector suma de las filas es:\n\n");

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

             printf("%d\t", vector[i]);

      getch();

      return 0;

   }

 

Creo que no hay mucho por explicar, el uso de una matriz en C, es bastante parecido al de un vector, pero con las diferencias que en un vector tenemos únicamente una dimensión y en las matrices tenemos dos.


Ejemplo 2.


         Programa que capture las notas de 3 alumnos de 05 materias e imprima el

         Promedio de cada uno y de todos en conjunto.*/      

 

 #include <stdio.h>

#include <stdlib.h>

 

int main(){

    

     system("color 3a");

     int tabla [3][5];

    

     int promedio[3];

    

     for(int i=0;i<3;i++){

        

                     printf("\n\nIngrese la calificacion en matematicas del estudiante %i :",i+1);

                     scanf("%i",&tabla[i][0]);

                    

                     printf("\n\nIngrese la calificacion en Fisica del estudiante %i :",i+1);

                    

                     scanf("%i",&tabla[i][1]);

                    

                      

                     printf("\n\nIngrese la calificacion en Quimica del estudiante %i :",i+1);

                    

                     scanf("%i",&tabla[i][2]);

                      

                     printf("\n\nIngrese la calificacion en Ingles del estudiante %i :",i+1);

                    

                     scanf("%i",&tabla[i][3]);

                     

                     printf("\n\nIngrese la calificacion en Programacion del estudiante %i :",i+1);

                    

                     scanf("%i",&tabla[i][4]);

                     system("cls");

            

             }

            

            

    for(int x=0;x<3;x++){

    promedio[x]=((tabla[x][0]+tabla[x][1]+tabla[x][2]+tabla[x][3]+tabla[x][4])/5);

    printf("\nPromedio del alumno %i: %i",x+1,promedio[x]);

   

            }

   

    printf("\nPromedio total: %i",(promedio[0]+promedio[1]+promedio[2])/3);

    

    system("pause");

    return 0;   

 }


Ejemplo 3.


Supongamos que ahora queremos almacenar las temperaturas de toda la semana. Según lo que aprendimos en el capítulo anterior podríamos usar un array unidimiensional por cada día de la semana. En cada uno de esos arrays podríamos almacenar las temperaturas de cada día."

 

 

#include <stdio.h>

#define DIAS    7

#define HORAS   24

 

int main()

     {

     int temp[DIAS][HORAS];

    

     float media = 0;

     int hora, dia;

 

     for( dia=0 ; dia<DIAS ; dia++ ) {

          for( hora=0 ; hora<HORAS ; hora++ ) {

             printf( "Temperatura de las %d el día %d: ", hora, dia );

             scanf( "%i", &temp[dia][hora] );                           

             media += temp[dia][hora];

          }

     }

     media = media / HORAS / DIAS;

 

     printf( "\nLa temperatura media de toda la semana es %f\n", media );

     return 0;

}

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
5 febrero 2010 5 05 /02 /febrero /2010 02:25

            Arreglos, Matrices o Arrays.

 

            Definiciones, y Características.

 

            - Un arreglo, matriz o array es una estructura de datos homogénea, compuesta por varios elementos, todos del mismo tipo y almacenados consecutivamente en memoria.

 

            - Son estructuras en memoria que ayudan a almacenar múltiples elementos de datos que tienen una característica en común.

 

            - Conjunto de variables del mismo tipo que tienen el mismo nombre y se diferencian en el Índice.

 

            - A un arreglo se le referencia con un solo nombre, aunque puede tener múltiples elementos de datos.

 

            -  Los elementos de datos individuales pueden ser de cualquier tipo, tal como enteros, flotantes o caracteres.

 

- Dentro del arreglo, todos los elementos de datos deben ser de un solo tipo. Por ejemplo si se tienen un arreglo de 50 elementos, todos ellos deben ser de un mismo tipo, por ejemplo (int). No se pueden tener los primeros 20 elementos de tipo de datos int y el resto de ellos de tipo float.

Un array es un identificador que referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con solo cambiar el índice que lo referencia. El índice será un valor entero y positivo. En 'C' los arrays comienzan por la posición 0.

Vectores

Un vector es un array unidimensional, es decir, solo usa un índice para referenciar a cada uno de los elementos.

 

Su declaración será:                      tipo nombre [tamaño];

 

El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número de elementos del vector (se debe indicar entre corchetes [ ]). En el ejemplo puedes observar que la variable i es utilizada como índice, el primer for sirve para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones van de 0 a 9 (total 10 elementos).

Tipos de Arreglos.

Arreglos Unidimensionales.

12

24

3

69

10

 

            Declaración de Arreglos Unidimensionales.

 

            Los arreglos se declaran como las variables de tipo int, float, char. Es necesario especificar el tamaño del mismo, para definir el número de elementos en el mismo.

            La forma general de declarar un arreglo es la siguiente:

           

Tipo_de_dato nombre_arreglo[dimensión];

Tipo_ de_ dato: Nombre dado al arreglo.

Nombre_arreglo: Nombre dado al arreglo.

Dimensión: El número de elementos que tiene el arreglo.

 

Al declarar un arreglo o array se reserva en memoria tantas variables del tipo_de_dato, como las indicadas en la dimensión.

 

Ejemplo. Suponga que es un meteorólogo y quiere guardar en el computador la temperatura que ha hecho cada hora del día. Para darle cierta utilidad al final calcular la media de las temperatura.


Código en C.

#include <stdio.h>

#define ELEMENTOS 24

int main()

{

  int temp[ELEMENTOS];

 float media=0;

 int hora;

for(hora=0; hora<ELEMENTOS; hora++)

{

   printf("Temperatura de las %i:", hora);

   scanf("%i", &temp[hora]);

   media+=temp[hora];

}

media=media/ELEMENTOS;

printf(" \n La Temperatura media es %f\n", media);

}

Inicializar un Arreglo.

En C se puede inicializar un arreglo a través de asignación, al igual que las variables.

int k, num[100];

for(k=0; k<100; k++)

num[k]=0;

(Todos los 100 elementos del arreglo son inicializados en 0).

También se puede inicializar un arreglo en el momento de declararlo (para arreglos pequeños).

int  num[5]= {12, 24, 11, 65, 80}

 

Ejemplo.

Leer la entrada del usuario dentro del arreglo.

Codificación en C.

#include <stdio.h>

 main()

{

  int k, num[5];

  for(k=0; k<100; k++)

{

printf (“Ingresar un valor entero para el elemento %d:”, k+1);

scanf(“%d”, &num[k]);

}

}

En este ejemplo directo, los valores de entrada se suministran del teclado para num[0], num[1], y así sucesivamente. Después que el bucle termino, se tiene un arreglo con los valores de entrada almacenados desde num[0] hasta num[9].

 

Programa para imprimir los valores de un arreglo.

#include <stdio.h>

 main()

{

 int k, num[100];

  for(k=0; k<100; k++)

       num[k]= k+1;

for(k=0; k<100; k++)

printf(“num[%d]=%d\n”, k, num[k]);

}

Este ejemplo imprime lo siguiente:

num[0]=1

num[1]=2

num[2]=3

.

.

.

num[99]=100

3) Ejemplo:

int num[100]; /*Arreglo de tipo entero compuesto de 100 posiciones*/

 

char nom[80]; /*Texto de 80 caracteres*/

 

float x[12]; /*arreglo de 12 elementos punto flotantes */


Ejemplo

Diseñe un programa que lea un vector de 10 posiciones, luego determine si la quinta posición es positiva, si la primera posición es negativa y si la última posición es cero.

#include <stdio.h>

#include <conio.h>

#define N 10

main()

   {

      float x[N];

      int i;

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

             {

                printf("Ingrese el valor %d:\n", i);

                scanf("%f", &x[i]);

             }

      if(x[4]>0)

      {

             printf("La quinta Posici¢n es Positiva\n\n");

      }

      if(x[0]<0)

      {

             printf("La 1ø Posici¢n es Negativo\n\n");

      }

      if(x[N-1]==0)

      {

             printf("La Ultima Posici¢n es cero\n\n");

      }

 

      getch();

      return 0;

   }

 

Explicación

En este ejemplo estamos haciendo uso de la constante simbólica, de cuyos beneficios ya se habló. La definimos con 10 posiciones, recordando que C, empieza a contar desde cero.  Luego definimos el vector llamado x, como punto flotante, y ojo, que éste va acompañado de su dimensión. Luego haciendo uso de un for, empezamos a llenar el vector. Luego preguntamos si la posición cuatro es positiva. El lector se preguntará el por que, la instrucción es x[4] y no x[5], ya que; lo que queremos es averiguar, si la posición cinco es la positiva. Pues bien, la posición identificada con el número cuatro, es en efecto la que contiene el quinto número.

Repost 0
Published by Prof.Luis Eduardo Aponte
Comenta este artículo
10 junio 2009 3 10 /06 /junio /2009 14:09

                                                     

5.     Funciones en las que usamos Menú

  En la práctica, muchas veces debemos diseñar programas, que nos permitan elegir la acción o acciones a realizar, es decir haciendo uso de un menú. El cual, no es más ni menos que la aplicación de un selector múltiple. Un switch.

Veamos un ejemplo.

Ejemplo 5.6

Diseñe un programa, que dado un ángulo, muestre su seno, coseno o tangente; según lo desee el usuario.

#include <stdio.h>

#include <conio.h>

#include <math.h>

void seno (float angulo);

void coseno (float angulo);

void tangente (float angulo);

main()

    {

       float angulo;

       int opcion, ban=1;

       clrscr();

       while(ban==1)

              {

                  printf("\t\tBIENVENIDO/A\n\n");

                  printf("Introduzca el valor del angulo, por favor:\n");

                  scanf("%f", &angulo);

                  printf("¨Que desea hacer?:\n\n");

                  printf("********************************************\n");

                  printf("****        1. seno del angulo          ****\n");

                  printf("****        2. coseno del angulo        ****\n");

                  printf("****        3. tangente del angulo      ****\n");

                  printf("********************************************\n");

                  scanf("%d", &opcion);

                  while(opcion<0 || opcion>3)

                         {

                          printf("ERROR, la opcion debe estar entre 0 y 3:\n");

                          scanf("%d", &opcion);

                          }

                  clrscr();

                  switch(opcion)

                         {

                           case 1: seno (angulo);

                                      break;

                           case 2: coseno (angulo);

                                      break;

                           case 3: tangente (angulo);

                                      break;

                         }

                  printf("¨Hay mas datos? (si=1 y no=0)\n");

                  scanf("%d",&ban);

              }

              getch();

              return 0;

       }

       void seno (float angulo)

       {

             float y;

             y=sin (angulo);

             printf("El seno de %f es %f\n\n", angulo, y);

       }

       void coseno (float angulo)

       {

             float y;

             y=cos(angulo);

             printf("El coseno de %f es %f\n\n", angulo, y);

       }

       void tangente (float angulo)

       {

              float y;

              y=tan(angulo);

              printf("La tangente de %f es %f\n\n", angulo, y);

              getch();

       }                                                                                                                                         

 

Repost 0
Published by Prof.Luis Eduardo Aponte
Comenta este artículo

Presentación

  • : El blog de Luis Eduardo Aponte
  • : Blog, para facilitar del Lenguaje de Programación C
  • Contacto

Enlaces