Ermitteln der Anzahl der Bytes für einen Zeiger im Speicher

Question

Ich bin verwirrt auf Inkrementieren von Zeigern für Arrays und dann Messen der Differenz in Bytes für die Zeigerorte.

Ich verstehe, dass ein Zeiger *p um die Größe des Datentyps beim Bewegen durch ein mehrdimensionales Array inkrementieren wird. Wenn jedoch ein Array wird thisArray verwendet:

int thisArray[ 7 ][ 4 ]; 

Wie soll thisArrray + 1 bewertet werden? Zahle ich sowohl Zeilen als auch Spalten hoch?

Ich möchte wissen, um wie viele Byte auseinander diese Zeiger im Speicher sein werden.

Ich weiß, dass die genaue Antwort plattformabhängig sein wird. Ich suche die Methode der Lösung, nicht die genaue Antwort.

Da ich keinen Code in den Kommentaren formatiert werden kann: Ich bin es setzen sich hier:

// sizeof Mit

#include <stdio.h> 

int main(void) { 

int tbl[ 7 ][ 4 ]; 

// Size of tbl 
int x = sizeof(*tbl); 
printf ("%d\n" , x); 

// Size of tbl + 1; 
int y = sizeof(*tbl+1); 
printf("%d\n", y); 

//Size apart in bytes 
int z = y - x; 
printf("%d\n", z); 

return 0; 
} 

Answer 1

how should thisArrray + 1 be evaluated?

Wenn thisArray auf einen Zeiger zerfällt, ist die Zeiger-Typ int (*)[4]. Der Typ thisArray+1 ist der gleiche.

Do I increment both rows and columns?

Ja.

Wenn Sie bei der Erinnerung an thisArray sehen eine Zeilen- und Spaltenstruktur verwenden, müssen Sie:

thisArray ->  +----+----+----+----+ 
        | | | | | 
thisArray + 1 -> +----+----+----+----+ 
        | | | | | 
thisArray + 2 -> +----+----+----+----+ 
        | | | | | 
thisArray + 3 -> +----+----+----+----+ 
        | | | | | 
thisArray + 4 -> +----+----+----+----+ 
        | | | | | 
thisArray + 5 -> +----+----+----+----+ 
        | | | | | 
thisArray + 6 -> +----+----+----+----+ 
        | | | | | 
thisArray + 7 -> +----+----+----+----+ 

Wenn Sie Traverse Elemente des Arrays verwenden möchten, können Sie entweder die Indizes oder Zeiger.

Verfahrgeschwindigkeit mit Indizes:

for (int i = 0; i < 7; ++i) 
{ 
    for (int j = 0; j < 4; ++j) 
    { 
     // Use thisArray[i][j]; 
    } 
} 

Verfahrgeschwindigkeit mit Zeigern:

for (int (*ptr1)[4] = thisArray; ptr1 < thisArray+7; ++ptr1) 
{ 
    for (int* ptr2 = *ptr1; ptr2 < *ptr1 + 4; ++ptr2) 
    { 
     // Use *ptr2 
    } 
} 

Von einer Ablesbarkeit Sicht Indizes mit Hilfe der Array zu durchlaufen ist viel intuitiver. Ich empfehle dringend, das zu verwenden.

Answer 2

Wenn Sie einen Index selbst verwenden, wird dieser mit der vom Typ definierten Größe multipliziert. Angenommen, Ihr int ist 4 Bytes, dann wird jeder int in einem Array vom Typ int 4 Bytes auseinander. So würde Ihr zweiter oder innerer Index (4) funktionieren.

Check-out diese gute Antwort: How are multi-dimensional arrays formatted in memory?

Um der erste Index (7) zu verstehen, beachten Sie, dass eine zweidimensionale Anordnung ist tatsächlich ein Array von Arrays. In unserem Beispiel ist die zweite Dimension vier Elemente breit, so dass Sie 4x4 = 16 Bytes für jedes Inkrement Ihres ersten Index überspringen. Also ist dieses Array eine Adresse im Speicher und [2] [3] würde 2x16 + 3x4 = 44 Bytes hinzufügen. Das ist der 4 + 4 + 3 = elfte aufeinanderfolgende Punkt im Speicher, wo jeder Punkt 4 Bytes ist.