hola amigo muy buenos ejercicios... tendras algunos de cadenas por alli?

Hola alguien puede mirar este programa para ver los errores de codificacion que tiene que no soy capaz de solucionar, el error tiene que estar por donde esta señalado.gracias


#include <stdio.h>
#include <conio.h>

#define MAXPER 100
#define IMPED 1200
#define LIMING 30000
#define DIVIN 120000
#define FIN "XXXX"

/* se define la estructura del registro que mas adelante se utilizara*/
typedef struct
 {
  char nom[10],ape[10];
  float ing;
 }tPersona;

/*se definen los modulos que se van a ulilizar en el modulo principal*/
void recuperarPers(char[],tPersona[],int*);
int leerEntero(int,int);
void aniadirPers(tPersona[],int*,int);
void mostrarPers(tPersona[],int);
void eliminarPers(tPersona[],int*);
void calcImpuestos(tPersona[],int);
void grabarPers(char [],tPersona[],int);


void main()
 {
  tPersona pers[MAXPER];
  int np,opc;
  clrscr();
  /*llamada al modulo recuperarPers*/
  recuperarPers("PERSONAS.DAT",pers,&np);

  do
    {
     printf("1. A¤adir personas\n2. Mostrar personas\n3. Eliminar una persona\n4. Impuestos\n5. Salir\nIntroduce una opci¢n: ");
     /*llamada al modulo leerEntero que devuelve un numero del 1 al 5 que se le asocia a la variable opc*/
     opc=leerEntero(1,5);
     switch(opc)
      {
   case 1:
     {
      /*llamada al modulo aniadirPers*/
      aniadirPers(pers,&np,MAXPER);
      /*llamada al modulo grabarPers*/
      grabarPers("PERSONAS.DAT",pers,np);
     }
     break;
   case 2:
     {
      /*llamada al modulo mostrarPers*/
      mostrarPers(pers,np);
     }
     break;
   case 3:
     {
     /*llamada al modulo eliminarPers*/
      eliminarPers(pers,&np);
      /*llamada al modulo grabarPers*/
      grabarPers("PERSONAS.DAT",pers,np);
     }
     break;
   case 4:
     {
      /*llamada al modulo calcImpuestos*/
      calcImpuestos(pers,np);
     }
     break;
      }
    }
  while(opc!=5);
  getch();
 }
/* cuerpo del modulo recuperarPers(lee el numero de personas y la lista de personas)*/
void recuperarPers(char PERSONA.DAT[],tPersona pers[],int *pnp)
 {
  FILE *fpers;
  /*se abre el archivo para saber si ya hay algo escrito en el*/
  fpers=fopen("PERSONAS.DAT","r");
  if (fpers==NULL)
    {
     *pnp=0;
    }
  else
    {
     /*si no esta vacio el archivo lee el numero de personas y la lista de personas y las lleva al modulo principal*/
     fread(*pnp,sizeof(int),1,fpers);
     fread(pers,sizeof(tPersona),*pnp,fPers);
     fclose(fPers);
    }
 }


/* cuerpo del modulo leerEntero(limita el intervalo de numero que el usuario puede escoger*/
int leerEntero(int MINIMO,int MAXIMO)
 {
  int n;
  printf("\nIntroduce una opci¢n: ");
  scanf("%d",&n);
  while(n<MINIMO||n>MAXIMO)
    {
     printf("\nError, debe estar en el intervalo [%d,%d]: ",MINIMO,MAXIMO);
     scanf("%d",&n);
    }
  /*devuelve "n" al modulo principal*/
  return(n);
 }

#define MAXPER 100
#define FIN "XXXX"
/* se define el modulo que va a ser ulilizado dentro del modulo aniadirPers*/
float leerNoNegativo()
/*cuerpo del modulo aniadirPers(a¤ade personas a la lista)*/
void aniadirPers(tPersona pers[],int *pnp,int MAXPER)
 {
  char apellido[];
  /*solo se podra a¤adir una persona mas si la lista no esta llena*/
  if(*pnp<MAXPER)
    {
     printf("PERSONA %d:",*pnp);
     printf("\nApellido: ");
     /* introducir el apellido a la lista*/
     flushall();
     gets(apellido);
     strupr(apellido);
     /* si el apellido es = a FIN no se a¤ade a la lista y se sale de ella*/
     while(apellido!=FIN && *pnp<=MAXPER)
       {
   /*se le asocia el apellido introducido por el usuario al registro definido anteriormente*/
   pers[*pnp].ape=apellido;
   printf("\nNombre:");
   /*se introduce el nombre*/
   flushall();
   gets(pers[*pnp].nom);
   strupr(pers[*pnp].nom);
   printf("\nIngresos:");
   /*se llama al modulo leerNoNegativo y se asocia a la parte de ingresos del registro*/
   pers[*pnp].ing=leerNoNegativo();
   *pnp=*pnp+1;
   /* te vuelve a pedir otro apellido y empezar el ciclo solo si no se supera el maximo de personas*/
   if(*pnp<MAXPER)
     {
      printf("\nPersona %d:",*pnp);
      printf("\nApellido: ");
      flushall();
      gets(apellido);
      strupr(apellido);
     }
   else
     {
      printf("\nSe ha alcanzado el n£mero m ximo de personas.");
     }
       }
  else
    {
     printf("\nSe ha alcanzado el n£mero m ximo de personas.");
    }
 }
/* cuerpo del modulo leerNoNegativo( lee el numero si es negativo te pide otro asta que sea positivo)*/
float leerNoNegativo()
 {
  float n;
  scanf("%f",&n);
  while(n<0)
    {
     printf("\nError: el n£mero ha de ser mayor o igual que cero.");
     scanf("%f",&n);
    }
  return(n);
 }
/* cuerpo del modulo mostrarPers(muestra por pantalla la lista de personas)*/
void mostrarPers(tPersona pers[],int np)
 {
  int iP;
  clrscr();
  printf("Id.  APELLIDO   NOMBRE     INGRESOS\n===================================");
  for(iP=0;iP<=np-1;iP=iP+1)
    {
     /*muestra por pantalla lo que esta almacenado en el registro*/
     printf("\n  %2d. %11s%11s%f.2",iP+1,pers[iP].ape,pers[iP].nom,pers[iP].ing);
     if((iP+1%20)=0)
       {
   getch();
   clrscr();
       }
    }
 }
/* se define el modulo leerEntero que sera utilizado dentro del modulo eliminarPers*/
int leerEntero(int,int);

/*cuerpo del modulo eliminarPers(sirve para eliminar nombres de la lista y sus datos asociados en el registro)*/
void eliminarPers(tPersona pers[],int *pnp)
 {
  int nOrd,iP;
  printf("\nIntroduce el n£mero de orden de la persona a eliminar (0-cancelar): ");
  nOrd=leerEntero(0,*pnp);
  /* si el nOrd(numero de orden en la lista) es distinto de 0 se elimina el nombre que este en ese numero de orden*/
  if(nOrd!=0)
    {
     for(iP=nOrd;iP<=*pnp,iP=iP+1)
       {
   /*la persona de esa posicion toma el nombre del siguiente y se borra el seleccionado*/
   pers[iP-1]=pers[iP];
       }
     *pnp=*pnp-1;
    }
 }
#define IMPED 1200
#define LIMING 30000
#define DIVIN 120000

/*cuerpo del modulo calcImpuestos(calcula los impuestos que se utilizaran para cada familia)*/
void calcImpuestos(tPersona pers[],int np)
 {
  int iP,fin,nDed;
  float ingFam,ingAj,impFam,porc;
  if(np>0)
    {
     clrscr();
     printf("FAMILIA     IMPUESTOS\n=====================)");
     iP=0;
     do
       {
   /*se igualan las variables a 0*/
   fin=0;
   nDed=0;
   ingFam=0;
   do
     {
      /*si los ingresos de una persona son nulos se a¤ade una deduccion a la familia*/
      if(pers[iP].ing=0)
        {
         nDed=nDed+1;
        }
      /* si tiene algun ingreso se le suma al ingreso familiar*/
      else
        {
         ingFam=ingFam+pers[iP].ing;
        }
      if(iP=np-1)
        {
         /* se iguala a 1 la variable fin si ya no hay mas personas sobre las que calcular los impuestos para salir del bucle*/
         fin=1;
        }
      /* si no es la ultima persnoa se compara el siguiente apellido para ver si es de la misma familia*/
      else
        {
         if(pers[iP].ape!=pers[iP+1].ape
      {
       fin=1;
      }
      /* se pasa al siguiente nombre de la lista*/
      iP=iP+1;
     }
   /*cuando se termina con una familia (fin=1) se procede a hacer los calculos */
   while(fin==1);
   /*ingreso ajustado teniendo en cuenta el numero de deducciones de la familia*/
   ingAj=ingFam-IMPDED*nDed;
   if(ingAj>0)
     {
      /*se comparan los ingresos ajustados con el limite de ingresos para hacer los calculos dependiendo de ello*/
      if(ingAj>LIMING)
        {
         porc=(LIMING/DIVING);
        }
      else
        {
         porc=(ingAj/DIVING);
        }
      impFam=porc*ingAj;
     }
   else
     {
      impFam=0;
     }
       }
     while(iP<=np-1);
    }
 }
/*cuerpo del modulo grabarPers(graba los cambios que se producen)*/
void grabarPers(char nomArch[],tPersona pers [],int np)
 {
  FILE *Fpers;
  /*se abre el archivo en modo escritura*/
  fPers=fopen(nomArch"w");
  /*se guarda el tama¤o y la lista*/
  fwrite(&np,sizeof(int),1,fPers);
  fwrite(pers,sizeof(tPersonas),np,fPers);
  /*se cierra el archivo*/
  fclose(fPers);
 }

Realmente no es %10 sino %  exclusivamente, ese es el operador Modulus en C/C++ sirve para evaluar el residuo de una division (Si el residuo de la division es par pues el resultado es cero, si el residuo de la division es impar pues el resultado es otro numero distinto a cero).

Por lo que, al hacer:

int d1=numero%10;

Lanzaria el residuo final de numero / 10   Si resulta que el residuo es equivalente a un numero par.. lanzara cero, pero si el residuo es equivalente a un numero impar lanzara el resultado o residuo real (cualquier numero diferente a Cero).

Yo tengo una duda:
En condicional (if, while, for) se puede elaborar centinela. ¿En arreglos u matrices se puede hacer también eso?

ola recien stoy aprendiendo el c++ alguien podria ayudarme con esto;
programa en c++ q obtenga la relacion de triangulos rectangulos de lados menores q 50, en la cual su hipotenusa sea un numero primo.

he avansado con esto.....

#include<iostream.h>
#include<stdlib.h>
#include<conio.h>
#include<stdio.h>
#include<math.h>

void main()

{   int a,b,c,i;      
      for(a=1;a<50;a++)
      for(b=1;b!=a;b++)
      for(c=1;c<50;c++)
      if(c*c==a*a+b*b)
   cout<<"Lado a "<<a<<" Lado b "<<b<<" Hipotenusa "<<c<<endl;
   int cont_pri=0;
   while(cont_pri<100)
   {   int cont_div=0;
      for (i=1;i<=c;i++);
      {   if (c%i==0)
            cont_div++;
      }
      if (cont_div==2)
      {   cout<<"Lado a "<<a<<" Lado b "<<b<<" Hipotenusa "<<c<<endl;
         cont_pri++;
      }
   }
   cout<<endl;
}

quiero k alguien m ayude a hacer 4 programas de vectores los k sean