Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Templates und Operatoren

Werbeanzeige

Samuel G.

Treue Seele

  • »Samuel G.« ist der Autor dieses Themas

Beiträge: 110

Wohnort: Stuttgart

Beruf: Schüler

  • Private Nachricht senden

1

03.07.2005, 00:45

Templates und Operatoren

Hallo :) :) :)


Ich implementier grad meine Matrix- und Vektoren-Klassen. Meine Idee war, ne allgemeine Matrizenklasse zu haben (n-dimensional) und da dann die 4D-Matrix abzuleiten und die Vektoren abzuleiten. Ungefähr so:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

template <unsigned int uiCountM,unsigned int uiCountN> class sgCMatrix
{
    protected:
        float m_aaf[uiCountM][uiCountN];
    public:
        inline sgCMatrix(void);
        inline sgCMatrix(const float** aaf);
        inline sgCMatrix(const sgCMatrix<uiCountM,uiCountN>& Matrix);
        inline ~sgCMatrix(void);

        inline float GetF(const unsigned int uiM,const unsigned int uiN) const;
        inline float** GetAAF(void) const;
        inline sgCMatrix<uiCountM,uiCountN> operator -(void) const;

        inline void SetF(const unsigned int uiM,const unsigned int uiN,const float f);

        inline sgCMatrix<uiCountM,uiCountN> operator+(const sgCMatrix<uiCountM,uiCountN>& Matrix) const;
        inline sgCMatrix<uiCountM,uiCountN> operator-(const sgCMatrix<uiCountM,uiCountN>& Matrix) const;
        inline sgCMatrix<uiCountM,uiCountN> operator*(const float f) const;
        inline sgCMatrix<uiCountM,uiCountN> operator/(const float f) const;

        inline sgCMatrix<uiCountM,uiCountN>& operator=(const sgCMatrix<uiCountM,uiCountN>& Matrix);
        inline sgCMatrix<uiCountM,uiCountN>& operator+=(const sgCMatrix<uiCountM,uiCountN>& Matrix);
        inline sgCMatrix<uiCountM,uiCountN>& operator-=(const sgCMatrix<uiCountM,uiCountN>& Matrix);
        inline sgCMatrix<uiCountM,uiCountN>& operator*=(const float f);
        inline sgCMatrix<uiCountM,uiCountN>& operator/=(const float f);

        inline int operator==(const sgCMatrix<uiCountM,uiCountN>& Matrix) const;
        inline int operator!=(const sgCMatrix<uiCountM,uiCountN>& Matrix) const;
};
// hier fehlt noch der operator*, kommt später


Dann leite ich mir ne Quadratische Matrix ab:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

template <unsigned int uiCountM>
class sgCMatrixSquare: public sgCMatrix<uiCountM,uiCountM>
{
    
    inline friend sgCMatrixSquare<uiCountM> sgGetMatrixInvert(const sgCMatrixSquare<uiCountM>& Matrix);
    inline friend sgCMatrixSquare<uiCountM> sgGetMatrixTransposed(const sgCMatrixSquare<uiCountM>& Matrix);
    public:
        inline sgCMatrixSquare(void);
        inline sgCMatrixSquare(const float** aaf);
        inline sgCMatrixSquare(const sgCMatrixSquare<uiCountM>& Matrix);
        inline ~sgCMatrixSquare(void);

        inline sgCMatrixSquare<uiCountM-1> GetFSubDeterminant(const unsigned int uiIndexM,const unsigned int uiIndexN) const;
        inline float GetFDeterminant(void) const;

        inline sgCMatrixSquare<uiCountM> operator/(const sgCMatrixSquare<uiCountM>& Matrix) const;
        inline sgCMatrixSquare<uiCountM> operator/=(const sgCMatrixSquare<uiCountM>&Matrix);
};


Und dann 4Dimensionale Matrix und Vektor. Der Fehler tritt in der Vektor-Klasse auf, also hier dessen Code:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class sgCVector3D: public sgCMatrix<1,3>
{
    inline friend sgCVector3D sgMultiplyCross(const sgCVector3D& Vector1,const sgCVector3D& Vector2); 
    inline friend float sgMultiplyPoint(const sgCVector3D& Vector1,const sgCVector3D& Vector2);
    inline friend sgCVector3D sgNormalize(const sgCVector3D& Vector);
    
    protected:

    public:
        inline sgCVector3D(const float fX=0,const float fY=0,const float fZ=0);
        inline sgCVector3D(const float af[]);
        inline sgCVector3D(const D3DVECTOR& D3DVector);
        inline sgCVector3D(const sgCVector3D& Vector);
        inline virtual~sgCVector3D(void);

        inline float GetFX(void) const;
        inline float GetFY(void) const;
        inline float GetFZ(void) const;
        inline float* GetAF(void);
        inline operator D3DVECTOR() const;
        inline sgCVector3D operator -(void) const;

        inline void SetFX(const float fX);
        inline void SetFY(const float fY);
        inline void SetFZ(const float fZ);
        inline void SetF(const float f,const unsigned int uiIndex);

        inline sgCVector3D operator*(const sgCVector3D& Vector) const;
        inline sgCVector3D operator/(const sgCVector3D& Vector) const;

        inline sgCVector3D& operator*=(const sgCVector3D& Vector);
        inline sgCVector3D& operator/=(const sgCVector3D& Vector);
};


Das Problem: Die Vektoren-Klasse und die Matrix4D scheinen die operatoren von sgCMatrix nicht zu erben. Wenn ich zum Beispiel im Code stehen habe:

C-/C++-Quelltext

 
1

sgCVector3D PrivateVectorZAxis(sgNormalize(VectorDirection-VectorTranslation));

krieg ich den Fehler:
e:\samuel\programmierung\c++\visualc++\directx\direct3d\projectmatrixvector\include\\unitsgmatrixsquare4d.h(219) : error C2676: binary '-' : 'const class sgCVector3D' does not define this operator or a conversion to a type acceptable to the predefin
ed operator

Warum? Kann da denn nich der operator- aus sgCMatrix verwendet werden?


Samuel G.
Quak

Samuel G.

Treue Seele

  • »Samuel G.« ist der Autor dieses Themas

Beiträge: 110

Wohnort: Stuttgart

Beruf: Schüler

  • Private Nachricht senden

2

03.07.2005, 18:45

Beitrag

Ich glaub ich weiß, inzwischen, woran es liegt: wenn man in einer Klasse den operator der Vaterklasse überschreibt, so muss man alle aus diesem Operator zusammengesetzen Operatoren überschreiben. Wenn ich zum Beispiel sage:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class CFather
{
  public:
    CFather& operator*(const CFather& Father) const;
    CFather& operator*=(const CFather& Father);
    //noch massig andere operatoren...

}

class CBsp: public CFather
{
  public:
    CBsp& operator*(const CBsp& Bsp) const;
    //dann muss ich auch sagen:

    CBsp& operator*=(const CBsp& Bsp);
};


Das Überladen des operator*= ist wichtig! Wenn man operator* überschreibt, dann erbt man nicht mehr operator*= ! Man muss ihn auch definieren! (Das gilt auch für den Operator mit anderen Parametern)


Samuel G.
Quak