2D-Array bekannter Größe als Call by Reference an Memberfkt. übergeben

T0bi

Hier mal nen Beispiel:

class CClass {

    private:

        int    **m_p2DArray;

    public:

        CClass( );
        CClass( int iFirstDim, int iSecondDim, int iInitial );
        ~CClass( );

        int       GetValue( int iFirstDim, int iSecondDim ) const;

};

// ***** Default constructor *****
CClass::CClass( ) {

    m_p2DArray = 0;
}

// ***** (1) constructor *****
CClass::CClass( int iFirstDim, int iSecondDim, int iInitial ) {

    // ***** Allocate some memory *****
    m_p2DArray = new int*[ iFirstDim * sizeof( int ) ];

	for( int i = 0; i < iFirstDim; i++ )
		m_p2DArray[ i ]= new int[ iSecondDim * sizeof( int ) ];

    // ***** Initial array *****
    for( int y = 0; y < iSecondDim; y++ ) {

        for( int x = 0; x < iFirstDim; x++ ) {

            m_p2DArray[ x ][ y ] = iInitial;
        }
    }       
}

// ***** Destructor *****
CClass::~CClass( ) {

    free( m_p2DArray );
}

// ***** Get value *****
int CClass::GetValue( int iFirstDim, int iSecondDim ) const {

    return m_p2DArray[ iFirstDim ][ iSecondDim ];
}

int main( ) {

    CClass foo( 5, 5, 1 );

    cout << foo.GetValue( 2, 1 ) << endl;
    getchar( );
	return 0;
}

MFK

Selbst wenn du im Destruktor statt free delete benutzt hättest, wie es sich gehört, hättest du da ein schönes Speicherleck. Und warum nicht std::vector?

T0bi

Wieso hat er dann nen Speicherleck? Wird etwa nicht alles wieder freigegeben?

Gruß Tobi.

MFK

T0bi schrieb:

Wieso hat er dann nen Speicherleck?

Weil du iFirstDim+1-mal new aufrufst, aber nur einmal delete?

T0bi

Hmm dann müsste er es mit einer For-Schleife alles deleten?

T0bi schrieb:

Hmm dann müsste er es mit einer For-Schleife alles deleten?

Ganz einfache Regel: Für jedes new/new[] muss auch ein korrespondierendes delete/delete[] aufgerufen werden.

T0bi

ein 2D-Array deleten?

Horroreyes

Ich hab gelernt, das man 2d arrays garnicht mit new erstellen kann... stattdessen kann man die spalten "hintereinander" hängen... damit würde sich zumindest die Frage klären wie man 2d-arrays deletet: garnicht

drakon

Merker++ schrieb:

drakon schrieb:

Hi.
Bekanntes Anfängerproblem. Zuerst sei mal klargestellt, dass ein 2 Dimensionales Feld kein ** (Doppelzeiger) ist. Das wird oft falsch vermittelt.

Hat jemand etwas von Doppelzeigern geschrieben?
Doppelzeiger gibt es btw. auch gar nicht, wenn dann Zeiger auf Zeiger.

Gar niemand. (zumindes bis zu deinem Post). Aber Doppelzeiger werden (wie jetzt auch bereits) sehr gerne mit 2D Array in Verbindung gebracht, welche so direkt nichts miteinander zu tun hat. (Jah man KANN 2D Arrays und Doppelpointer benutzen, aber bei seinem Fall ist das wahrscheinlich nicht erwünscht).

ein 2D-Array deleten?

Du hast die Antwort bereits geschrieben. Mit einer Schlaufe. Irgendwo habe ich das hier mal mit einem dynamischen 3D Array gemacht. (Sieht grauenhaft aus und std::vector sollte da eher benutzt werden).

Ich hab gelernt, das man 2d arrays garnicht mit new erstellen kann... stattdessen kann man die spalten "hintereinander" hängen... damit würde sich zumindest die Frage klären wie man 2d-arrays deletet: garnicht

Richtig. Im herkömmlichen Sinne ist es nicht möglich dynamsich ein 2D Array zu erstellen. Jedoch ist das, was du vorschlägst ("hintereinanderlegen") genau das, was der Compiler so oder so auch bei 2D Arrays macht.
Das mit dem deleten stimmt nicht. Man muss die genau gleich, wie alles anderen deleten. Wenn man da hald in einer Schlaufe Speicher per new anfordert, dann muss man den hald auch wieder mit delete in einer Schlaufe freigeben.

EDIT:
Hier war das mit dem 3D Array:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-211534-and-highlight-is-.html

btw. Die Forensuche hier ist ***..

Horroreyes

klar muss man die normalen arrays wieder deleten, jedoch stellt sich die frage nicht mehr wie man 2d-arrays deleten soll, es lässt sich auf einen langen array beschränken, der einfach mit delete[] freigegeben wird