error al compilar; URGENTE¡¡¡¡¡¡!!!!!!!!!!!!!!!!!!

[yaye]

hola, estoy con un programa de gestion deportiva, pero me he creado unos array como variables locales y me da error al compilar, quien me ayuda??

Código (cpp) [Seleccionar] Expandir


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//#define L_INSTALACION_DEPORTIVA 3

struct categoria_deportiva{
char identificador[3];
char nombre[40];
char descripcion[100];
int contador_instalaciones;
struct instalacion_deportiva array_instalacion[23];//[L_INSTALACION_DEPORTIVA];
};
struct socio{
int num;
char nombre[20];
char apellidos [30];
char dni [10];
char direccion[40];
int telefono;
};
struct  socio array_socios[50];
contador_socio=0;
struct reserva{
int numero_socio;
char identificador[6];
int dia;
char mes;
int hora_inicio;
int hora_final;

};

struct instalacion_deportiva{
char codigo[10];
char nombre[40];
char descripcion[100];
float dimensiones;
int telefono;
float precio;
char calle[100];
int numero[4];
char ciudad[20];
struct reserva array_reservas[30];
int contador_reservas=0;

};
struct categoria_Deportiva array_categorias[10];
contador_categorias=0;

int menu(void);
void alta_categoria(void);
int buscar_caracter(char[],char);
char* trozo_cadena(char[], int);
int borrar_categoria(struct categoria_deportiva[],int,char);
void alta_instalacion(void);
int borrar_instalacion(struct instalacion_deportiva[],int);
void alta_socio(void);
void borrar_socio(struct socio[],int);
void reserva(void);

int main  (void){

   int opcion, pos;

 
 
 

   while(1){
      opcion=menu();
  int clave_buscar;
  int contador_categorias=0;
  int
      switch (opcion){
          case 1:
              alta_categoria();
              printf("\n\n");
              break;
          case 2:
           
             pos=borrar_categoria( array_categorias,contador_categorias,clave_buscar);
           break;      


           case 3:
          alta_instalacion();
          printf("\n\n");
   break;

      case 4:
           pos=borrar_instalacion(array_instalacion,contador_instalaciones);
           break;
     

      case 5:
          alta_socio();
          printf("\n\n");
          break;
case 6:

break;
case 7:
alta_reserva();
printf("\n\n");
break;
case 8:
exit(0);
               printf("\n\nEl Programa ha terminado\n\n");
               break;



           default:
               printf("\nOpcion incorrecta, seleccione una opcion del listado.\n\n");
               break;
       }

   }    while (opcion != 8);

   return 0;




int menu(){
int opcion;
printf("opcion 1: dar de alta nueva catgoria\n");
printf("opcion 2: dar de baja una categoria\n");
printf("opcion 3: dar de alta nueva instalacion\n");
printf("opcion 4: dar de baja una instalacion\n");
printf("opcion 5: dar de alta un nuevo socio\n");
printf("opcion 6: dar de baja un socio\n");
printf("opcion 7: realizar una reserva\n");
printf("opcion 8: salir");

printf("elija una opcion");
scanf("%d",&opcion);
return opcion;
}

void alta_categoria(){//aqui pongo el nimbre de la estructura en la que tengo que trabajar y como la voy a llaar. ref de ref. bibliograficas y struct ref... que es el tipo que devuelve
  printf("\nintroduzca el identificador: ");
   fflush(stdin);
 gets(array_categorias[contador_categorias].identificador);
  printf("intoduzca el nombre: ");
   fflush(stdin);
  gets(array_categorias[contador_categorias].nombre);
  printf("introduzca la descricion: ");
   fflush(stdin);
  gets(array_categorias[contador_categorias].descripcion);
 
contador_categorias++;

}

int buscar_caracter(char* cadena,char caracter){
       for (int i=0;i<strlen(cadena);i++){
               if(cadena[i]==caracter){
                       return i;
               }
       }
       return -1;

}

char* trozo_cadena(char clave[], int pos){//me localiza el identificador numerico
       char* cad;
       int j=0;
       for(int i=pos; i<strlen(clave); i++){
             
                   break;
               cad[j]=clave[i];
               j++;

       }

       return cad;
}








int borrar_categoria(struct categoria_deportiva array_categria[], int contador_caegoria_dep, char *clave_buscar){
char clave_buscar[9];
int contador_instalaciones;
int contador_categoria_dep;
char respuesta;
         
           printf("introduzca el identificadorque quiere borrar:\n");
            fflush(stdin);
           gets(clave_buscar);//una vez que tengo guardada la clave que quiro buscar la coparo con las posiciones del array.
             
                   if(pos==-1){
                           printf("no se encuentra el identificador");
                   } else  {
                   if (array_categoria[pos].contador_instalaciones >0){
                                   fflush(stdin);
                                   printf("esta categoria tiene al menos una instalacion, desea borrarlo?(s/n)");
                                   scanf("%c",&respuesta);
                   }
                   else if(array_categoria_dep[pos].contador_instalaciones >0  ){
                    respuesta=='s';
                   }
                   
                   if(respuesta=='s'){
                   

                   




                           for(int i=pos;i<contador_categoria_dep-1;i++){//si se cumple la condicion de arriba lo borro con el codigo que viene a continuacion atrasando la posicion en el array
                   //la pisicion me la va a dar la i, asi que igualo j a la posicion que quiero buscar y j tiene que ser menor que el contador catalogo que es el maximo que tenemos en este mometo de elementos de total de caralogos
           //ahora lo que tengo que hacer una vez localizada la posocion es borrarlo y mover todos los elementos uno para atras.lo hago copiando a la siguiente posicion.
           

//array_categoria_dep[]
strcpy(array_categoria_dep[i].identificador,array_categoria_dep[i+1].identificacdor);//con esto copio campo a campo en la posicion siguiente
           strcpy(array_categoria_dep[i].nombre,array_categoria_dep[i+1].nombre);
           strcpy(array_categoria_dep[i].descripcion,array_categoria_dep[i+1].descripcion);
           array_categoria_dep[i].contador_instalaciones = array_categoria_dep[i+1].contador_instalaciones;
           for(int j=0;j<array_categoria_dep[i].contador_instalaciones;j++){//vaciar las instalaciones de la posicion j del categoria.
           strcpy(array_categoria_dep[i].array_instalaciones[j].codigo,"");//ponemos las "" por que estamos dejando la cadena vacia, es decir vamos a vaciar esa referencia y rellenerla con la siguiente
          strcpy(array_categoria_dep[i].array_instalaciones[j].nombre,"");
          strcpy(array_categoria_dep[i].array_instalaciones[j].descripcion,"");
           strcpy(array_categoria_dep[i].array_instalaciones[j].dimensiones,"");
           strcpy(array_categoria_dep[i].array_instalaciones[j].precio,"");
          array_categoria_dep[i].array_instalaciones[j].telefono=0;//vaciar la referencia, al ser un entero las ponemos a 0
           strcpy(array_categoria_dep[i].array_instalaciones[j].calle,"");
           strcpy(array_categoria_dep[i].array_instalaciones[j].ciudad,"");
           array_categoria_dep[i].array_instalaciones[j].numero=0;
}

         
   }

  for(int i=0; i<contador_categoria_dep; i++){
      if(strcmp( array_categoria_deportiva[i].identificador,clave_buscar)==0){//comparo la clave de cada posicion del catalogo con la clave que estamos buscando que es la clave_buscar.
           return i;//i es la posicion donde la he encontrado.
       }
  }

  return -1; // si no lo encuentro
}

void alta_instalacion(){//aqui pongo el nimbre de la estructura en la que tengo que trabajar y como la voy a llaar. ref de ref. bibliograficas y struct ref... que es el tipo que devuelve
  printf("introduzca el codigo: ");
   fflush(stdin);
 gets(array_instalacion[contador_instalaciones].codigo);
  printf("intoduzca el nombre: ");
   fflush(stdin);
  gets(array_instalacion[contador_instalaciones].nombre);
  printf("introduzca la descropcion: ");
   fflush(stdin);
  gets(array_instalacion[contador_instalaciones].descripcion);
  printf("introduzca la dimesion: ");
   fflush(stdin);
  gets("%f",&array_instalacion[contador_instalaciones].dimensiones);
  printf("introduzca el precio: ");
   fflush(stdin);
  gets(array_instalacion[contador_instalaciones].precio);
  printf("introduzca la calle ");
   fflush(stdin);
  gets(array_instalacion[contador_instalaciones].calle);
  fprintf("introduzca el numero");
  fflush(stdin);
  gets(array_instalacion[contador_instalaciones].numero);
  printf("introduzca la ciudad");
  fflush(stdin);
  gets(array_instalacion[contador_instalaciones].ciudad);

  contador_instalaciones++;

}



void borrar_instalacion(struct instalacion_deportiva array_instalaciones_deportivas[],int contador_instalaciones){
int pos;
   char *id;
   char clave_buscar[5];
   char *numero_cadena;//obtenemos el numero del identificador que nos interesa
   int numero_entero;//variable donde guardamos la conversion de esa cadena a numero entero.
   int  posicion_2;//calculamos la posicion que tiene el "-"
   printf("introduzca el identificador de la instalacoin de la que quiere borrar ");
    fflush(stdin);
  gets(clave_buscar);//una vez que tengo guardada la clave que quiro buscar la coparo con las posiciones del array.
         
   pos=buscar_caracter(clave_buscar,'_');
    if(pos==-1){
            printf("no se encuentra la instalacion");
    }
    else{


  // printf("POSICION: %d",pos);
   id=trozo_cadena(codigo,pos);//trozo de cadena  no se la longitud que va a tener y por eso lo almaceno en el puntero id
   //printf("\nCADENA: %s",id);
   for(int i=0;i<contador_instalacion;i++){
       if(strcmp(array_instalacion[i].codigo,id)==0){
       
               
                       numero_cadena=trozo_cadena(clave_buscar,pos);
                       //para pasarlo al numero entero
                       numero_entero=atoi(numero_cadena);

  //ahora vamos a resolver lo del numero de copias si tienes mas copias hay que borrarlas
                        if(array_categorias[pos].array_instalacion[numero_entero].reservas >0){
                        array_categorias[pos].array_instalacion[numero_entero].reservas--;//para restarle una copia
                        if(array_categorias[pos].array_instalacion[numero_entero].reservas==0){

                        strcpy(array_categorias[pos].array_instalacion[numero_entero].codigo,"");//ponemos las "" por que estamos dejando la cadena vacia, es decir vamos a vaciar esa referencia y rellenerla con la siguiente
strcpy(array_categorias[pos].array_instalacion[numero_entero].nombre,"");                        
                       strcpy(array_categorias[pos].array_instalacion[numero_entero].descripcion,"");
                       strcpy(array_categorias[pos].array_instalacion[numero_entero].calle,"");
                       strcpy(array_categorias[pos].array_instalacion[numero_entero].ciudad,"");
                       array_categorias[pos].array_instalacion[numero_entero].dimension =0;//vaciar la referencia, al ser un entero las ponemos a
array_categorias[pos].array_instalacion[numero_entero].precio =0;
array_categorias[pos].array_instalacion[numero_entero].telefono =0;
array_categorias[pos].array_instalacion[numero_entero].numero =0;

                        for(int m=numero_entero;m<array_categorias[pos].contador_instalaciones;m++){
                           //vamos trasladando una posicion posterior  una anterior y la empezamos desde la posicon borrada
                           strcpy(array_categorias[pos].array_instalaciones[m].codigo,array_categorias[pos+1].array_instalacion[m].codigo);
strcpy(array_categorias[pos].array_instalaciones[m].nombre,array_categorias[pos+1].array_instalacion[m].nombre);          
strcpy(array_categorias[pos].array_instalaciones[m].descripcion,array_categorias[pos+1].array_instalacion[m].descripcion);
strcpy(array_categorias[pos].array_instalaciones[m].calle,array_categorias[pos+1].array_instalacion[m].calle);
strcpy(array_categorias[pos].array_instalaciones[m].ciudad,array_categorias[pos+1].array_instalacion[m].ciudad);
array_categorias[pos].array_instalacion[m].dimension =array_categotias[pos+1].array_instalacion[m].dimension;
                          array_categorias[pos].array_instalacion[m].telefono =array_categotias[pos+1].array_instalacion[m].telefono;
                          array_categorias[pos].array_instalacion[m].precio =array_categotias[pos+1].array_instalacion[m].precio;
                          array_categorias[pos].array_instalacion[m].numero =array_categotias[pos+1].array_instalacion[m].numero;

                            array_categorias[pos].contador_instalaciones --;//le estamps restando una posicion.
                        }
                    }
               

            }
        }
       }
     
       }
   }


}



void alta_scio(){
int pos;
array_socios[contador_socios].num=contador_socios;
printf("introduzca el nombre del socio: \n");
fflush(stdin);
gets(array_socios[contador_socios].nombre);
printf("introduzca el apellido: \n");
fflush(stdin);
gets(array_socios[contador_socios].apellidos);
printf("introduzca el dni:\n");
fflush(stdin);
gets(array_socios[contador_socios].dni);
printf("introduzca la direccion");
fflush(stdin);
gets(array_socios[contador_socios].direccion);
printf("introduzc el telefono: \n");
fflush(stdin);
gets(array_socios[contador_socios].telefono);

contador_socios++;

}
int borra_socio(struct socio array_socios[],int contador_socio){
int pos;
printf("introduzca el numero de socio que quiere borrar: \n");
fflush(stdin);
gets(num);

for(int i=pos;i<contador_socio-1;i++){

strcpy(array_socio[pos].nombre,array_socio[pos+1].nombre);
strcpy(array_socio[pos].apellidos,array_socio[pos+1].apellidos);
strcpy(array_socio[pos].dni,array_socio[pos+1].dni);
strcpy(array_socio[pos].direccion,array_socio[pos+1].direccion);
array_socio[pos].telefono =array_socio[pos+1].telefono;
for(int j=0;j<contador_socio;j++){
strcpy(array_socios[i].nombre,"");
strcpy(array_socios[i].apellidos,"");
strcpy(array_socios[i].dni,"");
strcpy(array_socios[i].direccion,"");
array_socios[i].telefono=0;

}

contador_instalaciones --;


}    


void reservas(){

printf("a que categoria pertenece la reserva que quiere realizar: \n");
fflush(stdin);
gets(array_categorias)

pritf("de que instalacion quiere realizar la reserva: \n")
fflush(stdin);
gets(array_instalacion);
printf("introduzca el numero de socio que va a realizar la reserva: \n");
fflush(stdin);
gets(array_reservas[contador_reservas].num_socio);
printf("introduzca el identificador: \n");
fflush(stdin);
gets(array_reservas[contador_reservas].identificador);
printf("introduzca el dia de la reserva: \n");
fflush(stdin);
gets(array_reservas[contador_reservas].dia);
printf("introduzca el mes de la reserva: \n");
fflush(stdin);
gets(array_reservas[contador_reservas].mes);
printf("introduzca la hora de inicio: \n");
fflush(stdin);
gets(array_reservas[contador_reservas].hora_inicio);
printf("introduzca la hora de fin: \n");
fflush(stdin);
gets(array_reservas[contador_reservas].hora_final);
contador_reservas++;

}



[engel lex]

que error de compilación te da?

[yaye]

No me lee las variables globales. Ni struct instalacion_deportiva array_instalacion[23];//[L_INSTALACION_DEPORTIVA];

[ivancea96]

Pon aquí el error tal y como te lo da el compilador.

[MAFUS]

Lo que ocurre es que el compilador trabaja de forma secuencial, es decir, no puedes usar algo sin antes haberlo declarado (haberle dicho al compilador que existe).

Por ejemplo, línea 11:

Código [Seleccionar] Expandir

struct instalacion_deportiva array_instalacion[23];//[L_INSTALACION_DEPORTIVA];

ese struct instalacion_deportiva no existe en el momento de usarlo ya que lo defines en la línea 33.

Así que debes ordenar tu código para usar las cosas en el momento adecuado o haz declaraciones incompletas, eso es, solo defines los tipos de datos y más adelante los defines.