Contenu | Rechercher | Menus

Annonce

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

#1 Le 15/03/2011, à 23:16

Maneithel

[RÉSOLU] 'Class' does not name a type, définition circulaire, C++

Bonjour !
Je prépare le terrain pour un logiciel de 3D et j'implémente certaines fonctions mathématiques.  Je travaille en C++ avec Qt dans QtCreator.
Je commence par me faire une Bibliothèque Partagée nommée Math.
J'y défini plusieurs classes : Angle, Radian, Degree, Vector3d, Vector4d, Matrix4d et une classe sans objet (contenant que des fonctions statiques) Math.  Par contre, on dirait que le compilateur n'arrive jamais à compiler completement une certaine classe et me donne certaines erreurs comme "error: 'Angle' does not name a type".  Par contre, même si ce n'est pas très rigoureux, si je survole Angle avec la souris, il le reconnais comme tel.
Si je prédéfinis les classes en haut de fichier, il m'offre plutôt des messages du genre "error: variable 'const Radian PIrad' has initializer but incomplete type", mais bien sûr seulement où il y a instanciation explicite de la dite classe.  Je cherche depuis plusieurs heures et je profiterais bien d'un coup de pouce !
Merci beaucoup d'avance !

Il y a beaucoup de code (en fait, j'ai à peu pres tout mis...), mais je ne pense pas que le probleme nécessite une grande analyse de tout : c'est sûrement un truc avec les Bibliotheques partagées que je n'ai pas compris...  Aussi, j'ai noté dans le code les lieux d'erreur.

Voici mon code, dans l'ordre :
Messages d'erreur
Fichier pro
Math_global.h (utilisé pour inclure la lib ensuite)
libmath.h
libmath.cpp
angle.h
angle.cpp
vector3d.h
vector3d.cpp
vector4d.h
vector4d.cpp
matrix4d.h
matrix4d.cpp
constantes.h

Sortie de console

Exécution des étapes de compilation pour le projet Math...
Configuration inchangée, étape QMake sautée.
Commence : "/usr/bin/make" -w
make: entrant dans le répertoire « /home/charles/Geek/dev/C++ workspace/infographie H2011/TP2INFOGRAPHIE_PROJECTS/Math-build-desktop »
g++ -c -m64 -pipe -g -Wall -W -D_REENTRANT -fPIC -DMATH_LIBRARY -DQT_GUI_LIB -DQT_SHARED -I../../../../Qt-SDK/qt/mkspecs/linux-g++-64 -I../Math -I../../../../Qt-SDK/qt/include/QtGui -I../../../../Qt-SDK/qt/include -I. -I../Math -I. -o libmath.o ../Math/libmath.cpp
In file included from ../Math/libmath.h:5,
                 from ../Math/libmath.cpp:1:
../Math/constantes.h:18: warning: 'visibility' attribute ignored
../Math/constantes.h:19: warning: 'visibility' attribute ignored
../Math/constantes.h:20: warning: 'visibility' attribute ignored
../Math/constantes.h:21: warning: 'visibility' attribute ignored
../Math/constantes.h:23: warning: 'visibility' attribute ignored
../Math/constantes.h:24: warning: 'visibility' attribute ignored
../Math/constantes.h:25: warning: 'visibility' attribute ignored
../Math/constantes.h:26: warning: 'visibility' attribute ignored
../Math/constantes.h:28: warning: 'visibility' attribute ignored
../Math/constantes.h:29: warning: 'visibility' attribute ignored
../Math/constantes.h:30: warning: 'visibility' attribute ignored
../Math/constantes.h:31: warning: 'visibility' attribute ignored
../Math/constantes.h:33: warning: 'visibility' attribute ignored
../Math/constantes.h:34: warning: 'visibility' attribute ignored
../Math/constantes.h:36: warning: 'visibility' attribute ignored
../Math/constantes.h:37: warning: 'visibility' attribute ignored
../Math/constantes.h:39: warning: 'visibility' attribute ignored
../Math/constantes.h:41: warning: 'visibility' attribute ignored
../Math/constantes.h:42: warning: 'visibility' attribute ignored
../Math/constantes.h:43: warning: 'visibility' attribute ignored
../Math/constantes.h:44: warning: 'visibility' attribute ignored
../Math/constantes.h:46: warning: 'visibility' attribute ignored
../Math/constantes.h:47: warning: 'visibility' attribute ignored
../Math/constantes.h:48: warning: 'visibility' attribute ignored
../Math/constantes.h:49: warning: 'visibility' attribute ignored
../Math/constantes.h:50: warning: 'visibility' attribute ignored
../Math/constantes.h:52: warning: 'visibility' attribute ignored
g++ -c -m64 -pipe -g -Wall -W -D_REENTRANT -fPIC -DMATH_LIBRARY -DQT_GUI_LIB -DQT_SHARED -I../../../../Qt-SDK/qt/mkspecs/linux-g++-64 -I../Math -I../../../../Qt-SDK/qt/include/QtGui -I../../../../Qt-SDK/qt/include -I. -I../Math -I. -o vector3d.o ../Math/vector3d.cpp
In file included from ../Math/constantes.h:7,
                 from ../Math/libmath.h:5,
                 from ../Math/angle.h:4,
                 from ../Math/vector3d.h:7,
                 from ../Math/vector3d.cpp:1:
../Math/vector4d.h:174: error: 'Angle' does not name a type
../Math/vector4d.h:182: error: 'Angle' does not name a type
../Math/vector4d.h:190: error: 'Angle' does not name a type
../Math/vector4d.h:198: error: 'Angle' does not name a type
../Math/vector4d.h:220: error: ISO C++ forbids declaration of 'Vector3d' with no type
../Math/vector4d.h:220: error: expected ';' before '&' token
../Math/vector4d.h:240: error: ISO C++ forbids declaration of 'Vector3d' with no type
../Math/vector4d.h:240: error: expected ',' or '...' before '&' token
In file included from ../Math/constantes.h:8,
                 from ../Math/libmath.h:5,
                 from ../Math/angle.h:4,
                 from ../Math/vector3d.h:7,
                 from ../Math/vector3d.cpp:1:
../Math/matrix4d.h:55: error: ISO C++ forbids declaration of 'Vector3d' with no type
../Math/matrix4d.h:55: error: expected ',' or '...' before '&' token
../Math/matrix4d.h:69: error: ISO C++ forbids declaration of 'Vector3d' with no type
../Math/matrix4d.h:69: error: expected ';' before '&' token
In file included from ../Math/libmath.h:5,
                 from ../Math/angle.h:4,
                 from ../Math/vector3d.h:7,
                 from ../Math/vector3d.cpp:1:
../Math/constantes.h:18: warning: 'visibility' attribute ignored
../Math/constantes.h:19: warning: 'visibility' attribute ignored
../Math/constantes.h:20: warning: 'visibility' attribute ignored
../Math/constantes.h:21: warning: 'visibility' attribute ignored
../Math/constantes.h:23: warning: 'visibility' attribute ignored
../Math/constantes.h:23: error: variable 'const Radian PIrad' has initializer but incomplete type
../Math/constantes.h:24: warning: 'visibility' attribute ignored
../Math/constantes.h:24: error: variable 'const Radian PI2rad' has initializer but incomplete type
../Math/constantes.h:25: warning: 'visibility' attribute ignored
../Math/constantes.h:25: error: variable 'const Radian PI3_2rad' has initializer but incomplete type
../Math/constantes.h:26: warning: 'visibility' attribute ignored
../Math/constantes.h:26: error: variable 'const Radian PI1_2rad' has initializer but incomplete type
../Math/constantes.h:28: warning: 'visibility' attribute ignored
../Math/constantes.h:28: error: variable 'const Degree PIdeg' has initializer but incomplete type
../Math/constantes.h:29: warning: 'visibility' attribute ignored
../Math/constantes.h:29: error: variable 'const Degree PI2deg' has initializer but incomplete type
../Math/constantes.h:30: warning: 'visibility' attribute ignored
../Math/constantes.h:30: error: variable 'const Degree PI3_2deg' has initializer but incomplete type
../Math/constantes.h:31: warning: 'visibility' attribute ignored
../Math/constantes.h:31: error: variable 'const Degree PI1_2deg' has initializer but incomplete type
../Math/constantes.h:33: warning: 'visibility' attribute ignored
../Math/constantes.h:34: warning: 'visibility' attribute ignored
../Math/constantes.h:36: warning: 'visibility' attribute ignored
../Math/constantes.h:37: warning: 'visibility' attribute ignored
../Math/constantes.h:39: warning: 'visibility' attribute ignored
../Math/constantes.h:41: warning: 'visibility' attribute ignored
../Math/constantes.h:41: error: variable 'const Vector3d ONES' has initializer but incomplete type
../Math/constantes.h:42: warning: 'visibility' attribute ignored
../Math/constantes.h:42: error: variable 'const Vector3d AXEX' has initializer but incomplete type
../Math/constantes.h:43: warning: 'visibility' attribute ignored
../Math/constantes.h:43: error: variable 'const Vector3d AXEY' has initializer but incomplete type
../Math/constantes.h:44: warning: 'visibility' attribute ignored
../Math/constantes.h:44: error: variable 'const Vector3d AXEZ' has initializer but incomplete type
../Math/constantes.h:46: warning: 'visibility' attribute ignored
../Math/constantes.h:47: warning: 'visibility' attribute ignored
../Math/constantes.h:48: warning: 'visibility' attribute ignored
../Math/constantes.h:49: warning: 'visibility' attribute ignored
../Math/constantes.h:50: warning: 'visibility' attribute ignored
../Math/constantes.h:52: warning: 'visibility' attribute ignored
../Math/vector3d.cpp: In member function 'Angle Vector3d::angleBetweenXAxis() const':
../Math/vector3d.cpp:82: warning: no return statement in function returning non-void
../Math/vector3d.cpp: In member function 'Angle Vector3d::angleBetweenYAxis() const':
../Math/vector3d.cpp:86: warning: no return statement in function returning non-void
../Math/vector3d.cpp: In member function 'Angle Vector3d::angleBetweenZAxis() const':
../Math/vector3d.cpp:90: warning: no return statement in function returning non-void
../Math/vector3d.cpp: In member function 'float* Vector3d::data() const':
../Math/vector3d.cpp:98: warning: address of local variable 'array' returned
../Math/vector3d.cpp: In member function 'Vector3d& Vector3d::projectionSurLigne(const QVector3D&)':
../Math/vector3d.cpp:104: warning: no return statement in function returning non-void
../Math/vector3d.cpp: At global scope:
../Math/vector3d.cpp:101: warning: unused parameter 'v'
../Math/vector3d.cpp: In member function 'Vector3d& Vector3d::projectionSurPlan(QVector3D, QVector3D)':
../Math/vector3d.cpp:108: warning: no return statement in function returning non-void
../Math/vector3d.cpp: At global scope:
../Math/vector3d.cpp:105: warning: unused parameter 'p1'
../Math/vector3d.cpp:105: warning: unused parameter 'p2'
../Math/libmath.h:23: warning: inline function 'static float Math::Random()' used but never defined
../Math/constantes.h:23: warning: 'PIrad' defined but not used
../Math/constantes.h:24: warning: 'PI2rad' defined but not used
../Math/constantes.h:25: warning: 'PI3_2rad' defined but not used
../Math/constantes.h:26: warning: 'PI1_2rad' defined but not used
../Math/constantes.h:28: warning: 'PIdeg' defined but not used
../Math/constantes.h:29: warning: 'PI2deg' defined but not used
../Math/constantes.h:30: warning: 'PI3_2deg' defined but not used
../Math/constantes.h:31: warning: 'PI1_2deg' defined but not used
../Math/constantes.h:41: warning: 'ONES' defined but not used
../Math/constantes.h:42: warning: 'AXEX' defined but not used
../Math/constantes.h:43: warning: 'AXEY' defined but not used
../Math/constantes.h:44: warning: 'AXEZ' defined but not used
make: quittant le répertoire « /home/charles/Geek/dev/C++ workspace/infographie H2011/TP2INFOGRAPHIE_PROJECTS/Math-build-desktop »
make: *** [vector3d.o] Erreur 1
Le processus "/usr/bin/make" s'est terminé avec le code %2.
Erreur à la compilation du projet Math (cible : Bureau)
Lors de l'exécution de l'étape 'Make'

Fichier Math.pro

QT       -= core

TARGET = Math
TEMPLATE = lib

# ajout à la main
DESTDIR = ../GUI/

DEFINES += MATH_LIBRARY

SOURCES += libmath.cpp \
    vector3d.cpp \
    vector4d.cpp \
    angle.cpp \
    matrix4d.cpp

HEADERS += libmath.h\
        Math_global.h \
    vector3d.h \
    vector4d.h  \
    angle.h \
    constantes.h \
    matrix4d.h

Fichier Math_global.h (entête utilisée pour inclure la librairie)

#ifndef MATH_GLOBAL_H
#define MATH_GLOBAL_H

#include <QtCore/qglobal.h>

#if defined(MATH_LIBRARY)
#  define MATHSHARED_EXPORT Q_DECL_EXPORT
#else
#  define MATHSHARED_EXPORT Q_DECL_IMPORT
#endif

#endif // MATH_GLOBAL_H

Fichier libmath.h (nommé ainsi pour éviter des problèmes de namespace avec math.h standard)

#ifndef MATH_H
#define MATH_H

#include "Math_global.h"
#include "constantes.h"
#include "angle.h"
#include "vector3d.h"

class Matrix4d;
class Vector3d;
class Radian;
class Degree;
class Angle;

class MATHSHARED_EXPORT Math {
public:
    Math();

    inline static Radian DegreeToRadian(const Degree &d);
    inline static Degree RadianToDegree(const Radian &r);

    inline static int   Randomize();
    inline static float Random();
    inline static int RandomIntegerBetween( int min, int max );
    inline static float Round(float value, int precision);
    static void Unproject(Vector3d& Origin,
                          Vector3d& Direction,
                          const Vector3d& Position2D,
                          const Matrix4d& ViewInverse,
                          const Matrix4d& Projection,
                          int ScreenWidth,
                          int ScreenHeight);

    template <typename T>
            static T Clamp(T val, T min, T max)
    {
        return std::max(std::min(val, max), min);
    }
};

#endif // MATH_H

Fichier libmath.cpp

#include "libmath.h"

Math::Math()
{
}

Fichier angle.h

#ifndef ANGLE_H
#define ANGLE_H

#include "libmath.h"
#include "Math_global.h"

class Degree;
class Angle;

class MATHSHARED_EXPORT Radian
{
public:
                            Radian      (const Degree& a);
                            Radian      (const float a);
                          Radian      (const Radian& r);

    inline Radian&          operator=   (const float& f);
    inline Radian&          operator=   (const Radian& r);
    inline Radian&          operator=   (const Degree& d);

    inline float            valueDegrees() const;
    inline float            valueRadians() const;

    inline static Degree RadianToDegree (const Radian RadAngle);

    inline const Radian&    operator +  () const;
    inline Radian           operator +  (const Radian& r ) const;
    inline Radian           operator +  (const Degree& d ) const;
    inline Radian&          operator += (const Radian& r );
    inline Radian&          operator += (const Degree& d );
    inline Radian           operator -  () const;
    inline Radian           operator -  (const Radian& r ) const;
    inline Radian           operator -  (const Degree& d ) const;
    inline Radian&          operator -= ( const Radian& r );
    inline Radian&          operator -= ( const Degree& d );
    inline Radian           operator *  (const float f ) const;
    inline Radian           operator *  (const Radian& f ) const;
    inline Radian&          operator *= (const float f );
    inline Radian           operator /  (const float f ) const;
    inline Radian&          operator /= (const float f );

    inline bool             operator <  ( const Radian& r ) const;
    inline bool             operator <= ( const Radian& r ) const;
    inline bool             operator == ( const Radian& r ) const;
    inline bool             operator != ( const Radian& r ) const;
    inline bool             operator >= ( const Radian& r ) const;
    inline bool             operator >  ( const Radian& r ) const;

private:
            float           m_rad;

};

class MATHSHARED_EXPORT Degree
{
public:
                            Degree (const  float d=0);
                            Degree ( const Radian& r );
                            Degree ( const Degree& d );
    inline Degree&          operator = ( const float& f );
    inline Degree&          operator = ( const Degree& d );
    inline Degree&          operator = ( const Radian& r );

    inline float            valueDegrees() const;
    inline float            valueRadians() const;

    inline static Radian    DegreeToRadian(const Degree DegAngle);

    inline const Degree&    operator + () const;
    inline Degree           operator + ( const Degree& d ) const;
    inline Degree           operator + ( const Radian& r ) const;
    inline Degree&          operator += ( const Degree& d );
    inline Degree&          operator += ( const Radian& r );
    inline Degree           operator - () const;
    inline Degree           operator - ( const Degree& d ) const;
    inline Degree           operator - ( const Radian& r ) const;
    inline Degree&          operator -= ( const Degree& d );
    inline Degree&          operator -= ( const Radian& r );
    inline Degree           operator * ( float f ) const;
    inline Degree           operator * ( const Degree& f ) const;
    inline Degree&          operator *= ( float f );
    inline Degree           operator / ( float f ) const;
    inline Degree&          operator /= ( float f );

    inline bool             operator <  ( const Degree& d ) const;
    inline bool             operator <= ( const Degree& d ) const;
    inline bool             operator == ( const Degree& d ) const;
    inline bool             operator != ( const Degree& d ) const;
    inline bool             operator >= ( const Degree& d ) const;
    inline bool             operator >  ( const Degree& d ) const;

private:
            float            m_deg;
};

class MATHSHARED_EXPORT Angle
{
public:
                            Angle(const float angle);
                            Angle(const Angle &a);
                            Angle(const Radian &r);
    inline                  Angle(const Degree &d);
    inline float            angle()const {return m_angle;}
    inline Radian           radian() const;
    inline Degree           degree() const;

    enum                    UniteAngle {DEGREE, RADIAN};

    inline UniteAngle       uniteAngle()const {return m_uniteAngle;}
    inline void             setUniteAngle(const UniteAngle u){m_uniteAngle = u;}

    inline void             set(const Degree &d);
    inline void             set(const Radian &r);
    inline void             set(const Angle &a);
    inline void             set(const float f);

    inline Radian           AngleToRadian()const;
    inline Degree           AngleToDegree()const;

private:
    static UniteAngle       m_uniteAngle;

            float           m_angle;
};

#endif // ANGLE_H

Fichier angle.cpp

#include "angle.h"

// RADIAN **********************************************************************
Radian::Radian(const Degree& d) : m_rad(d.valueRadians())
{
}
Radian::Radian(const float a) : m_rad(a)
{
}
Radian::Radian(const Radian& r) : m_rad(r.valueRadians())
{
}

inline Radian& Radian::operator= (const float& f)
{
    m_rad = f; return *this;
}
inline Radian& Radian::operator= (const Radian& r)
{
    m_rad = r.valueRadians(); return *this;
}
inline Radian& Radian::operator= ( const Degree& d )
{
    m_rad = d.valueRadians(); return *this;
}

inline float Radian::valueDegrees() const
{
    return RadianToDegree(m_rad).valueDegrees();
}
inline float Radian::valueRadians() const { return m_rad; }

inline Degree Radian::RadianToDegree(const Radian RadAngle)
{
    return (Degree(RadAngle * RAD2DEG));
}


inline const Radian& Radian::operator + () const
{
  return *this;
}
inline Radian Radian::operator + ( const Radian& r ) const
{
  return Radian ( m_rad + r.m_rad );
}
inline Radian Radian::operator + ( const Degree& d ) const
{
    return Radian ( m_rad + d.valueRadians());
}
inline Radian& Radian::operator += ( const Radian& r )
{
  m_rad += r.m_rad;
  return *this;
}
inline Radian& Radian::operator += ( const Degree& d )
{
    m_rad += d.valueRadians();
    return *this;
}
inline Radian Radian::operator - () const
{
  return Radian(-m_rad);
}
inline Radian Radian::operator - ( const Radian& r ) const
{
  return Radian ( m_rad - r.m_rad );
}
inline Radian Radian::operator - ( const Degree& d ) const
{
    return Radian ( m_rad - d.valueRadians() );
}
inline Radian& Radian::operator -= ( const Radian& r )
{
  m_rad -= r.m_rad; return *this;
}
inline Radian& Radian::operator -= ( const Degree& d )
{
    m_rad -= d.valueRadians();
    return *this;
}

inline Radian Radian::operator * ( const float f ) const
{
  return Radian(m_rad * f);
}
inline Radian Radian::operator * ( const Radian& f ) const
{
  return Radian ( m_rad * f.m_rad );
}
inline Radian& Radian::operator *= (const float f )
{
    m_rad *= f; return *this;
}
inline Radian Radian::operator / ( float f ) const
{
  return Radian ( m_rad / f );
}
inline Radian& Radian::operator /= ( float f )
{
  m_rad /= f; return *this;
}

inline bool Radian::operator <  ( const Radian& r ) const
{
  return m_rad <  r.m_rad;
}
inline bool Radian::operator <= ( const Radian& r ) const
{
  return m_rad <= r.m_rad;
}
inline bool Radian::operator == ( const Radian& r ) const
{
  return m_rad == r.m_rad;
}
inline bool Radian::operator != ( const Radian& r ) const
{
  return m_rad != r.m_rad;
}
inline bool Radian::operator >= ( const Radian& r ) const
{
  return m_rad >= r.m_rad;
}
inline bool Radian::operator >  ( const Radian& r ) const
{
  return m_rad >  r.m_rad;
}
// FIN RADIAN ******************************************************************

// DEGREE **********************************************************************
Degree::Degree ( float d) : m_deg(d) {}
Degree::Degree ( const Radian& r ) : m_deg(r.valueDegrees()) {}
Degree::Degree (const Degree& d): m_deg(d.valueDegrees()){}

inline Degree& Degree::operator = ( const float& f )
{
  m_deg = f;
  return *this;
}
inline Degree& Degree::operator = ( const Degree& d )
{
  m_deg = d.m_deg;
  return *this;
}
inline Degree& Degree::operator = ( const Radian& r )
{
  m_deg = r.valueDegrees();
  return *this;
}

inline float Degree::valueDegrees() const { return m_deg; }
inline float Degree::valueRadians() const
{
    return DegreeToRadian(m_deg).valueRadians();
}

inline Radian Degree::DegreeToRadian(const Degree DegAngle)
{
    return(Radian(DegAngle * DEG2RAD));
}

inline const Degree& Degree::operator + () const { return *this; }
inline Degree Degree::operator + ( const Degree& d ) const
{
  return Degree ( m_deg + d.m_deg );
}
inline Degree Degree::operator + ( const Radian& r ) const
{
  return Degree ( m_deg + r.valueDegrees() );
}
inline Degree& Degree::operator += ( const Degree& d )
{
  m_deg += d.m_deg;
  return *this;
}
inline Degree& Degree::operator += ( const Radian& r )
{
  m_deg += r.valueDegrees();
  return *this;
}
inline Degree Degree::operator - () const { return Degree(-m_deg); }
inline Degree Degree::operator - ( const Degree& d ) const
{
  return Degree ( m_deg - d.m_deg );
}
inline Degree Degree::operator - ( const Radian& r ) const
{
  return Degree ( m_deg - r.valueDegrees() );
}
inline Degree& Degree::operator -= ( const Degree& d )
{
  m_deg -= d.m_deg;
  return *this;
}
inline Degree& Degree::operator -= ( const Radian& r )
{
  m_deg -= r.valueDegrees();
  return *this;
}
inline Degree Degree::operator * ( float f ) const
{
  return Degree ( m_deg * f );
}
inline Degree Degree::operator * ( const Degree& f ) const
{
  return Degree ( m_deg * f.m_deg );
}
inline Degree& Degree::operator *= ( float f ) { m_deg *= f; return *this; }
inline Degree Degree::operator / ( float f ) const
{
  return Degree ( m_deg / f );
}
inline Degree& Degree::operator /= ( float f ) { m_deg /= f; return *this; }

inline bool Degree::operator <  ( const Degree& d ) const
{
  return m_deg <  d.m_deg;
}
inline bool Degree::operator <= ( const Degree& d ) const
{
  return m_deg <= d.m_deg;
}
inline bool Degree::operator == ( const Degree& d ) const
{
  return m_deg == d.m_deg;
}
inline bool Degree::operator != ( const Degree& d ) const
{
  return m_deg != d.m_deg;
}
inline bool Degree::operator >= ( const Degree& d ) const
{
  return m_deg >= d.m_deg;
}
inline bool Degree::operator >  ( const Degree& d ) const
{
  return m_deg >  d.m_deg;
}
// FIN DEGREE ******************************************************************

// ANGLE **********************************************************************
Angle::Angle(const float angle):m_angle(angle){}
Angle::Angle(const Angle &a):m_angle(a.angle()){}
Angle::Angle(const Radian &r)
{
    if (uniteAngle() == DEGREE)
        m_angle = r.valueDegrees();
    else if (uniteAngle() == RADIAN)
        m_angle = r.valueRadians();
    else
        return;
}
inline Angle::Angle(const Degree &d)
{
    if (uniteAngle() == DEGREE)
        m_angle = d.valueDegrees();
    else if (uniteAngle() == RADIAN)
        m_angle = d.valueRadians();
    else
        return;
}
inline Radian Angle::radian() const
{
    return AngleToRadian();
}
inline Degree Angle::degree() const
{
    return AngleToDegree();
}
inline Radian Angle::AngleToRadian() const
{
    if (uniteAngle() == RADIAN)
        return (Radian(angle()));
    if (uniteAngle() == DEGREE)
        return Math::DegreeToRadian(Degree(angle()));
    else return Radian(0);
}
inline Degree Angle::AngleToDegree() const
{
    if (uniteAngle() == DEGREE)
        return (Degree(angle()));
    if (uniteAngle() == RADIAN)
        return Math::RadianToDegree(Radian(angle()));
    else return Degree(0);
}

inline void Angle::set(const Degree &d)
{
    set(Angle(d));
}
inline void Angle::set(const Radian &r)
{
    set(Angle(r));
}
inline void Angle::set(const Angle &a)
{
    m_angle = a.angle();
}
inline void Angle::set(const float f)
{
    set(Angle(f));
}

// FIN ANGLE *******************************************************************

Fichier vector3d.h

#ifndef VECTOR3D_H
#define VECTOR3D_H

#include <QVector3D>
#include <math.h>
#include "Math_global.h"
#include "angle.h"
#include "libmath.h"

class Angle;

/*!
  \class Vector3d

  \brief Cette classe représente un vecteur dans un espace en
  troisième dimension

  Cette classe regroupe tous les opérateurs utiles, commmandes de diagnostiques,
  etc, liés à l'usage des vecteurs de R³ dans le cas général.  Pour les
  méthodes spécifiques à des vertices, voir la classe Vertex3d
 */
class MATHSHARED_EXPORT Vector3d : public QVector3D
{
public:
// CONSTRUCTEURS
/*!
  \fn Vector3d()

  \brief Constructeur par défaut

  Construit un vecteur nul à trois composantes.
 */
    Vector3d();
/*!
  \fn Vector3d(const float x, const float y, const float z)

  \brief Constructeur à partir de 3 nombres réels

  Construit un vecteur à partir des trois composantes fournies en paramètre.
 */
    Vector3d(const float x, const float y, const float z);
/*!
  \fn Vector3d(const Vector3d v)

  \brief Constructeur copie
 */
    Vector3d(const QVector3D& v);
/*!
  \fn Vector3d(const float array[3])

  \brief Constructeur par défaut

  Construit un vecteur nul à trois composantes.
 */
    Vector3d(const float array[3]);
/*!
  \fn Vector3d(const int array[3])

  \brief Constructeur par défaut

  Construit un vecteur nul à trois composantes.
 */
    Vector3d(const int array[3]);
/*!
  \fn Vector3d(const float scalaire)

  \brief Constructeur par défaut

  Construit un vecteur nul à trois composantes.
 */
    Vector3d(const float scalaire);
/*!
  \fn Vector3d(const QPoint & point)

  \brief Constructeur à partir d'un QPoint.

  Les composantes z est ignorée.
 */
    Vector3d ( const QPoint & point );
/*!
  \fn Vector3d(const QPointF & point)

  \brief Constructeur à partir d'un QPointF.

  La composante z est ignorée.
 */
    Vector3d ( const QPointF & point );
    /*!
  \fn Vector3d(const QVector2D & vector)

  \brief Constructeur à partir d'un QVector2D.

  La composante z est ignorée.
 */
    Vector3d ( const QVector2D & vector );
/*!
  \fn Vector3d(const QVector2D & vector, const float z)

  \brief Constructeur à partir d'un QVector2D et de deux scalaires.

  La composante z est désignée par ce scalaire.
 */
    Vector3d (const QVector2D & vector, const float z);

// MUTATEURS DIRECTS
/*!
  \fn void set(const float x, const float y, const float z)

  \brief Mutateur

  Ceci est une fonction surchargée.
 */
    void set(const float x, const float y, const float z);
/*!
  \fn void set(const float x, const float y, const float z)

  \brief Mutateur

  Cette fonction assigne à chacune composante du Vector3d courrant la valeur
  correspondante passée en paramètre.
 */
    void set(const QVector3D &v);
/*!
  \fn void reset()

  \brief Mutateur

  Cette fonction transforme le vecteur courrant en vecteur nul.
 */
    void reset();

// ACCESSEURS INDIRECTS
/*!
  \fn distanceToVec(const Vector3d &v) const

  \brief Accesseur de la distance entre deux vecteurs.

  Cette fonction retourne la norme du vecteur courrant.

  \remarks Cette fonction nécessite l'usage d'une racine carrée.  Dans les cas
  où la norme exacte n'est pas requise (pour comparer deux vecteurs, par
  exemple), utiliser distanceSquared() const plutôt.
 */
    float distanceToVec(const QVector3D &v) const;
/*!
  \fn distanceToVecSquared(const Vector3d &v) const

  \brief Accesseur de la distance entre deux vecteurs.

  Cette fonction retourne la distance au carre entre le vecteur courrant et le
  vecteur passé en paramètre.
 */
    float distanceToVecSquared(const QVector3D &v) const;
/*!
  \fn Angle angleBetween(const Vector3d & v)

  \brief Accesseur de l'angle entre deux vecteurs.

  Cette fonction retourne l'angle antre le vecteur courrant et le vecteur passé
  en paramêtre
 */
    Angle angleBetween(const QVector3D & v)const;
/*!
  Cette fonction retourne l'angle antre le vecteur courrant et l'axe X.
 */
    Angle angleBetweenXAxis()const;
/*!
  Cette fonction retourne l'angle antre le vecteur courrant et l'axe Y.
 */
    Angle angleBetweenYAxis()const;
/*!
  Cette fonction retourne l'angle antre le vecteur courrant et l'axe Z.
 */
    Angle angleBetweenZAxis()const;

// DIAGNOSTIC
/*!
  \fn bool isUnit()

  \brief Diagnostic

  Cette fonction retourne true si la norme du vecteur courrant est unitaire,
  false sinon.
 */
    bool isUnit()const;

/*!
  \fn float* toArray();

  \brief Fonction de compatibilité

  Cette fonction retourne un pointeur sur la première composante du vecteur
  courrant de manière à pouvoir traiter ce vecteur un comme un tableau standard.
 */
    float* data()const;

// OPÉRATEURS GÉOMÉTRIQUES
/*!
  \fn Vector3d projectionSurLigne(const Vector3d& v)

  \brief Opérateurs géométrique : projection sur un vecteur

  Cette fonction retourne le vecteur résultant de la projection du vecteur
  courrant sur le vecteur passé en paramêtre
 */
    Vector3d& projectionSurLigne(const QVector3D& v);
/*!
  Retourne le vecteur résultant de la projection du vecteur
  courrant sur le plan défini par les deux vecteurs passés en paramètre.
 */
    Vector3d& projectionSurPlan(const QVector3D p1, const QVector3D p2);

// OPÉRATEURS SURCHARGÉS
/*!
  \fn void operator=(const Vector3d & v)

  \brief Opérateur surchargé d'assignation

  Cette fonction assigne à chaque composantes du vecteur courrant la valeur de
  la composante correspondante du vecteur passé en paramètre.
 */
    void operator=(const Vector3d & v);

// AUTRES
/*!
  \fn Vector3d fuzz(const float amp)

  \brief
 */
    Vector3d fuzz(const float amp);
};

#endif // VECTOR3D_H

Fichier vector3d.cpp

#include "vector3d.h"
#include <math.h>

Vector3d::Vector3d():QVector3D()
{
}
Vector3d::Vector3d(const float x, const float y, const float z):QVector3D(x,y,z)
{

}
Vector3d::Vector3d(const float array[3]):QVector3D(array[0],array[1],array[2])
{
}
Vector3d::Vector3d(const int array[3]):QVector3D(array[0], array[1], array[2])
{
}
Vector3d::Vector3d(const float s):QVector3D(s,s,s)
{
}
Vector3d::Vector3d(const QPoint &point):QVector3D(point)
{

}
Vector3d::Vector3d(const QPointF &point):QVector3D(point)
{

}
Vector3d::Vector3d(const QVector2D &v):QVector3D(v)
{

}
Vector3d::Vector3d(const QVector2D &vector, const float z):QVector3D(vector, z)
{

}
Vector3d::Vector3d(const QVector3D &v):QVector3D(v.x(),v.y(),v.z())
{
}

void Vector3d::set(const float x, const float y, const float z)
{
    setX(x);
    setY(y);
    setZ(z);
}
void Vector3d::set(const QVector3D &v)
{
    setX(v.x());
    setY(v.y());
    setZ(v.z());
}
void Vector3d::reset()
{
    set(0,0,0);
}

float Vector3d::distanceToVec(const QVector3D &v)const
{
    return sqrt(distanceToVecSquared(v));
}
float Vector3d::distanceToVecSquared(const QVector3D &v)const
{
    return (*this - v).lengthSquared();
}
Angle Vector3d::angleBetween(const QVector3D & v)const
{
    float produitDesNormes = this->length() * v.length();

    // Prévention de la division par zéro
    if (produitDesNormes < 1e-6f)
        produitDesNormes = 1e-6f;

    float a = dotProduct(*this,v)/produitDesNormes;

    float b = acos(Math::Clamp(a, 0.0f-1.0f, 1.0f));

    return Angle(Radian(b));
}
Angle Vector3d::angleBetweenXAxis()const
{
//    return angleBetween(AXEX);
}
Angle Vector3d::angleBetweenYAxis()const
{
//    return angleBetween(AXEY);
}
Angle Vector3d::angleBetweenZAxis()const
{
//    return angleBetween(AXEZ);
}
bool Vector3d::isUnit()const
{
    return (lengthSquared() == 1);
}

float* Vector3d::data()const
{
    float array[3] = {x(), y(), z()};
    return array;
}
Vector3d& Vector3d::projectionSurLigne(const QVector3D& v)
{
 //FAUX
}
Vector3d& Vector3d::projectionSurPlan(const QVector3D p1, const QVector3D p2)
{

}

void Vector3d::operator=(const Vector3d & v)
{
    set(v);
}

Vector3d Vector3d::fuzz(const float amp)
{
    Vector3d v(x() + (Math::Random() * (amp * 2) - amp),
            y() + (Math::Random() * (amp * 2) - amp),
            z() + (Math::Random() * (amp * 2) - amp));
    return v;
}

Fichier vector4d.h

#ifndef VECTOR4D_H
#define VECTOR4D_H

#include <QVector4D>
#include "Math_global.h"
#include "libmath.h"
#include "angle.h"
#include "vector3d.h"

/*!
  \class Vector4d

  \brief Cette classe represente un vecteur dans un espace en quatre dimensions.

  À La différence des quaternions, pour des raisons de compatibilités, la partie
  scalaire du Vector4d est sa quatrième composante.  cette classe regroupe tous les
  opérateurs utiles, commandes de diagnostiques, etc liés à l'usage des vecteur
  de R^4 dans le cas général.  Pour les méthodes spécifiques à des vertices ou à
  des couleurs, voir les classes Vertex et Color4.
 */
class MATHSHARED_EXPORT Vector4d : public QVector4D
{
public:
// CONSTRUCTEURS
/*!
  \fn Vector4d()

  \brief Constructeur par défaut

  Construit un vecteur nul à quatre composantes.
 */
    Vector4d();
/*!
  \fn Vector4d(const float x, const float y, const float z, const float w)

  \brief Constructeur à partir de quatre nombres réels

  Construit un vecteur à partir des quatres composantes fournies en paramètre.
 */
    Vector4d(const float x, const float y, const float z,  const float w);
/*!
  \fn Vector4d(const Vector4d v)

  \brief Constructeur copie
 */
    Vector4d(const Vector4d & v):QVector4D(v.x(),v.y(),v.z(),v.w()){}
/*!
  \fn Vector4d(const float array[4])

  \brief Constructeur par défaut

  Construit un vecteur à partir des quatres composantes fournies en paramètre.
 */
    Vector4d(const float array[4]);
/*!
  \fn Vector4d(const int array[4])

  \brief Constructeur par défaut

  Construit un vecteur à partir des quatres composantes fournies en paramètre.
 */
    Vector4d(const int array[4]);
/*!
  \fn Vector4d(const float scalaire)

  \brief Constructeur par défaut

  Construit un vecteur à partir de la composante fournie en paramètre. */
    Vector4d(const float scalaire);
/*!
  \fn Vector4d(const QPoint & point)

  \brief Constructeur à partir d'un QPoint.

  Les composantes z et w sont ignorées.
 */
    Vector4d ( const QPoint & point ):QVector4D(point){}
/*!
  \fn Vector4d(const QPointF & point)

  \brief Constructeur à partir d'un QPointF.

  Les composantes z et w sont ignorées.
 */
    Vector4d ( const QPointF & point ):QVector4D(point){}
/*!
  \fn Vector4d(const QVector2D & vector)

  \brief Constructeur à partir d'un QVector2D.

  Les composantes z et w sont ignorées.
 */
    Vector4d ( const QVector2D & vector ):QVector4D(vector){}
/*!
  \fn Vector4d(const QVector2D & vector, const float z, const float w)

  \brief Constructeur à partir d'un QVector2D et de deux scalaires.

  Les composantes z et w sont désignées par ces scalaires.
 */
    Vector4d (const QVector2D & vector, const float z, const float w):QVector4D(vector,z,w){}
/*!
  \fn Vector4d (const QVector3D & vector)

  \brief Constructeur à partir d'un QVector3D.

  La composante w est ignorée.
 */
    Vector4d ( const QVector3D & vector ):QVector4D(vector){}
/*!
  \fn Vector4d (const QVector4D & vector)

  \brief Constructeur à partir d'un QVector4D.
 */
    Vector4d ( const QVector4D & vector ):QVector4D(vector){}
/*!
  \fn Vector4d (const QVector3D & vector, const float w)

  \brief Constructeur à partir d'un QVector3D et d'un scalaire.

  La composante w est désignée par ce scalaire.
 */
    Vector4d ( const QVector3D & vector, const float wpos ):QVector4D(vector, wpos){}

// MUTATEURS DIRECTS
/*!
  \fn void setAll(const float x, const float y, const float z, const float w)

  \brief Mutateur

  Cette fonction assigne à chacune composante du Vector4d courrant la valeur
  correspondante passée en paramètre.
 */
    inline void setAll(const float x, const float y, const float z, const float w);
/*!
  \fn void reset()

  \brief Mutateur

  Cette fonction transforme le vecteur courrant en vecteur nul.
 */
    inline void reset();

// ACCESSEURS INDIRECTS
/*!
  \fn distanceToVec(const Vector4d &v) const

  \brief Accesseur de la distance entre deux vecteurs.

  Cette fonction retourne la norme du vecteur courrant.

  \remarks Cette fonction nécessite l'usage d'une racine carrée.  Dans les cas
  où la norme exacte n'est pas requise (pour comparer deux vecteurs, par
  exemple), utiliser distancetoVecSquared() const plutôt.
 */
    float distanceToVec(const Vector4d &v) const;
/*!
  \fn distanceToVecSquared(const Vector4d &v) const

  \brief Accesseur de la distance entre deux vecteurs.

  Cette fonction retourne la distance au carre entre le vecteur courrant et le
  vecteur passé en paramètre.
 */
    float distanceToVecSquared(const Vector4d &v) const;
/*!
  \fn Angle angleBetween(const Vector4d & v)

  \brief Accesseur de l'angle entre deux vecteurs.

  Cette fonction retourne l'angle antre le vecteur courrant et le vecteur passé
  en paramêtre
 */
    Angle angleBetween(const Vector4d & v)const;     //error: 'Angle' does not name a type
/*!
  \fn Angle angleBetweenXAxis();

  \brief Accesseur : angle

  Cette fonction retourne l'angle antre le vecteur courrant et l'axe X.
 */
    Angle angleBetweenXAxis()const;       //error: 'Angle' does not name a type
/*!
  \fn Angle angleBetweenYAxis();

  \brief Accesseur : angle

  Cette fonction retourne l'angle antre le vecteur courrant et l'axe Y.
 */
    Angle angleBetweenYAxis()const;       //error: 'Angle' does not name a type
/*!
  \fn Angle angleBetweenZAxis();

  \brief Accesseur : angle

  Cette fonction retourne l'angle antre le vecteur courrant et l'axe Z.
 */
    Angle angleBetweenZAxis()const;        //error: 'Angle' does not name a type

// DIAGNOSTIC
/*!
  \fn bool isUnit()

  \brief Diagnostic

  Cette fonction retourne true si la norme du vecteur courrant est unitaire,
  false sinon.
 */
    inline bool isUnit() const;

// COMPATIBILITÉ
/*!
  \fn Vector3d & toVector3d()

  \brief Fonction de compatibilité : Vector3d

  Cette fonction retourne une copie du vecteur courrant sous forme d'un Vector3d.
  La composante w est donc perdue.
 */
    Vector3d & toVector3d()const;                  //error: ISO C++ forbids declaration of 'Vector3d' with no type

/*!
  \fn float* toArray();

  \brief Fonction de compatibilité : tableau statique

  Cette fonction retourne un pointeur sur la première composante du vecteur
  courrant de manière à pouvoir traiter ce vecteur un comme un tableau standard.
 */
    float* data()const;

// OPÉRATEURS GÉOMÉTRIQUES
/*!
  \fn Vector4d projectionSurLigne(const Vector4d& v)

  \brief Opérateurs géométrique : projection sur un vecteur

  Cette fonction retourne le vecteur résultant de la projection du vecteur
  courrant sur le vecteur passé en paramêtre
 */
    Vector4d & projectionSurLigne(const Vector3d& v);               //error: ISO C++ forbids declaration of 'Vector3d' with no type

/*!
  \fn Vector4d projectionSurLigne(const Vector4d& v)

  \brief Opérateurs géométrique : projection sur un vecteur

  Méthode surchargée
 */
    Vector4d & projectionSurLigne(const Vector4d& v);
/*!
  \fn Vector4d projectionSurPlan(const QVector3D p1, const QVector3D p2)

  \brief Opérateur géométrique : projection sur un plan

  Retourne le vecteur résultant de la projection du vecteur
  courrant sur le plan défini par les deux vecteurs passés en paramètre.
 */

/*!
  \fn Vector4d projectionSurPlan(const Vector4d p1, const Vector4d p2)

  \brief Opérateur géométrique : projection sur un plan

  Méthode surchargée
 */
    Vector4d & projectionSurPlan(const Vector4d p1, const Vector4d p2);

// OPÉRATEURS SURCHARGÉS
/*!
  \fn void operator=(const Vector4d & v)

  \brief Opérateur surchargé d'assignation

  Cette fonction assigne à chaque composantes du vecteur courrant la valeur de
  la composante correspondante du vecteur passé en paramètre.
 */
    void operator=(const Vector4d & v);

// AUTRES
/*!
  \fn Vector4d fuzz(const float amp)

  \brief
 */
    Vector4d fuzz(const float amp);
};

#endif // VECTOR4D_H

Fichier vector4d.cpp

#include "vector4d.h"

Vector4d::Vector4d()
{
}

Fichier Matrix4d.h

#ifndef MATRIX4D_H
#define MATRIX4D_H

#include <QMatrix4x4>
#include "Math_global.h"
#include "libmath.h"
#include "vector3d.h"
#include "vector4d.h"

class MATHSHARED_EXPORT Matrix4d : public QMatrix4x4
{
public:
/*!
 \fn Matrix4d()

 \brief Constructeur par défaut

 Construit une matrice identité.
 */
    Matrix4d():QMatrix4x4(){}
/*!
  \fn Matrix4(const float m11, const float m12, const float m13, const float m14,
              const float m21, const float m22, const float m23, const float m24,
              const float m31, const float m32, const float m33, const float m34,
              const float m41, const float m42, const float m43, const float m44)

  \brief Constructeur à partir des 16 valeurs passées en paramètre.
 */
    Matrix4d(const float m11, const float m12, const float m13, const float m14,
            const float m21, const float m22, const float m23, const float m24,
            const float m31, const float m32, const float m33, const float m34,
            const float m41, const float m42, const float m43, const float m44)
                :QMatrix4x4(m11, m12, m13, m14,
                            m21, m22, m23, m24,
                            m31, m32, m33, m34,
                            m41, m42, m43, m44){}
/*!
  \fn Matrix4d(const Matrix4d & m)

  \brief Constructeur copie
 */
    Matrix4d(const Matrix4d & m):QMatrix4x4(m){}
/*!
  \fn Matrix4d* clone()

  \brief Cette fonction retourne un clone en profondeur de la matrice courrante.
 */
    Matrix4d* clone() {return new Matrix4d(*this);}
/*!
  \fn initFromEulerAngle(const Vector3d &v)

  \brief Cette fonction initialise la matrice courrante par l'angle de Euler
  passé en paramètre.
 */
    void initFromEulerAngle(const Vector3d &v);                                 //error: ISO C++ forbids declaration of 'Vector3d' with no type
/*!
  \fn initFromEulerAngle(const float x, const float y, const float z)

  \brief Ceci est une fonction surchargée.
 */
    void initFromEulerAngle(const float x, const float y, const float z);  
/*!
  \fn Vector3d& extractEulerAngle()const

  \brief Cette fonction retourne le vecteur représentant l'angle de Euler
  relatif à la matrice courrante.
 */
    Vector3d& extractEulerAngle()const;                                           //error: ISO C++ forbids declaration of 'Vector3d' with no type

};
#endif // MATRIX4D_H

Fichier matrix4d.cpp

#include "matrix4d.h"

Fichier constantes.h

#ifndef CONSTANTES_H
#define CONSTANTES_H

#include <math.h>
#include "Math_global.h"
#include "vector3d.h"
#include "vector4d.h"
#include "matrix4d.h"
#include "angle.h"

class Angle;
class Radian;
class Degree;
class Vector3d;
class Vector4d;
class Matrix4d;

MATHSHARED_EXPORT const static float  PI        = (4.0 * atan(1.0));
MATHSHARED_EXPORT const static float  PI2       = 2.0 * PI;
MATHSHARED_EXPORT const static float  PI3_2     = 1.5 * PI;
MATHSHARED_EXPORT const static float  PI1_2     = 0.5 * PI;

MATHSHARED_EXPORT const static Radian PIrad     (PI);              //error: variable 'const Radian PI3_PIrad' has initializer but incomplete type
MATHSHARED_EXPORT const static Radian PI2rad    (PI2);           //error: variable 'const Radian PI2rad' has initializer but incomplete type
MATHSHARED_EXPORT const static Radian PI3_2rad  (PI3_2);     //error: variable 'const Radian PI3_2rad' has initializer but incomplete type
MATHSHARED_EXPORT const static Radian PI1_2rad  (PI1_2);     //error: variable 'const Radian PI1_2rad' has initializer but incomplete type

MATHSHARED_EXPORT const static Degree PIdeg     (PI);             //error: variable 'const Degree PIdeg' has initializer but incomplete type
MATHSHARED_EXPORT const static Degree PI2deg    (PI2);          //error: variable 'const Degree PI2deg' has initializer but incomplete type
MATHSHARED_EXPORT const static Degree PI3_2deg  (PI3_2);    //error: variable 'const Degree PI3_2deg' has initializer but incomplete type
MATHSHARED_EXPORT const static Degree PI1_2deg  (PI1_2);    //error: variable 'const Degree PI1_2deg' has initializer but incomplete type

MATHSHARED_EXPORT const static float  PHI       = 1.61803389f;
MATHSHARED_EXPORT const static float  phi       = 0.61803389f;

MATHSHARED_EXPORT const static float DEG2RAD    = PI / 180;
MATHSHARED_EXPORT const static float RAD2DEG    = 1 / DEG2RAD;

MATHSHARED_EXPORT const static float LOG2       = log(2.0);

MATHSHARED_EXPORT const static Vector3d  ONES    (1.0f, 1.0f, 1.0f);  //error: variable 'const Vector3d ONES' has initializer but incomplete type
MATHSHARED_EXPORT const static Vector3d  AXEX    (1.0f, 0.0f, 0.0f);   //error: variable 'const Vector3d AXEX' has initializer but incomplete type
MATHSHARED_EXPORT const static Vector3d  AXEY    (0.0f, 1.0f, 0.0f);   //error: variable 'const Vector3d AXEY' has initializer but incomplete type
MATHSHARED_EXPORT const static Vector3d  AXEZ    (0.0f, 0.0f, 1.0f);   //error: variable 'const Vector3d AXEZ' has initializer but incomplete type

MATHSHARED_EXPORT const static Vector4d  ONES4   (1.0f, 1.0f, 1.0f, 1.0f);
MATHSHARED_EXPORT const static Vector4d  AXEX4   (1.0f, 0.0f, 0.0f, 0.0f);
MATHSHARED_EXPORT const static Vector4d  AXEY4   (0.0f, 1.0f, 0.0f, 0.0f);
MATHSHARED_EXPORT const static Vector4d  AXEZ4   (0.0f, 0.0f, 1.0f, 0.0f);
MATHSHARED_EXPORT const static Vector4d  AXEW4   (0.0f, 0.0f, 0.0f, 1.0f);

MATHSHARED_EXPORT const static Matrix4d I4 (1.0f,0.0f,0.0f,0.0f,
                                            0.0f,1.0f,0.0f,0.0f,
                                            0.0f,0.0f,1.0f,0.0f,
                                            0.0f,0.0f,0.0f,1.0f);

#endif // CONSTANTES_H

EDIT : En mettant RÉSOLU, j'ai changé le titre de la discution pour avoir un sens plus proche du problème.  Le titre était à l'origine Librairie maison, 'Class' does not name a type Qt, C++ QtCreator

Dernière modification par Maneithel (Le 17/03/2011, à 04:08)

Hors ligne

#2 Le 17/03/2011, à 01:19

Le Farfadet Spatial

Re : [RÉSOLU] 'Class' does not name a type, définition circulaire, C++

Salut à tous !

   Il y a plusieurs problèmes dans ton code et ce que tu donnes ne peux pas être compilé sans QtCreator, à moins de faire un peu de travail. Bref, difficile d'être efficace.

   Pour que nous puissions t'aider, essaye d'isoler chaque problème et de créer des exemples minimums et complets : tout ce qu'il faut pour reproduire le problème (un seul par exemple minimal complet) et uniquement ce qu'il faut pour reproduire le problème.

   À bientôt.

Le Farfadet Spatial

Hors ligne

#3 Le 17/03/2011, à 04:05

Maneithel

Re : [RÉSOLU] 'Class' does not name a type, définition circulaire, C++

Bonjour !

Ouf, j'étais sûr d'avoir envoyé une version simplifiée.  J'ai dû être interrompu et avoir fermer mon ordinateur précipitament avoir d'avoir fini... merci quand même d'avoir essayé et (en relisant le code) je salue ton courage !

J'ai aujourd'hui trouvé la solution.  Pour que cette discution ne soit pas totalement inutile pour la communauté, je vais reformuler une version simple et expliciter les correctifs.

J'ai trois classes : Angle, Radian et Degree, voici leur déclaration simplifiée  (leur définition est sans importance):
Classe Angle (fichier angle.h)

#include "constantes.h"
class Angle
{
public: 
    Angle (const float a = 0);    // constructeur par défaut
    Angle (const Angle& a);      // constructeur copie
    Angle (const Degree& d);   // constructeur à partir d'un Degree
    Angle (const Radian& r);    // constructeur à partir d'un Radian

    enum TypeAngle {DEGREE, RADIAN};
private:
    float m_angle;                     // un attribut
    TypeAngle m_type;             // attribut qui détermine comment un angle est représenté dans la classe.
};

Class Radian (fichier radian.h)

#include "constantes.h"
class Radian
{
public: 
    Radian (const float a = 0);    // constructeur par défaut
    Radian (const Radian& a);    // constructeur copie
    Radian (const Degree& d);   // constructeur à partir d'un Degree
    Radian (const Angle& r);      // constructeur à partir d'un Angle
private:
    float m_angle;                     // un attribut
};

Class Degree (fichier degree.h

#include "constantes.h"
class Degree
{
public: 
    Degree (const float a = 0);    // constructeur par défaut
    Degree (const Degree& a);   // constructeur copie
    Degree (const Radian& d);   // constructeur à partir d'un Radian
    Degree (const Angle& r);      // constructeur à partir d'un Angle
private:
    float m_angle;                     // un attribut
};

Dans chacun des fichies angle.h, degree.h et radian.h, on inclue le fichier suivant (constantes.h)
Fichier constantes.h

#include "angle.h"
#include "radian.h"
#include "degree.h"
#include <math.h>

const static float PI = (4.0 * atan(1.0));           // La valeur du nombre pi
const static float DEG2RAD = (PI / 180.0f);    // Ce par quoi on multiplie un degre pour avoir l'analogue en radian
const static float RAD2DEG = (1.0F / DEG2RAD);  // Ce par quoi on multiplie un radian pour avoir l'analogue en degree

const static Angle PIang (PI);                         // Un angle de pi (soit pi, soit 180°, dépendant de la valeur de m_type)
const static Radian PIrad (PI);                       // pi
const static Degree PIdeg (PI);                      // 180°

Or ce code ne compile pas.  En effet, les définitions sont beaucoup trop circulaires.  L'appel des constructeurs dans les dernières lignes de constantes.h demande que les classes soient bien définies, or elle ont besoin du reste du contenu de constantes.h pour l'être puisqu'elle utilisent DEG2RAD et RAD2DEG dans leur définition.  On placera alors chacune des constantes PIang, PIrad et PIdeg dans leur fichier respectifs, après la déclaration de la classe (en fin de fichier).  De plus, pour éviter plus amples confusions, constantes.h ne devra pas inclure les trois autres fichiers (même si une simple mesure de prévention d'exclusion multiple suffirait à pallier à ce problème).
Par contre, ce n'est pas suffisant.  Étant donné que chaque classe possède un constructeur à partir de chaque autre, le compilateur a besoin de savoir de quoi il s'agit.  Notons que une simple déclaration préventive suffit parce que , comme dans l'exemple

Angle (const Degree& d);

le constructeur de Degree n'est pas explicitement appellé comme dans constantes.h.  Le compilateur n'a donc pas besoin d'avoir un définition complète de cette classe. 

En somme, le fichier constantes.h devra être comme ceci

Fichier constantes.h

#include <math.h>

const static float PI = (4.0 * atan(1.0));           // La valeur du nombre pi
const static float DEG2RAD = (PI / 180.0f);    // Ce par quoi on multiplie un degre pour avoir l'analogue en radian
const static float RAD2DEG = (1.0F / DEG2RAD);  // Ce par quoi on multiplie un radian pour avoir l'analogue en degree

et le fichier angle.h comme ceci

Fichier angle.h

#include "constantes.h"

class Degree;
class Radian;

class Angle
{
public: 
    Angle (const float a = 0);    // constructeur par défaut
    Angle (const Angle& a);      // constructeur copie
    Angle (const Degree& d);   // constructeur à partir d'un Degree
    Angle (const Radian& r);    // constructeur à partir d'un Radian

    enum TypeAngle {DEGREE, RADIAN};
private:
    float m_angle;                     // un attribut
    TypeAngle m_type;             // attribut qui détermine comment un angle est représenté dans la classe.
};

// angle constant en fin de fichier
const static Angle PIang (PI);                         // Un angle de pi (soit pi, soit 180°, dépendant de la valeur de m_type)

Les fichiers degree.h et radian.h devraient être écrit de manière analogue, avec la prédéclaration des autres classes et l'angle constant en fin de fichier.

Voilà !
Et, merci pour ton temps, Farfadet Spatial smile

Hors ligne