Tema: ayuda para ver errores
Ver Mensaje Individual
  #1 (permalink)  
Antiguo 31/01/2010, 15:48
jares88
 
Fecha de Ingreso: enero-2010
Mensajes: 3
Antigüedad: 14 años, 9 meses
Puntos: 0
ayuda para ver errores
hola alguien puede ayudarme a arreglar los errores que tenga el programa me da error por la linea 136 y alguno mas

Código C++: 
Ver original
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6.  
  7. #define MAXPER 100
  8. #define IMPED 1200
  9. #define LIMING 30000
  10. #define DIVIN 120000
  11. #define FIN "XXXX"
  12.  
  13. /* se define la estructura del registro que mas adelante se utilizara*/
  14. typedef struct
  15.  {
  16.   char nom[10],ape[10];
  17.   float ing;
  18.  }tPersona;
  19.  
  20. /*se definen los modulos que se van a ulilizar en el modulo principal*/
  21. void recuperarPers(char[],tPersona[],int*);
  22. int leerEntero(int,int);
  23. void aniadirPers(tPersona[],int*,int);
  24. void mostrarPers(tPersona[],int);
  25. void eliminarPers(tPersona[],int*);
  26. void calcImpuestos(tPersona[],int);
  27. void grabarPers(char[],tPersona[],int);
  28.  
  29.  
  30.  
  31. void main()
  32.  {
  33.   tPersona pers[MAXPER];
  34.   int np,opc,maxp;
  35.   clrscr();
  36.   /*llamada al modulo recuperarPers*/
  37.   recuperarPers("PERSONAS.DAT",pers,&np);
  38.  
  39.   do
  40.     {
  41.      printf("1. A¤adir personas\n2. Mostrar personas\n3. Eliminar una persona\n4. Impuestos\n5. Salir\nIntroduce una opci¢n: ");
  42.      /*llamada al modulo leerEntero que devuelve un numero del 1 al 5 que se le asocia a la variable opc*/
  43.      opc=leerEntero(1,5);
  44.      switch(opc)
  45.       {
  46.     case 1:
  47.       {
  48.        /*llamada al modulo aniadirPers*/
  49.        aniadirPers(pers,&np,maxp);
  50.        /*llamada al modulo grabarPers*/
  51.        grabarPers("PERSONAS.DAT",pers,np);
  52.       }
  53.       break;
  54.     case 2:
  55.       {
  56.        /*llamada al modulo mostrarPers*/
  57.        mostrarPers(pers,np);
  58.       }
  59.       break;
  60.     case 3:
  61.       {
  62.       /*llamada al modulo eliminarPers*/
  63.        eliminarPers(pers,&np);
  64.        /*llamada al modulo grabarPers*/
  65.        grabarPers("PERSONAS.DAT",pers,np);
  66.       }
  67.       break;
  68.     case 4:
  69.       {
  70.        /*llamada al modulo calcImpuestos*/
  71.        calcImpuestos(pers,np);
  72.       }
  73.       break;
  74.       }
  75.     }
  76.   while(opc!=5);
  77.   getch();
  78.  }
  79. /* cuerpo del modulo recuperarPers(lee el numero de personas y la lista de personas)*/
  80. void recuperarPers(char nomArch[],tPersona pers[],int *pnp)
  81.  {
  82.   FILE *fpers;
  83.   /*se abre el archivo para saber si ya hay algo escrito en el*/
  84.   fpers=fopen(nomArch,"r");
  85.   if (fpers==NULL)
  86.     {
  87.      *pnp=0;
  88.     }
  89.   else
  90.     {
  91.      /*si no esta vacio el archivo lee el numero de personas y la lista de personas y las lleva al modulo principal*/
  92.      fread(pnp,sizeof(int),1,fpers);
  93.      fread(pers,sizeof(tPersona),*pnp,fpers);
  94.      fclose(fpers);
  95.     }
  96.  }
  97.  
  98.  
  99. /* cuerpo del modulo leerEntero(limita el intervalo de numero que el usuario puede escoger*/
  100. int leerEntero(int MINIMO,int MAXIMO)
  101.  {
  102.   int n;
  103.   printf("\nIntroduce una opci¢n: ");
  104.   scanf("%d",&n);
  105.   while(n<MINIMO||n>MAXIMO)
  106.     {
  107.      printf("\nError, debe estar en el intervalo [%d,%d]: ",MINIMO,MAXIMO);
  108.      scanf("%d",&n);
  109.     }
  110.   /*devuelve "n" al modulo principal*/
  111.   return(n);
  112.  }
  113.  
  114. #define MAXPER 100
  115. #define FIN "XXXX"
  116. /* se define el modulo que va a ser ulilizado dentro del modulo aniadirPers*/
  117.  
  118. float leerNoNegativo(float);
  119. /*cuerpo del modulo aniadirPers(a¤ade personas a la lista)*/
  120. void aniadirPers(tPersona pers[],int *pnp,int maxp)
  121.  {
  122.   char apellido[10];
  123.   /*solo se podra a¤adir una persona mas si la lista no esta llena*/
  124.   if(*pnp<maxp)
  125.     {
  126.      printf("PERSONA %d:",*pnp);
  127.      printf("\nApellido: ");
  128.      /* introducir el apellido a la lista*/
  129.      flushall();
  130.      gets(apellido);
  131.      strupr(apellido);
  132.      /* si el apellido es = a FIN no se a¤ade a la lista y se sale de ella*/
  133.      while(strcmp(apellido,FIN)!=0 && *pnp<=maxp)
  134.        {
  135.     /*se le asocia el apellido introducido por el usuario al registro definido anteriormente*/
  136.     pers[*pnp].ape=apellido;
  137.     printf("\nNombre:");
  138.     /*se introduce el nombre*/
  139.     flushall();
  140.     gets(pers[*pnp].nom);
  141.     strupr(pers[*pnp].nom);
  142.     printf("\nIngresos:");
  143.     leerNoNegativo(n);
  144.     /*se llama al modulo leerNoNegativo y se asocia a la parte de ingresos del registro*/
  145.     pers[*pnp].ing=leerNoNegativo(n);
  146.     *pnp=*pnp+1;
  147.     /* te vuelve a pedir otro apellido y empezar el ciclo solo si no se supera el maximo de personas*/
  148.     if(*pnp<maxp)
  149.       {
  150.        printf("\nPersona %d:",*pnp);
  151.        printf("\nApellido: ");
  152.        flushall();
  153.        gets(apellido);
  154.        strupr(apellido);
  155.       }
  156.     else
  157.       {
  158.        printf("\nSe ha alcanzado el n£mero m*ximo de personas.");
  159.       }
  160.        }
  161.     }
  162.   else
  163.     {
  164.      printf("\nSe ha alcanzado el n£mero m*ximo de personas.");
  165.     }
  166.  }
  167. /* cuerpo del modulo leerNoNegativo( lee el numero si es negativo te pide otro asta que sea positivo)*/
  168. float leerNoNegativo(float n)
  169.  {
  170.   float n;
  171.   scanf("%f",&n);
  172.   while(n<0)
  173.     {
  174.      printf("\nError: el n£mero ha de ser mayor o igual que cero.");
  175.      scanf("%f",&n);
  176.     }
  177.   return (n);
  178.  }
  179. /* cuerpo del modulo mostrarPers(muestra por pantalla la lista de personas)*/
  180. void mostrarPers(tPersona pers[],int np)
  181.  {
  182.   int iP;
  183.   clrscr();
  184.   printf("Id.  APELLIDO   NOMBRE     INGRESOS\n===================================");
  185.   for(iP=0;iP<=np-1;iP=iP+1)
  186.     {
  187.      /*muestra por pantalla lo que esta almacenado en el registro*/
  188.      printf("\n  %2d. %11s%11s%f.2",iP+1,pers[iP].ape,pers[iP].nom,pers[iP].ing);
  189.      if((iP+1%20)=0)
  190.        {
  191.     getch();
  192.     clrscr();
  193.        }
  194.     }
  195.  }
  196. /* se define el modulo leerEntero que sera utilizado dentro del modulo eliminarPers*/
  197. int leerEntero(int,int);
  198.  
  199. /*cuerpo del modulo eliminarPers(sirve para eliminar nombres de la lista y sus datos asociados en el registro)*/
  200. void eliminarPers(tPersona pers[],int *pnp)
  201.  {
  202.   int nOrd,iP;
  203.   printf("\nIntroduce el n£mero de orden de la persona a eliminar (0-cancelar): ");
  204.   nOrd=leerEntero(0,*pnp);
  205.   /* si el nOrd(numero de orden en la lista) es distinto de 0 se elimina el nombre que este en ese numero de orden*/
  206.   if(nOrd!=0)
  207.     {
  208.      for(iP=nOrd;iP<=*pnp,iP=iP+1)
  209.        {
  210.     /*la persona de esa posicion toma el nombre del siguiente y se borra el seleccionado*/
  211.     pers[iP-1]=pers[iP];
  212.        }
  213.      *pnp=*pnp-1;
  214.     }
  215.  }
  216. #define IMPED 1200
  217. #define LIMING 30000
  218. #define DIVIN 120000
  219.  
  220. /*cuerpo del modulo calcImpuestos(calcula los impuestos que se utilizaran para cada familia)*/
  221. void calcImpuestos(tPersona pers[],int np)
  222.  {
  223.   int iP,fin,nDed;
  224.   float ingFam,ingAj,impFam,porc;
  225.   if(np>0)
  226.     {
  227.      clrscr();
  228.      printf("FAMILIA     IMPUESTOS\n=====================)");
  229.      iP=0;
  230.      do
  231.        {
  232.     /*se igualan las variables a 0*/
  233.     fin=0;
  234.     nDed=0;
  235.     ingFam=0;
  236.     do
  237.       {
  238.        /*si los ingresos de una persona son nulos se a¤ade una deduccion a la familia*/
  239.        if(pers[iP].ing=0)
  240.          {
  241.           nDed=nDed+1;
  242.          }
  243.        /* si tiene algun ingreso se le suma al ingreso familiar*/
  244.        else
  245.          {
  246.           ingFam=ingFam+pers[iP].ing;
  247.          }
  248.        if(iP=np-1)
  249.          {
  250.           /* se iguala a 1 la variable fin si ya no hay mas personas sobre las que calcular los impuestos para salir del bucle*/
  251.           fin=1;
  252.          }
  253.        /* si no es la ultima persnoa se compara el siguiente apellido para ver si es de la misma familia*/
  254.        else
  255.          {
  256.           if(pers[iP].ape!=pers[iP+1].ape
  257.         {
  258.          fin=1;
  259.         }
  260.        /* se pasa al siguiente nombre de la lista*/
  261.        iP=iP+1;
  262.       }
  263.     /*cuando se termina con una familia (fin=1) se procede a hacer los calculos */
  264.     while(fin==1);
  265.     /*ingreso ajustado teniendo en cuenta el numero de deducciones de la familia*/
  266.     ingAj=ingFam-IMPDED*nDed;
  267.     if(ingAj>0)
  268.       {
  269.        /*se comparan los ingresos ajustados con el limite de ingresos para hacer los calculos dependiendo de ello*/
  270.        if(ingAj>LIMING)
  271.          {
  272.           porc=(LIMING/DIVING);
  273.          }
  274.        else
  275.          {
  276.           porc=(ingAj/DIVING);
  277.          }
  278.        impFam=porc*ingAj;
  279.       }
  280.     else
  281.       {
  282.        impFam=0;
  283.       }
  284.        }
  285.      while(iP<=np-1);
  286.     }
  287.  }
  288. /*cuerpo del modulo grabarPers(graba los cambios que se producen)*/
  289. void grabarPers(char nomArch[],tPersona pers [],int np)
  290.  {
  291.   FILE *fpers;
  292.   /*se abre el archivo en modo escritura*/
  293.   fpers=fopen(nomArch"w");
  294.   /*se guarda el tama¤o y la lista*/
  295.   fwrite(&np,sizeof(int),1,fpers);
  296.   fwrite(pers,sizeof(tPersonas),np,fpers);
  297.   /*se cierra el archivo*/
  298.   fclose(fpers);
  299.  }
Última edición por jares88; 01/02/2010 a las 03:03 Razón: voy editando si soluciono algo