zur zeit schreibe ich an einem 4 gewinnt spiel. Ich habe dafür die Klasse Spielfeld entwickelt:

s4 gewinnt.hpp

#include <ctime>
#include <cstdlib>
#include <cassert>
#include <iostream>

class spielfeld {
    private:
        class proxy {
            public:
                short int operator[](short int x) ;
                short int inhalt[7];
        };
        short int hoehe[7];
        proxy feld[6];
        bool aktu_spieler;
    public:
    //Konstruktur
        spielfeld();

    //Gewonnen ja oder nein, gibt nicht den spieler, der gewonnen hat zurück
        bool gewinn_ueberpruefung(short int x);

    // die position auf der x achse wo er auftritt
        bool stein_faellt(short int x);

        proxy& operator[](short int y) ;
};

und dazu die implementierung

#include "4 gewinnt.hpp"

// das feld wird auf 0 gesetzt

using namespace std;
spielfeld::spielfeld() {
    int i, j;
    for( i=1; i<=6; ++i) {
        for( j=1; j<=7; ++j)
             feld[i].inhalt[j] = 0;
        hoehe[i] = 6;
    }
    hoehe[7] = 6;

}

//
// der überladene Operator []

short int spielfeld::proxy::operator[](const short int y) {
    assert((y<=7) && (y > 0));
        return inhalt[y];
}

spielfeld::proxy& spielfeld::operator[](const short int x) {
    assert((x<=6) && (x > 0));
        return feld[x];
}

// Stein fällt

bool spielfeld::stein_faellt(short int x) {
    assert((x<=7) && (x > 0));
        if (hoehe[x] > 0) { // zählt die felder die noch leer sind
            cout << "Speicher Spieler:" <<&aktu_spieler << " Speicher feld:" << &feld[5].inhalt[7] << endl; // die ausgabe der addressen
            feld[hoehe[x]].inhalt[x] = aktu_spieler + 1;
            --hoehe[x];
            aktu_spieler = 1 - aktu_spieler; // wird immer gewechselt;
            return 0;
        } else
            return 1;

}

main.cpp

#include <iostream>
#include "Header\4 gewinnt.hpp"

using namespace std;

int main()
{
    int i, j, ende;
    spielfeld test;
    cout << endl;
    // nur für testzzwecke
    do {
        for( i=1; i<=6; ++i) {
            for( j=1; j<=7; ++j)
                cout << test[i][j];
            cout << endl;
        }
        cin >> ende;
        cout << endl;
        test.stein_faellt(ende);
    }while (ende != 0);

}

sooo. hier wollte ich nun mit der Gewinn überrüfung weitermachen. Allerdings fiel mir ein fehler auf.
Alls ich ein paar steine fallen ließ, hat das feld [7][5] immer seinen Inhalt gewechselt. und zwar immer zum inhalt das aktu_spieler. Ich habe mir mal die Speicheraddresen der beiden angeschaut und sah, das sie identisch waren. Ich weiß aber nicht warum.

Kann mir bitte einer erklären warum die speicheraddressen der beiden identisch sind und eine lösung nennen?