Discussion :

[CocoLeNain]

Bonjour,

J'ai une classe appelé Countdown qui gère un compte à rebours. Pour cela, j'utilise boost::asio::deadline_timer en asynchrone.
J'aimerai passer en paramètre de mon constructeur la fonction a déclencher lorsque le compte à rebours a expiré et démarrer le compte à rebours par une fonction start.

Mon problème est que je n'arrive pas à déclencher la fonction passée en paramètre.

Voici le code:

Countdown.hpp

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
#ifndef COUNTDOWN_HPP_
#define COUNTDOWN_HPP_
 
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/function.hpp>
 
class Countdown
{
private:
	bool m_actived;
	bool m_suspended;
	boost::asio::deadline_timer m_runTimer;
	boost::function<void(const boost::system::error_code& error)> m_handler;
 
public:
	Countdown(boost::asio::io_service& ioService,boost::function<void(const boost::system::error_code& error)> handler);
	~Countdown();
	void start();
	void suspend();
	void stop();
	void setValue(short value);
};
 
 
#endif /* COUNTDOWN_HPP_ */

Countdown.cpp

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
#include "Countdown.hpp"
 
Countdown::Countdown(boost::asio::io_service& ioService,boost::function<void(const boost::system::error_code& error)> handler)
: m_actived(true),m_suspended(false),m_runTimer(ioService),m_handler(handler)
{
	m_runTimer.expires_from_now(boost::posix_time::seconds(1));
}
 
Countdown::~Countdown()
{
	m_actived = false;
	m_runTimer.cancel();
}
 
void Countdown::start()
{
	m_actived = true;
	m_runTimer.async_wait(m_handler);
}
 
void Countdown::suspend()
{
	if(m_suspended)
	{
 
	}
	else
	{
 
	}
}
 
void Countdown::stop()
{
	m_actived = false;
	m_runTimer.cancel();
}
 
void Countdown::setValue(short value)
{
	m_runTimer.expires_from_now(boost::posix_time::seconds(value));
}

main.cpp

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
#include <iostream>
#include <windows.h>
 
#include "Countdown.hpp"
 
void expireHandler(const boost::system::error_code& error)
{
	std::cout << "end of the countdown" << std::endl;
}
 
int main() {
	boost::asio::io_service ioService;
	boost::system::error_code error;
	Countdown countdown(ioService,
			boost::bind(
					&expireHandler,
					error
	));
	countdown.setValue(5);
	std::cout << "Start of the countdown" << std::endl;
	countdown.start();
	Sleep(10000);
	std::cout << "end of the program" << std::endl;
	return 0;
}

Résultat

Code :

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

1
2
Start of the countdown
end of the program

[Trademark]

Le truc bizarre que je vois c'est dans ton bind tu passes directement une copie locale de error, or c'est pas comme ça que tu dois faire.

Code :

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

1
2
3
4
5
Countdown countdown(ioService,
			boost::bind(
					&expireHandler,
					boost::asio::placeholders::error
	));

D'un autre côté, ça m'étonne que tu n'as pas d'erreur de compilation vu que après ton bind, ton expireHandler devrait devenir une fonction sans argument. Vu que avec ton bind tu dis : "le premier paramètre de expireHandler sera toujours une copie locale de boost::system::error_code".

Mais en fait tu n'es même pas obligé d'utilisé un bind, passer simplement ta fonction en paramètre devrait suffire :

Code :

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

Countdown countdown(ioService, &expireHandler);

[Arzar]

Le bind est faux il faire Countdown countdown(ioService, boost::bind(&expireHandler, _1));

Une petite exemple pour bien comprendre. Ce code :

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
#include <iostream>
#include <boost/bind.hpp>
 
void foo(int i)
{
   std::cout << i << std::endl;
}
 
int main() 
{
   auto b1 = boost::bind(&foo, 4);
   b1(5); // 5 ne va pas être utilisé, le premier argument est déjà bindé
   b1(6); // 6 ne va pas être utilisé, le premier argument est déjà bindé
   b1();
 
   auto b2 = boost::bind(&foo, _1); // _1 est un placeholder
   b2(5);
   b2(6);
   //b2(); // ne compile pas, il faut un argument
}

affiche

Code :

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

1
2
3
4
5
4
4
4
5
6

Mais comme l'a dit trademark ici on peut faire encore plus simple car vu que ton constructeur prend une std::function il n'y a même pas besoin de faire un bind, tu peux simplement passer l'adresse de la fonction.