zweidimensionales Array übergeben...

CharlieHarper

Hallo Leute,
Ersteinmal zu mir : Ich programmiere ca. seit einem Jahr in Java und nun habe ich mit c++ begonnen. Ich nutze momentan Microsoft Visual Studio 2010 als Entwicklungsumgebung.

Momentan programmiere ich erstmal ( zum warm werden ) kleinere Programme.
In meinem aktuellen Programm möchte ich mich ein bisschen mit Arrays beschäftigen. Dabei bin ich nun auf folgendes Problem gestoßen : Ich habe eine Funktion der ich ein zweidimensionales Array übergeben möchte. Jedoch klappt dies nicht wirklich.

Hier mal ein Bsp. Code wie ich es bis jetzt probiert habe :

using namespace std;

// Prototypen
void fk1( int arr[][]);

int main()
{
    int const groesse = 5;
    int arr[groesse][groesse];
    fk1(arr);

    system("Pause");
    return 0;

}

void fk1( int brett[][])
{

    // Anweisungen
}

Kann mir jemand erklären wie es richtig funktioniert? Ebenfalls verlangt der Compiler beim Anlegen des Arrays ein Konstanten wert. Wie würde es denn aussehen wenn ich z.B. über ein cin die Größe des Arrays bestimmen möchte?

Danke jetzt schonmal

mfG

CharlieHarper

Konstant:

void f(int x[10][5])
{
}

int main()
{
	int a[10][5];

	f(a);
}

Variabel:

#include <iostream>

void f(int **a, int x, int y)
{
}

int main()
{
	int x = 10;
	int y = 5;

// Speicheranforderung
	int **a = new int*[x];

	for (int i = 0; i < x; ++i)
	{
		a[i] = new int[y];
	}

// Übergabe
	f(a, x, y);

// Speicherfreigabe
	for (int i = 0; i < x; ++i)
	{
		delete[] a[i];
	}

	delete[] a;
}

Siehe auch http://www.c-plusplus.net/forum/viewtopic-var-t-is-39489.html

Ohne konstanten Wert musst du Pointer und new verwenden und diese schlimmen Sachen sollten in C++ vermieden werden.

Deshalb verwendet man für 2dimensionale Arrays:

std::vector<int> a(groesse*groesse) // selbstgecodedes Jagged Array
std::vector<std::vector<int>> b(groesse) // Die Werte von b[0-groesse] müssen noch reserviert werden
oder boost::multi_array<int, 2> c(boost::extents[groesse][groesse]) // aus dem Kopf, vielleicht habe ich irgendwas vertauscht

Torsten Robitzki

CharlieHarper schrieb:

Wie würde es denn aussehen wenn ich z.B. über ein cin die Größe des Arrays bestimmen möchte?

#include <vector>
#include <iostream>

void f(const std::vector<std::vector<int> >&)
{
}

int main()
{
    int dim1 = 0;
    int dim2 = 0;

    std::cin >> dim1 >> dim2;

    std::vector<std::vector<int> > array(dim1, std::vector<int>(dim2));

    f(array);
}

CharlieHarper

Hallo!
Danke für die vielen Antworten!
Ich habe es jetzt mal so versucht wie Torsten Robitzki es geschrieben hat. Das erstellen funktioniert jetzt super und vom Syntax her meckert der Compiler nun auch nicht mehr.
Allerdings habe ich nun, beim Funktionsaufruf folgenden Fehler :

http://www.xup.in/pic,48400991/vector.png

Ich habe mir die Vector Variable im Debugging-Modus angeschaut und dabei erfreut festgestellt, das die Initialisierung, nur wenn das Programm schließlich zum Funktionsaufruf kommt, erscheint diese Fehlermeldung.

Weiß da jemand evtl. bescheid?

Danke schonmal

LG

CharlieHarper

Panke

Du greifst auf einen Index zu, der zu groß ist. Zeig mal den Code.

CharlieHarper

achh dankeschön. Ich habe lediglich die Größe des Vector´s falsch ausgelesen.

Allerdings hätte ich da noch eine Frage zu dem Thema Vectoren in c++ und zwar habe ich nun ja den 2D Vector. Ich möchte diesen nun per Pointer einer Funktion übergeben, dies mache ich denke ich mal richtig.
Hier mal der Prototyp

bool sprungKorrekt(int anfangx, char anfangy, int sprungx, char sprungy, vector<vector<int>> *vekPoint);

Allerdings stehe ich momentan völlig auf dem Schlauch, wie ich nun einen Pointer von dem Vektor erstelle und wie ich anschließend in der Funktion von dem Pointer wieder zurück auf den Vektor komme.

Weiß jemand rat?

SeppJ

Ganz genauso wie bei allen anderen Typen auch: Der &-Operator gibt einen Zeiger auf das Objekt auf welches er angewendet wird, der *-Operator dereferenziert einen Zeiger.

Bleibt aber die Frage: Wozu? Was würde hier nicht durch eine Referenz besser gelöst werden?

Torsten Robitzki

CharlieHarper schrieb:

bool sprungKorrekt(int anfangx, char anfangy, int sprungx, char sprungy, vector<vector<int>> *vekPoint);
Allerdings stehe ich momentan völlig auf dem Schlauch, wie ich nun einen Pointer von dem Vektor erstelle und wie ich anschließend in der Funktion von dem Pointer wieder zurück auf den Vektor komme.

Wenn es den unbedingt ein pointer sein muss, wäre der Aufruf:

vector<vector<int> > v;
sprungKorrekt(42, 42, 42, 42, &v);

Aber warum soll es ausgerechnet ein Zeiger sein? Wenn der 5te Parameter nicht optional sein soll und die Funktion in der Lage sein soll, die übergebenen Daten zu ändern, bietet sich eine Referenz an:

bool sprungKorrekt(int anfangx, char anfangy, int sprungx, char sprungy, vector<vector<int> > &vekPoint);

mfg Torsten

Nexus

Torsten Robitzki schrieb:

Aber warum soll es ausgerechnet ein Zeiger sein? Wenn der 5te Parameter nicht optional sein soll und die Funktion in der Lage sein soll, die übergebenen Daten zu ändern, bietet sich eine Referenz an:
bool sprungKorrekt(int anfangx, char anfangy, int sprungx, char sprungy, vector<vector<int>> *vekPoint);

Du hast den entscheidenden Unterschied vergessen.
Nimm für Referenzen & statt * .

Und auch optionale Parameter kannst du mit Referenzen und Funktionsüberladung implementieren. In letzter Zeit tendiere ich dazu, diesen Weg dem nullbaren Zeiger und der entsprechenden If-Abfrage vorzuziehen.

Ach ja, und für portablen Code musst du ein Leerzeichen zwischen > und > haben.

vector<vector<int> >

Torsten Robitzki

Nexus schrieb:

Du hast den entscheidenden Unterschied vergessen.

Oh, danke für den Tip!

pumuckl

SeppJ schrieb:

Ganz genauso wie bei allen anderen Typen

... die den unären operator& nicht überladen haben