Eine Klasse ouput über C++ Klasse

Question

Ich habe diesen Code:

#include <iostream> 
using namespace std; 
class test { 
public: 
    int base; 
    test() { 
     base = 0; 
    } 
}; 
class deri : public test { 
public: 
    int der; 
    deri() { 
     der = 1; 
    } 
}; 
void foo(test* a, size_t size) { 
    for (int i = 0; i != size; i++, a++) { 
     cout << (*a).base << endl;; 
    } 
    cout << endl; 
} 
int main() { 
// test a[5]; 
    deri b[5]; 
// foo(a, 5); 
    foo(b, 5); 
    return 0; 
} 

Diese Ausgänge:

0 
1 
0 
1 

Warum funktioniert der Code ausgegeben wie in den Kommentaren?

Answer 1

Was foo denkt Sie vorbei, ein Array von test Instanzen:

 -------------------------- 
a --> |base|base|base|base|base| 
     -------------------------- 

wo jeder base auf 0 initialisiert.

, was Sie vorbei eigentlich ein Array von deri Instanzen:

 ---------------------------------------------- 
a --> |base,der|base,der|base,der|base,der|base,der| 
     ---------------------------------------------- 

wo jeder base-0 initialisiert wird, und jeder der auf 1 initialisiert.

Wenn a inkrementiert, die Funktion inkrementiert die Speicheradresse für den Schritt einer test Trägerrechnung (da dies die Art von a), die But-Ein Mitglied hat: base. In Wirklichkeit ist das Objekt, das übergeben wird, deri und hat somit zwei Mitglieder: base und der. So nach dem ersten Zuwachs, denken Sie dies tun:

 -------------------------- 
     |base|base|base|base|base| 
     -------------------------- 
    a -------^ 

aber in Wirklichkeit Sie dies tun:

 ---------------------------------------------- 
     |base,der|base,der|base,der|base,der|base,der| 
     ---------------------------------------------- 
    a -------^ 

und a, dachte, es weist auf die zweite test, ist eigentlich zeigt auf das zweite Mitglied der erstenderi Objekt. Eine kleine Instrumentierung wird dies zeigen. Drucken der Adressen jedes Mitglied, bevor wir das Array foo, dann senden die zeigen, was wir tun, tatsächlich in foo:

#include <iostream> 
using namespace std; 
class test { 
public: 
    int base; 
    test() { 
     base = 0; 
    } 
}; 

class deri : public test { 
public: 
    int der; 
    deri() { 
     der = 1; 
    } 
}; 
void foo(test* a, size_t size) { 
    for (int i = 0; i != size; i++, a++) { 
     cout << (const void*)&(*a).base << ',' << (*a).base << endl;; 
    } 
    cout << endl; 
} 
int main() 
{ 
    deri b[5]; 
    for (auto const& x : b) 
     std::cout <<(const void*)&x.base << ',' << (const void*)&x.der << '\n'; 

    foo(b, 5); 
    return 0; 
} 

Ausgabe

0x7fff5fbff970,0x7fff5fbff974 
0x7fff5fbff978,0x7fff5fbff97c 
0x7fff5fbff980,0x7fff5fbff984 
0x7fff5fbff988,0x7fff5fbff98c 
0x7fff5fbff990,0x7fff5fbff994 
0x7fff5fbff970,0 
0x7fff5fbff974,1 
0x7fff5fbff978,0 
0x7fff5fbff97c,1 
0x7fff5fbff980,0 

Beachten Sie die Adressen werden systemabhängig aber hoffentlich kommst du auf die Idee. Kurz gesagt, Sie haben einen Fehler.

Answer 2

Sie iterieren auch auf "a" (a ++). Sie geben also das erste "a" ein (für Befehl beginnen auf der rechten, also a ++ vor i ++) und geben ihre Basis aus: 0 Sie iterieren diese Basis und zeigen sie an: 1 Dann iterieren Sie ein weiteres Mal auf "a" und Anzeige der Basis: 0. Und so weiter ...

Answer 3

Wie ich verstanden habe, ist die Größe der Deri-Klasse zweimal größer als die Größe des Tests. Ich denke, dass Zeiger a beim ersten Iterationspunkt auf das Betteln von Objekt b [0] und a.base = b [0] .base zeigt. Bei der zweiten Iteration zeigt a jedoch auf die Mitte von b [0] und a.base in Wirklichkeit ist b [0] .der. In der 3. Iteration zeigt a auf das Betteln von b [1] und so weiter.