Bonjour,

j'ai besoin du temps passé entre deux utilisations d'une fonction, même si le programme est fermé.

Pour ça j'utilise localtime et time_t, mais mon programme trouve des fois une valeur nègative...

Pourquoi et comment ke pourrais le régler ?

Merci.

P.S.

Code:

std::string Player::prod()
{
	std::string return_;
	std::vector<int> nb_coll(3);
	time_t time_ = time(0);
	struct tm *t;

	t = localtime(&time_);

	long int act_time, diff_time;
	float diff_time_h;
	if((t->tm_mday < 31) && (t->tm_hour < 23) && (t->tm_min < 59) && (t->tm_sec < 59)) //Ne compte plus au dela d'un 
																					   //délai de 31 jours.
		act_time = (t->tm_mday*86400) + ((t->tm_hour+1)*3600) + ((t->tm_min+1)*60) + t->tm_sec+1;
	else
		act_time = 2678400; //Equivalent de 31j.
	diff_time = act_time-m_time_coll; //Calcul de la diffèrence entre la dernière collecte et maintenant.
	diff_time_h = diff_time/3600.f; //Convertion en heures.
	std::cout << diff_time_h << std::endl; ///Débug
	m_time_coll = act_time; //Remise à "zéro" du temps de la collecte.
	for(auto i : m_area.get_vec_prod())
	{
		switch(i.get_id_product())
		{
			case STONE:
				m_ressource[STONE].add(i.get_product_h()*diff_time_h);
				nb_coll[STONE] += i.get_product_h()*diff_time_h;
				break;
			case BRICKS:
				m_ressource[BRICKS].add(i.get_product_h()*diff_time_h);
				nb_coll[BRICKS] += i.get_product_h()*diff_time_h;
				break;
			case WOOD:
				m_ressource[WOOD].add(i.get_product_h()*diff_time_h);
				nb_coll[WOOD] += i.get_product_h()*diff_time_h; 
				break;
			default:
				break;
		}   
	}
	return return_;
}

-
Edité par EnderRayquaza 13 octobre 2020 à 21:55:49

Bonjour,

Il y a des erreurs pour les lignes 12 et 13 (le 1er à 0:00:00 on trouverait 86400+3600+60+1 au lieu de 0 et à 0:00:59 on trouverait 2678400 au lieu de 59), le 31 à 23:59:59 on devrait avoir 2678400-1. Il faudrait plutôt écrire:

if (t->tm_mday <= 31 && t->tm_hour <= 23 && t->tm_min <= 59 && t->tm_sec <= 59) //Ne compte plus au dela d'un
                                                                                //délai de 31 jours.
        act_time = (t->tm_mday-1)*86400 + t->tm_hour*3600 + t->tm_min*60 + t->tm_sec;
    else
        act_time = 31*24*60*60; //Equivalent de 31j.

-
Edité par Dalfab 13 octobre 2020 à 23:33:14

Ça n'a pas de sens de faire des calculs sur les durées en ne se basant que sur les jours du mois, forcément que cela fait négative quand on change de mois -> les valeurs reviennent à 0. Il y a ce qu'il faut dans l'en tête <chrono> pour calculer les différences entre 2 mesures de temps.

ça marche sauf si on quitte le programme...

-
Edité par EnderRayquaza 14 octobre 2020 à 20:06:13

Quand on quitte un programme toutes ses variables disparaissent.
Pour avoir un focntionnement qui reprend quand on relance le programme, il faut sauvegarder ce que tu veux conserver dans un fichier, et au démarrage de l'application il faut ces données dans le même fichier.

Oui c'est vrai, en plus j'ai déjà fait une fonction pour mes autres variables...

J'arrive à la sauvgarder, mais pas convetir l'int en std::chrono::steady_clock::time_point pour la charger.

-
Edité par EnderRayquaza 15 octobre 2020 à 16:47:16

Ce que tu dois charger dépend de ce que tu as sauvegardé, par exemple pour une sauvegarde des secondes écoulées depuis la date de référence:

// à partir de time_point_to_save, on obtient un seconds_since_epoch
std::chrono::steady_clock::duration  duration_since_epoch = time_point_to_save.time_since_epoch();
long long  seconds_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(duration_since_epoch).count();
// ... => sauvegarde de seconds_since_epoch

// ... à partir du chargement de seconds_since_epoch, on obtient un time_point_read
std::chrono::time_point<std::chrono::steady_clock>  time_point_read{};
time_point_read += std::chrono::seconds(sec_since_epoch);

-
Edité par Dalfab 15 octobre 2020 à 21:06:18

Il doit y avoir un problème au niveau de la convertion car après une minute, il dit qu'il s'est écoulé 1.0e6 s, soit 300 h....

Question à part, j'utilise #ifndef H_... #def... #endif, mais j'ai vu que #pragma once remplissait la même fonction.

La quelle est la mieux en c++ moderne ?

"#pragma once" n'est pas standardisé mais fonctionne dans la majorité des compilateurs à large audience récents, malgré le fait qu'il soit bien pratique.

Il est assez facile de faire en sorte de passer d'un type de "header guard" à l'autre en customisant votre gestionnaire de source au moment de l'extraction des sources.