Eigenen Datentyp?

Dravere

Hacker schrieb:

SeppJ, SeppJ! Guck mal, was ich gebastelt hab! Ich mache es später noch mit einem Allokator.

Du weisst schon, dass dein Code verschiedene Fehler hat und zudem undefiniertes Verhalten auslöst? Zudem hat er auch noch einige Unschönheiten drin.

Grüssli

PS: Falls du mehr erfahren willst, solltest du einen eigenen Thread starten.

Dravere schrieb:

...
PS: Falls du mehr erfahren willst, solltest du einen eigenen Thread starten.

War doch nur aus spaß!

cooky451

Hacker schrieb:

Außerdem wird der Speicher erst beim Ende des Programms gelöscht, was zwischenzeitliche Performance-einbußen wegmacht

Na super, das kannste auch alle major Betriebssysteme für dich machen lassen, die machen das sogar wesentlich effizienter als dein Zeugs.

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

314159265358979

Hacker schrieb:

SeppJ, SeppJ! Guck mal, was ich gebastelt hab! Ich mache es später noch mit einem Allokator.

Das ist nicht nur hässlich sondern auch noch falsch. Dein Move-Ctor ist ein kaputter Copy-Ctor. Da du nicht auf Alignment geachtet hast, handelst du dir herrlich UB ein. Ansonsten gehe ich darauf nicht mehr ein, cookies Kommentar triffts am besten.

vip*r

Könnte sich vielleicht nochmal jemand zu meinem Matrixmultikplikationsproblem äußern? Das wär sehr nett!

cooky451

Nö. In dem Thread steht bereits alles was du brauchst, eine schöne Lösung von SeppJ und eine einfache Lösung von mir. Lies.

vip*r

Gut. Ich hab ja schon die Tage über jeden einzelnen Beitrag gelesen, aber ich weiß nicht wo ich hier Hilfe zu einer MATRIXMULTIPLIKATION (!) finden soll...

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?