Mensajes

En Windows XP y superiores tienes cmd.exe el interprete de comandos, ahí puedes teclear los comandos.

ss64.com

Te dejo el código que use comentado para que se entienda un poco mejor:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
double inversos (int k);
double cuadrados (int k);
double funcsuma (int n, double (*f)(int k));
/* f es un puntero a función que acepta como argumento un int y que devuelve un double */
/* Es la manera correcta de describir ese parámetro en la función funcsuma */

int main(void)
{
    double (*pf)(int, double (*)(int)) = &funcsuma;

    /* pf es un puntero a función */
    /* pf acepta como argumentos :

    {
        un int
        un puntero a función que acepta un int y que devuelve un double
    }

    Al puntero a función pf le asignamos la dirección de memoria de la función funcsuma
    De ahí que usemos el operador &, aunque se puede omitir.

    */

    /* Invocamos a la función funcsuma a través del puntero que acabamos de declarar que apunta hacia ella */
    /* Como puedes ver, utilizamos los mismos argumentos que la función necesita
         int     double (*)(int)
    pf(   5,         &inversos )

    Pasamos por referencia la función inversos

    */

    printf ("Suma de cinco inversos: %.3f \n", pf(5, &inversos)); //Pasa la direccion de inversos

    printf ("Suma de tres cuadrados: %.3f \n", pf(3, &cuadrados)); //Pasa la direccion de cuadrados
    return 0;
}

double funcsuma (int n, double (*f) (int k))
{ //f recibe la dirección de la función
  double s = 0;
  int i;
  for (i = 1; i <= n; i++)
    s += f (i); //Llamada a la función correspondiente pasandole el valor de i

    /*

    s += f(i);

    Se llama a la función correspondiente, según hallamos invocado.
    pf(5, &inversos) -> s += inversos(i);
    pf(3, &cuadrados) -> s += cuadrados(i)

    */


  return s;
}

double inversos (int k)
{
  return 1.0 / k;
}

double cuadrados (int k)
{
  return (double) k *k;
}


Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

typedef int tipo;

typedef struct Pila
{
   int aux;
   int dato;
   struct Pila *Sig;
} PILAD;


void InsertaPila(PILAD **, tipo);
tipo eliminar(PILAD **);
int Tope(PILAD *);
void BorraPila(PILAD **);
void ImprimirPila(PILAD *);

void InsertaPila(PILAD **top ,tipo Elem)

{
   PILAD *Aux = (PILAD *)malloc(sizeof(PILAD));
   Aux->dato=Elem;
   Aux->Sig = *top;
   *top = Aux;

}

void mostrar(PILAD *p)
{
  PILAD *aux;
  aux = p;
  printf("\nElementos existentes en la Pila:\n");
  if(aux == NULL)
  {
     printf("\n No hay Datos en la Pila!...");
  }
  else
  {
     while(aux != NULL)
     {
        printf("--> %d\n", aux->dato);
        aux = aux->Sig;
     }
  }

}


void tope(PILAD *p)

{
  PILAD *aux;
  aux = p;
  if (aux != NULL)
  {
     printf("\n\nEl Primer ELEMENTO de la Pila es: %i",aux->dato);
  }
}






int eliminar(PILAD **A)
{
   tipo cont;
   PILAD *auxiliar = (PILAD *)malloc(sizeof(PILAD));
   PILAD *aux = *A;

   if(!aux)
   {
       cont = aux->dato;
       *A = (*A)->Sig;
       free(aux);
       return  cont;
   }

   else
   {
        printf("Pila vacia");
        exit(-1);
   }
}



void BorrarPila(PILAD **A)
{
    int Elem;
    while (!A)

    {
        Elem = eliminar (A);
    }

}

void ImprimirPila(PILAD *A)
{
    PILAD *Aux = A;

    int Elem;

//     for(Aux = A; Aux != NULL; Aux = Aux->Sig)
//     {
//         Elem = Aux->dato;
//         printf(" %d \n", Aux->dato);
//     }

       while(Aux != NULL)
       {
           printf(" %d ", Aux->dato);
           Aux = Aux->Sig;
       }
}





//#include "funciones.cpp"

int main ()
{
    char Opc1;
    int Opc2,aux;
    PILAD *A = NULL;

    do
    {
        system("cls");
        printf ("\t\t Estructura Pila Dinamica\n\n\n");
        printf ("1.- Insertar elemento en pila ");
        printf ("\n2.- Quitar elemento de pila");
        printf ("\n3.- Ver el primer elemento y el numero de elemtos en la pila");
        printf ("\n4.- Vaciar la pila");
        printf ("\n5.- Ver elcontenido de la pila");
        printf ("\n6.- Salir de la aplicacion");
        printf ("\n\n\n  Inserta el numero de la funcion a realizar: ");
        scanf ("%d",&Opc2);

        switch(Opc2)

        {
            case 1:
                 system("cls");
                 printf ("\n\n Ingresa un numero para insertar en la pila: ");
                 scanf ("%d",&aux);
                 InsertaPila (&A, aux);
            break;

            case 2:
                 system("cls");
                 printf ("\n\n El ultimo elemento extraido de la pila es: %d",eliminar(&A));

            break;

            case 3:
                 system("cls");
                 //printf ("\n\n El primer elemento de la pila es: %d",Tope (A));
            break;

            case 4:
                 system("cls");
                 BorrarPila(&A);
                 printf ("\n\n La pila a sido eliminada exitosamente");

            break;

            case 5:
                 system("cls");
                 ImprimirPila(A);
            break;

            case 6:
                 exit(-1);
            break;

            default:
                  system("cls");
                  printf ("La opcion no es valida");
            break;
        }

        printf ("\n\nDeseas seguir en esta aplicacion [S/N]: ");
        scanf ("%s",&Opc1);
    }


    while ( Opc1 == 'S'  ||  Opc1 == 's' );
}


Te dejo el programa compilando, tiene bastantes errores, trata de resolverlos sino nos dices para ayudarte.

Algo importante, cuando trabajas con listas enlazadas o pilas, como quieras decirle, cuando vas a empezar a agregar elementos es importante que la inicialices a NULL.

Código (c) [Seleccionar] Expandir

PILAD *A = NULL;

Consejo, usa nombres para las variables que te digan algo, A no es un buen identificador, no dice NADA.

Otra cosa, aunque des la opción de eliminar la pila, debes vaciar la memoria asignada, independientemente de que el usuario no quiera.

Saludos.

[pitoloko]

GRacias pitoloko  si voy a repasar un poco lo que pasa que no domino mucho programacion bath. 

Batch.

Uso el Borland C++ 5.02 .. 

Utiliza otro, el que utilizas está obsoleto.

Necesitas un arreglo dinámico de estructuras. Algo como esto:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

struct people
{
    /* Tú cambias los campos, solo es un ejemplo */
    int x;
    int y;
};

int main(void)
{
    unsigned n;
    printf("Número de personas : ");
    fflush(stdout);
    scanf("%u", &n);

    struct people *personas = malloc(sizeof(struct people) * n);

    unsigned i;

    for(i = 0; i < n; i++)
    {
        printf("personas[%u].x = ", i);
        scanf("%d", &personas[i].x);
        printf("personas[%u].y = ", i);
        scanf("%d", &personas[i].y);
    }

    free(personas);

    return 0;
}


Acomoda los campos a tu conveniencia, nota que hay que liberar la memoria ocupada con free().

El programa  tiene algunos errores.

No puedes comparar el espacio con "num"

Código [Seleccionar] Expandir

while(num!=""){
num es de tipo int, el espacio es un caracter, aparte tu estás tratando de comparar num con la cadena " ".

Lo que puedes hacer es checar la entrada del scanf(), el scanf() te devuelve algo según lo que se haya leído, puedes checar así:

Código (c) [Seleccionar] Expandir


   while(scanf("%d", &numero) != 0)


Es decir, el ciclo terminará cuando se haya ingresado algo que no sea un número, por ejemplo una letra.

Para comprobar si un número es par o impar deberías de checar el residuo.

if(numero % 2 == 0) <---- si el residuo de la división de numero entre 2 es 0, quiere decir que el número es par. También puedes usar la función fmod() definida en math.h para checar el residuo.

Otra cosa, no estás inicializando las variables parp,parn,imparp,imparn por lo que estás acumulando en valores basura.

Otra cosa, se llaman "ciclos", no cyclos.
Otra cosa, no es necesaria la librería conio.h ni getch(). Puedes pausar la ejecución del programa con una función estándard como getchar().

Aquí está la corrección a tu programa, c estándard:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main(void)
{
   int numero = 0;
   int pares = 0;
   int impares = 0;

   printf("Numero : ");
   while(scanf("%d", &numero) != 0)
   {
       if(numero % 2 == 0)
           pares++;
       else
           impares++;
       printf("Numero : ");
   }

   printf("\nPares : %d\nImpares : %d\n", pares, impares);

   while(getchar() != '\n');
   getchar();

   return 0;
}

Una versión más corta:
[code=c]while(scanf("%d", &numero) != 0)
    {
        fmod(numero, 2.0) == 0 ? pares++ : impares++;
        printf("Numero : ");
    }

[/code]

Así es, puedes usar "especificadores de formato", mira un ejemplo:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
int main(void)
{
int valor;
scanf("%*s %d", &valor);
printf("[%d]\n", valor);
return 0;
}


Esto me permite ingresas cosas como:

Código [Seleccionar] Expandir

┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./code
foro.elhacker.net 5
[5]
┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./code
Holaaaaaaaaaaaaaaaaaaaaaaaaaaaa!!!!!!!!!!!! 123
[123]


Lo que pasa es que al poner

Código (c) [Seleccionar] Expandir

scanf("Hola mundo %d", &valor);
Estás diciendo que forzosamente debe de haber la cadena "Hola mundo " antes del número, sino no se asignará correctamente en valor.

Mira la siguiente salida:

Código [Seleccionar] Expandir

┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./args
Hola mundo 123
123
┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./args
Hola mundoo 123
15949812
┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./args
123
2543604
┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./args
hola mundo 123
2785268
┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─> ./args
Hola mundo
123
123
┌─[0 leo@leo-945GCT-M ~/Escritorio]$
└─>


Fijate que solo se asigna correctamente cuando ponemos "Hola mundo " seguido de un número.

Si se te complica entender un poco, personalmente me gusta más manejar las cosas así, aunque basicamente es la misma, pero bueno, me ayuda a entender.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
double inversos (int k);
double cuadrados (int k);
double funcsuma (int n, double (*f) (int k)); //f es un puntero a funcion

int main ()
{
    double (*pf)(int, double (*)(int)) = &funcsuma;
    printf ("Suma de cinco inversos: %.3f \n", pf(5, inversos)); //Pasa la direccion de inversos
    printf ("Suma de tres cuadrados: %.3f \n", pf(3, cuadrados)); //Pasa la direccion de cuadrados
    return 0;
}

double funcsuma (int n, double (*f) (int k))
{ //f recibe la dirección de la función
  double s = 0;
  int i;
  for (i = 1; i <= n; i++)
    s += f (i); //Llamada a la función correspondiente pasandole el valor de i
  return s;
}

double inversos (int k)
{
  return 1.0 / k;
}

double cuadrados (int k)
{
  return (double) k *k;
}