[D3D10] Welche Mathe lib

[Andi]

Ich muss mir leider eingestehen, mit Templates nicht wirklich umgehen zu können. Hoffe Ihr könnt mir weiterhelfen.

Ich versuch mein Beispiel auf das Wesentliche zu kürzen:

Code: Alles auswählen

template<typename T, size_t N> 
class VectorCondition
{
  protected:
    T m_Data[N];
}

template<typename T> 
class VectorCondition<T, 2>
{
  public:
    union
    {
      T m_Data[2];

      struct
      {
        T x, y;
      };
    }

    VectorCondition<T, 2>(T x, T y) : x(x), y(y) {}
}

und das gleiche Prinzip für 3D und 4D Vektoren.

Die Basis-Klasse:

Code: Alles auswählen

template<typename T, size_t N> 
class Vector_t : public VectorCondition<T, N>
{
  public:
    Vector_t<T, N>() : Vector_t<T, N>(0);

    Vector_t<T, N>(T value);

    Vector_t<T, N>(const Vector_t<T, N>& v);

typedef Vector_t<float, 2> Float2;
typedef Vector_t<float, 3> Float3;
typedef Vector_t<float, 4> Float4

Müssten Float2, Float3 und Float4 eigentlich alle Konstrukotren und Member aus Vector_t und VectorCondition vererben? Mit den überladenen Operatoren hab ich eine ähnliche Logiklücke.

[Schrompf]

Nein, die "erben" gar nix. Du musst Dir das so vorstellen: VectorCondition ist die generische Klasse, und die spezialisierst Du jetzt für N == 2. Das bedeutet, für jedes andere N, mit dem Du den Typen instanziierst, hat die Klasse die einen Membervars und Methoden, und für den Spezialfall N == 2 hat es die anderen Vars und Methoden. Wenn Du wirklich Methoden wiederverwenden willst, musst Du von VectorCondition ableiten. Und bei Ableitung glaube ich, steigt dann der VisualStudio-Optimizer aus, weil's kein POD mehr ist. Das ist aber nur Vermutung, als mach, was Du für richtig hältst.

[Krishty]

Hier ist ein sieben Jahre alter Thread, wo ich die selbe Scheiße gebaut habe. Schrompf und Helmut wollten mir die Flausen damals ausreden, aber ich hab’ nicht drauf gehört und vier Wochen meines Lebens verschwendet. Jetzt steh ich hier und sag’ das Gleiche.

Also: Spezialisier das Template von Hand; verzichte auf Vererbung; geh stattdessen vier Wochen saufen und ficken.

[Spiele Programmierer]

Ich würde "m_Data" "public" machen. Ich sehe absolut keinen Sinn darin, die einzelnen Koordinaten ab der 4en Dimension vor der Außenwelt zu verstecken.

typedefs sind keine Verebung sondern definieren bloß einen anderen Namen für exakt das selbe.
Die Frage ob etwas vererbt wird, passt also nicht. Wenn man einen Type Alias benutzt, funktioniert der Code exakt so, als ob man den Typ auf den der Alias zeigt direkt verwendet hätte.
Das kann man auch in C++ selbst überprüfen:

Code: Alles auswählen

#include <type_traits>

class A {};
class B0 : public A {};
typedef A B1;

static_assert(!std::is_same<A, B0>::value, "A und B0 ist ein und das selbe"); //Wird nicht ausgelöst-
static_assert(!std::is_same<A, B1>::value, "A und B1 ist ein und das selbe"); //Wird ausgelöst

Die Operatoren kann man ganz wunderbar in "Vector_t" mit ein paar kleinen Schleifen definieren.
Konstruktoren sind ein wenig kniffliger. Als ich meine Klassen damals geschrieben habe, habe ich einfach Konstruktoren mit 1 bis 4 Parameter in "Vector_t" gepackt. Das funktioniert und liefert eine Warnung wenn man zuviele Parameter übergibt. Es sollte allerdings inzwischen mit C++11 möglich sein, dass noch besser zu lösen. Am Besten mit Konstruktorvererbung. Du definierst deine speziellen Konstruktoren mit einer unterschiedlichen Anzahl Parameter in den den verschiedenen Ausprägungen der Basisklasse, die bei dir "VectorCondition" heißt. In "Vector_t" kannst du diese spezialisierten Konstruktoren dann mit "using VectorCondition<T, N>::VectorCondition;" erben, wenn du das am Anfang der Klassendefinition von "vector_t" packst.

EDIT:
Auch in dem Thread von Kristhy wird das Problem mit den Konstruktoren beschrieben. Das ist allerdings inzwischen in C++ sehr schön lösbar.

[Andi]

Danke für die Antworten, den Threat lese ich mir gleich durch. Hab heute Mittag noch sowas versucht.

Code: Alles auswählen

template<typename T, size_t N>
class vector_t : VectorCondition<T, N>
{
  using VectorCondition<T, N>
......
}

Müsste so was in der Art das "Problem" nicht lösen, also Theoretisch? Praktisch, stellt sich VS 2013 quer.

Edit:
Danke für den Link. Lustig das wir fast den gleichen Ansatz hatten, Krishty :)
Wohl oder Übel muss ich alles in die Vector_t klasse packen, schön finde ich das nicht, aber da muss ich jetzt durch :(

[Spiele Programmierer]

Wenn du Constructor Inheritance nutzen willst, das gibt es noch nicht in der offiziellen Version von Visual Studio
Allerdings wird es in der November CTP der 2013er Version unterstützt und wahrscheinlich auch in VS 2015, was in nicht all zu langer Zeit erscheinen sollte. Bis dahin würde ich einfach alle Konstruktoren in "vector_t" definieren. Wenn man einen Falschen verwendet gibt es immerhin eine Warnung und man kann es mit "static_assert" sogar narrensicher machen.

[Alexander Kornrumpf]

Hier ist ein sieben Jahre alter Thread, wo ich die selbe Scheiße gebaut habe. Schrompf und Helmut wollten mir die Flausen damals ausreden, aber ich hab’ nicht drauf gehört und vier Wochen meines Lebens verschwendet. Jetzt steh ich hier und sag’ das Gleiche.

Also: Spezialisier das Template von Hand; verzichte auf Vererbung; geh stattdessen vier Wochen saufen und ficken.

Aber das Gefühl binnen sieben Jahren was gelernt zu haben ist geil, oder?

[Krishty]

Klar; nur Sprache wurde erfunden, damit der Nachwuchs nicht jedes Mal aufs Neue vom Säbelzahntiger gefressen werden muss.

Wäre doch schade wenn wir – statt einfach auf die richtigen Leute zu hören – irgendwann an einem Punkt ankämen, an dem man 15 Jahre lang Fehlentscheidungen durchmachen muss um zu lernen, wie man richtig Software mit C++ entwickelt, und wenn man es dann endlich raus hat, entwickelt die ganze Welt nur noch durch Zusammenstecken von Wrappern jahrzehntealter Bibliotheken in C# und JavaScript.

Oh.

[Andi]

Klar; nur Sprache wurde erfunden, damit der Nachwuchs nicht jedes Mal aufs Neue vom Säbelzahntiger gefressen werden muss.

Wäre doch schade wenn wir – statt einfach auf die richtigen Leute zu hören – irgendwann an einem Punkt ankämen, an dem man 15 Jahre lang Fehlentscheidungen durchmachen muss um zu lernen, wie man richtig Software mit C++ entwickelt, und wenn man es dann endlich raus hat, entwickelt die ganze Welt nur noch durch Zusammenstecken von Wrappern jahrzehntealter Bibliotheken in C# und JavaScript.

Oh.

Sehe ich genauso und darum danke für den Schubs in die richtige Richtung, in 5min war alles erledigt :D Leider ist das mit dem jahrzehntealten Bibliotheken irgend wie Standard, hab zumindest teilweise das Gefühl. Mit JavaScript wird einfach jquery und co benutzt für simple Aktionen wie einen fadein/out, selber machen mag kaum noch wer.

Nun hab ich leider ein letztes Problemchen mit dem Union in der Matrix klasse, denn es klappt so wie folgt nicht. Kann mir bitte einer erklären an was das liegt?

Code: Alles auswählen

template<typename T, size_t I, size_t J>
class MatrixAccessors
{
  Vector_t<T, J> m_Data[I];
};

template<typename T>
class MatrixAccesors<T, 3, 3>
{
  Union
  {
    Vector_t<T, 3> m_Data[3];

    struct
    {
      Vector_t<T, 3> a, b, c;
    };
  };
};

template<typename T, size_t I, size_t J>
class Matrix_t : MatrixAccessors<T, I, J>
{
..
};

Edit:

Der obige Code hatte ich aus dem Kopf getippt, hab meinen Laptop seit 3 Tage verlegt, kann also nicht copy&pasten, habs jedenfalls nochmals überprüft und müsste soweit stimmen. Beim kompilieren krieg ich keine Fehler oder Warnungen.

Ich definiere:

Code: Alles auswählen

Matrix_t<float, 3, 3> m;

Der Defaultkonstruktor erstellt eine Einheits-Matrix, kann ich per m.GetValue(0,0), m.GetValue(1,1),... überprüfen. Soweit alles Korrekt. Jedoch stehen sämtlich Werte auf -107374176, also m.a.x, m.a.y, m.a.z, m.b.x,.....

[Schrompf]

Was ist der Compiler und was die Fehlermeldung?

[Andi]

Der Fehler beläuft sich darauf, dass ich immer nur die kleinste mögliche zahl als Wert zurück bekomme für x, y (z, w), hab ich vergessen mit zu schreiben. Compiler bin vc++ 2013.

[Spiele Programmierer]

Welchen Code führst du den aus?
Mehr Informationen bitte.

Nebenbei: Vector_t<T, J> kommt mir komisch vor. Das sollte eigentlich T stehen.

[Andi]

Siehe Edit in meinem Vorherigen Post mit dem Beispielscode

[Schrompf]

Das ist jetzt nicht sonderlich hilfreich, den Zusammenhang so zu zerstören. Aber wenn ich Dein aktualisiertes Problem richtig verstehe, hast Du einfach die Membervars der Matrix nicht initialisiert. Die -1045252 Zahl ist, wenn ich mich richtig erinnere, die float-Interpretation der VisualStudio-Runtime-Debug-Speicherfüllung 0xCCCCCCCC. Lösung: schreib einen Default Constructor. Oder besser: belasse Dir die Option, das Ding uninitialisiert zu verwenden, und schreibe stattdessen ein Rudel Konstruktoren mit Parametern. Es kann sich in der Tat lohnen, wenn Du mal ein großes Array davon anlegen willst.

[Andi]

Hab oben im Post mit dem Pseudocode mit "Edit" das Angehängt was von Anfang an hätte da sein sollen, und im Post darunter die Falschmeldung durchgestrichen. Verstehe darum nicht ganz, wo oder wie der Zusammenhang zerstört wurde.

Muss an meinem chronischen Schlafmangel liegen, das ich mich nicht verständlich genug ausgedrückt habe. Alles funktioniert bei der Matrix Klasse, die Arithmetik passt, per Set und Get Methoden kann ich die Werte beliebig ändern oder auslesen, nur das Union krieg ich nicht mit dem Array gebunden. Brauche das Union eigentlich nicht unbedingt, würde jedoch gerne verstehen warum es nicht klappt.
Beide Klassen, also Vector_t und Matrix_t haben einen default und einen copy Constructor. Bei der Matrix-Klasse settet der default Constructor die Werte auf Einheitsmatrix (im Moment auch noch für nicht Quadratische), bei der Vektor-Klasse auf 0 (oder W auf 1 falls 4D).

Hoffe man kann mein Problem mit dem Union nun nachvollziehen/interpretieren.