Discussion :

[seeme]

Bonsoir,

Je veux faire un scheduler. Il s'agit d'une classe singleton � laquelle on va ajouter des taches (interface Task). Les Task impl�mentent une m�thode pour l'op�rateur <, ce qui permet au scheduler d'ordonnacer les t�ches selon
l'heure � laquelle on voudrait les lancer et leur priorit�.

A terme, l'objectif est que le scheduler fasse tourner un thread qui va entretenir une horloge temps r�el et une horloge virtuelle qui vont servir � lancer les diff�rentes t�ches (m�thode virtuelle pure "run").

Voil� pour le d�cor.

J'ai commenc� par faire un singleton en reprenant ce que j'ai trouv� sur un des tutos de developpez (au final �a ne fonctionnait pas, j'en suis revenu � un b�te copi�/coll�), ainsi que ma classe Scheduler.

Malheureusement, quand j'essaye de r�cup�rer mon scheduler, le compilo me dit que la m�thode n'est pas d�finie..

La class template singleton

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
 
/*
 * Singleton.h
 *
 *  Created on: 5 sept. 2010
 *      Author: seeme
 */
//Not safe in multithread! Be carreful..
 
#ifndef SINGLETON_H_
#define SINGLETON_H_
 
template <class T> class Singleton{
public:
	static T* get();
	static void kill();
 
protected:
	static T* m_i;
 
private:
	T& operator=(const T&){}
};
 
#endif /* SINGLETON_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
 
/*
 * Singleton.h
 *
 *  Created on: 5 sept. 2010
 *      Author: seeme
 */
//Not safe in multithread! Be carreful..
 
#include "Singleton.h"
 
template <class T> T* Singleton<T>::m_i=0;
 
 
template <class T>  T* Singleton<T>::get(){
        if(m_i==0){
                m_i=new T();
        }
        return m_i;
}
 
template <class T> void Singleton<T>::kill(){
        delete m_i;
        m_i=0;
}

Et le scheduler

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
 
/*
 * Scheduler.h
 *
 *  Created on: 5 sept. 2010
 *      Author: seeme
 */
 
#ifndef SCHEDULER_H_
#define SCHEDULER_H_
 
#include <list>
#include <ctime>
#include "Task.h"
#include "../Tools/Singleton.h"
#include <ostream>
#include <iterator>
 
class Scheduler: public Singleton<Scheduler>{
 
    friend Scheduler* Singleton<Scheduler>::get();
    friend void Singleton<Scheduler>::kill();
 
 
private:
	std::list<Task*>* m_taskList;
	unsigned long m_virtualTime;
	void run();
	Scheduler();
	~Scheduler();
 
public:
 
	void addTask(Task* t);
 
 
	virtual void print(std::ostream& o) const {
		o << "Scheduler: " << std::endl;
		std::list<Task*>::iterator it;
		it = m_taskList->begin();
		while(it != m_taskList->end()){
			o << **it << std::endl;
			it++;
		}
	}
 
	friend std::ostream& operator<<(std::ostream& out, const Scheduler& v){
		v.print(out);
		return out;
	}
 
};
 
struct Compar
{
  bool operator()(Task* left, Task* right){
      return (*left < *right);
  }
};
 
#endif /* SCHEDULER_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
 
/*
 * Scheduler.cpp
 *
 *  Created on: 5 sept. 2010
 *      Author: seeme
 */
 
#include "Scheduler.h"
#include <iostream>
 
Scheduler::Scheduler() {
	m_taskList = new std::list<Task*>();
	m_virtualTime = 0;
	std::cout << "Constructor" << std::endl;
}
 
Scheduler::~Scheduler() {
	//All remaining task are to be deleted
	while(m_taskList->begin() != m_taskList->end())
		delete *m_taskList->begin();
 
	std::cout << "Destructor" << std::endl;
}
 
void Scheduler::addTask(Task* t){
	m_taskList->push_back(t);
	m_taskList->sort(Compar());
}

et un exemple d'utilisation qui plante lamentablement:

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
 
/*
 * Main.cpp
 *
 *  Created on: 29 août 2010
 *      Author: seeme
 */
 
#include "Main.h"
#include "Scheduler/Scheduler.h"
#include <iostream>
 
using namespace std;
 
int main(int argc, char**argv){
 
	Scheduler::get(); // <-- undifined ref to Singleton<Scheduler>::get()
 
	/*Scheduler * s = Singleton<Scheduler>::get();
	s->addTask(new Task("Une tache", 10, 1, 1, NORMAL));
 
 
	Scheduler::kill();*/
	return 0;
}

Merci d'avance
Seeme

[fafacpp]

Salut,
le probl�me vient du fait que tu a s�par� la d�claration et l'impl�mentation de ton template Singleton (c'est possible de le faire mais il faut faire plus attention => FAQ). Met tout dans Singleton.h et �a devrait aller mieux.

[seeme]

Merci beaucoup...

En conclusion, je suis un boulet et j'ai perdu ma soir�e :p

Jamais �a ne me paraitra logique ce syst�me de .h / .cpp avec les templates..

[koala01]

Salut,

Merci beaucoup...

En conclusion, je suis un boulet et j'ai perdu ma soir�e :p

Jamais �a ne me paraitra logique ce syst�me de .h / .cpp avec les templates..

Le fait est que l'utilisation des template revient � dire au compilateur

je ne sais pas quel type de donn�es je vais manipuler, mais je sais comment je vais le faire

De ce fait, le compilateur ne peut absolument pas pr�voir la taille des donn�es manipul�es tant... qu'on ne pr�cise pas le type de celles-ci.

Il ne pourra donc cr�er le code binaire ex�cutable que... lorsqu'il saura quelle donn�e est r�ellement manipul�e

Si tu s�pares l'impl�mentation des diff�rentes fonctions de ta classes et la d�finition de cette derni�re, il faudra donc que tu inclue l'impl�mentation des fonctions lorsque tu souhaite manipuler un type d'objet particulier

Mais comme il est commun�ment admis qu'il ne faut pas inclure les fichier *.cpp, il est pr�f�rable de ne pas placer l'impl�mentation dans un fichier *.cpp, pour �viter toute confusion.

Si tu souhaite effectivement s�parer la d�finition d'une classe template et l'impl�mentation de ses fonctions, tu peux le faire, mais tu dois alors veiller � utiliser une autre extension pour le fichier d'impl�mentation (*.impl ou *.tpp, par exemple), de mani�re � ce que celui qui lira ton code ne se pose pas la question "mais pourquoi diable inclut-il un *.cpp... il ne sait pas que c'est pas recommand� "