Problème d'algorithmie temps C++

[sandrecarpe]

Bonsoir,
J'essaye de faire transposer un algorithme de temps en C++ mais j'ai un petit soucis dans la réflexion. Le but est de lancer une fonction lancer à 4 heures différentes.
Disons que l'on a t1 < t2 < t3 < t4, représentant les temps avant l’exécution de la fonction lancer

Je lance l'algorithme à l'instant t0. A cet instant, la première fois que l'on exécutera la fonction lancer, ça sera dans t1 secondes.
Une fois t1 secondes écoulées, il faut attendre t2-t1 secondes avant de relancer la fonction.
Une fois les t2-t1 secondes écoulées, il faut attendre t3-t2 secondes avant de relancer la fonction
Une fois les t3-t2 secondes écoulées, il faut attendre t4-t3 secondes avant de relancer la fonction
Une fois les t4-t3 secondes écoulées, combien faut-il de temps pour exécuter à nouveau la fonction à l'heure associée a t1 ?
En gros, j'aimerai relancer l'algorithme une fois le 4e temps atteint

Pouvez-vous me donner un coup de main ?

Voici le code si vous voulez y jetez un coup d'oeil :

 Cliquez pour afficher

#include <iostream>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <vector>
#include <string>

using namespace std;
using namespace boost::asio;
using namespace boost::posix_time;

void print(const boost::system::error_code& error, deadline_timer* timer, vector<pair<string, int>> *diffs, int *count)
{

	time_t currentTime = time(0);
	localtime(&currentTime);


	cout << "coucou bonjour " << *count << endl;

	//on affiche le contenu de diffs pour verifier qu'on a bien l'ordre croissant
	for_each(diffs->begin(), diffs->end(), [](pair<string, int> &param){cout << param.first << ";" << param.second << endl;});

	string etat = diffs->at(*count).first;
	cout << "etat " << etat << endl;

	if(*count == 3)
		*count = 0;
	else
		++(*count);

	int temps_perdu = 0;
	for_each(diffs->begin(), diffs->begin()+(*count), [&](pair<string, int> &param){temps_perdu += param.second;});
	cout << "relancement dans " << diffs->at(*count).second << " sec" << endl;
	if((*count) > 0)
	{
		cout << "relancement apres calcul " << (diffs->at(*count).second) - (diffs->at((*count)-1)).second << endl << endl;
		timer->expires_from_now(boost::posix_time::seconds(2));
		timer->async_wait(boost::bind(print, boost::asio::placeholders::error, timer, diffs, count));
	}
	else
	{
		cout << "relancement apres calcul " << diffs->front().second << endl << endl;
//		timer->expires_from_now(boost::posix_time::seconds(diffs->front().second));
		timer->expires_from_now(boost::posix_time::seconds(2));
		timer->async_wait(boost::bind(print, boost::asio::placeholders::error, timer, diffs, count));
	}

	//timer->expires_from_now(boost::posix_time::seconds(diffs->at(*count).second));
	

}



void lancer(tm *const matinStart, tm *const matinEnd, tm *const soirStart, tm *const soirEnd)
{
	time_t currentTime = time(0);
	//time(&currentTime);
	struct tm now;
	now = *localtime(&currentTime);

	//@diffMatinStart : différence de secondes entre le temps ou la fonction et est lancé et le temps ou je veux allumer la lumière le matin
	const double diffMatinStart = abs(difftime(mktime(matinStart), currentTime)); //mktime : conversion struct tm en time_t
	const double diffMatinEnd = abs(difftime(currentTime, mktime(matinEnd)));
	const double diffSoirStart = abs(difftime(currentTime, mktime(soirStart)));
	const double diffSoirEnd = abs(difftime(currentTime, mktime(soirEnd)));

	cout << "matinStart " << asctime(matinStart) << diffMatinStart << endl; //asctime : conversion structure tm en string
	cout << "matinEnd " << asctime(matinEnd) << diffMatinEnd << endl;
	cout << "soirStart " << asctime(soirStart) << diffSoirStart << endl;
	cout << "soirEnd " << asctime(soirEnd) << diffSoirEnd << endl;


	vector<pair<string, int>> diffs;
	diffs.push_back(std::pair<string, int>("on", diffMatinStart));
	diffs.push_back(std::pair<string, int>("off", diffMatinEnd));
	diffs.push_back(std::pair<string, int>("on", diffSoirStart));
	diffs.push_back(std::pair<string, int>("off", diffSoirEnd));

	//on trie par ordre croissant
	sort(diffs.begin(), diffs.end(), [](pair<string, int> param1, pair<string, int> param2){return param1.second < param2.second;});

	double prochaineEcheanceTime = diffs.front().second;
	

	diffs.at(0) = pair<string, int>(diffs.at(0).first, abs(difftime(mktime(matinStart), mktime(soirEnd))));
	cout << "Secondes avant lancement " << prochaineEcheanceTime << endl; //on affiche le minimum de la liste

	int count = 0;
	io_service io;
	//deadline_timer timer(io, seconds(prochaineEcheanceTime));
	deadline_timer timer(io, seconds(5));
	timer.async_wait(boost::bind(print,	boost::asio::placeholders::error, &timer, &diffs, &count));

	io.run();
}


int main()
{
	time_t now = time(0);

	struct tm today;
	today = *localtime(&now);

	struct tm soirStart;
	soirStart = *localtime(&now);
	soirStart.tm_hour = 18;
	soirStart.tm_min = 30;
	soirStart.tm_sec = 0;
	if(soirStart.tm_hour < today.tm_hour)
	{
		soirStart.tm_mday++;
	}


	struct tm soirEnd;
	soirEnd = *localtime(&now);
	soirEnd.tm_hour = 21;
	soirEnd.tm_min = 30;
	soirEnd.tm_sec = 0;
	if(soirEnd.tm_hour < today.tm_hour)
	{
		soirEnd.tm_mday++;
	}

	struct tm matinEnd;
	matinEnd = *localtime(&now);
	matinEnd.tm_hour = 9;
	matinEnd.tm_min = 0;
	matinEnd.tm_sec = 0;
	if(matinEnd.tm_hour < today.tm_hour)
	{
		matinEnd.tm_mday++;
	}

	struct tm matinStart;
	matinStart = *localtime(&now);
	matinStart.tm_hour = 6;
	matinStart.tm_min = 30;
	matinStart.tm_sec = 0;
	if(matinStart.tm_hour < today.tm_hour)
	{
		matinStart.tm_mday++;
	}

	lancer(&matinStart, &matinEnd, &soirStart, &soirEnd);
	return 0;
}

-----