web-dev-qa-db-fra.com

Passer struct par référence en C

Ce code est-il correct? Il fonctionne comme prévu, mais ce code utilise-t-il correctement les pointeurs et la notation par points pour la structure?

struct someStruct {
 unsigned int total;
};

int test(struct someStruct* state) {
 state->total = 4;
}

int main () {
 struct someStruct s;
 s.total = 5;
 test(&s);
 printf("\ns.total = %d\n", s.total);
}
cstruct
27
Donald

Votre utilisation de la notation par pointeur et point est bonne. Le compilateur devrait vous donner des erreurs et/ou des avertissements en cas de problème.

Voici une copie de votre code avec quelques notes supplémentaires et des éléments à prendre en compte, tels que l’utilisation de structures, de pointeurs et de fonctions et la portée des variables.

// Define the new variable type which is a struct.
// This definition must be visible to any function that is accessing the
// members of a variable of this type.
struct someStruct {
    unsigned int total;
};

/*
 * Modifies the struct that exists in the calling function.
 *   Function test() takes a pointer to a struct someStruct variable
 *   so that any modifications to the variable made in the function test()
 *   will be to the variable pointed to.
 *   A pointer contains the address of a variable and is not the variable iteself.
 *   This allows the function test() to modify the variable provided by the
 *   caller of test() rather than a local copy.
 */
int test(struct someStruct *state) {
    state->total = 4;
    return 0;
}

/* 
 * Modifies the local copy of the struct, the original
 * in the calling function is not modified.
 * The C compiler will make a copy of the variable provided by the
 * caller of function test2() and so any changes that test2() makes
 * to the argument will be discarded since test2() is working with a
 * copy of the caller's variable and not the actual variable.
 */
int test2(struct someStruct state) {
    state.total = 8;
    return 0;
}

int test3(struct someStruct *state) {
    struct someStruct  stateCopy;
    stateCopy = *state;    // make a local copy of the struct
    stateCopy.total = 12;  // modify the local copy of the struct
    *state = stateCopy;    /* assign the local copy back to the original in the
                              calling function. Assigning by dereferencing pointer. */
    return 0;
}

int main () {
    struct someStruct s;

    /* Set the value then call a function that will change the value. */
    s.total = 5;
    test(&s);
    printf("after test(): s.total = %d\n", s.total);

    /*
     * Set the value then call a function that will change its local copy 
     * but not this one.
     */
    s.total = 5;
    test2(s);
    printf("after test2(): s.total = %d\n", s.total);

    /* 
     * Call a function that will make a copy, change the copy,
       then put the copy into this one.
     */
    test3(&s);
    printf("after test3(): s.total = %d\n", s.total);

    return 0;
}
45
Richard Chambers

C'est l'utilisation correcte de la structure. Il y a des questions sur vos valeurs de retour.

De plus, comme vous imprimez un int non signé, vous devriez utiliser %u au lieu de %d.

15
Bill Lynch

Oui c'est vrai. Il crée une structure s, fixe son total à 5, lui transmet un pointeur sur une fonction qui utilise le pointeur pour définir le total sur 4, puis l’affiche. -> est destiné aux membres des pointeurs sur structs et . est destiné aux membres de structs. Tout comme vous les avez utilisés.

Les valeurs de retour sont différentes cependant. test devrait probablement être vide, et main a besoin d'un return 0 à la fin.

3
nmichaels

Oui. C'est correct. Si ce n'était pas le cas (du point de vue./->), votre compilateur crierait.

1
Raveline

Oui, son utilisation correcte des structures. Vous pouvez aussi utiliser

typedef struct someStruct {
 unsigned int total;
} someStruct;

Ensuite, vous n'aurez plus à écrire struct someStruct s; plusieurs fois, mais vous pourrez utiliser someStruct s; ensuite.

0
Waqar Rashid