Eigene Vektor und Matrizentypen mit oder ohne Methoden

hefekuchen

Hallo,

ich bin relativ neu in der C/C++ Programmierung und wollte jetzt erst mal anfangen mir häufig benutzte Typen zu deklarieren (in meinem Fall Vektoren und Matrizen). Jetzt bin ich mir nicht sicher ob ich diese als Klassen definieren soll und vor allem ob es sinnvoll ist, die Funktionen zum bearbeiten des Vektors in die Klasse mit aufzunehmen.

Beispiel

struct Triple {
  double x,y,z;

  double Absolut();   // Berechne Vektorbetrag
  Triple Add(Triple); // Addiere anderen Vektor dazu
  }

Triple Multiply(Triple : aVector) { //..} // Multipliziere anderen Vektor

Was ich also wissen will, ob es sinnvoller ist ein strukt nur mit den Daten zu deklariern und Absolut() sowie Add() nach außen zu verlagern oder Multiply() mit ins strukt (oder class) aufzunehmen. Macht es einen Unterschied bezüglich resourcen und performance? Ein struct mit drei double-werten würde vermutlich 24 Byte belegen. Wie viel größer wird eine Instanz mit den Funktionen?

Von solch einem Typ könnten in meinen Programmen etliche 100 oder 1000 Instanzen erzeugt werden. Z.B als Vertices in der 3D-Programmierung, daher will ich natürlich nicht für jeden Vektor so viel Speicher mitschleppen

Nexus

Die Instanzen werden durch die Funktionen nicht grösser, da diese nicht direkt zum Objekt gehören. Eigentlich kann man sich Memberfunktionen wie normale Funktionen vorstellen, die als ersten Parameter implizit einen this -Zeiger erhalten.

Für das Rechnen mit den Vektoren und Matrizen würde ich von Memberfunktionen abraten. Wenn, dann als globale Funktionen. Eleganter wäre natürlich, dafür Operatoren zu überladen.

Absolut() ist noch okay als Memberfunktion, wobei man sich hier auch streiten kann. Kommt halt auch drauf an, ob du die Funktion in grösseren Ausdrücken benötigst.

hefekuchen

Ah, vielen Dank erst mal. Aber wenn ich das richtig verstanden habe, dann sind überladene Operatoren doch auch so ähnlich wie Memberfunktionen die im Grunde genauso implementiert werden müssen. Statt Add() müsste ich dann halt operator+() definieren, was sicher eleganter ist.
Was spricht denn bei Absolut() für und gegen die implementierung als member bzw. globale funktion

Nexus

hefekuchen schrieb:

Ah, vielen Dank erst mal. Aber wenn ich das richtig verstanden habe, dann sind überladene Operatoren doch auch so ähnlich wie Memberfunktionen die im Grunde genauso implementiert werden müssen. Statt Add() müsste ich dann halt operator+() definieren, was sicher eleganter ist.

Ja, Operatoren sind im Grunde genommen normale Funktionen. Aber + , - , und die würde ich global machen, += , -= etc. als Member. Du kannst dann die globalen über die internen implementieren.

Für globale Funktionen spricht, dass sie nicht direkt zum Objekt gehören. Wenn beide Operanden gleichwertig sind, ist das neutraler. Was würdest du schreiben:

Add(Triple1, Triple2);
Triple1.Add(Triple2);

Gleich ist das eigentlich bei den Operatoren, nur sieht man es dann bei der Kurzschreibweise nicht.

operator+(Triple1, Triple2);
Triple1.operator+(Triple2);
Triple1 + Triple2;            // kurz

Bei Member-Operatoren ist das erste Argument (=linker Operand) implizit ein Objekt der Klasse selbst. Das heisst, falls du beispielsweise mal zu einem int addieren willst (blödes Beispiel, aber prinzipiell), kannst du den int nur als rechten Operanden benutzen. Bei globalen Funktionen bist du diesbezüglich freier.