Nun noch meine 2. Frage:
Ich habe wieder eine Funktion und innerhalb soll ein neues Array erstellt werden. Wie kann ich das anstellen, da ich ja bei der Dimension eine Konstante brauche?
Oder kann ich das Problem nur mit einem Vector lösen?

void Funktion(const int DIM)
{
    int arr[DIM]; //Geht nicht... aber dachte DIM ist eine konstante?!
}

Gruß Speedy_92

Die Übergabe wird normalerweise mittels eines Zeigers auf den Anfang des Arrays + 1 oder 2 Dimensionen angegeben.

void Funktion(const int DIM)
{
    int *arr=new int[DIM];
}

DIM ist hier konstant, aber keine konstante, da es zum zeitpunkt des kompilierens nicht bekannt ist.

void Funktion(int (*ptr_arr)[])
{

}

So richtig?!
Aber eine Frage noch:
Wie kann ich nun auf die einzelnen Ints zugreifen?
So in entwa?:

//Innerhalb der Funktion
ptr_arr[2] //???

Mein Problem ist dabei halt nur das es 2-Dimensional ist... Bei einer Dimension würde ich es hinbekommen.

void Funktion(int arr[]);

oder

void Funktion(int *arr);

die beiden ausdrücke sind identisch. welchen man lieber benutzt, ist geschmackssache.

zugriff auf ein so übergebenes array, funktioniert wie sonst auch:

void Funktion(int *arr)
{
 ptr[0]; //für das erste element
}

bzw.

void Funktion(int arr[])
{
 ptr[0]; //für das erste element
}

nein. foo[] ist ein zeiger, da c/c++ keinen unterschied zwischen zeigern und arrays macht. daher übergibt man ein array ohne bestimmte größe so:

void Funktion(int arr[]);

oder

void Funktion(int *arr);

die beiden ausdrücke sind identisch. welchen man lieber benutzt, ist geschmackssache.

zugriff auf ein so übergebenes array, funktioniert wie sonst auch:

void Funktion(int *arr)
{
 ptr[0]; //für das erste element
}

bzw.

void Funktion(int arr[])
{
 ptr[0]; //für das erste element
}

Aber wenn ich ein 2-Dimensionales nehme bekomme ich folgenden Fehler:

Feldindex fehlt

void Funktion(int arr[][])

int **arr;
arr=new (int*)[DIM];
for (unsigned int i=0;i<DIM;++i)
	arr[i]=new int[DIM];

int arr1[10][10];

arr1[1][0] // 10tes element

inr arr2[10][100000000000];

arr2[1][0] // 100000000000tes element

nein. foo[] ist ein zeiger, da c/c++ keinen unterschied zwischen zeigern und arrays macht.

Nein! C++ macht sehr wohl einen Unterschied zwischen Arrays und Zeiger, nur bei der Parameterübergabe spielt die Syntax keine Rolle. Hier gab es eine Diskussion zu diesem Thema.

Ausserdem dürfte Folgendes wegen der Klammern um int* zu einem Fehler führen:

ghorst schrieb:

int **arr;
arr=new (int*)[DIM];

Und jeden Speicher, den man mit new anfordert, muss man mit delete wieder löschen. Gleiches gilt für new[] beziehungsweise delete[] .

Nicht zuletzt deswegen (und auch, weil man auf die explizite Übergabe der Dimension verzichten kann) lohnt sich auch der Einsatz von STL-Containern, z.B. std::vector .

Und was die Klammerung angeht: Kompiliert

int **arr;
arr=new (int*)[DIM];

bei dir? Wenn ja, was für eine IDE/welchen Compiler benutzt du?

Die Klammer nach dem new ist eigentlich dazu da, zusätzliche Argumente an den new -Operator zu übergeben, z.B. nothrow .

c++ null unterschied. ob du nun int[] oder *int zu dem ding sagst

Inkrementier mal einen Zeiger und inkrementier mal ein Array.

void Funk(int arr[10])
{
    arr[0] = 0; //Wird geändert
}

wenn ich das gleiche mit einer normalen int-Variable machen würde, dann würde sie ja nicht geändert werden:

void Funk(int var)
{
    var = 5; //Wird nicht geändert
}

Ich hoffe das stimmt was ich hier sage

Das heisst, wenn du eine Kopie haben willst, musst du die selber anlegen, oder std::vector o.ä. benutzen.

ansonsten macht c++ null unterschied. ob du nun int[] oder *int zu dem ding sagst, ist gleich.

Arrays sind keine Lvalues. Zeiger schon. Siehe drakon

Was ich noch nicht so ganz verstehe ist, warum man bei einem Array als Parameter keine Referenz machen muss um es zu ändern.

Verständlich gesagt: Bei der Übergabe eines Arrays ist es so als würdest du einen Zeiger übergeben, deswegen weiß die Funktion, wo sich das Array im Speicher befindet und kann es somit modifizieren.

Wieder ein Grund für std::vector

Du musst dir bei der Übergabe eines Arrays immer die Dimension als zusätzlichen Parameter übergeben (oder du arbeitest mit konstanten Werten), da sizeof innerhalb der Funktion nicht das gewünschte Ergebnis erzielt, weil die Grösse des Zeigers ermittelt wird.

Wieder ein Grund für std::vector

Naja... ich möchte ein Feld erstellen. Damit möchte ich hinterher arbeiten, also z.B. mit WINAPI zeichnen... Deshalb finde ich es in diesem Moment schöner mit einer Konstanten Dimension zu arbeiten.

Behalte einfach den vector im Hinterkopf, falls du einmal dynamische Arrays benötigst

Nexus schrieb:

Du musst dir bei der Übergabe eines Arrays immer die Dimension als zusätzlichen Parameter übergeben (oder du arbeitest mit konstanten Werten), da sizeof innerhalb der Funktion nicht das gewünschte Ergebnis erzielt, weil die Grösse des Zeigers ermittelt wird.

Wieder ein Grund für std::vector

Naja... ich möchte ein Feld erstellen. Damit möchte ich hinterher arbeiten, also z.B. mit WINAPI zeichnen... Deshalb finde ich es in diesem Moment schöner mit einer Konstanten Dimension zu arbeiten.

Das eine hat mit dem anderen doch nichts zu tun. Du kannst ja auch aus einem std::vector mit der WinAPI zeichnen. Wo ist das Problem?
Zusätzlich ist std::vector um einiges komfortabler.
Ansonsten gibt es auch nocht boost::multiarray:
http://www.boost.org/doc/libs/1_36_0/libs/multi_array/doc/index.html

Speedy_92 schrieb:

Nexus schrieb:

Du musst dir bei der Übergabe eines Arrays immer die Dimension als zusätzlichen Parameter übergeben (oder du arbeitest mit konstanten Werten), da sizeof innerhalb der Funktion nicht das gewünschte Ergebnis erzielt, weil die Grösse des Zeigers ermittelt wird.

Wieder ein Grund für std::vector

Naja... ich möchte ein Feld erstellen. Damit möchte ich hinterher arbeiten, also z.B. mit WINAPI zeichnen... Deshalb finde ich es in diesem Moment schöner mit einer Konstanten Dimension zu arbeiten.

Das eine hat mit dem anderen doch nichts zu tun. Du kannst ja auch aus einem std::vector mit der WinAPI zeichnen. Wo ist das Problem?
Zusätzlich ist std::vector um einiges komfortabler.
Ansonsten gibt es auch nocht boost::multiarray:
http://www.boost.org/doc/libs/1_36_0/libs/multi_array/doc/index.html

Naja... nur irgendwie finde ich es bei Feldern einfach schöner

Naja... nur irgendwie finde ich es bei Feldern einfach schöner

Plus fehleranfälliger und weniger komfortabel