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

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

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

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);
}

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

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?

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

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

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> >

Du hast den entscheidenden Unterschied vergessen.

Oh, danke für den Tip!

Ganz genauso wie bei allen anderen Typen

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