Pasando struct para funcionar

Soy un nuevo progtwigdor de C y quería saber cómo puedo pasar una struct a una función. Me aparece un error y no puedo encontrar la syntax correcta para hacerlo. Aquí está el código para eso …

Struct:

 struct student{ char firstname[30]; char surname[30]; }; struct student person; 

Llamada:

 addStudent(person); 

Prototipo:

 void addStudent(struct student); 

y la función real:

 void addStudent(person) { return; } 

Errores del comstackdor:

línea 21: advertencia: statement de etiqueta dudosa: struct student
línea 223: argumento # 1 es incompatible con el prototipo:

La implementación de la función de línea debe ser:

 void addStudent(struct student person) { } 

person no es un tipo, sino una variable, no se puede usar como el tipo de un parámetro de función.

Además, asegúrese de que su estructura esté definida antes del prototipo de la función addStudent tal como lo utiliza el prototipo.

Esta es la forma de pasar la struct por referencia. Esto significa que su función puede acceder a la struct fuera de la función y modificar sus valores. Para ello, pasa un puntero a la estructura de la función.

 #include  /* card structure definition */ struct card { int face; // define pointer face }; // end structure card typedef struct card Card ; /* prototype */ void passByReference(Card *c) ; int main(void) { Card c ; c.face = 1 ; Card *cptr = &c ; // pointer to Card c printf("The value of c before function passing = %d\n", c.face); printf("The value of cptr before function = %d\n",cptr->face); passByReference(cptr); printf("The value of c after function passing = %d\n", c.face); return 0 ; // successfully ran program } void passByReference(Card *c) { c->face = 4; } 

Así es como pasa la struct por valor para que su función reciba una copia de la struct y no pueda acceder a la estructura exterior para modificarla. Por exterior quiero decir fuera de la función.

 #include  /* global card structure definition */ struct card { int face ; // define pointer face };// end structure card typedef struct card Card ; /* function prototypes */ void passByValue(Card c); int main(void) { Card c ; c.face = 1; printf("c.face before passByValue() = %d\n", c.face); passByValue(c); printf("c.face after passByValue() = %d\n",c.face); printf("As you can see the value of c did not change\n"); printf("\nand the Card c inside the function has been destroyed" "\n(no longer in memory)"); } void passByValue(Card c) { c.face = 5; } 

Al pasar una estructura a otra función, generalmente sería mejor hacer lo que Donnell sugirió antes y pasarlo por referencia.

Una muy buena razón para esto es que facilita las cosas si desea realizar cambios que se reflejarán cuando regrese a la función que creó la instancia de la misma.

Aquí hay un ejemplo de la forma más simple de hacer esto:

 #include  typedef struct student { int age; } student; void addStudent(student *s) { /* Here we can use the arrow operator (->) to dereference the pointer and access any of it's members: */ s->age = 10; } int main(void) { student aStudent = {0}; /* create an instance of the student struct */ addStudent(&aStudent); /* pass a pointer to the instance */ printf("%d", aStudent.age); return 0; } 

En este ejemplo, el argumento para la función addStudent() es un puntero a una instancia de un student struct – student *s . En main() , creamos una instancia de la estructura del student y luego le pasamos una referencia a nuestra función addStudent() usando el operador de referencia ( & ).

En la función addStudent() podemos utilizar el operador de flecha ( -> ) para eliminar la referencia del puntero y acceder a cualquiera de sus miembros (funcionalmente equivalente a: (*s).age ).

Cualquier cambio que hagamos en la función addStudent() se reflejará cuando volvamos a main() , porque el puntero nos dio una referencia a dónde en la memoria se está almacenando la instancia de la estructura del student . Esto se ilustra con printf() , que generará “10” en este ejemplo.

Si no hubiera pasado una referencia, estaría trabajando con una copia de la estructura que pasó a la función, lo que significa que los cambios no se reflejarán cuando regrese a main , a menos que haya implementado una forma de pasar la nueva versión de la estructura vuelve al principal o algo por el estilo

Aunque los consejos pueden parecer desalentadores al principio, una vez que entiendes cómo funcionan y por qué son tan útiles, se convierten en una segunda naturaleza, ¡y te preguntas cómo te las arreglaste sin ellos!

Debe especificar un tipo en persona:

 void addStudent(struct student person) { ... } 

Además, puede tipear su estructura para evitar tener que escribir struct cada vez que la use:

 typedef struct student{ ... } student_t; void addStudent(student_t person) { ... } 

En lugar de:

 void addStudent(person) { return; } 

prueba esto:

 void addStudent(student person) { return; } 

Como ya ha declarado una estructura llamada ‘estudiante’, no necesariamente tiene que especificarlo en la implementación de la función como en:

 void addStudent(struct student person) { return; }