Mensajes

La idea del static es que el dato se mantenga de llamada a llamada pero solo sea accesible para esa función. Si sabes que debes usar ese dato fuera de la función hazlo global.

Creo entender el problema:
Se te queda el carácter '\n' en el buffer después de capturar con scanf y cuando llegas a fgets este recoge el '\n' y regresa.

Soluciona esto con un

Código (c) [Seleccionar] Expandir

while(getchar() != '\n'); después del scanf.
Hay otras formas, pero esta es una de las mas fáciles.

A ver si te sirve esto. Está en C, compila en GCC.

Código (c) [Seleccionar] Expandir

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

void crear_lista(char ***lista, const char *origen) {
   char *palabra;
   char **l;
   char *delimitadores = " \t";
   char *copia;
   unsigned i = 0;
   
   // Guarda para saber si origen está vacío.
   if(origen == NULL) {
       *lista = NULL;
        return;
   }
   
   // Una copia no constante de origen para strtok
   copia = malloc((strlen(origen) + 1) * sizeof(char));
   strcpy(copia, origen);
   
   // Se saca la primera palabra de origen
   palabra = strtok(copia, delimitadores);
   
   // Se genera espacio para guardar un elemento en la lista
   l = malloc(sizeof(char *));
   
   // Se genera espacio para guardar la primera palabra...
   l[i] = malloc((strlen(palabra)+1) * sizeof(char));
   // y se guarda
   strcpy(l[i], palabra);
   
   // Se avanza el puntero de la lista en una posición
   ++i;
   
   // Mientras queden palabas en origen
   while((palabra = strtok(NULL, delimitadores))) {
       // Se repiten los pasos anteriores. El uso de realloc
       // es por que se redimensiona la lista.
       l = realloc(l, sizeof(char *) * i+1);
       l[i] = malloc((strlen(palabra)+1) * sizeof(char));
       strcpy(l[i], palabra);
       ++i;
   }
   
   // Se libera la variable copia.
   free(copia);
   
   // Para terminar una última redimensión...
   l = realloc(l, sizeof(char *) * i+1);
   // para alojar el valor nulo que marca el fin de la lista.
   l[i] = NULL;
   
   // Se guarda la lista en la variable del parámetro de la función.
   *lista = l;
}
   
void liberar_lista(char ***lista) {
   int i;
   
   // Si no hay nada que liberar regresa.
   if(!*lista) return;
   
   // Por cada elemento en la lista...
   for(i = 0; lista[i]; ++i)
       // liberar esa posición.
       free((*lista)[i]);
   
   // Se libera la lista.
   free(*lista);
   
   // Se marca nula la lista en la variable
   // del parámetro de la función y así indicar
   // que dicha variable está libre para usarse
   // de nuevo.
   *lista = NULL;
}

int main() {
   const char *s = "cadena_uno cadena_dos cadena_tres cadena_cuatro cadena_cinco";
   char **ss;
   int i;
   
   crear_lista(&ss, s);
   
   for(i = 0; ss[i]; ++i)
       printf("%s\n", ss[i]);
       
   liberar_lista(&ss);
}

Te voy a dejar una solución de con un ejemplo. Aviso que es un temporizador el cual solo puede existir uno al mismo tiempo. Hay que mirar todo el rato si ha terminado (polling) pero siendo el juego un bucle que se repite no tendrás problema.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <time.h>

enum {
   TIMEOUT_RUNNING,
   TIMEOUT_DONE,
   TIMEOUT_ERROR = -1
};

int timeout(unsigned segundos) {
   static time_t t;
   static unsigned s;
   
   if(segundos) {
       time(&t);
       s = segundos;
   }
   
   if(!s)
       return TIMEOUT_ERROR;
       
   if(difftime(time(NULL), t) >= s) {
       s = 0;
       return TIMEOUT_DONE;
   }
   
   return TIMEOUT_RUNNING;
}

int main() {
   int i = 0;
   
   if(timeout(1) == TIMEOUT_ERROR)
       return 1;
   
   while(i < 5) {
       printf("%i seg\r", i);
       fflush(stdout);
       
       if(timeout(0) == TIMEOUT_DONE) {
           timeout(1);
           ++i;
       }
   }
}

Funciona pasándole, en una primera llamada un valor en segundos que quieres que la rutina espere hasta que indique que ha pasado el tiempo. Sólo comprueba, así que no clava el programa para esperar a que pase el tiempo, tu juego puede seguir ejecutándose.

Una vez que termine el conteo se debe iniciar pasándole de nuevo un valor, sino devolverá un error de que no hay tiempo que temporizar, el TIMEOUT_ERROR.

Una cosa es el editor y la otra el compilador/intérprete.

Con un editor puedes crear cualquier código en cualquier lenguaje pues todos sirven para escribir. Puedes hasta escribir El Quijote con ellos si quieres. Otra cosa es que cuándo vayas a compilar te acepte ese código. Ese el problema que te encuentras. Le das al compilador de C++ de tu editor un código en C# que no entiende para nada. Así que es normal que se queje.

Elige en que lenguaje quieres hacer las cosas y consigue el IDE para programar con él.

¿Qué tal si empiezas encerrándolo todo dentro de una función? Por ejemplo int main()

No entendí lo que quieres hacer.

TVehiculosReg es el tipo vector<Vehiculo> y no una instancia suya, por eso no puedes guardar nada en él.

Podrías mostrar como es LISTA y NODO. Los puedo intuir pero para estar seguro mejor verlo.

En la función no usas la LISTA que le has pasado pues esta la has llamado l y tú te refieres a ella como lista.

Devuelves NULL a un tipo de dato int. Debes devolver 0 o un valor negativo si la función hs fallado (una convención bastante extendida), pero no NULL.

Si quieres hacer el trabajo que hace el arduino con labview, entiendo que lo vas a emular, te digo que hagas una secuencia y trabajes con los bloques de labview.