Discussion :

[the Hound]

Peux ( si tu as le temps et l'envie biens sur) me fournir un exemple stp, car un exemple illustre et explique toujours mieux que des phrases .........

C'est aussi une manière de recopier bêtement du code et de ne pas le comprendre ...
(Je ne dis pas que tu le fais, je dis juste que ça se fait)

Ton start date of execution là ... C'est bien la date de début d'exécution de ton programme ?
Parce que le __DATE__ que tu mets dans ton code il te donne la date de compilation ... du coup c'est normal que les deux dates affichées ne soient pas dans le même format.

[luffy_m]

Sorry, oui je compile mon code en effet et c'est ce que je veux.

Mais si l'on souhaite tracer un logiciel, comment faire ( i.e comment récupèrer son nom) ?

[luffy_m]

Sorry, oui je compile mon code en effet et c'est ce que je veux.

Mais si l'on souhaite tracer un logiciel, comment faire ( i.e comment récupèrer son nom) ?

Je compile le code puis l'execute ..... g++ main.cpp -o exec
./exec

[the Hound]

Sorry, oui je compile mon code en effet et c'est ce que je veux.

Sans vouloir être indiscret ... pourquoi vouloir toujours le recompiler ?

[therwald]

Je compile le code puis l'execute ..... g++ main.cpp -o exec
./exec

Dans ce cas même en admettant que tu ne puisse ajouter de bibliothèque, les deux premières solution que je te propose "clef en main" (utilisation de la macro __FILE__ et constante de nom de module dans le module) et toute autre solution définie dans ton propre code source, sont possibles.

[ternel]

Puisque tu es sur linux, tu peux essayer la commande time.
time prend la commande complète à exécuter, l'exécute et afficher le temps utilisé pour cela.

Et ça te donne les temps suivant: réel, système et utilisateur.

Par exemple, pour mesurer la commande grep -i "log" /tmp/*.log, ce sera time grep -i "log" /tmp/*.log.


PS: le marteau, les clous, tout ca...

[luffy_m]

Désolé d'insister, mais je comprends pas, pouvez vous me donner un exemple concret reprenant ( si possible ) mon code ?

[ternel]

si la compilation crée le programme executable, la commande time executable l'exécutera puis affichera le temps passé.

[luffy_m]

Mais je souhaite écrire les temps d'exécutions dans mon fichier log.

A ce propos, j'ai un exemple d'API pour une classe qui permet d'écrire des traces, mais je ne sais pas trop comment l'implémenter .

voici le 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
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
 
 
#ifndef __STUC__TRACE__HXX__
#define __STUC__TRACE__HXX__
 
#include <string>
 
/*!
 * Print a timestamped and labeled trace.
 * These traces will be recognised by STUC.
 */
class StucTrace
{
  public:
    /*!
    *  Save the label and the begin time.
    *  The begin time can be changed later by begin().
    */
    StucTrace(const std::string& label);
 
    virtual ~StucTrace();
 
    /*!
    *  Reset the begin time
    */
    void begin();
 
    /*!
    *  Save the end time and print the trace
    */
    void end();
 
    /*!
    *  Get the formated trace.
    */
    const std::string& getTrace()const;
 
    /*!
    *  Overload this method in your derived class in order to define where
    *  the trace should be written.
    */
    virtual void print()const;
 
  private:
    std::string _label;
    char _beginTime[64];
    char _endTime[64];
    mutable std::string _trace;
};
 
#endif

[ternel]

en implémentation de base, j'aurai utilisé soit std::chrono (mais je ne le connais pas encore), soit <ctime>

avec <ctime>, on ferait:

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
namespace util {
class timer {
private:
    const long start;
public:
    timer() : start(std::time(NULL)){}
 
    //donne le temps écoulé depuis la création du timer.
    long now() const {return std::time(NULL)-start;}
 
//deux alias: l'opérateur() et la conversion en long
    long operator() ()const {return now();}
    operator long () const {return now();}
};
}

Et pour l'usage, ca donnerait:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int main() {
    std::fstream logs("log.log");
    util::timer timer;
    //du travail...
    //encore du travail
    //dixit: le paysan de warcraft
 
    logs<<"temps total:"<<timer()<<std::endl;
}

Ton API a un défaut, elle mélange la mesure du temps et son affichage.
Mieux vaut avoir d'un côté une mesure du temps autonome (et RAII...), et de l'autre (fstream ou autre) son utilisation.
Ainsi, tu pourras mesurer du temps dans un autre but que l'affichage: optimisation de parcours, prédiction de temps d'attente, etc

Il te reste alors à créer et utiliser une classe STUClogger, qui hériterait peut-être de ostream, et qui gèrera l'écriture dans le bon format.
Éventuellement, en faire une capsule autour d'un std::ostream&, pour pouvoir lui donner arbitrairement cout ou un fstream

[luffy_m]

Voici mon avancement du 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
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
 
#include <iostream>
#include <string>
#include <fstream>
#include <ctime>
#include <chrono>
 
 
//fonction qui change un point temporel en string
std::string to_string(std::chrono::system_clock::time_point const& tp){
  //on récupère une structure time_t
  std::time_t tt{ std::chrono::system_clock::to_time_t(tp) };
  //on retourne le texte généré par ctime à partir de cette structure
  return ctime(&tt);
}
 
//on crée un point temporel initialisé à "maintenant"
  system_clock::time_point beg = system_clock::now();
 
  //on fait semblant de travailler
  //std::this_thread::sleep_for(seconds(42));
 
  // on crée un point temporel intialisé à "maintenant" 
  system_clock::time_point end = system_clock::now();
 
void startDateExecution(fstream& fichier) {
 
    if(fichier)
        {
 
           fichier << "[TRACE] Start date of execution : " << to_string(beg) << endl;
 
        }
         else
            cerr << "Impossible d'ouvrir le fichier" << endl;
}
 
void endDateExecution(fstream& fichier) {
 
        time_t result = time(NULL);
        fichier << "End date of execution : " << to_string(end) << endl;
 
        fichier.close();
}
 
void displayDate(fstream& fichier) {
 
 
        startDateExecution(fichier);
        endDateExecution(fichier);
 
}
 
int main(){
         fstream fichier("trace.log", ios::out | ios::trunc);
         displayDate(fichier);
         return 0;  
}

Le résultat :

Code :

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

1
2
3
4
5
 
 
[TRACE] , Start date of execution : Tue Aug 26 15:32:44 2014
 
End date of execution : Tue Aug 26 15:32:44 2014

Mais je souhaite obtenir un résultat de cette forme : [TRACE] 2014-07-24 14:18:50,2014-07-24 14:18:52