Pas struct door verwijzing in C

Is deze code juist is? Het loopt zoals verwacht, maar is deze code goed gebruik van de aanwijzingen en de dot-notatie voor de struct?

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);
}
  • waarom is de test moet retourneren van een int ? eigenlijk is er niet terugkeren.
  • C heeft referenties? Verrast …
  • niet in de C++ – gevoel, maar voor C++ werd uitgevonden, verwijzingen waren een soort van “referentie” (omdat ze een “referand”). Nu hebben ze een “pointee” of iets van dergelijke onzin. Sinds someStruct waarde heeft semantiek, “pass-by-reference” (die C niet in C++ voorwaarden) is precies hetzelfde als “het passeren van een verwijzing door de waarde (die het doet, de “referentie” in vraag wordt een pointer).
  • c++ verwijzingen (aangegeven met het teken & amp; token) zijn superieur in dat: 1) Het is minder waarschijnlijk voor het schrijven van een insect met een c++ – reference, en 2) de code die is geschreven in c++ referenties is meer waarschijnlijk om de compiler te maken aliasing optimalisaties. Sinds aliasing is onmogelijk in fortran, unoptimized aanwijzer routines in c kan leiden tot verlegenheid.
InformationsquelleAutor Donald | 2010-11-30

 

5 Replies
  1. 51

    Uw gebruik van de pointer en de dot-notatie is goed. De compiler geeft je fouten en/of waarschuwingen als er een probleem was.

    Hier is een kopie van uw code met enkele aanvullende opmerkingen en dingen om over na te denken, voor zover het gebruik van structs en pointers en functies en de omvang van variabelen.

    //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;
    }
    • wat is de betekenis van de invoering van de “*” voor de naam van de variabele (zoals in dit bericht) of na de type naam (zoals is gedaan door het OP)? HIER: int test(struct someStruct *staat) OP: int test(struct someStruct* staat)
    • de asterisk geeft aan dat bij het specificeren van het type van een variabele geeft aan dat het een aanwijzer voor het type van de variabele. Dus someStruct state is een variabele is van het type someStruct echter someStruct *state is een verwijzing naar een variabele van het type someStruct. Zie Aanwijzer Basis.
    • Waardeer uw reactie; echter, mijn vraag was niet wat het * is voor mijn vraag was WAT IS de BETEKENIS van het HEBBEN VAN DE * (a) na de typenaam van de struct en (b) dat het voor de toegewezen naam van struct. ik hoop dat mijn questin duidelijker.
    • sorry, maar uw verduidelijking niet duidelijk. Weet u niet wat u bedoelt met “naam van struct”. Misschien bedoel je dat ik een spatie na de struct naam in de aangifte en het OP zetten van een ruimte achter de naam? Er is geen verschil met de compiler, slechts een van de leesbaarheid en de gewoonte verschil. Ik geef de voorkeur zet het sterretje naast de naam van de variabele, want als ik meer dan één variabele in een verklaring. struct someStruct *p1, *p2, var1; twee wijzers en een variabele. struct someStruct* p1, p2, var1; zal maken van één wijzer, p1 en twee variabelen p2 en var1`.
    • ja. Dat is precies wat ik vroeg. Veel dank voor het opruimen dat uit
  2. 15

    Dat is het juiste gebruik van de struct. Er zijn vragen over uw waarden retourneren.

    Ook, omdat je printfing een unsigned int, moet u gebruik maken van %u in plaats van %d.

  3. 3

    Ja, dat klopt. Het maakt een struct s, stelt zijn totaal op 5, geeft een pointer naar een functie die gebruik maakt van de aanwijzer om het totaal aan 4, dan drukt het uit. -> is voor de leden van verwijzingen naar structs en . is voor de leden van structs. Net als u ze gebruikt.

    De return waarden zijn anders. test moet waarschijnlijk worden nietig verklaard, en main moet een return 0 op zijn einde.

  4. 0

    Ja, een correct gebruik van de structuren. U kunt ook gebruik maken van

    typedef struct someStruct {
     unsigned int total;
    } someStruct;

    Dan hoeft u niet in te schrijven struct someStruct s; opnieuw en opnieuw, maar gebruik kunnen maken van someStruct s; dan.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *