Matrixmultiplikation

Count_Omega

wie fülle ich dann int em[1000][1000] mit nullen?

Du könntest z.B. mal eine Suchmaschine deiner Wahl bemühen.

Da kommt das sowas raus wie https://de.wikibooks.org/wiki/C-Programmierung:_Arrays

Count_Omega

Ok danke und was ist jetzt der Fehler bei der Übergabe?

Techel

#include <cstddef> //für den Datentyp 'size_t'
#include <array> //für den Datentyp 'array' im Namensraum 'std'

int main()
{
	int b[10][12] = {0}; //jedes Element auf 0 setzen
	int c[10][12] = {6}; //erstes Element auf 6 setzen.
        int g[2][3] = { {1,2,3}, {4,5,6} }; //...oder jedes Einzeln.

	//statt auf rohe Arrays kann man auch auf 'std::array' setzen, was
	//unter anderem davor warnen kann, wenn ungültige
	//Indizes verwendet werden.
	std::array<int, 10> d1, d2; //2 Arrays mit jeweils 10 ints.
	std::array<std::array<int, 12>, 10> m; //Array von 10 Arrays mit jeweils 12 ints.

	//Bietet auch andere nette Sachen an, z.B.
	//lässt sich so ein std::array kopieren:
	d1 = d2; //funktioniert super.

	//b = c //funktioniert leider nicht...

	//mit einer Schleife initialisieren:
	for(size_t row = 0; row < 10; ++row)
	{
		for(size_t col = 0; col < 12; ++col)
			b[row][col] = 1;
	}

	//...oder:
	for(int (&row)[12] : b)
	//heißt: gehe jedes Element (=Array von 12 ints) durch und lass 'row'
	//dieses referenzieren (=Referenz auf Array von 12 ints).
	{
		for(int &cell : row)
		//gehe jedes Element durch (=ints) durch und lass 'cell'
		//dieses referenzieren (=Referenz auf int)
			cell = 2; //den int, den 'cell' referenziert, auf 2 setzen.
	}
}

Upsi, kam wohl etwas zu spät. Aber die std::array-Klasse ist ziemlich super.

Techel schrieb:

int c[10][12] = {6}; //jedes Element auf 6 setzen.

Nein. Erstes Element (c[0][0]) auf 6, alle anderen auf 0 setzen.

Count_Omega schrieb:

Tut mir leid, ich verstehe nicht, was ihr meint. Em soll ein Feld Mit Größe 1000x1000 sein und nur Nullen beeinhalten(anfangs).

Jemandem, der nach nicht einmal 10 Minuten mit "verstehe ich nicht" kommt, ohne auch nur im Ansatz auf dei gestellten Fragen einzugehen, helfe ich nicht.

Techel

wob schrieb:

Techel schrieb:
int c[10][12] = {6}; //jedes Element auf 6 setzen.
Nein. Erstes Element (c[0][0]) auf 6, alle anderen auf 0 setzen.

Da hast du recht, mein Fehler. Ist nun korrigiert.

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.