Matrixmultiplikation

Count_Omega

He ich habe die Fragen beantwortet. Ich habe 3h vorher bereits zu meinem Fehler recherchiert und bin zu keinem ERgebnis gekommen. Nun wäre ich froh wenn mir jemand helfen würde.

Andromeda

Für 2D-Arrays siehe auch hier: https://www.c-plusplus.net/forum/39489-full

Count_Omega

Sorry, aber was genau ist der Fehler bei der Übergabe(oder Nichtübergabe) der Arrays?

so wie du es machst, ist es falsch.
so ist es richtig: http://stackoverflow.com/questions/8767166/passing-a-2d-array-to-a-c-function

manni66 schrieb:

so wie du es machst, ist es falsch.
so ist es richtig: http://stackoverflow.com/questions/8767166/passing-a-2d-array-to-a-c-function

Und schon wieder eine Schnapsnase mit geklautem Namen

Kinder, denkt euch mal 'n eigenen Namen aus. Ich benutze meinen schon seit Jahren...

Count_Omega

Kann sein dass ich blöd bin aber keine Lösung funktioniert.
Das Ziel ist

void myFunction(double myArray)

{
...
}
..
double anArray[10][10];
...
myFunction(anArray)

ohne Fehler zu rechnen.

Andromeda

Count_Omega schrieb:

Kann sein dass ich blöd bin aber keine Lösung funktioniert.
Das Ziel ist
void myFunction(double myArray)
{
...
}
..
double anArray[10][10];
...
myFunction(anArray)

ohne Fehler zu rechnen.

Probier mal so:

void myFunction(double (*myArray)[10])

Das Herumreichen von 2D (und mehr D) Arrays ist ein bisschen doof in C++.
Aber das kriegste schon hin.

DirkB

Count_Omega schrieb:

Sorry, aber was genau ist der Fehler bei der Übergabe(oder Nichtübergabe) der Arrays?

Du übergibst das Element mit dem Index [1000][1000], das nicht einmal existiert.
Dies ist ein einzelnes Element vom Typ int und kein Array.

Bei der Multiplikation greifst du doch auch mit Ma[i][j] auf die Elemente zu.

Nebenbei halte ich knappe 4 Megabyte für eine Matrix auf dem Stack etwas übertrieben.

Count_Omega

Seht gut, danke. Scheint zu funktionieren. Der einzige verbliebene fehler ist

Quelle1.cpp:32:34: error: invalid operands of types ‘int [1000]’ and ‘int [1000]’ to binary ‘operator*’
Em[i][k] = Ma[i][j] * Mb[j][k];
. Darf ich * bei arrays nich verwenden?

DirkB

Count_Omega schrieb:

Darf ich * bei arrays nich verwenden?

Du musst zwischem dem Array (bzw. der Adresse eines (vom ersten) Element) und einem Element vom Array unterscheiden.

Der * ist bei einem Array der Dereferenzierungsoperator.

Wenn Ma oder Mb jeweils 2D-int-Arrays oder
wenn Ma oder Mb Zeiger auf 1D-Zeiger_auf_int-Arrays sind, dann ist Ma[i][j] bzw. Mb[j][k] ein int.
Und bei int ist * die Multiplikation.

Demnach sind bei dir Ma und Mb keine 2D-Arrays.

Zeige den ganzen Code!

Count_Omega

[code="cpp"]
#include <iostream>
#define size 1000

using namespace std;

void matrixmult(*Ma[size][size], * Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
int z = 1000;
int z1 = 1000;
int z2 = 1000;

int m1[1000][1000];
int m2[1000][1000];
matrixmult(*m1, *m2, z, z1, z2);
}

int ma[size][size];
int mab[size][size];
void matrixmult( *Ma[size][size], *Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
int Em[1000][1000] = { 0 };
for (int i = 0; i< zeilenmc; ++i)
{
for (int j = 0; j < zeilenmb; ++j)
{

for (int k = 0; k < spaltenmc; ++k)
{

Em[i][k] = Ma[i][j] * Mb[j][k];
}
}

}
std::cout << Em[zeilenmc][spaltenmc] << endl;
}

Andromeda

Count_Omega schrieb:

#include <iostream>
#define size 1000

using namespace std;

void matrixmult(*Ma[size][size], * Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 1000;
	int z1 = 1000;
	int z2 = 1000;

	int m1[1000][1000];
	int m2[1000][1000];
	matrixmult(*m1, *m2, z, z1, z2);
}

int ma[size][size];
int mab[size][size];
void matrixmult( *Ma[size][size],  *Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[1000][1000] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{
				
				Em[i][k] = Ma[i][j] * Mb[j][k];
			}
		}

	}
	std::cout << Em[zeilenmc][spaltenmc] << endl;
}

// Die Funktion sollte so anfangen
void matrixmult(int Ma[][size], int Mb[][size] ....
// oder so
void matrixmult(int (*Ma)[size], int (*Mb)[size] ...
// aber nicht so
void matrixmult( *Ma[size][size],  *Mb[size][size] ....
...
// und sollte so aufgerufen werden
matrixmult(m1, m2, ...
// aber nicht so
matrixmult(*m1, *m2, ...

ausserdem sollte Em[i][k] = Ma[i][j] * Mb[j][k]; sinnigerweise Em[i][k] += (Ma[i][j] * Mb[j][k]); heissen.

Swordfish

Um. Welche Sprache?

DirkB

Count_Omega schrieb:

std::cout << Em[zeilenmc][spaltenmc] << endl;

Das gibt das Element (und nur dieses eine Element) Em[1000][1000] des Arrays Em aus. (bei deinen Parametern)
Nach deiner Definition existiert das Element aber gar nicht.

Count_Omega

Ich habe den Code nochmals überprüft und jetzt kompiliert es. Beim Ausführen bekomme ich jedoch den error Speicherzugriffsfehler (Speicherabzug geschrieben).
Dies liegt vermutlich an den Arrraygrenzen; wenn ich diese dynamisch festlegen will funktioniert es nicht.

#include <iostream>
#define size 100

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 100;
	int z1 = 100;
	int z2 = 100;

	int m1[100][100];
	int m2[100][100];
	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[100][100] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{

				Em[i][k] = Ma[i][j] * Mb[j][k];
			}
		}

	}
	std::cout << Em[zeilenmc][spaltenmc] << endl;
}

unskilled

Count_Omega schrieb:

#include <iostream>
#define size 100
//?

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

//int main(int argc, char **argv)
int main()
{
	int z = 100;
	int z1 = 100;
	int z2 = 100;

	int m1[100][100];
	int m2[100][100];
	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[100][100] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{
				
				Em[i][k] = Ma[i][j] * Mb[j][k];
//ist auch noch immer falsch.
			}
		}

	}
	std::cout << Em[zeilenmc][spaltenmc] << endl;
}

Beim Ausführen bekomme ich jedoch den Fehler Speicherzugriffsfehler (Speicherabzug geschrieben).

DirkB schrieb:

Count_Omega schrieb:
std::cout << Em[zeilenmc][spaltenmc] << endl;
Das gibt das Element (und nur dieses eine Element) Em[1000][1000] des Arrays Em aus. (bei deinen Parametern)
Nach deiner Definition existiert das Element aber gar nicht.

scheinst ein bisschen auf kriegsfuß mit lesen zu stehen?

Count_Omega

ist es dann richtig mit

...
Em[i][k] += Ma[i][j] * Mb[j][k];
...
for (int l = 0; l > size; ++l)
	{
		for (int m = 0; m > size; ++m)
		{
			std::cout << Em[l][m] << endl;
		}
	}

Nein. Denn < und > solltest du besser nicht verwechseln (2x).

Du kannst nicht einfach irgendwelche Zeichen wie *, +, <, =, > raten, sondern musst überlegen, welches jeweils passt! (ok, du kannst schon raten, aber dann ist es Glückssache, ob es richtig wird)

Count_Omega

Hat sich erledigt, fuktioniert. Trotzdem vielen Dank. Code:

#include <iostream>
#define size 100

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 100;
	int z1 = 100;
	int z2 = 100;

	int m1[100][100];
	int m2[100][100];
	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[100][100] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{

				Em[i][k] = Ma[i][j] * Mb[j][k];
			}
		}

	}
	for (int l = 0; l < size; ++l)
	{
		for (int m = 0; m < size; ++m)
		{
			std::cout << Em[l][m] << endl;
		}
	}
}

Die Matrizen müssen noch gefüllt werden,aber das ist nebensächlich.