title: Another "expected unqualified-id before numeric constant" error
body: <p>I am trying to get working a very simple C/C++ program and I was struggling the last hours and I can't find the error! It's not homework, just an exercise to remember my old C.</p>
  <p><strong>Main.c</strong></p>
  <pre><code>#include &lt;iostream&gt;
  #include &quot;Persona.h&quot;
  #include &quot;BaseDeDatos.h&quot;
  
  using namespace std;
  
  #define agregarPersona      1
  #define eliminarPersona     2
  #define imprimirListado     3
  #define buscarPersona       4
  #define salir               5
  
  int main(){
      BaseDeDatos datos(&quot;Personas.txt&quot;);
  
      Persona piter(2000, &quot;Andres Ledesma&quot;, &quot;Cabrera 2000&quot;);
      datos.agregarPersona(piter);
  
      return 0;
  }
  </code></pre>
  <p><strong>BaseDeDatos.h</strong></p>
  <pre><code>#ifndef BASEDEDATOS_H
  #define BASEDEDATOS_H
  
  #include &quot;Persona.h&quot;
  #include &lt;inttypes.h&gt;
  #include &lt;vector&gt;
  #include &lt;string.h&gt;
  #include &lt;iostream&gt;
  #include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  
  #define identificadorNombre     '%'
  #define identificadorLegajo     '#'
  #define identificadorDomicilio  '$'
  
  class BaseDeDatos{
      public:
          BaseDeDatos(char nombreDelArchivo[]);
  
          void agregarPersona(Persona persona);
          bool eliminarPersona(long legajo);
          void imprimirListado();
          void buscarPersona(char nombre[]);
  
          ~BaseDeDatos();
  
      private:
          void obtenerLinea(unsigned int x, char buffer[]);
          bool existeEnArray(unsigned int data[], unsigned int tamanio, unsigned int x);
  
          FILE *ptrFile;
          char buffer[40];
          char nombreDelArchivo[40];
  
  };
  
  #endif // BASEDEDATOS_H
  </code></pre>
  <p><strong>BaseDeDatos.c</strong></p>
  <pre><code>#include &quot;BaseDeDatos.h&quot;
  
  BaseDeDatos::BaseDeDatos(char nombreDelArchivo[]){
      strcpy(this-&gt;nombreDelArchivo, nombreDelArchivo);
  
      // Solo para pruebas
      remove(nombreDelArchivo);
  
      if ((ptrFile = fopen(nombreDelArchivo, &quot;r+&quot;)) != NULL){
          std::cout &lt;&lt; &quot;Archivo existe&quot; &lt;&lt; std::endl;
      }else{
          std::cout &lt;&lt; &quot;Archivo no existe. Lo creamos.&quot; &lt;&lt; std::endl;
          ptrFile = fopen(nombreDelArchivo, &quot;w+&quot;);
      }
  
      char dato[41];
      char nombre[40];
      // Leo los nombres mientras no llegue al final del archivo
      while(fgets(dato, 40, ptrFile) != NULL){
          if(dato[0] == identificadorNombre){
              memcpy(nombre, &amp;dato[1], 39);           // Copio el nombre sacando el identidicador
              std::cout &lt;&lt; &quot;Nombre: &quot; &lt;&lt; nombre &lt;&lt; std::endl;
          }
          memset(dato, 0, strlen(dato));      // Borro el nombre para la nueva lectura
          memset(nombre, 0, strlen(nombre));
      }
  }
  
  void BaseDeDatos::agregarPersona(Persona persona){
      fseek(ptrFile, 0, SEEK_END);    // Voy al final del archivo
      fprintf(ptrFile, &quot;%c%ld\n&quot;, identificadorLegajo, persona.obtenerLegajo());
      fprintf(ptrFile, &quot;%c%s\n&quot;, identificadorDomicilio, persona.obtenerDomicilio());
      fprintf(ptrFile, &quot;%c%s\n&quot;, identificadorNombre, persona.obtenerNombreCompleto());
  
      // Escribo al archivo
      fflush(ptrFile);
  }
  
  // Eliminamos a la persona dada tomando como identificador su legajo
  bool BaseDeDatos::eliminarPersona(long legajo){
      unsigned int numeroDeLinea = 0;
      bool encontreLegajo = false;
      long legajoPersona = legajo;
      unsigned int lineasIgnoradas[3];
  
      rewind(ptrFile);    // Vamos al comienzo del archivo
  
      char dato[41];
      char legajoString[40];
      // Busco el legajo de la persona
      while(fgets(dato, 40, ptrFile) != NULL){
          if(dato[0] == identificadorLegajo){
              // Convierto el string (terminado en NULL) en un long en base 10
              memcpy(legajoString, &amp;dato[1], 39);
              long legajo = strtoumax(legajoString, NULL, 10);
  
              if(legajo == legajoPersona){
                  std::cout &lt;&lt; &quot;Legajo encontrado: &quot; &lt;&lt; legajo &lt;&lt; std::endl;
                  encontreLegajo = true;
                  break;
              }
          }
          ++numeroDeLinea;
      }
  
      if(encontreLegajo == false){
          std::cout &lt;&lt; &quot;Legajo no encontrado&quot; &lt;&lt; std::endl;
          return false;
      }
  
      // Lineas a ignorar en el nuevo archivo
      lineasIgnoradas[0] = numeroDeLinea;
      lineasIgnoradas[1] = numeroDeLinea+1;
      lineasIgnoradas[2] = numeroDeLinea+2;
  
      rewind(ptrFile);
      numeroDeLinea = 0;
  
      // Creo un nuevo archivo con la extension .bak donde guardaremos el archivo con las lineas que deseamos eliminar
      char extension[] = {&quot;.bak&quot;};
      char nombreNuevoArchivo[40];
      strcpy(nombreNuevoArchivo, nombreDelArchivo);
      strcat(nombreNuevoArchivo, extension);
  
      FILE *nuevoArchivo = fopen(nombreNuevoArchivo, &quot;w+&quot;);
      while(fgets(dato, 40, ptrFile) != NULL){
          // Si la linea no debe ser ignorada la escribo en el nuevo archivo
          if(existeEnArray(lineasIgnoradas, 3, numeroDeLinea) == false){
              obtenerLinea(numeroDeLinea, buffer);
              std::cout &lt;&lt; &quot;Linea: &quot; &lt;&lt; buffer &lt;&lt; std::endl;
              fputs(buffer, nuevoArchivo);
          }
          ++numeroDeLinea;
      }
  
      // Cerramos ambos archivos
      fclose(ptrFile);
      fclose(nuevoArchivo);
  
      // Eliminamos el archivo viejo
      remove(nombreDelArchivo);
  
      // Renombramos el archivo nuevo que creamos al por defecto
      rename(nombreNuevoArchivo, nombreDelArchivo);
  
      // Abrimos nuevamente el archivo
      ptrFile = fopen(nombreDelArchivo, &quot;r+&quot;);
      return true;
  }
  
  void BaseDeDatos::imprimirListado(){
  
  }
  
  void BaseDeDatos::buscarPersona(char nombre[]){
  
  }
  
  /**
    * Verifica si en el array existe el elemento x
    * @param data array que contiene los datos a comprobar
    * @param tamanio tamaño del array pasado
    * @param x dato que se desea saber si existe en el array pasado
    */
  bool BaseDeDatos::existeEnArray(unsigned int data[], unsigned int tamanio, unsigned int x){
      for(unsigned int n = 0; n &lt; tamanio; ++n){
          if(data[n] == x) return true;
      }
      return false;
  }
  
  void BaseDeDatos::obtenerLinea(unsigned int x, char buffer[]){
      unsigned int numeroDeLinea = 0;
      int c;
      char dato[40];
  
      rewind(ptrFile);
      if(x == 0) {
          fgets(dato, 40, ptrFile);
          strcpy(buffer, dato);
          return;
      }
      while((c = fgetc(ptrFile)) != EOF){
          // 10 es el fin de linea LF (Line feed)
          if(c == 10){
              ++numeroDeLinea;
          }
          if(numeroDeLinea == x){
              fgets(dato, 40, ptrFile);
              strcpy(buffer, dato);
              std::cout &lt;&lt; &quot;Linea es: &quot; &lt;&lt; dato &lt;&lt; std::endl;
              return;
          }
      }
  }
  
  BaseDeDatos::~BaseDeDatos(){
      fclose(ptrFile);
  }
  </code></pre>
  <p><strong>Persona.h</strong></p>
  <pre><code>#ifndef PERSONA_H
  #define PERSONA_H
  
  class Persona{
      public:
          // Crea una clase Persona en donde tenemos que definir su legajo, nombre y domicilo
          Persona(long legajo, char nombreCompleto[], char domicilio[]);
  
          // Obtiene el numero de legajo de la persona
          long obtenerLegajo();
  
          // Obtiene el nombre de la persona
          char* obtenerNombreCompleto();
  
          // Obtiene el domicilio de la persona
          char* obtenerDomicilio();
  
          ~Persona();
  
      private:
          long legajo;
          char nombreCompleto[40];
          char domicilio[40];
  };
  
  #endif // PERSONA_H
  </code></pre>
  <p><strong>Persona.c</strong></p>
  <pre><code>#include &quot;Persona.h&quot;
  #include &lt;string.h&gt;
  
  Persona::Persona(long legajo, char nombreCompleto[], char domicilio[]){
      // Copio el legajo a la clase Persona
      this-&gt;legajo = legajo;
  
      // Copia el nombre que me pasaron, al nombre de la clase -&gt; strcpy(destino, origen)
      strcpy(this-&gt;nombreCompleto, nombreCompleto);
      strcpy(this-&gt;domicilio, domicilio);
  }
  
  long Persona::obtenerLegajo(){
      return legajo;
  }
  
  char* Persona::obtenerNombreCompleto(){
      return nombreCompleto;
  }
  
  char* Persona::obtenerDomicilio(){
      return domicilio;
  }
  
  Persona::~Persona(){}
  </code></pre>
  <p>It doesn't mater what method of <code>BaseDeDatos</code> I use, I always get the same error:</p>
  <blockquote>
  <p>Line 17 Error: expected unqualified-id before numeric constant</p>
  <p>Line 17 Error: expected ';' before numeric constant</p>
  </blockquote>
  <p>Line 17 is <code>datos.agregarPersona(piter);</code> or whatever method I use from <code>BaseDeDatos</code>. I can't find any missing <code>;</code> and it's driving me crazy it's a simple program!</p>