Overblog Seguir este blog
Administration Create my blog
22 octubre 2010 5 22 /10 /octubre /2010 16:59

 Ejemplo.1

Se pide que, cree una agenda, donde pueda almacenar el nombre, teléfono y correo electrónico de sus amigos; haciendo uso de una lista enlazada. Dicha agenda, debe permitirle: añadir un nuevo registro, eliminar y Mostrar la lista de todos los registros.

 

#include <stdio.h>
#include <conio2.h>
#include <stdlib.h>
struct nodo{
     int corre;
      char nom[80];
      char tel[9];
      char email[50];
      struct nodo *sig;
};
typedef struct nodo *Lista;
Lista p, cabeza;
Lista getnodo();
void insafter(Lista p, char nom[80], char tel[9], char email[50], int i);
void eliminar (Lista p, int k);
void imprimir(Lista p);
main()
{
      char nom[80], tel[9], email[50];
      int k, opc=8, i=0;
      clrscr();
      p=getnodo();
      cabeza=p;
      while(opc!=4)
      {
     printf("\t\t\nMENU PRINCIPAL\n\n\n");
     printf("\t\t1. Registrar Nuevos Datos\n");
     printf("\t\t2. Imprime todos los registros\n");
     printf("\t\t3. Eliminar Datos\n");
     printf("\t\t4.Salir\n");
     scanf("%d", &opc);
     switch(opc)
     {
  case 1: printf("Ingrese el Nombre:");
   scanf("%s", &nom);
   printf("Telefono:");
   scanf("%s", &tel);
   printf("e-mail:");
   scanf("%s", email);
   i++;
   insafter(&p, nom, tel, email, i);
   break;
  case 2: printf("Listado de todos los registros\n\n");
   imprimir(&p);
   break;
  case 3: printf("¨A quien desea eliminar?(ingrese el correlativo)\n");
   scanf("%d", &k);
   eliminar(&p, k);
   break;
     }
     clrscr();
      }

      return 0;
}
Lista getnodo()
{
    Lista p;
    p=(Lista)malloc(sizeof(struct nodo));
    if(p==NULL)
 printf("Memoria Insuficiente\a\n");
    return p;
}

void insafter(Lista p, char nom[80], char tel[9], char email[50], int i)
{
   Lista q;

   if(p==NULL)
       printf("ERROR, lista vac¡a\n\a");
   else
   {
 q=getnodo();
 strcpy(q->nom, nom);
 strcpy(q->tel, tel);
 strcpy(q->email, email);
 q->corre=i;
 q->sig=p->sig;
 p->sig=q;
 p=p->sig;
   }
}
void imprimir(Lista p)
{
   Lista dir;
   p=p->sig;
   for(dir=p; dir!=NULL; dir=dir->sig)

   {
       printf("\n\t***********************************\n");
       printf("\t correlativo: %d\n", dir->corre);
       printf("\t Nombre %s\n", dir->nom);
       printf("\t Telefono: %s\n", dir->tel);
       printf("\t e-mail: %s\n", dir->email);
       printf("\n\t***********************************\n");
       getch();
   }

}
void eliminar(Lista p, int k)
{
    Lista indice;
    cabeza=p;

    for(indice=cabeza; indice!=NULL; indice=indice->sig)
    {


 if(indice->corre==k)
 {
      cabeza=cabeza->sig;
      printf("%s est  hiciendo eliminado\n", indice->nom);
      getch();

      if(p==NULL || p->sig==NULL)
     printf("ERROR, ya no hay m s datos\n");
      else
      {
    cabeza->sig=indice->sig;

    free(indice);
      }
 }
    }
}

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
13 octubre 2010 3 13 /10 /octubre /2010 02:38

Lista Enlazada

Es una colección de elementos dispuestos uno detrás del otro, en la que cada elemento se conecta al siguiente por un “Enlace” o “Puntero”.

Los nodos de las listas al igual que las colas y pilas, está compuesta por una parte de información (que pude ser datos enteros, flotantes, caracteres, estructuras..) y el puntero que mantiene el enlace entre un nodo y otro.

Existen varios tipos de Listas, pero para efectos de comprensión y sintetización, hablaremos de cuatro tipos esenciales de listas:

Tipos De Listas

  1. Lista simplemente enlazada: Cada nodo, contiene un único apuntador hacia el siguiente nodo, por lo cual hace de él una estructura muy eficiente, ya que el último de la lista apunta hacia null, por ello, es fácil hacer recorridos directos.

 

  1. Listas Doblemente enlazada: Esta lista se caracteriza por que sus nodos contienen dos punteros, uno hacia el nodo siguiente y otro hacia el nodo anterior.

 

  1. Listas Circulares: Este tipo de lista, es sólo una extensión de las lista simplemente enlazada, con la diferencia que el último elemento se enlaza al primer elemento de la lista, lo cual permite el recorrido en forma de anillo

  1. Lista Circular Doblemente enlazada: Quizá este tipo de lista, sea la más compleja, ya que es la combinación de la lista circular y las doblemente enlazadas, ya que es una lista doblemente enlazada donde el primer elemento se conecta con el último y viceversa.

 

El TAD (Tipo Abstracto de Datos) Lista

En una lista podemos almacenar datos del mismo tipo, con la característica que puede contener un número indeterminado de elementos y que, mantienen un orden explícito, porque cada elemento, se une a otro mediante un puntero, como ya se ha dicho anteriormente, los elementos constitutivos de las listas se denominan nodos.

Las listas son estructuras de datos dinámicos, por tanto, pueden cambiar de tamaño durante la ejecución del programa, aumentando o disminuyendo el número de nodos.

Un aspecto importante de las listas es que las inserciones, las podemos hacer por el frente, al final, en medio, después de..., etc, etc, etc; es decir que, no existen reglamentos que nos restringían añadir datos a una lista, en la posición que nosotros queramos.

De igual manera, para las eliminaciones de nodos, podemos hacerlo como nosotros lo queramos, si embargo, se acostumbra ingresando el campo de información o dato que se desea eliminar.

 

 

Operaciones con las listas

P: puntero a un nodo

L: puntero a la lista

àListaVacia(L): Iniciliza la lista L, como lista vacía

 

àempty(L): determina si la lista está vacía o no

 

àInsertar(L, x, p): Inserta al dato x, en un nuevo nodo de la lista L, después del nodo apuntado por p

 

àeliminar(L, x): elimina, de la lista L, el nodo que contiene a x

 

àNodo(p): Hace referencia la nodo que apunta p

 

àInfo(p): hace referencia al info del nodo

 

ànext(p): siguiente dirección si p no es NULL

 

àInfo(next(p)): info del nodo que sigue a nodo (p) en la lista

 

Se puede decir que, estas son las operaciones básicas para una lista; sin embargo, como ya se ha insistido, eso dependerá del programador y de la complejidad del problema que se está resolviendo, además del tipo de lista que se haya elegido.

Para ello, acontinuación hablaremos, por separado, de cada uno de los tipos de listas.

 

Listas Simplemente Enlazadas

Una estructura como ésta, requiere, que se tengan en cuenta, las operaciones básicas que, se realizarán:

Estructura del Nodo

Por ejemplo, la podemos definir así:

struct nodo{

      int x;

      struct nodo *sig;

};

 

typedef struct nodo *Lista; /* Sinónimo para el tipo de dato*/

Lista p; /* Aquí guardaremos la dirección del primer nodo */

 

p=getnodo();

 

Función getnodo()

Esta función, se utiliza para pedirle memoria a la computadora, lo cual puede realizarse en  las misma función de insertar, pero para tener un mekor orden, es mejor hacerlo por aparte.

Por tanto, es evidente que, ésta función lo que devuelve es una dirección de memoria.

 

Lista getnodo()

{

      Lista  p;

      p=(Lista)malloc(sizeof(struct nodo));

      return p;

}

Operaciones con las listas

P: puntero a un nodo

L: puntero a la lista

àListaVacia(L): Iniciliza la lista L, como lista vacía

 

àempty(L): determina si la lista está vacía o no

 

àInsertar(L, x, p): Inserta al dato x, en un nuevo nodo de la lista L, después del nodo apuntado por p

 

àeliminar(L, x): elimina, de la lista L, el nodo que contiene a x

 

àNodo(p): Hace referencia la nodo que apunta p

 

àInfo(p): hace referencia al info del nodo

 

ànext(p): siguiente dirección si p no es NULL

 

àInfo(next(p)): info del nodo que sigue a nodo (p) en la lista

 

Se puede decir que, estas son las operaciones básicas para una lista; sin embargo, como ya se ha insistido, eso dependerá del programador y de la complejidad del problema que se está resolviendo, además del tipo de lista que se haya elegido.

Para ello, a continuación hablaremos, por separado, de cada uno de los tipos de listas.

 

Listas Simplemente Enlazadas

Una estructura como ésta, requiere, que se tengan en cuenta, las operaciones básicas que, se realizarán:

Estructura del Nodo

Por ejemplo, la podemos definir así:

struct nodo{

      int x;

      struct nodo *sig;

};

 

typedef struct nodo *Lista; /* Sinónimo para el tipo de dato*/

Lista p; /* Aquí guardaremos la dirección del primer nodo */

 

p=getnodo();

 

Función getnodo()

Esta función, se utiliza para pedirle memoria a la computadora, lo cual puede realizarse en  las misma función de insertar, pero para tener un mekor orden, es mejor hacerlo por aparte.

Por tanto, es evidente que, ésta función lo que devuelve es una dirección de memoria.

 

Lista getnodo()

{

      Lista  p;

      p=(Lista)malloc(sizeof(struct nodo));

      return p;

}

Función Borrar después de...

Ésta función es muy similar a la función de eliminar de las pilas y colas, con la diferencia que debemos enlazar el nodo anterior con el siguiente nodo:

 

 

Algoritmo:

  1. Crear un nodo auxiliar apuntado por q.
  2. si p, apunta a nullo p->sig apunta a NULL, imprima mensaje de error
  3. sino; q, en suparte de siguiente, debe tener la dirección a la que apuntaba, p->sig.
  4. p->sig debe apuntar a q en su parte de siguiente.
  5. Liberar de memoria el nodo apuntado por q.

void delafter(Lista p, char *px)

{

            Lista q;

            If(p==NULL || p->sig==NULL)

                        Printf(“ERROR, lista vacía\a\n”);

            Else

            {

                        q->sig=p->sig;

                        p->sig=q->sig;

                        free(q);

            }

}

 

Función de Lista Vacía

Int empty(Lista p)

{

            int r;

            if(p==NULL)

                        r=1;

            else

                        r=0;

            return r;

}

 

/* Para limpiar la lista*/

void limpiar (Lista L)

{

            L=NULL;

}

 

Con ésta función, lo que hacemos es inicializar la lista a NULL, por lo que se pierden los elementos que habíamos guardado en los nodos. Pero Ojo, eso no significa que hayamos liberado memoria que ocuparon, los nodos, esa memoria será liberada, cuando se deje de ejecutar el programa, o  si hubiésemos, utilizado la función free(), para cada nodo.

Función Buscar

Ésta función, nos devuelve, la dirección de memoria de un valor que deseamos buscar en la lista.

 

Lista  buscar(Lista frente, char x)

{

            /* frente: puntero que indica la cabeza de una lista.

                X: carácter que deseamos buscar

            */

            Lista dir;

            For(dir=frente; dir!=NULL; dir=dir->sig)

            If(x==dir->x)

                        Return dir;

            Return NULL;

}

 

 

 

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
13 octubre 2010 3 13 /10 /octubre /2010 02:38

Lista Enlazada

Es una colección de elementos dispuestos uno detrás del otro, en la que cada elemento se conecta al siguiente por un “Enlace” o “Puntero”.

Los nodos de las listas al igual que las colas y pilas, está compuesta por una parte de información (que pude ser datos enteros, flotantes, caracteres, estructuras..) y el puntero que mantiene el enlace entre un nodo y otro.

Existen varios tipos de Listas, pero para efectos de comprensión y sintetización, hablaremos de cuatro tipos esenciales de listas:

Tipos De Listas

  1. Lista simplemente enlazada: Cada nodo, contiene un único apuntador hacia el siguiente nodo, por lo cual hace de él una estructura muy eficiente, ya que el último de la lista apunta hacia null, por ello, es fácil hacer recorridos directos.

 

  1. Listas Doblemente enlazada: Esta lista se caracteriza por que sus nodos contienen dos punteros, uno hacia el nodo siguiente y otro hacia el nodo anterior.

 

  1. Listas Circulares: Este tipo de lista, es sólo una extensión de las lista simplemente enlazada, con la diferencia que el último elemento se enlaza al primer elemento de la lista, lo cual permite el recorrido en forma de anillo

  1. Lista Circular Doblemente enlazada: Quizá este tipo de lista, sea la más compleja, ya que es la combinación de la lista circular y las doblemente enlazadas, ya que es una lista doblemente enlazada donde el primer elemento se conecta con el último y viceversa.

 

El TAD (Tipo Abstracto de Datos) Lista

En una lista podemos almacenar datos del mismo tipo, con la característica que puede contener un número indeterminado de elementos y que, mantienen un orden explícito, porque cada elemento, se une a otro mediante un puntero, como ya se ha dicho anteriormente, los elementos constitutivos de las listas se denominan nodos.

Las listas son estructuras de datos dinámicos, por tanto, pueden cambiar de tamaño durante la ejecución del programa, aumentando o disminuyendo el número de nodos.

Un aspecto importante de las listas es que las inserciones, las podemos hacer por el frente, al final, en medio, después de..., etc, etc, etc; es decir que, no existen reglamentos que nos restringían añadir datos a una lista, en la posición que nosotros queramos.

De igual manera, para las eliminaciones de nodos, podemos hacerlo como nosotros lo queramos, si embargo, se acostumbra ingresando el campo de información o dato que se desea eliminar.

 

 

Operaciones con las listas

P: puntero a un nodo

L: puntero a la lista

àListaVacia(L): Iniciliza la lista L, como lista vacía

 

àempty(L): determina si la lista está vacía o no

 

àInsertar(L, x, p): Inserta al dato x, en un nuevo nodo de la lista L, después del nodo apuntado por p

 

àeliminar(L, x): elimina, de la lista L, el nodo que contiene a x

 

àNodo(p): Hace referencia la nodo que apunta p

 

àInfo(p): hace referencia al info del nodo

 

ànext(p): siguiente dirección si p no es NULL

 

àInfo(next(p)): info del nodo que sigue a nodo (p) en la lista

 

Se puede decir que, estas son las operaciones básicas para una lista; sin embargo, como ya se ha insistido, eso dependerá del programador y de la complejidad del problema que se está resolviendo, además del tipo de lista que se haya elegido.

Para ello, acontinuación hablaremos, por separado, de cada uno de los tipos de listas.

 

Listas Simplemente Enlazadas

Una estructura como ésta, requiere, que se tengan en cuenta, las operaciones básicas que, se realizarán:

Estructura del Nodo

Por ejemplo, la podemos definir así:

struct nodo{

      int x;

      struct nodo *sig;

};

 

typedef struct nodo *Lista; /* Sinónimo para el tipo de dato*/

Lista p; /* Aquí guardaremos la dirección del primer nodo */

 

p=getnodo();

 

Función getnodo()

Esta función, se utiliza para pedirle memoria a la computadora, lo cual puede realizarse en  las misma función de insertar, pero para tener un mekor orden, es mejor hacerlo por aparte.

Por tanto, es evidente que, ésta función lo que devuelve es una dirección de memoria.

 

Lista getnodo()

{

      Lista  p;

      p=(Lista)malloc(sizeof(struct nodo));

      return p;

}

Operaciones con las listas

P: puntero a un nodo

L: puntero a la lista

àListaVacia(L): Iniciliza la lista L, como lista vacía

 

àempty(L): determina si la lista está vacía o no

 

àInsertar(L, x, p): Inserta al dato x, en un nuevo nodo de la lista L, después del nodo apuntado por p

 

àeliminar(L, x): elimina, de la lista L, el nodo que contiene a x

 

àNodo(p): Hace referencia la nodo que apunta p

 

àInfo(p): hace referencia al info del nodo

 

ànext(p): siguiente dirección si p no es NULL

 

àInfo(next(p)): info del nodo que sigue a nodo (p) en la lista

 

Se puede decir que, estas son las operaciones básicas para una lista; sin embargo, como ya se ha insistido, eso dependerá del programador y de la complejidad del problema que se está resolviendo, además del tipo de lista que se haya elegido.

Para ello, a continuación hablaremos, por separado, de cada uno de los tipos de listas.

 

Listas Simplemente Enlazadas

Una estructura como ésta, requiere, que se tengan en cuenta, las operaciones básicas que, se realizarán:

Estructura del Nodo

Por ejemplo, la podemos definir así:

struct nodo{

      int x;

      struct nodo *sig;

};

 

typedef struct nodo *Lista; /* Sinónimo para el tipo de dato*/

Lista p; /* Aquí guardaremos la dirección del primer nodo */

 

p=getnodo();

 

Función getnodo()

Esta función, se utiliza para pedirle memoria a la computadora, lo cual puede realizarse en  las misma función de insertar, pero para tener un mekor orden, es mejor hacerlo por aparte.

Por tanto, es evidente que, ésta función lo que devuelve es una dirección de memoria.

 

Lista getnodo()

{

      Lista  p;

      p=(Lista)malloc(sizeof(struct nodo));

      return p;

}

Función Borrar después de...

Ésta función es muy similar a la función de eliminar de las pilas y colas, con la diferencia que debemos enlazar el nodo anterior con el siguiente nodo:

 

 

Algoritmo:

  1. Crear un nodo auxiliar apuntado por q.
  2. si p, apunta a nullo p->sig apunta a NULL, imprima mensaje de error
  3. sino; q, en suparte de siguiente, debe tener la dirección a la que apuntaba, p->sig.
  4. p->sig debe apuntar a q en su parte de siguiente.
  5. Liberar de memoria el nodo apuntado por q.

void delafter(Lista p, char *px)

{

            Lista q;

            If(p==NULL || p->sig==NULL)

                        Printf(“ERROR, lista vacía\a\n”);

            Else

            {

                        q->sig=p->sig;

                        p->sig=q->sig;

                        free(q);

            }

}

 

Función de Lista Vacía

Int empty(Lista p)

{

            int r;

            if(p==NULL)

                        r=1;

            else

                        r=0;

            return r;

}

 

/* Para limpiar la lista*/

void limpiar (Lista L)

{

            L=NULL;

}

 

Con ésta función, lo que hacemos es inicializar la lista a NULL, por lo que se pierden los elementos que habíamos guardado en los nodos. Pero Ojo, eso no significa que hayamos liberado memoria que ocuparon, los nodos, esa memoria será liberada, cuando se deje de ejecutar el programa, o  si hubiésemos, utilizado la función free(), para cada nodo.

Función Buscar

Ésta función, nos devuelve, la dirección de memoria de un valor que deseamos buscar en la lista.

 

Lista  buscar(Lista frente, char x)

{

            /* frente: puntero que indica la cabeza de una lista.

                X: carácter que deseamos buscar

            */

            Lista dir;

            For(dir=frente; dir!=NULL; dir=dir->sig)

            If(x==dir->x)

                        Return dir;

            Return NULL;

}

 

 

 

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
13 octubre 2010 3 13 /10 /octubre /2010 02:06

 Diapositiva3

 

 

Punteros.

 

 

Los Punteros o Apuntadores, son variables que contienen la dirección de otra variable.

 

Los usos principales, que tienen, los punteros, son los siguientes:

->Nos ayuda, para que una función devuelva más de un valor. Por ejemplo, una función que devuelva un vector de enteros, en dicha función mandamos la dirección del primer elemento a la función principal, y a partir de ella, imprimimos todos los valores contenidos en el vector.

->Mejor uso de la memoria dinámica. Esto es lo que más nos tiene cuenta, el lector debe tener presente que, el uso de punteros, ayuda a ahorrar memoria y por consiguiente, hace más efectivo el uso y administración de la misma.

 

Declaración de Punteros.

 

La forma de declarar un apuntador, es la siguiente:

int *p;

int->indica que, es un puntero hacia un entero.

*->indica al compilador que esa variable, es un puntero

p-> Es el identificador del puntero.

Otros ejemplos:

float *q; /*apuntador hacia un flotante*/

char *z; /*puntero que contiene la dirección de una variable que guarda un carácter */

Para referirnos a un valor a través de un apuntador, lo hacemos mediante un proceso llamado indireccion.  

Por ejemplo, para mandar a impresión el valor entero, hacia el cual a punta “p”, sería así: printf(“%d”, *p);

 

Los punteros, pueden ser inicializados  a 0, NULL ó alguna dirección válida:

float *p1;

p1=0;

p1=NULL;

 

Ahora bien, para guardar la dirección de alguna variable, en un puntero se tiene &->Operador de Dirección.

 

P1=&a;

 

 Ejemplos

 

 

1.    Diseñe un programa que muestre el uso de operadores básicos en la declaración de punteros empleando el direccionamiento y el operador indireccion.

 

 

#include <stdio.h>

#include <conio.h>

main()

{

   int a;

   /*Declaración de un puntero a un entero */

   int *p;

   clrscr();

   printf("Ingrese un valor ENTERO para la variable:\n");

   scanf("%d", &a);

   while(a<0)

   {

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

       scanf("%d", &a);

   }

   clrscr();

    /*Limpiamos la pantalla */

   printf("a=%d\n", a); /*Imprimo el valor de a*/

   printf("La dirección de a es %p\n", &a);

   printf("*p=%p\n", p); /*Imprimo la dirección que guarda p*/

   /*imprimo el valor guardado en la dirección a la que apunta p*/

   printf("a=%d\n", *p);

   printf("El tamaño de *p es %d\n", sizeof(p));

   getch();

   return 0;

}

2. Diseñe un programa, que sume dos variables de tipo entero, por medio de apuntadores.

 

 

#include <stdio.h>

#include <conio.h>

main()

{

   int a, b, c;

   int *p1, *p2, *p3; /*declaración de los punteros */

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

   scanf("%d", &a);

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

   scanf("%d", &b);

   c=a+b;

   printf("a+b=%d\n", c);

   /*asignamos las direcciones a los punteros correspondientes/

   p1=&a;

   p2=&b;

   printf("*p1 + *p2=%d\n", *p1+*p2);

   p3=&c;

   printf(" Dirección de a es %p\n Dirección de b es %p\n Y la de c es %p\n\n", p1, p2, p3);

   getch();

   return 0;

}

 

3. Programa que lee un arreglo y una matriz usando  aritmética de punteros */

 

 

#include <stdio.h>

#include <conio.h>

#define M 3

#define N 3

main()

  {

     int x[3][3], y[3];

     int f=0,c=0;

     clrscr();

     for(f=0; f< M; f++)

            {

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

                  {

                         printf("*(x+ %d)+%d)=", f,c);

                         scanf("%d", *(x+f)+c);

                  }

               printf("Elemento %d del vector:\n", f);

               scanf("%d", &y[f]);

            }

     printf("IMPRESIONES:\n");

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

     for(f=0; f<M; f++)

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

               printf("%d", *(*(x+f)+c));

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

     for(f=0; f<M; f++)

             printf("%d", *(y+f));

     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: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
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: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: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
25 marzo 2009 3 25 /03 /marzo /2009 03:45

Prof. Luís E. Aponte I.

LIBRERIAS EN LENGUAJE C

#include <stdio.h>

clearerr

fclose

feof

ferror

fflush

fgetc

fgetpos

fgets

fopen

formato

fprintf

fputc

fputs

fread

freopen

fscanf

fseek

fsetpos

ftell

fwrite

getc

getchar

gets

perror

printf

putc

putchar

puts

remove

rename

rewind

scanf

setbuf

setybuf

sprintf

sscanf

tmpfile

tmpnam

ungetc

vfprintf

vprintf

vsprintf

#include <stdlib.h>

abort

abs

atexit

atof

atoi

atol

bsearch

calloc

div

exit

free

getenv

labs

ldiv

malloc

mblen

mbstowcs

mbtowc

qsort

rand

Realloc

srand

strtod

strtol

strtoul

system

wctomb

 

#include <string.h>

memchr

memcmp

memcpy

memmove

memset

strcat

strchr

strcmp

strcoll

strcpy

strcspn

strerror

strlen

strmcat

strmcmp

strmcpy

strpbrk

strrchr

strspn

strstr

strtok

strxfrm

 

 

 

 

 

 

#include <ctype.h>

tolower

toupper

 

 

 

 

 

#include <locale.h>

localeconv

setlocale

 

 

 

 

 

 

 

#include <math.h>

Acos

Asin

atan

atan2

ceil

cos

cosh

Exp

Fabs

floor

fmod

frexp

ldexp

log

log10

modf

pow

sin

sinh

sqrt

tan

tanh

 

 

 

 

 

 

#include <setjmp.h>

longjmp

setjmp

 

 

 

 

 

#include <signal.h>

raise

signal

 

 

 

 

 

#include <time.h>

asctime

clock

ctime

difftime

Gmtime

localtime

mktime

strftime

time

 

 

 

 

 

Otras librerias que no tienen funciones asociadas. Pero tienen macros constantes y/o estructuras.

·         #include <assert.h>

·         #include <errno.h>

·         #include <float.h>

·         #include <limits.h>

·         #include <stdarg.h>

·         #include <stddef.h>

RESUMEN DE LIBRERIAS

Ø  assert.h Contiene una macro para el diagnóstico dentro de los programas.

Ø  ctype.h Contiene varias funciones para comprobación de tipos y transformación de caracteres.

Ø  errno.h Contiene varias macros usadas para informar de errores.

Ø  limits.h Contienen varias macros que definen constantes para el tamaño de tipo enteros.

Ø  float.h Contienen varias macros que definen constantes para el tamaño de tipo flotante.

Ø  locale.h Contienen varias macros, funciones y tipos para unidades locales, como unidad monetaria, tiempo, dígitos, etc.

Ø  math.h Contiene una macro y varias funciones matemáticas.

Ø  setjmp.h Contienen declaraciones que proporcionan una forma de evitar la secuencia normal de llamada y regreso de funciones.

Ø  signal.h Contiene un tipo, dos funciones y varias macros para manejar condiciones excepcionales que aparecen durante la ejecución, tal como una señal de interrupción de una fuente externa o un error en la ejecución.

Ø  stdarg.h Contiene un tipo y tres macros que proporcionan recursos para recorrer una lista de argumentos de función de tamaño y tipo desconocido.

Ø  stddef.h Contiene varios tipos y macros que también están definidas en otras librerías, como size_t.

Ø  stdio.h Contiene tipos, macros y funciones para la realización de tareas de E/S.

Ø  stdlib.h Contiene tipos, macros y funciones para la conversión numérica, generación de números aleatorios, búsquedas y ordenación, gestión de memoria y tareas similares.

Ø  string.h Contiene tipos, macros y funciones para la manipulación de cadenas de caracteres.

Ø  time.h Contiene tipos, macros y funciones para la la manipulación de información sobre fechas y horas.

 

Tipos: char, int, float, long, long long, short, double, void.

CADENAS DE FORMATO

d, i

entero decimal con signo

o

entero octal sin signo

u

entero decimal sin signo

x

entero hexadecimal sin signo (en minúsculas)

X

entero hexadecimal sin signo (en mayúsculas)

f

Coma flotante en la forma [-]dddd.dddd

e

Coma flotante en la forma [-]d.dddd e[+/-]ddd

g

Coma flotante según el valor

E

Como e pero en mayúsculas

G

Como g pero en mayúsculas

c

un carácter

s

cadena de caracteres terminada en '\0'

%

imprime el carácter %

p

puntero

SECUENCIA DE ESCAPE

\a

Alerta

\b

Espacio atrás

\f

Salto de página

\n

Salto de línea

\r

Retorno de carro

\t

Tabulación horizontal

\v

Tabulación vertical

\\

Barra invertida

\'

Comilla simple

\"

Comillas dobles

\OOO

Visualiza un carácter cuyo código ASCII es OOO en octal

\xHHH

Visualiza un carácter cuyo código ASCII es HHH en hexadecimal

Funcionabilidad de la Función System, que pertenece a la librería <stlib.h>

Colores de Fondo

0 = Negro
1 = Azul
2 = Verde
3 = Aguamarina
4 = Rojo
5 = Púrpura
6 = Amarillo
7 = Blanco
8 = Gris
9 = Azul claro

Colores de Fuente
a = Verde claro
b = Aguamarina claro
c = Rojo claro
d = Púrpura claro
e = Amarillo claro
f = Blanco brillante

Repost 0
Published by Prof.Luis Eduardo Aponte - en Basica
Comenta este artículo
23 marzo 2009 1 23 /03 /marzo /2009 22:08

Buenas Tardes, Cordiales Saludos.

Le estoy remitiendo un link para la la Descarga del Compilador Dev-C++, compatible con Sistemas Opertivos Windows 7 y Vista.


http://dev-c.softonic.com/

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

Presentación

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

Enlaces