C: Pointer-Frage

[Expandable]

Hallo allerseits,

heute haben wir die Aufgabe bekommen, eine Matrix mit einem Vektor zu multiplizieren (in C). Leider haben wir in der Vorlesung noch keine Pointer durchgenommen, die man dafür aber braucht (wird sogar noch hämisch am Anfang des Aufgabenblattes erwähnt ;o))

Jedenfalls habe ich es nach vielem Ausprobieren endlich geschafft, das ganze zum Laufen zu bekommen. Nur - ich verstehe nicht wirklich, wieso und kann mir nicht vorstellen, dass man das nicht besser lösen kann.

In der Aufgabe steht nun, man soll eine Funktion zur Multiplikation eines Vektors mit einer m * m Matrix schreiben, mit folgendem Prototyp:

void MtxMulVec(float fVec[], float fMtx[], float fVecResult[], int iLen);

Ich habe das nun wie folgt gelöst (zunächst der Code aus der main-Funktion zum Aufrufen, dann die Funktion selbst):


float matrix[3][3] = {{2, 4, -1}, {3, 0, 2}, {0, 2, -1}};

// Vec1 mit der Matrix multiplizieren
// Wir benötigen einen Pointer auf das erste Array-Element für die Funktion MtxMulVec...
float *mtx = &matrix[0][0];
// ... und einen Ergebnisvektor, der auf 0, 0, 0 initialisiert wird
float matVec[3] = {0, 0, 0};
MtxMulVec(vec1, mtx, matVec, iLen);

void MtxMulVec(float fVec[], float fMtx[], float fVecResult[], int iLen)
{
for (int i = 0; i < iLen; i++)
{
for (int j = 0; j < iLen; j++)
{
fVecResult[i] += fMtx[i * iLen + j] * fVec[j];
}
}
}


Das ist ja fürchterlich kompliziert. Deswegen also meine Fragen:

- Was genau mache ich da eigentlich?
- Ich habe des öfteren gelesen, float *mtx = &matrix[0][0]; sei äquivalent zu float *mtx = matrix; - wieso spuckt der Compiler da 'ne Fehlermeldung aus?
- Wieso kann ich nicht einfach matrix an die Funktion übergeben? Fehlermeldung: "cannot convert parameter 2 from 'float [3][3]' to 'float []'"? Wieso interessiert den Compiler, ob es ein ein- oder zweidimensionales Array ist, bzw. warum ist es überhaupt wichtig zu kennzeichnen, dass es sich um ein Array handelt (bin diesbezüglich etwas verwöhnt, weil ich viel PHP programmiere, wo das alles scheißegal ist).
- Wieso kann ich in der Funktion nicht einfach mit fMtx[i][j] auf ein Element zugreifen? Bzw. kann man es irgendwie so lösen, dass man das kann?

Danke für Eure Hilfe!

[Coda]

Das ist eigentlich gar nicht so kompliziert gelöst.

- Eine Multiplikation einer iLen*iLen-Matrix mit einem iLen Vektor
- Ist es nicht. "float *mtx = matrix[0]" wäre das gleiche
- C ist streng typisiert.
- Ja kann man

void MtxMulVec(float *fVec, float **fMtx, float *fVecResult, int iLen)
{
for (int i = 0; i < iLen; i++)
{
for (int j = 0; j < iLen; j++)
{
fVecResult[i] += fMtx[i][j] * fVec[j];
}
}
}

[Trap]

void MtxMulVec(float *fVec, float **fMtx, float *fVecResult, int iLen) [...]
fVecResult[i] += fMtx[i][j] * fVec[j]; [...]

Das geht? Würde mich sehr überraschen, fMtx[i] <=> *(fMtx+i) und das ist kein float* sondern ein float.

[zeckensack]

Ich glaube auch nicht dass das geht.
Dafür bräuchte man ein Array von Zeigern (auf Spaltenvektoren), und das ist einfach nicht da. Das zaubert der Compiler nicht mal eben aus dem Hut, wenn man Typen umwandelt.

[Expandable]

Danke für Eure Antworten.

Mich würde aber trotzdem mal im Detail interessieren, was ich da jetzt mache. So wie ich das sehe, weiße ich einem Zeiger die Adresse des ersten Array-Elements zu. Dann übergebe ich das an die Funktion. Aber: Der Zeiger ist ja kein Array, warum meckert der Compiler da nicht?

In der Funktion selbst laufe ich dann über iLen * i + j für jedes Element eine Speicheradresse weiter, oder wie? Und warum geht das überhaupt so? Ist es denn absolut sicher, dass die Speicheradressen wirklich so aufeinander folgen und nicht anders?

[Coda]

Ich glaube auch nicht dass das geht.
Dafür bräuchte man ein Array von Zeigern (auf Spaltenvektoren), und das ist einfach nicht da. Das zaubert der Compiler nicht mal eben aus dem Hut, wenn man Typen umwandelt.Ohje, war gestern schon spät... Bitte ignoriert den Scheiß X-D

Nein das geht nicht anders, weil die Funktion ja mindestens die zweite Dimension wissen müsste um die Speicherstelle auszurechnen:

void MtxMulVec(float fVec[], float fMtx[][3], float fVecResult[], int iLen)geht nämlich, bringt dir aber wohl nichts.

[GloomY]

Danke für Eure Antworten.

Mich würde aber trotzdem mal im Detail interessieren, was ich da jetzt mache. So wie ich das sehe, weiße ich einem Zeiger die Adresse des ersten Array-Elements zu. Dann übergebe ich das an die Funktion. Aber: Der Zeiger ist ja kein Array, warum meckert der Compiler da nicht?*lächel* ;)

Man kann keine Arrays an Funktionen übergeben. Grundsätzlich nicht. Man kann nur Zeiger übergeben und genau das machst du hier. Der Name eines Arrays ist gleichzeitig ein Zeiger auf das aller erste Element des Arrays.
Wenn du also meinst, dass du bei deiner Funktion ein Array übergibst, dann machst du das in Wirklichkeit nicht sondern übergibst nur einen Zeiger auf das aller erste Element.

Ich weiss, dass sich das jetzt für jemanden, der von PHP herkommt, schwierig oder blödsinnig anhört, aber das ist es nicht. Es ist einfach sehr effizient.
Man stelle sich vor, dass das Array 1 GB groß ist. Einen Parameter einer Funktion zu übergeben heisst, diesen auf den Stack zu pushen, die Funktion aufzurufen und diesen dann wieder herunterzunehmen. Bei einem so großen Array könnte man diese Zeit vielleicht sogar mit der Hand stoppen ;)
Deshalb lieber nur einen kleinen Zeiger übergeben und dann mit diesem innerhalb der Funktion auf das Array zugreifen :)

btw: Hier mal ein aktueller Codeschnipsel aus einem Projekt von mir:
extern void complain_and_exit(int what);

double* matrix_vektor_mul(double** m, double* vek, uint laenge) {
int i, j;
double* erg = (double*) malloc(laenge * sizeof(double));
if (erg == NULL) complain_and_exit(NO_MEM);
for (i=0; i<laenge; ++i) {
double summe = 0.0;
for(j=0; j<laenge; ++j) {
summe += m[i][j] * vek[j];
}
erg[i] = summe;
}
return erg;
}

[Expandable]

Nein das geht nicht anders, weil die Funktion ja mindestens die zweite Dimension wissen müsste um die Speicherstelle auszurechnen:

void MtxMulVec(float fVec[], float fMtx[][3], float fVecResult[], int iLen)geht nämlich, bringt dir aber wohl nichts.

Und dann könnte man mit fMtx[i][j] drauf zugreifen? Und mit float fMtx[] geht's nur so wie's ich gemacht hab?

Kann mir jemand beantworten, warum der Compiler nicht meckert, wenn ich einen Pointer auf das erste Array-Element übergebe, aber im Funktionsprototyp die Variable als Array deklariert ist? Weil ein Pointer ist ja kein Array, sondern eben ein Pointer, der lediglich die Anfangsadresse zu einem Array enthält. Aber das macht ihn doch nicht zum Array.... ???

[Coda]

Und dann könnte man mit fMtx[i][j] drauf zugreifen? Und mit float fMtx[] geht's nur so wie's ich gemacht hab?Ja und ja.

Ein Array in C ist eigentlich nichts weiteres als ein konstanter Pointer. Du kannst auf einen Pointer ja auch den Indexoperator [] anwenden.

[Expandable]

Danke.

Andere Frage: Wenn ich wie folgt eine Matrix anlege:

int **maqu = new int *[dim];
for (int i = 0; i < dim; i++)
maqu[i] = new int[dim];

und ich täte dies innerhalb einer Funktion createMatrix, wie bekomme ich die erstellte Matrix aus meiner Funktions raus? D.h., z.B. in meine Main-Funktion rein, sodass ich sie an eine andere Funktion übergeben kann?

Also ich will in der main sowas haben:

?? matrix = ??;
entweder:
matrix = createMatrix(); (Rückgabe als return-Wert)
oder:
createMatrix(matrix); (also Rückgabe als Pointer irgendwie)
rechneMitMatrix(matrix);

[Coda]

Du kannst einfach int** zurückgeben.

Aber anscheinend verwendest du ja sogar C++. Darf ich fragen warum du die ganze Matrix-Sache nicht einfach in einem Objekt kapselst?

[GloomY]

Erste Möglichkeit:const int dim = 17;

int **createMatrix(void) {
int **maqu = new int *[dim];
for (int i = 0; i < dim; i++) {
maqu[i] = new int[dim];
}
return maqu;
}


int main(void) {
int **matrix;
matrix = createMatrix();

return 0;
}oderconst int dim = 17;

void createMatrix(int **m) {
m = new int *[dim];
for (int i = 0; i < dim; i++) {
m[i] = new int[dim];
}
return;
}


int main(void) {
int **matrix;
createMatrix(matrix);

return 0;
}
Dabei fehlt natürlich noch die obligatorische Abfrage nach NULL. Das habe ich jetzt aber mal weggelassen.

[Coda]

Wieso sollte die Abfrage nach 0 (es gibt kein NULL in C++) obligatorisch sein? (Abgesehen davon, dass das Macro an der Stelle absolut unnötig ist und somit böse)

delete/delete[] machen bei 0 sowieso nichts und new/new[] sollten eine Exception auslösen wenn kein Speicher mehr verfügbar ist.

[Expandable]

Aber anscheinend verwendest du ja sogar C++. Darf ich fragen warum du die ganze Matrix-Sache nicht einfach in einem Objekt kapselst?

Coda: In der Vorlesung behandeln wir gerade C. Unser Prof meint aber, ein paar Dinge gingen in C++ so viel besser (z.B. BOOL'sche Werte, Variablendeklarationen wo man will, new statt alloc, etc.), sodass wir diese Dinge aus C++ verwenden dürfen. Objekt-orientierte Programmierung ist allerdings nicht erlaubt - in der Angabe stand auch extra, dass die Matrix mit new erzeugt werden soll.

Andererseits hat er heut was von der Vector-Klasse erzählt. Sehr konsequent ist er ja nicht, der gute :)

Danke GloomY für die Codebeispiele! Frag mich aber, wieso ich da nciht von selbst draufgekommen bin. Andererseits hatte ich gestern die Schnauze von Pointern gestrichen voll, lag vielleicht daran ;)

[Coda]

Hm da hat der gute Mann aber recht. C++ als besseres C ist ok ;)

[zeckensack]

<...>
oderconst int dim = 17;

void createMatrix(int **m) {
m = new int *[dim];
for (int i = 0; i < dim; i++) {
m[i] = new int[dim];
}
return;
}


int main(void) {
int **matrix;
createMatrix(matrix);

return 0;
}Schlecht. Die Variable matrix in main() bleibt über den Aufruf unverändert. Ergo ein reines Speicherleck ohne sinnvollen Effekt.
Besser:const int dim = 17;

void createMatrix(int ***m) {
*m = new int *[dim];
for (int i = 0; i < dim; i++) {
(*m)[i] = new int[dim];
}
return;
}


int main(void) {
int **matrix;
createMatrix(&matrix);

return 0;
}

[GloomY]

Argh!!! *an den Kopf fass'* :hammer:

Zeckensack, du hast natürlich vollkommen Recht. Ich benutze im Übrigen die andere Methode mit dem Rückgabewert. Da kann man imho nicht so viel falsch machen ;)

[Coda]

oder int &** X-D

[Expandable]

oder int &** X-D

*lol* Jetzt bin ich verwirrt. Was macht das und wie funktioniert das genau?

[Neomi]

oder int &** X-D

Ohne das ausprobiert zu haben... sollte eine Referenz auf einen int** nicht eher ein int**& sein?

[Coda]

Doch hast recht. Ich brauch sowas fast nie und wenn dann probiert man halt kurz rum ;)

[Expandable]

Okay, ich versteh's einfach nicht. Folgender Code:


struct Face
{
public:
float *normal;
float **vertices;
int numOfVertices;
};

In einer Funktion folgender Code-Ausschnitt:
Face **faces;
hier zu sagen: faces = new Face*[irgend ne nummer] funktioniert, allerdings ist der Wert von numOfFaces erst in GetFaces bekannt!
GetFaces(faces, numOfFaces);

for (int i = 0; i < *numOfFaces; ++i)
{
for (int j = 0; j < faces[i]->numOfVertices; ++j) // Hier Access Violation
{
float *test = faces[i]->vertices[j]; // Hier Access Violation
}
}

Funktion GetFaces():
void GetFaces(Face **faces, int *numOfFaces)
{
....... u.a. wird numOfFaces gesetzt
faces = new Face*[*numOfFaces];
if (faces == 0) return;

for (int i = 0; i < *numOfFaces; ++i)
{
faces[i] = new Face();
if (faces[i] == 0) return;
}

// Store all faces in the array
int index = 0;
for (int i = 0; i < numOfBrushes; ++i)
{
for (int j = 0; j < brushes[i]->numOfPlanes; ++j)
{
/*faces[index] = new Face();
if (faces[index] == 0) return;*/

faces[index]->normal = new float[3];
if (faces[index]->normal == 0) return;

brushes[i]->planes[j].normal.ToArray(faces[index]->normal);
faces[index]->numOfVertices = brushes[i]->planes[j].numOfVertices;

faces[index]->vertices = new float*[faces[index]->numOfVertices];
if (faces[index]->vertices == 0) return;

for (int k = 0; k < brushes[i]->planes[j].numOfVertices; ++k)
{
faces[index]->vertices[k] = new float[3];
if (faces[index]->vertices[k] == 0) return;

brushes[i]->planes[j].vertices[k].ToArray(faces[index]->vertices[k]);
}

++index;
}
}
}


In der obigen Vorschleife erhalte ich beim Zugriff auf numOfVertices eine Access-Violation, ebenso beim Zugriff auf eine andere Variable der Struktur face. Warum? Da die Forschleife in GetFaces() direkt unterhalb der Initialisierung von **faces funktioniert, gehe ich davon aus, dass beim Beenden der Funktion irgendwelche lokale Variablen gelöscht werden. Aber bei faces dürfte noch nix gelöscht werden, das hab ich doch komplett mit new angelegt?

Komischerweise funktioniert der Code, wenn ich faces VOR getFaces() mit new anlege!

Wäre für ein paar klärende Worte dankbar :)

[Trap]

GetFaces(faces,numOfFaces) ändert den Inhalt von faces und numOfFaces nicht, kann es auch garnicht. Parameter werden in C immer per Wert übergeben. Wenn du Variablen ändern willst musst du die explizit per Referenz übergeben: GetFaces(&faces,&numOfFaces)

[Expandable]

Hä? Ich übergeb aber doch POINTER! Und wenn ich den Inhalt der Pointer dereferenziere, ändere ich doch den Inhalt unabhängig von der Funktion, in der ich bin, oder?

[del_4901]

Hä? Ich übergeb aber doch POINTER! Und wenn ich den Inhalt der Pointer dereferenziere, ändere ich doch den Inhalt unabhängig von der Funktion, in der ich bin, oder?

jap, aber du legst mit new auch eine neue Adresse an und veränderst somit den wert des pointers ... sprich nach getFaces ist dein faces wieder 0

deine Fqaces gibs zwar noch irgendwo im Speicher, du hast aber die Adresse "vergessen" wo genau ... und das ist sehr sehr pöhze :)

[Expandable]

jap, aber du legst mit new auch eine neue Adresse an und veränderst somit den wert des pointers ... sprich nach getFaces ist dein faces wieder 0

deine Fqaces gibs zwar noch irgendwo im Speicher, du hast aber die Adresse "vergessen" wo genau ... und das ist sehr sehr pöhze :)

Da war also mein Denkfehler! :hammer: Verdammt ;) new generiert eine neue Adresse und weißt diese zu - muss es ja eigentlich auch... aaah... Mist ;)

Also lässt sich das Problem einfach dadurch lösen, dass ich den Pointer entweder per Referenz übergebe, oder aber einen Pointer auf den Pointer auf den Pointer ;o)

Gut, danke soweit, nächste Frage:
Wenn ich das so hätte:

Face *faces;
faces = new Face[100];

Werden dann die 100 Face-Objekte auch auf dem Heap abgelegt (wo ja auch faces liegt), oder aber im Stack? Wenn ich also in GetFaces() keine Pointer auf 100 Face-Objekte in *faces, sondern die Face-Objekte direkt in *faces speichere, werden dann die Face-Objekte als lokale Variablen behandelt und gelöscht oder landen die auch auf dem Stack?

Wenn ich das so mache (anderes Beispiel jetzt):
Face *myFace = new Face();

dann habe ich ja einen Pointer auf ein Objekt vom Typ Face. Face hat nun z.B. eine Integer-Variable (int myInteger). Wenn ich nun myFace->myInteger = 2; zuweise, wird diese zwei wie myFace im Heap abgelegt? Mit anderen Worten, myFace->myInteger wird beim Verlassen der Funktion nicht gelöscht? Liegt das daran, weil der Compiler bei new Face() im Heap genügend Platz reserviert, um ALLE Variablen in myFace zu speichern, seien dies nun "lokale Variablen bezogen auf myFace (also z.B. int myInteger)", wofür dann 4 Bytes belegt werden, oder auch Pointer (z.B. Plane *myPlane), wobei dann auch nur 4 Bytes für den Pointer belegt werden, und das Plane-Objekt selbst steht irgendwo anders im Heap (allerdings nur, wenn irgendwo myFace->myPlane = new Plane() stand und NICHT myFace->myPlane = &irgendwas, weil irgendwas im Stack stehen könnte)?

Hoffe, es versteht jemand, was ich meine. Aber das ist irgendwie nicht so leicht zu erklären ;)

[del_4901]

wenn mich nicht alles täuscht, dann liegt faces auf dem Stack und alles was dran hängt im Heap (new erzeugt immer Objekte auf dem Heap) Es hängt nun von den Conventions ab ob Variablen wie z.B:

typ variable1;
void main (void)
{
typ variable2;
}

im Stack oder im Codesegment abgelegt werden

void main (void)
{
typ variable;
variable = func(variable);
}

typ func(typ var1) // liegt immer auf dem Stack (als Kopie)
{
typ ret; //liegt glaube ich immer auf dem Stack
...
return ret
}


typ func(typ &var1) // liegt immer auf dem Stack (als Referenz bzw. Adresse)
{
typ ret; //liegt glaube ich immer auf dem Stack
...
return ret
}

[Coda]

Alles dynamisch allozierte landed auf dem Heap.

[Gast]

Alles falsch es ist nur gesagt dass sie auf dem "Free Store" landen, mehr nicht. Bei einem heutigen Betriebsystem (Windows, Linux etc) ist der Free Store eben als Heap organisiert.

Pointer übergiebt man nicht per Referenz, das ist so gut wie immer Blödsinn! Des weiteren rate ich von dynamischen 2-dimensionalen Arrays ohne Wrapper-Klasse ab, da bricht man sich nur beide die Beine.

// die stl-variante

const int sizex = 10, sizey = 15;
vector<vector<float> > matrix;
matrix.resize(sizex);
for_each(matrix.begin(), matrix.end(),
bind2nd(mem_fun_ref(&vector<float>::resize), sizey) );

void machWasMitMeinerMatrix(vector<vector<float> >& matrix)
{
/* ... */
}

[Coda]

Mit dem for_each-bin2nd-Zeug bist du aber auch nicht gerade anfängerfreundlich ;)

[Trap]

Nicht nur das, es ist auch unnötig kompliziert:
vector<vector<float> > matrix(sizex,vector<float>(sizey));

Aber zurück zu den Fragen:
Wenn man mit new X() etwas erzeugt, dann wird sizeof(X) Speicher reserviert und dann der Konstruktor von X für den Speicher aufgerufen.

Es funktioniert genauso wie ohne new, nur dass mit new das Objekt im free store angelegt wird. Lokale Objekte werden auf dem Stack angelegt. Als 3. Möglichkeit gibt es noch placement-new bei dem man den Speicher in dem es erzeugt werden soll explizit angibt.

[Xmas]

Kann mir jemand beantworten, warum der Compiler nicht meckert, wenn ich einen Pointer auf das erste Array-Element übergebe, aber im Funktionsprototyp die Variable als Array deklariert ist? Weil ein Pointer ist ja kein Array, sondern eben ein Pointer, der lediglich die Anfangsadresse zu einem Array enthält. Aber das macht ihn doch nicht zum Array.... ???
Die Parameter sind nicht als Array deklariert.

float fVec[] ist kein Array sondern ein Pointer und funktional völlig identisch zu float *fVec.

Das einzige was Arrays von konstanten Pointern unterscheidet ist dass sie eine Größe (sizeof()-Operator) haben die der Anzahl der Elemente * Elementgröße entspricht, während Pointer immer dieselbe systemabhängige Größe haben (meist 32 oder 64 Bit; jaja, near und far Pointer können unterschiedlich breit sein).

Deswegen funktionieren mehrdimensionale Arrays auch überhaupt erst. Das sind nämlich Arrays von Arrays, und nur wenn der Compiler die Größe der Arrayelemente kennt, kann er auch die Position eines indizierten Arrayelements bestimmen.

Coda: In der Vorlesung behandeln wir gerade C. Unser Prof meint aber, ein paar Dinge gingen in C++ so viel besser (z.B. BOOL'sche Werte, Variablendeklarationen wo man will, new statt alloc, etc.),
Der Prof könnte sich auch mit C99 beschäftigen, denn dort gibt es die ersten beiden Dinge.

[Coda]

bool ist in C99 aber eher hässlich imho.

[Expandable]

Ich schreibs jetzt einfach mal in den Thread rein, auch, wenn's ein anderes Problem ist.

Wir sollen als Übung eine Klasse Familienkutsche implementieren. Ich habe dort nun folgendes (nur relevanter Code):


#include <iostream>
#include <map>
#include <string>

typedef std::map<std::string, bool> boolMap;
typedef std::map<std::string, int> intMap;

class Familienkutsche
{
private:
boolMap kindersitze;
intMap sitze;
...

void Familienkutsche::kopieren(const Familienkutsche &rhs)
{
kindersitze.clear();
sitze.clear();

kindersitze["vorn"] = rhs.kindersitze["vorn"];
}


Wenn ich das so mache, bekomme ich folgenden Compiler-Error:
e:\eigene dateien\studium\visual studio\übung 10\aufgabe 3\aufgabe 3.cpp(116) : error C2678: binary '[' : no operator found which takes a left-hand operand of type 'const boolMap' (or there is no acceptable conversion)
c:\programme\microsoft visual studio\vc\include\map(166): could be 'bool &std::map<_Kty,_Ty>::operator [](const std::basic_string<_Elem,_Traits,_Ax> &)'
with
[
_Kty=std::string,
_Ty=bool,
_Elem=char,
_Traits=std::char_traits<char>,
_Ax=std::allocator<char>
]
while trying to match the argument list '(const boolMap, const char [5])'

Mache ich das so, funktioniert's:

void Familienkutsche::kopieren(const Familienkutsche &rhs)
{
kindersitze.clear();
sitze.clear();

boolMap test = rhs.kindersitze;

kindersitze["mitte1"] = test["mitte1"];
}


WIEEESSOOOOO???? Danke schonmal!

[Coda]

Lass das const weg.

[Expandable]

Aha und wieso?

[Coda]

Weil's dann vermutlich geht.

[Expandable]

Weil's dann vermutlich geht.

Aha. Für solche Antworten brauchst Du Deine Zeit eigentlich nicht verschwenden, weil die ABSOLUT NIX BRINGEN. Und ja, es geht. Ich würde aber gerne wissen, WARUM.

[Coda]

no operator found which takes a left-hand operand of type 'const boolMap'Das Problem ist dass der []-Operator keine konstante Operation ist, weil er auch Elemente einfügen kann. Deshalb geht der bei einer const-map nicht.

Wenn du es mit const benützen willst must du wohl map::find benützen.

[Expandable]

Danke.