Umwandlung von 2D-array-Zeiger-zu-Zeiger

Der Grund, Sie können dies tun, für eindimensionale arrays und nicht zwei-dimensionalen arrays zu tun hat mit der Art und Weise, in der der eigentliche array-Elemente im Speicher gespeichert werden. Für eindimensionale arrays, die alle Elemente gespeichert sind, nacheinander, so dass die expression array[i] ist äquivalent zu dem Ausdruck *(array + i). Wie Sie sehen können, ist die array-Größe ist nicht notwendig zur Durchführung einer array-index operation. Jedoch, für zwei-dimensionale arrays, die Elemente, die gespeichert werden in der "row-major" Ordnung, was bedeutet, dass alle Elemente der nullten Zeile gespeichert sind, an Erster Stelle, gefolgt von den Elementen in der ersten Zeile, gefolgt von den Elementen in der zweiten Zeile, etc. Daher ist der Ausdruck array[i][j] entspricht *(array + (i * ROW_SIZE) + j), wo ROW_SIZE ist die Anzahl der Elemente in jeder Zeile. Deshalb wird auch der array - Zeile, die Größe, die erforderlich ist, um einen array-index operation, und Gießen Sie die array-variable ein Zeiger verliert die Informationen.

InformationsquelleAutor

Dies ist c++! Alles ist möglich! Aber dies ist c++ so Bedarf es einem gewissen Maß an Verständnis.

Zu diesem Zweck beginnen wir mit einem einfachen Beispiel 2 1-dimensionale arrays: char firstName[4] = { 'J', 'o', 'n', '\0' } und char lastName[4] = { 'M', 'e', 'e', '\0' } schauen wir uns eine mögliche memory layout hier:

+------------+-------+
|  Address   | Value |
+------------+-------+
| 0x76543210 | 0x4A  | <- firstName[0] - 'J'
| 0x76543211 | 0x6F  | <- firstName[1] - 'o'
| 0x76543212 | 0x6E  | <- firstName[2] - 'n'
| 0x76543213 | 0x00  | <- firstName[3] - '\0'
+------------+-------+
| 0x76543214 | 0x4D  | <- lastName[0] - 'M'
| 0x76543215 | 0x65  | <- lastName[1] - 'e'
| 0x76543216 | 0x65  | <- lastName[2] - 'e'
| 0x76543217 | 0x00  | <- lastName[3] - '\0'
+------------+-------+

Angesichts dieser Speicher-layout, wenn Sie waren zu tun cout << firstName << ' ' << lastName Sie bekommen würde:

0x76543210 0x76543214

Diese arrays sind eigentlich nur ein Zeiger auf Ihr erstes element! Dies verdeutlicht Array-Pointer-Decay -, Sie können mehr über Sie hier: http://en.cppreference.com/w/cpp/language/array#Array-to-pointer_decay

Bevor wir fortfahren, gibt es etwas wichtiges hier zu beachten, chars dauern, bis genau 1 byte, also die Adresse des nachfolgenden char im array werden einfach die nächste Adresse. Dass die Nutzung durch die Subskript-Operator in dieser Weise: firstName[1] entspricht *(firstName + 1). Dies gilt für chars, aber gilt auch für jede andere Art, die mehr als 1 byte. Nehmen wir als Beispiel: short siArray = { 1, 2, 3, 4 }, ein mögliches speicherlayout siArray würde wie folgt Aussehen:

+------------+--------+
|  Address   | Value  |
+------------+--------+
| 0x76543218 | 0x0001 | <- siArray[0] - 1
| 0x7654321A | 0x0002 | <- siArray[1] - 2
| 0x7654321C | 0x0003 | <- siArray[2] - 3
| 0x7654321E | 0x0004 | <- siArray[3] - 4
+------------+--------+

Obwohl cout << siArray << ' ' << &(siArray[1]) Ausgabe:

0x76543218 0x7654321A

*(siArray + 1) noch index das gleiche element von siArray als siArray[1]. Dies ist, weil, wenn Sie tun, Zeiger-Arithmetik c++ hält der Typ der Adresse, die auf betrieben, so Inkrementieren eines short* wird tatsächlich erhöhen die Adresse von sizeof(short). Lesen Sie mehr über Zeiger-Arithmetik hier: http://en.cppreference.com/w/cpp/language/operator_arithmetic

Schließlich schauen wir, wie die c++ speichert 2-dimensionale arrays. Gegeben: char name[2][4] = { { 'J', 'o', 'n', '\0' }, { 'M', 'e', 'e', '\0' } } eine mögliche memory layout wäre:

+------------+-------+
|  Address   | Value |
+------------+-------+
| 0x76543220 | 0x4A  | <- name[0][0] - 'J'
| 0x76543221 | 0x6F  | <- name[0][1] - 'o'
| 0x76543222 | 0x6E  | <- name[0][2] - 'n'
| 0x76543223 | 0x00  | <- name[0][3] - '\0'
| 0x76543224 | 0x4D  | <- name[1][0] - 'M'
| 0x76543225 | 0x65  | <- name[1][1] - 'e'
| 0x76543226 | 0x65  | <- name[1][2] - 'e'
| 0x76543227 | 0x00  | <- name[1][3] - '\0'
+------------+-------+

Da wir wissen, dass ein 1-dimensionales array-Wert ist wirklich nur ein Zeiger ist, können wir sehen, aus diesem Speicher-layout, das name[0] ist nicht einen Zeiger, es ist nur das erste Zeichen des ersten Arrays. So name nicht enthalten 2 1-dimensionales array von Zeigern, sondern enthält den Inhalt von 2 arrays. (Übrigens auf einem 32-bit-Maschine nicht die Speicherung der Zeiger speichert 8-Byte Speicher, was ganz wesentlich für eine 8-byte 2-dimensionales array.) So versuchen, zu behandeln name als char** würde versuchen, die Zeichen als Zeiger.

Verstanden zu haben, das wir wirklich brauchen nur zu vermeiden, mit c++'s Zeiger-Arithmetik zu finden dereferenzieren den Wert. Zu tun, dass wir arbeiten müssen, mit einem char* so, dass die Zugabe von 1 ist eigentlich nur das hinzufügen von 1. So zum Beispiel:

const short si2DArray[2][3] = { { 11, 12, 13 }, { 21, 22, 23 } };
const auto psi2DPointer = reinterpret_cast<const char*>(si2DArray);

for(auto i = 0U; i < size(si2DArray); ++i) {
    for(auto j = 0U; j < size(*si2DArray); ++j) {
        cout << *reinterpret_cast<const short*>(psi2DPointer + i * sizeof(*si2DArray) + j * sizeof(**si2DArray)) << '\t';
    }
    cout << endl;
}

Live Beispiel

Beachten Sie, dass in diesem Beispiel, obwohl ich mich auf si2DArray dachte psi2DPointer ich bin immer noch mit Informationen aus si2DArray zu tun, die Indizierung, nämlich:

1. Wie viele arrays in der ersten dimension: size(si2DArray)
2. Wie viele Elemente in die kleinere dimension: size(*si2DArray)
3. Was ist die Größe im Speicher der kleineren dimension: sizeof(*si2DArray)
4. Was ist der Elementtyp des Arrays: sizeof(**si2DArray)

Sie können also sehen, dass der Verlust von Informationen, die aus der Umwandlung von einem array zu einem Zeiger ist beträchtlich. Sie könnten versucht sein, erhalten Sie den element-Typ, und damit auch die Vereinfachung der Zeiger-Arithmetik. Es lohnt sich, zu beachten, dass nur eine Umstellung auf char* ist definiert als Verhalten von reinterpret_cast: http://en.cppreference.com/w/cpp/language/reinterpret_cast#Type_aliasing

InformationsquelleAutor

Nicht sicher, ob du für so etwas suchen. Sollten Sie mehr details über das, was Sie erreichen wollen. Sie sind grundsätzlich verschiedene Typen. Eine Lösung ist weiter unten.

Für die Aufzeichnung, wenn jemand findet es nützlich:

//define matrix
double A[3][3] = {
    { 1, 2, 3},
    { 4, 5, 6},
    { 7, 8, 9}
};

//allocate memory
double ** A_ptr = (double **) malloc(sizeof (double *) * 3);
for (int i = 0; i < 3; i++)
    A_ptr[i] = (double *) malloc(sizeof (double) * 3);

//copy matrix
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        A_ptr[i][j] = A[i][j];
        printf(" %f ", A_ptr[i][j]);
    }
}

InformationsquelleAutor