Pasando struct a la función

Question

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

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 de compilación:

line 21: warning: dubious tag declaration: struct student 
line 223: argument #1 is incompatible with prototype: 

Answer 1

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

void addStudent(struct student person) { 

} 

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

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

Answer 2

es necesario especificar un tipo de persona:

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

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

typedef struct student{ 
... 
} student_t; 

void addStudent(student_t person) { 
... 
} 

Answer 3

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

#include <stdio.h> 
/* 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; 
} 

Esta es la forma en que pase el struct por valor, de modo que su función recibe una copia de la struct y no puede acceder a la estructura exterior para modificarlo. Por exterior quiero decir fuera de la función.

#include <stdio.h> 


/* 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; 
} 

Answer 4

Al pasar una estructura a otra función, que por lo general sería mejor que hacer como se sugirió anteriormente Donnell y pasarlo por referencia en su lugar.

Una 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í es un ejemplo de la forma más sencilla de hacer esto:

#include <stdio.h> 

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 de la función addStudent() es un puntero a una instancia de una estructura student-student *s.En main(), creamos una instancia de la estructura student y luego le pasamos una referencia a nuestra función addStudent() usando el operador de referencia (&).

En la función addStudent() podemos hacer uso del operador flecha (->) para eliminar la referencia al puntero, y acceder a cualquiera de sus miembros (funcionalmente equivalentes a: (*s).age).

Cualquier cambio que hacemos en la función addStudent() se reflejarán cuando volvamos a main(), porque el puntero nos dio una referencia al lugar donde en la memoria se almacena la instancia de la estructura student. Esto se ilustra con printf(), que dará como resultado "10" en este ejemplo.

Si no hubiera pasado una referencia, en realidad 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 implemente una forma de aprobar la nueva versión de la estructura de nuevo a main o algo así!

Aunque los indicadores pueden parecer desalentadores al principio, una vez que entiendes cómo funcionan y por qué son tan útiles se convierten en algo natural y te preguntas cómo habrás podido lidiar sin ellos.

Answer 5

En lugar de:

void addStudent(person) 
{ 
    return; 
} 

intente esto:

void addStudent(student person) 
{ 
    return; 
} 

Dado que ya se ha declarado una estructura llamada 'estudiante' que no necesariamente tiene que especificar por lo que en la implementación de la función como en :

void addStudent(struct student person) 
{ 
    return; 
}