I couldn’t run your code, but I think the compilation problem is because you created a struct and made it a "type", for variables, using the definition typedef, however, when declaring a variable with the created type, you wanted to declare it as a simple structure.
When we declare a struct we can observe the following declaration rule:
struct <identificador>
{
<listagem dos tipos e membros>;
} <variavel>
where:
<identificador> is the name given to struct, to be able to identify the structure we are creating;
<variavel> is the variable itself declared;
Example:
/*declaracao da estrutura*/
struct ANIMAL
{
int patas;
char raca[10];
} gato // voce criou um variavel gato com a estrutura de um ANIMAL;
Or we can do it that way:
/*declaracao da estrutura*/
struct ANIMAL
{
int patas;
char raca[10];
}
/*declaracao da variavel*/
struct ANIMAL gato; // voce criou um variavel gato com a estrutura de um ANIMAL;
When you make a structure a type, using the typedef, you make this structure a known type for your program, as if it were a primitive type (int, char, float), that is, in your program, the structure you defined as a type, using typedef, is now a type for variables. The structure, for use of the typedef, works that way:
typedef < tipo > <nome_para_o_tipo>
where:
< tipo > is the type that will be "renamed", can be an existing type (int, char, float, etc), or a complex type (structs, enuns, ect);
<nome_para_o_tipo> is the name you’ll give to the guy;
See an example below:
/* Aqui, estamos dizendo que o tipo int também será conhecido, pelo o programa, como int32*/
typedef int int32; // definição do tipo int32
int32 cont; // declaração da variável "cont" do tipo int32 (que na verdade é um int)
For a structure will look like this:
/*Tranformando uma estrutura em um tipo*/
typedef < tipo >
{
<listagem dos tipos e membros>;
} <nome_para_o_tipo>
Example:
/*Aqui estamos tornando uma estrutura em um tipo complexo*/
typedef struct ANIMAIS
{
int patas;
char raca[10];
} ANIMAL // estamos dizendo que a struct ANIMAIS será conhecida, no programa, como o tipo complexo ANIMAL;
ANIMAL gato; // criamos uma variável gato do tipo complexo ANIMAL. como a estrutura virou um tipo, não é necessário colocar o struct antes do ANIMAL.
Well, therefore, I think the corrections to be made in your program are as follows::
typedef struct Fila {
int vetor[3][10];
int tamanho[3];
} FILA;
void fLimpar(int a, FILA *Carro);
void fArmazenar(int a, FILA *Carro, int e);
int fRemover(int a, FILA *Carro);
int Menu(struct carros *carro,FILA *Carro);
void fArmazenar(int a, FILA *Carro, int e) {
// Armazena o elemento na próxima posição vaga.
(*Carro).vetor[a][((*Carro).tamanho[a])] = e;
printf("teste : ta com %d", (*Carro).vetor[a][(*Carro).tamanho[a]]);
(*Carro).tamanho[a]++;
}
int fRemover(int a, FILA *Carro) {
int e, i;
// elemento a ser retornado é o primeiro da fila.
e = (*Carro).vetor[a][0];
// Move todos os elementos 1 posição para frente,
// exceto o 1º (pois este será descartado).
for (i = 1; i < (*Carro).tamanho[a]; i++) {
(*Carro).vetor[a][i - 1] = (*Carro).vetor[a][i];
}
// diminui o tamanho em 1 porque o elemento do início da fila foi removido.
(*Carro).tamanho[a]--;
return e;
}
Here are some links for you to find more details regarding structs and typedef: structs and typedef
Or you can declare the structure without the typedef and the variable FILA, this way, you won’t need to change the rest of your program:
struct Fila {
int vetor[3][10];
int tamanho[3];
};
Another thing you can check is if the variable Carro , that you are passing by parameter to the functions fArmazenar(int a, FILA *Carro, int e) and fRemover(int a, FILA *Carro), is a value or an address. This error, which the compiler is reporting, is typical of this type of error. You may want to pass a parameter by value, but the functions are waiting to receive a parameter by reference (a memory address).
Anyway, check this, or send the rest of the code, where you call these functions so we can see how you are declaring the Car variable and how you are passing parameters to the functions.