class Abstraite et perte de référence.

**SKone** · 13/11/2007, 19h08

Salut
Dans le cadre du développement de mon moteur Physique je code mon solver d'équation différentielle. Mais j'ai quelque petit problème j'ai plus de référence alors mettons nous en situation. Alors pour ça j'ai pas classe NumericalSolver

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template<class T>
    class NumericalSolver
    {
        public :
            NumericalSolver(const Vector3D<T> (*f)(const Vector3D<T>, const T), T, Vector3D<T>);
            NumericalSolver(const NumericalSolver<T>&);
            virtual ~NumericalSolver();
            const Vector3D<T> (*dF) (const Vector3D<T>, const T); // dy/dt
            Vector3D<T> F; // f
            T dt; // différentiel de temps
            T Tp; // temps courant
            virtual void Next() = 0; /// Fonction virtuelle pour calculer la position suivante
    };

dF étant un pointeur vers une fonction qui retourne F' F étant un Vecteur 3D exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
const Vector3D<float> Func(const Vector3D<float> v, const float t)
{
    // Attracteur de Lorentz
    return Vector3D<float>( 10*(v.y-v.x),
                            28*v.x-v.y-v.x*v.z,
                            v.x*v.y-8*v.z/3)
}

Voilà et j'ai plein de classe qui sont des NumericalSolver :
Euler_E, RK4_E, RK6_E, ABM, Gear, ... Exemple avec Euler :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
    template<class T>
    class Euler_E : public NumericalSolver<T>
    {
        public :
            Euler_E();
            Euler_E(const Vector3D<T> &);
            virtual ~Euler_E();
            void Next(); // F(n+dt)
    };
/// Calculer la position suivante
template<class T>
void Euler_E<T>::Next()
{
    /// Fn+dt = Fn + dF(F, Tp)*dt
    this->F += this->dF(this->F, this->Tp)*this->dt;
    this->Tp += this->dt;
}

Puis j'ai une classe pour la gestion général de la physique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    template<class T>
    class PhysicModel
    {
        public :
            PhysicModel();
            PhysicModel(const Vector3D<T> &);
            PhysicModel(const Vector3D<T> &, const NS, const T);
            virtual ~PhysicModel();
            static NS tns;
            static NumericalSolver<T> *ns;
 
            void Simulation();
 
        private :
            void Choise(const NS, const Vector3D<T> &);
    };

NS etant la méthode de résolution que nous voulons (NS_EULER_E, NS_RK4_E, ...)

et voilà un bout de l'implémentation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
/// Constructeur
template<class T>
PhysicModel<T>::PhysicModel(const Vector3D<T> &f0, const NS t_ns, const T Dt = 0.01)
{
    Choise(t_ns, f0);
    ns->F = f0;
    ns->dt = Dt;
}
 
/// Desctruteur
template<class T>
PhysicModel<T>::~PhysicModel()
{
    delete ns;
}
 
/// Lancer le model physique
template<class T>
void PhysicModel<T>::Simulation()
{
    ns->Next();
}
 
/// Choisir le solveur d'ODE
template<class T>
void PhysicModel<T>::Choise(const NS _tns, const Vector3D<T> &f0)
{
    switch(_tns)
    {
        case NS_EULER_E :
                ns = new Euler_E<T>(f0);
                tns = _tns;
            break;
        case NS_EULER_I :
                ns = new Euler_I<T>(f0);
                tns = _tns;
            break;
        case NS_RK2_E :
                ns = new RK2_E<T>(f0);
                tns = _tns;
            break;
        case NS_RK4_E :
                ns = new RK4_E<T>(f0);
                tns = _tns;
            break;
        case NS_RK6_E :
                ns = new RK6_E<T>(f0);
                tns = _tns;
            break;
        case NS_ABM2_E :
                ns = new ABM2_E<T>(f0);
                tns = _tns;
            break;
        case NS_ABM2_I :
                ns = new ABM2_I<T>(f0);
                tns = _tns;
            break;
        case NS_ABM3_E :
                ns = new ABM3_E<T>(f0);
                tns = _tns;
            break;
        case NS_ABM3_I :
                ns = new ABM3_I<T>(f0);
                tns = _tns;
            break;
        case NS_ABM4_E :
                ns = new ABM4_E<T>(f0);
                tns = _tns;
            break;
        case NS_ABM4_I :
                ns = new ABM4_I<T>(f0);
                tns = _tns;
            break;
        case NS_G2_I :
                ns = new Gear2_I<T>(f0);
                tns = _tns;
            break;
        case NS_G3_I :
                ns = new Gear3_I<T>(f0);
                tns = _tns;
            break;
        case NS_G4_I :
                ns = new Gear4_I<T>(f0);
                tns = _tns;
            break;
        default :
            ns = new Euler_E<T>(f0);
            tns = NS_EULER_E;
    }
}

voilà et dans mon main je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
VM::PhysicModel<float> *pm = new PhysicModel<float>(F, NS_RK6_E, 0.0003);
 
pm->ns->dF = Func;
 
// Dans une fonction Draw :
    glBegin(GL_LINE_STRIP);
        glVertex3f(pm->ns->F.x, pm->ns->F.y, pm->ns->F.z);
            pm->Simulation();
        glVertex3f(pm->ns->F.x, pm->ns->F.y, pm->ns->F.z);
    glEnd();

Mais le problème c'est que j'ai plein de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
.objs\main.o:main.cpp:(.text+0x470):: undefined reference to `VM::PhysicModel<float>::ns'
)]+0x11d):: undefined reference to `VM::PhysicModel<float>::ns'
)]+0x125):: undefined reference to `VM::PhysicModel<float>::tns'
::~PhysicModel()]+0x11):: undefined reference to `VM::PhysicModel<float>::ns'

Est ce que vous voyez où je me suis trompez ? Parce que ça me tue de stagné la dessus...

**Davidbrcz** · 13/11/2007, 21h22

Je ne suis pas totalment sûr de moi car tu ne détail pas l'organisation de tes fichiers, mais je pense que ceci va t'aider :
http://cpp.developpez.com/faq/cpp/?p...VERS_templates

**SKone** · 13/11/2007, 23h48

En effet je détail pas mais j'utilise la même méthode que dans la FAQ à coup de #include "fichier.hpp" ...

**Mat007** · 14/11/2007, 10h06

Salut,

Peut-être cette entrée de la FAQ alors ?

MAT.

**JolyLoic** · 14/11/2007, 10h18

C'est un peu ça, sauf que comme la classe est template, la syntaxe est légèrement différente. Voir par exemple http://www.devx.com/tips/Tip/5634 .

**SKone** · 14/11/2007, 16h28

Merci Merci mais j'ai une question :
Dans ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
template<class T> class C 
{
public: 
  static T stat; //declaration
};
template<class T> T C<T>::stat = 5;  //definition

Pourquoi on met le type avant d'affecter la variable ?
Parce que dans mon cas ça donnerais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
    template <class T> NS PhysicModel<T>::tns = NS::NS_EULER_E;
    template <class T> (NumericalSolver<T> *) PhysicModel<T>::ns = new VM::Euler_E<T>(Vector3D<T>(0, 0, 0));

NS étant un enum.
Et de plus avant ou sans j'ai des erreurs avec :

Envoyé par gcc

\PhysicModel.h:60: error: `NS' is not a class or namespace
\PhysicModel.h:61: error: expected `)' before '*' token
\PhysicModel.h:61: error: expected `;' before '*' token
:: === Build finished: 3 errors, 0 warnings ===

et sans :

Envoyé par gcc

\PhysicModel.h:60: error: expected constructor, destructor, or type conversion before '=' token
\PhysicModel.h:60: error: expected `;' before '=' token
\PhysicModel.h:61: error: expected constructor, destructor, or type conversion before '=' token
\PhysicModel.h:61: error: expected `;' before '=' token
:: === Build finished: 4 errors, 0 warnings ===

???

**JolyLoic** · 14/11/2007, 16h51

Ce n'est pas une affectation de variable, mais une définition. Et une définition est composée d'un type, d'un nom, et éventuellement d'une valeur d'initialisation.

Dans le cas simple de la FAQ, on défini la variable de type int, dans ce cas plus complexe, on doit la définir de type NS.

Pourquoi le compilateur a-t-il un problème ? Il ne connaît pas NS. Et moi non plus, il n'apparaît pas dans le code que tu as montré...

**SKone** · 14/11/2007, 18h03

En fait mon fichier PhysicModel.h:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#ifndef __PHYSICMODEL_H__
#define __PHYSICMODEL_H__
 
#include <vector>
 
#include "Euler_E.h"
#include "Euler_I.h"
#include "RK2_E.h"
#include "RK4_E.h"
#include "RK6_E.h"
#include "ABM2_E.h"
#include "ABM2_I.h"
#include "ABM3_E.h"
#include "ABM3_I.h"
#include "ABM4_E.h"
#include "ABM4_I.h"
#include "Gear2_I.h"
#include "Gear3_I.h"
#include "Gear4_I.h"
#include "Vector3D.h"
 
namespace VM
{
    enum NS
    {
        NS_EULER_E, ///Euler explicite
        NS_EULER_I, ///Euler implicite
        NS_RK2_E,   ///RungeKutta explicite
        NS_RK4_E,   ///RK4 explicite
        NS_RK6_E,   ///RK6 explicite
        NS_ABM2_E,  ///Adams-Bashforth-Moulton explicite d'ordre 2
        NS_ABM2_I,  ///Adams-Bashforth-Moulton implicite d'ordre 2
        NS_ABM3_E,  ///ABM3 explicite
        NS_ABM3_I,  ///ABM3 implicite
        NS_ABM4_E,  ///ABM4 explicite
        NS_ABM4_I,  ///ABM4 implicite
        NS_G2_I,    ///Gear implicite d'ordre 2
        NS_G3_I,    ///Gear implicite d'ordre 3
        NS_G4_I     ///Gear implicite d'ordre 4
    };
 
    /// Classe générique pour la gestion du model physique courant
    template<class T>
    class PhysicModel
    {
        public :
            PhysicModel();
            PhysicModel(const Vector3D<T> &);
            PhysicModel(const Vector3D<T> &, const NS, const T);
            virtual ~PhysicModel();
            static NS tns;
            static NumericalSolver<T> *ns;
 
            void Simulation();
 
        private :
            void Choise(const NS, const Vector3D<T> &);
    };
 
    template <class T> VM::NS PhysicModel<T>::tns = NS::NS_EULER_E;
    template <class T> VM::(NumericalSolver<T>*) PhysicModel<T>::ns = new VM::Euler_E<T>(Vector3D<T>(0, 0, 0));
 
    #include "PhysicModel.hpp"
}
 
#endif

Donc d'après moi il devrait le reconnaitre il est juste devant lui...
et GCC dit :

\PhysicModel.h:60: error: `NS' is not a class or namespace
\PhysicModel.h:61: error: expected unqualified-id before '(' token
\PhysicModel.h:61: error: expected constructor, destructor, or type conversion before "PhysicModel"
\PhysicModel.h:61: error: expected `;' before "PhysicModel"
:: === Build finished: 4 errors, 0 warnings ===

**JolyLoic** · 14/11/2007, 19h05

Et avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   template <class T> VM::NS PhysicModel<T>::tns = NS_EULER_E;

Au lieu de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   template <class T> VM::NS PhysicModel<T>::tns = NS::NS_EULER_E;

?

**SKone** · 14/11/2007, 19h51

Lol c'est vrai j'aurais du y pensé c'est pas une classe et pour les 3 autre erreur ?
Et pour les 3 autres erreurs j'ai juste enlevé les parenthèse Merci je peux continuer mon moteur Physique [Résolu] Thanks

class Abstraite et perte de référence.

C++

Discussions similaires

Partager

Partager