Was bedeutet “Anfrage nach Mitglied ‘*******’ in etwas, das keine Struktur oder Vereinigung ist”?

Lesezeit: 6 Minuten

Benutzeravatar von Pieter
Peter

Gibt es eine einfache Erklärung dafür, was dieser Fehler bedeutet?

request for member '*******' in something not a structure or union

Ich bin in der Zeit, in der ich C lerne, mehrmals darauf gestoßen, aber ich habe keine Ahnung, was es bedeutet.

  • Die bessere Antwort sollte nach oben akzeptiert werden.

    – T. Woody

    30. Oktober 2014 um 1:07 Uhr

Benutzeravatar von unwind
entspannen

Es passiert auch, wenn Sie versuchen, auf eine Instanz zuzugreifen, wenn Sie einen Zeiger haben, und umgekehrt:

struct foo
{
  int x, y, z;
};

struct foo a, *b = &a;

b.x = 12;  /* This will generate the error, should be b->x or (*b).x */

Wie in einem Kommentar erwähnt, kann dies unerträglich werden, wenn jemand geht und typedefsa Zeiger, dh enthält die * in einer Typedef, etwa so:

typedef struct foo* Foo;

Denn dann bekommst du das codiert sieht aus als würde es sich um Instanzen handeln, obwohl es sich tatsächlich um Zeiger handelt:

Foo a_foo = get_a_brand_new_foo();
a_foo->field = FANTASTIC_VALUE;

Beachten Sie, wie das obige aussieht, als ob es geschrieben werden sollte a_foo.fieldaber das würde da scheitern Foo ist ein Zeiger auf eine Struktur. Ich empfehle dringend gegen typedef:ed-Zeiger in C. Zeiger sind wichtig, verstecken Sie Ihre Sternchen nicht. Lass sie strahlen.

  • Ich wette, das ist das eigentliche Problem. Es beißt mich immer noch gelegentlich, besonders wenn jemand einen Zeigertyp typdefiniert hat.

    – Johannes Bode

    2. Februar 2010 um 15:04 Uhr

  • Ich möchte nur hinzufügen, dass dieser Fehler angezeigt wird, wenn ein Array nicht zugewiesen wurde (malloc) und auf es zugegriffen wird.

    – max

    14. März 2012 um 16:35 Uhr

  • Ich weiß, es ist ungefähr ein Jahrzehnt oder länger her, seit dies gepostet wurde, aber diese letzten beiden Sätze haben dies zu meinem neuen Lieblingspost gemacht. „Hinweise sind wichtig, verstecken Sie Ihre Sternchen nicht. Lassen Sie sie leuchten.“

    – Aiden Blishen Cuneo

    30. April 2020 um 23:58 Uhr

Sie versuchen, auf ein Mitglied einer Struktur zuzugreifen, aber in etwas, das keine Struktur ist. Zum Beispiel:

struct {
    int a;
    int b;
} foo;
int fum;
fum.d = 5;

Benutzeravatar von Kaustav Ray
Kaustav Ray

Es kann auch in folgendem Fall passieren:

z.B. wenn wir die Push-Funktion eines Stacks betrachten:

typedef struct stack
{
    int a[20];
    int head;
}stack;

void push(stack **s)
{
    int data;
    printf("Enter data:");
    scanf("%d",&(*s->a[++*s->head])); /* this is where the error is*/
}

main()
{
    stack *s;
    s=(stack *)calloc(1,sizeof(stack));
    s->head=-1;
    push(&s);
    return 0;
}

Der Fehler liegt in der Push-Funktion und in der auskommentierten Zeile. Der Zeiger s muss in Klammern gesetzt werden. Der richtige Code:

scanf("%d",&( (*s)->a[++(*s)->head]));

  • Vielen Dank, dass Sie den Hinweis (kein schreckliches Spiel mit der Sprache) explizit gemacht haben. Andere Antworten erwähnten es (z. B. “lass deine Zeiger glänzen”), aber um 2 Uhr morgens in einem epischen Kampf mit GDB und Valgrind zu kämpfen, schätzen Leute wie ich, dass deine Antwort ausdrücklich zeigt, wie der Zeiger ein Problem sein kann und wie dieses Problem behoben werden kann .

    – Max von Hippel

    6. Mai 2016 um 3:16 Uhr

Benutzeravatar von Mahesha999
Mahesha999

Ich habe möglicherweise alle Fälle aufgezählt, in denen dieser Fehler im Code und seinen Kommentaren unten auftreten kann. Bitte ergänzen Sie es, wenn Sie auf weitere Fälle stoßen.

#include<stdio.h>
#include<malloc.h>

typedef struct AStruct TypedefedStruct;

struct AStruct
{
    int member;
};

void main()
{
    /*  Case 1
        ============================================================================
        Use (->) operator to access structure member with structure pointer, instead
        of dot (.) operator. 
    */
    struct AStruct *aStructObjPtr = (struct AStruct *)malloc(sizeof(struct AStruct));
    //aStructObjPtr.member = 1;      //Error: request for member ‘member’ in something not 
                                      //a structure or union. 
                                      //It should be as below.
    aStructObjPtr->member = 1;
    printf("%d",aStructObjPtr->member); //1


    /*  Case 2
        ============================================================================
        We can use dot (.) operator with struct variable to access its members, but 
        not with with struct pointer. But we have to ensure we dont forget to wrap 
        pointer variable inside brackets.
    */
    //*aStructObjPtr.member = 2;     //Error, should be as below.
    (*aStructObjPtr).member = 2;
    printf("%d",(*aStructObjPtr).member); //2


    /* Case 3
       =============================================================================
       Use (->) operator to access structure member with typedefed structure pointer, 
       instead of dot (.) operator. 
    */
    TypedefedStruct *typedefStructObjPtr = (TypedefedStruct *)malloc(sizeof(TypedefedStruct));
    //typedefStructObjPtr.member=3;  //Error, should be as below.
    typedefStructObjPtr->member=3;
    printf("%d",typedefStructObjPtr->member);  //3


    /*  Case 4
        ============================================================================
        We can use dot (.) operator with struct variable to access its members, but 
        not with with struct pointer. But we have to ensure we dont forget to wrap 
        pointer variable inside brackets.
    */
    //*typedefStructObjPtr.member = 4;  //Error, should be as below.    
    (*typedefStructObjPtr).member=4;
    printf("%d",(*typedefStructObjPtr).member);  //4


    /* Case 5
       ============================================================================
       We have to be extra carefull when dealing with pointer to pointers to 
       ensure that we follow all above rules.
       We need to be double carefull while putting brackets around pointers.
    */

    //5.1. Access via struct_ptrptr and  ->
    struct AStruct **aStructObjPtrPtr = &aStructObjPtr;
    //*aStructObjPtrPtr->member = 5;  //Error, should be as below.
    (*aStructObjPtrPtr)->member = 5;
    printf("%d",(*aStructObjPtrPtr)->member); //5

    //5.2. Access via struct_ptrptr and .
    //**aStructObjPtrPtr.member = 6;  //Error, should be as below.
    (**aStructObjPtrPtr).member = 6;
    printf("%d",(**aStructObjPtrPtr).member); //6

    //5.3. Access via typedefed_strct_ptrptr and ->
    TypedefedStruct **typedefStructObjPtrPtr = &typedefStructObjPtr;
    //*typedefStructObjPtrPtr->member = 7;  //Error, should be as below.
    (*typedefStructObjPtrPtr)->member = 7;
    printf("%d",(*typedefStructObjPtrPtr)->member); //7

    //5.4. Access via typedefed_strct_ptrptr and .
    //**typedefStructObjPtrPtr->member = 8;  //Error, should be as below.
    (**typedefStructObjPtrPtr).member = 8;
    printf("%d",(**typedefStructObjPtrPtr).member); //8

    //5.5. All cases 5.1 to 5.4 will fail if you include incorrect number of *
    //     Below are examples of such usage of incorrect number *, correspnding
    //     to int values assigned to them

    //(aStructObjPtrPtr)->member = 5; //Error
    //(*aStructObjPtrPtr).member = 6; //Error 
    //(typedefStructObjPtrPtr)->member = 7; //Error 
    //(*typedefStructObjPtrPtr).member = 8; //Error
}

Die zugrunde liegenden Ideen sind klar:

  • Verwenden . mit Strukturvariable. (Fälle 2 und 4)
  • Verwenden -> mit Zeiger auf Struktur. (Fälle 1 und 3)
  • Wenn Sie die Strukturvariable oder den Zeiger auf die Strukturvariable mit folgendem Zeiger erreichen, schließen Sie den Zeiger in Klammern ein: (*ptr). und (*ptr)-> vs *ptr. und *ptr-> (Alle Fälle außer Fall 1)
  • Wenn Sie durch folgende Zeiger erreichen, stellen Sie sicher, dass Sie Zeiger auf Struktur oder Struktur richtig erreicht haben, je nachdem, was gewünscht ist. (Fall 5, insbesondere 5.5)

Dies kann bedeuten, dass Sie vergessen haben, eine Header-Datei einzuschließen, die diese Struktur/Union definiert. Zum Beispiel:

foo.h-Datei:

typedef union
{
    struct
    {
        uint8_t FIFO_BYTES_AVAILABLE    : 4;
        uint8_t STATE                   : 3;
        uint8_t CHIP_RDY                : 1;
    };
    uint8_t status;
} RF_CHIP_STATUS_t;

RF_CHIP_STATUS_t getStatus();

main.c-Datei:

.
.
.
if (getStatus().CHIP_RDY) /* This will generate the error, you must add the  #include "foo.h" */
.
.
.

Benutzeravatar von Nahum
Nahum

kann auch erscheinen, wenn:

struct foo {   int x, int y, int z }foo; 

foo.x=12

Anstatt von

struct foo {   int x; int y; int z; }foo; 

foo.x=12

Benutzeravatar von mosa
mosa

Ich habe das gesehen, als ich versucht habe, auf die Mitglieder zuzugreifen.

Meine Struktur war diese:

struct test { 
    int a;
    int b;
};
    
struct test testvar;

Normalerweise greifen wir auf Strukturmitglieder als zu

testvar.a;
testvar.b;

Ich verwechselte Testvar ein Zeiger zu sein und tat dies.

testvar->a;

Da sah ich diesen Fehler.

Anfrage nach Mitglied ‘a’ in etwas, das keine Struktur oder Gewerkschaft ist

1419970cookie-checkWas bedeutet “Anfrage nach Mitglied ‘*******’ in etwas, das keine Struktur oder Vereinigung ist”?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy