Eigenen Datentyp?

cooky451

cooky451 schrieb:

@vip@r
http://www.c-plusplus.net/forum/301055-2

vip*r

Shit. Entschuldige bitte. Das hab ich echt überlesen.

*duckundweg*

vip*r

Ich hab hier jetzt mal versucht den Code von dir auf mein Umgebung anzupassen. Bin dabei auf Probleme gestoßen:

matrix *matrix::mul(matrix *M)
{
	if((M->m) == n)	//m = Zeile, n = Spalte
	{
		matrix *ergebnis = new matrix (m, M->n);
		int ergebnis_size = m * (M->n);

		for (int i = ergebnis_size; i-- != 0; )
			for (int j = size; j-- != 0; )
				for (int k = size; k-- != 0; )
					ergebnis->feld[i] += m1(j, k) * m2(k, i);
	}
	else
	{
		cout << "Matrizen stimmen nicht ueberein! Abbruch!";
		return 0;
	}
}

In der Zeile wo ich in das "ergebnis" speichere, wird in deinem Code auf zweidimensionale Felder zugegriffen. Ich hab aber nur eindimensionale Felder... Wie mach ich das dann an dieser Stelle?

Bei der zweiten und dritten for-Schleife weiß ich nicht so genau welche "size" ich angeben muss...

cooky451

Umrechnen, oder (besser) den operator () so überladen wie ich. In jedem Fall kannst du dir das in meinem Code angucken.

Edit: Ah ne, kannste nicht, dachte ich nutze std::vector.
Dann so: v[i * y + j] für einen vector mit [x][y] Größe und Zugriff auf [i][j].

vip*r

Meinst du so:

matrix *matrix::mul(matrix *M)
{
	if((M->m) == n)	//m = Zeile, n = Spalte
	{
		matrix *ergebnis = new matrix (m, M->n);

		int ergebnis_size = m * (M->n);
		int size1 = n*m;
		int size2 = (M->m)*(M->n);

		for (int i = ergebnis_size; i-- != 0; )
			for (int j = size1; j-- != 0; )
				for (int k = size2; k-- != 0; )
					ergebnis->feld[i] += m1(j, k) * m2(k, i);
	}
	else
	{
		cout << "Matrizen stimmen nicht ueberein! Abbruch!";
		return 0;
	}
}

cooky451

Ne, so:

#include <cstddef>
#include <vector>

class matrix
{
  std::vector<float> data_;
public:
  const std::size_t m, n;
  matrix(std::size_t m, std::size_t n)
    : data_(m * n)
    , m(m)
    , n(n)
  {}
  matrix& operator = (const matrix& m)
  {
    *this = matrix(m); // wegen m, n const
  }
  float& operator() (std::size_t i, std::size_t j)
  {
    return data_[i * n + j];
  }
  const float& operator() (std::size_t i, std::size_t j) const
  {
    return data_[i * n + j];
  }
};

matrix operator * (const matrix& m1, const matrix& m2)
{
  // assert / test whatever auf passende Größe
  matrix r(m1.m, m2.n);
  for (std::size_t i = r.m; i-- != 0; )
    for (std::size_t j = r.n; j-- != 0; )
      for (std::size_t k = m1.n; k-- != 0; )
        r(i, j) += m1(j, k) * m2(k, i);
  return r;
}

int main()
{
  matrix m1(5, 5), m2(5, 5);
  m1(2, 3) = 5.5f;
	m2(3, 2) = 4.2f;
  // ...
  matrix m3 = m1 * m2;
}

vip*r

Nach eingehendem Studium deines Codes, muss ich sagen, ich kapier den nicht Wirklich. Sorry.

Ich hab hier jetzt meinen Versuch weiter umgeschrieben und der sollte eigentlich funktionieren. Was er aber nicht ganz tut. Bei einer 2x2-Matrix wird das letzte Ergebnis nicht berechnet; bei einer 3x3-Matrix werden die letzten zwei Ergebnisse nicht berechnet usw...

Kannst du mal drüber schaun?

matrix *matrix::mul(matrix *M)
{
	if (n != M->m)	//m = Zeile, n = Spalte
	{
		cout << "Matrizen passen nicht, abbruch!" << endl;
		return NULL;
	}

	matrix *ergebnis = new matrix(M->n,m);
	ergebnis->init();

	int counter = 0;

	for(int i=0; i<ergebnis->size; i++)
	{
		for (int j=0; j<n; j++)
		{
			ergebnis->feld[i] = ergebnis->feld[i] + feld[counter+(j)] * M->feld[((j)*M->n)+(i)%M->n];
		}

		if (i%M->n == 0)
		{
			counter = counter + n;
		}
	}

return ergebnis;
}

vip@r schrieb:

Nach eingehendem Studium deines Codes, muss ich sagen, ich kapier den nicht Wirklich. Sorry.

Kennst du schon Operatoren-Überladung?

butterbemme

Da es eigentlich in dem ganzen Thread schon um Grundlagen geht, würd ich gern ne Frage einschmeißen:

Ich hab mal gelernt und mittlerweile auch schon öfter gelesen, dass ein Array nie mit einer veränderbaren Variablen initialisiert werden darf, also z.B.

int i;
cin >> i;
int feld[i]

Deswegen versteh ich diesen Teil des Codes des TE nicht ganz, der auch von keinem hier im Thread angekreidet wurde:

...
int *feld = 0;
feld = new int [n];
...

Ist die Sache hier etwas anders, weil "new" mit ins Spiel kommt??

cooky451

butterbemme schrieb:

Ist die Sache hier etwas anders, weil "new" mit ins Spiel kommt??

Ja.

butterbemme schrieb:

Da es eigentlich in dem ganzen Thread schon um Grundlagen geht, würd ich gern ne Frage einschmeißen:

Ich hab mal gelernt und mittlerweile auch schon öfter gelesen, dass ein Array nie mit einer veränderbaren Variablen initialisiert werden darf, also z.B.
int i;
cin >> i;
int feld[i]
Deswegen versteh ich diesen Teil des Codes des TE nicht ganz, der auch von keinem hier im Thread angekreidet wurde:
...
int *feld = 0;
feld = new int [n];
...
Ist die Sache hier etwas anders, weil "new" mit ins Spiel kommt??

Ja. Da der Speicher mit new erst dynamisch zur Laufzeit reserviert wird, muss auch erst zur Laufzeit seine Größe bekannt sein (kann man aber AFAIR auch obiges problemlos machen, ab irgendeinem Standard).

Normalerweise benutzt man aber für statische und dynamische Arrays std::array und std::vector.

cooky451

Hacker schrieb:

kann man aber AFAIR auch obiges problemlos machen, ab irgendeinem Standard

Nein, das geht nur in C. (ab C99)

cooky451 schrieb:

Hacker schrieb:

kann man aber AFAIR auch obiges problemlos machen, ab irgendeinem Standard

Nein, das geht nur in C. (ab C99)

Aha. C hat ja auch new/delete. (?) Oder was versteh ich falsch?

Außerdem kann ich das machen, in meinem GCC 4.6.2, oder ist das IB?

cooky451

Meintest du mit "obiges" etwas anderes als int a[i]; ?

butterbemme

Danke für die schnellen Antworten

cooky451 schrieb:

Meintest du mit "obiges" etwas anderes als int a[i]; ?

Ney