Struct-Array, das dem Zeiger zugewiesen ist. Was ist los?

Question

EDIT: Was ist der Unterschied zwischen dem Zugriff auf ein Element in einem Array-Zeiger über Index pointer[i] vs über Zeiger Inkrementierung pointer+1. Leute markieren diese Frage als Duplikat zu diesem question Ich habe eine schwere Zeit zu verstehen, wie? Sicher, es ist eine Frage bezüglich Arrays und Zeigern, aber die Frage Ähnlichkeiten endet dort. Sicher, die Hinweise auf C99 könnten jemandem helfen tiefer in C99 zu graben .. aber warum sollte man SO benutzen? END EDIT

Ich habe eine Struktur (etwa so definiert, dass alle C-Dateien Zugriff darauf haben)

typedef struct 
{ 
    uint8_t a; 
    uint8_t b; 
} task_t; 

Und in einer C-Datei (sagen Sub.c) erstelle ich eine Reihe von solchen Strukturen

task_t ossList[10] = {}; 

, die weiter mit Werten für a gefüllt sind und b während der Laufzeit

In der gleichen C-Datei (Sub.c) ich habe eine schriftliche Funktion, die anderen C-Dateien ermöglicht, dieses struct-Array zu erhalten.

void HLP_GetStruct(task_t ** ossListGet) { 
    *ossListGet = ossList; 
} 

Die Art, wie ich die Struktur von anderen Dateien zu erhalten (sagen Top.c) ist von:

task_t * ossList; 
    HLP_GetStruct(&ossList); 

    for (k=0; k<nTasks; k++) { 
     printf("OssList %d %d", ossList[k].a, ossList[k].b) 
    } 

Und es ist alles gut. Aber dann, als ich genauer hinsah, habe ich mich gefragt, wie das überhaupt funktionieren kann. Was geht wirklich vor? In meiner äußeren C-Datei (Top.c) initialisiere ich einen Zeiger auf denselben Typ von Struktur.

task_t * ossList; 

I dann den Verweis auf die anderen C-Datei übergeben (Sub.c)

HLP_GetStruct(&ossList); 

und in dieser Datei C (Sub.c) ich meine Zeiger auf die "realen" ossList struct point Array und ich bekomme irgendwie einen Zeiger Array zurück !?

void HLP_GetStruct(task_t ** ossListGet) { 
     *ossListGet = ossList; 
    } 

Und ich kann die Indizes zugreifen, indem

for (k=0; k<nTasks; k++) { 
      printf("OssList %d %d", ossList[k].a, ossList[k].b) 
     } 

Wie?

(Ich habe es noch nie so gemacht, meine Arrays wurden mehr oder weniger immer als Zeiger deklariert, und Zeiger zeigt standardmäßig auf das erste Element und Sie können über den Zeiger usw. "kopieren")

Sub.c

task_t ossList[10] = {}; 
DoSomethingWithStructArray(); 
void HLP_GetStruct(task_t ** ossListGet) { 
    *ossListGet = ossList; 
} 

Top.c

task_t * ossList; 
HLP_GetStruct(&ossList); 

for (k=0; k<nTasks; k++) { 
    printf("OssList %d %d", ossList[k].a, ossList[k].b) 
} 

Answer 1

der Trick besteht darin, dass ossList Zugriff (wie in *ossListGet = ossList;) gibt Ihnen einen Zeiger auf nur die erste Element von ossList[10]; Ihr initialisierter Zeiger in Top.c wird nicht zu einem Array, sondern zeigt auf ossList[0].

Da Array Indexierungs pointer[i] Verwendung entspricht einen Zeiger durch i (dh pointer+i) zu inkrementieren, kann man die anderen Elemente des ossList[10] zugreifen, indem einfach der Zeiger auf das erste Element Inkrementieren (ossList+k) oder idealerweise unter Verwendung von [] (ossList[k]).