a parameter list without types is only allowed in a function definition; in struct (C)

I wrote a struct in C and wanted to print it with a separated func but when I try to compile it I get said error form the title (a parameter list without types is only allowed in a function definition) in regards to the marked line in my code:

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

typedef struct 
{
    char Name[20];
    char Farbe[20];
    int Laenge;
    int Bewertungen[7];
} Gemüse;

void Gemüse_ausgeben(Gemüse gemüse);

int main(void)
{

Gemüse Gurke;   
strcpy(Gurke.Name, "Gurke");
strcpy(Gurke.Farbe, "grün");
Gurke.Laenge = 28;
Gurke.Bewertungen[0] = 8;
Gurke.Bewertungen[1] = 7;
Gurke.Bewertungen[2] = 9;
Gurke.Bewertungen[3] = 6;
Gurke.Bewertungen[4] = 4;
Gurke.Bewertungen[5] = 2;
Gurke.Bewertungen[6] = 5;

 void Gemüse_ausgeben(Gurke);     // line of error

return 0;  
}


void Gemüse_ausgeben(Gemüse gemüse)
{
printf("Name: %s\n", gemüse.Name);
printf("Farbe: %s\n", gemüse.Farbe);
printf("Laenge: %d\n", gemüse.Laenge);
printf("Bewertungen: \n"); 
for(int i = 0; i < 7; i++)
{
    printf("%d: %d\n", i+1, gemüse.Bewertungen[i]);
}

}

The variables might be slightly confusing.

I expected the code to compile without any error. When I change the error causing line to:
void Gemüse_ausgeben(Gemüse Gurke); it compiles just fine but when carrying out the code nothing happens.
In addition when I paste the body of my void Gemüse_ausgeben func into the main and get rid of the func everything works just fine. But that defeats the purpose for me.

This is a function declaration:

void Gemüse_ausgeben(Gemüse gemüse);

This is a function definition:

void Gemüse_ausgeben(Gemüse gemüse) {
  ...
}

This is a function call:

Gemüse_ausgeben(g);

Note the syntax differences here. When declaring or defining you need to specify a return type. When calling you do not. For non-void returning functions you may want to capture the return value, like int x = y() but that's incidental.

A somewhat puzzling aspect of the design of early C is that the names of all of a function's arguments would be specified, in argument-passing order, followed by typed declarations of the any arguments that weren't int, specified in arbitrary order. Thus, a definition that today would be written as:

int doSomething(int a, double b, int c, double d)
{ ... }

could have been written as:

int doSomething(a,b,c,d)
  double b,d;
{ ... }

or as:

int doSomething(a,b,c,d)
  int a; double b; int c; double d;
{ ... }

or as:

int doSomething(a,b,c,d)
  int a,c; double b,d;
{ ... }

or other variations and permutations of those. In all cases, the parenthesis-enclosed comma-separated list of arguments includes just the names of the arguments, and no information about their types.

Since function declarations that aren't definitions would have no place to list argument types, and since a list of argument names without types wouldn't generally be very useful, old-style declarations that aren't definitions can't include arguments at all. New-style definitions can include arguments, of course, but each argument in a new-style definition includes the type as well as the name.