Bonjour j'ai un problème concernant les threads.

Voici mon code:

test.cpp

using namespace std;

#include <stdio.h>
#include <time.h>
#include <iostream>
#include <math.h>
#include <cstdlib>
#include <unistd.h>

#include <iostream>
#include <sstream>
#include <thread>
#include <vector>
#include <future>

#include "mychrono.hpp"

int main()

{
    
    std::vector<Chronometer*> car_crono;
    Chronometer chrono, output_chrono;
    std::vector<std::thread> threads;

    std::thread th;
    future<Chronometer> ft;


    while (1) {
       

        
        for(int i = 0; i < 1; i++)
        {
            car_crono.push_back(new Chronometer);
        }

        for(int i = 0; i<1; i++)
            {
        
                    //threads.push_back(std::thread(&Chronometer::start_chrono, car_crono[i], std::ref(chrono)));
                    auto ft = std::async(std::launch::async, [&chrono](){&Chronometer::start_chrono(chrono); });                 
            
             }
        ft.get();
        // std::cout << "Threads size: " << threads.size();
        // for (auto &th : threads) {
        //            th.join(); 
        //             }
            
       std::cout << "Hello-world" << std::endl;
       
    }
}

mychrono.cpp

#include "mychrono.hpp"

#include <time.h>
#include <iostream>
#include <cstdlib>
#include <unistd.h>

#include <sstream>
#include <thread>


//int Chronometer::hour(0), min(0), sec(0);

Chronometer::Chronometer() : hour(0), min(0), sec(0)
{

}

Chronometer& Chronometer::start_chrono(Chronometer& chrono)
{
 
  // if(chrono.hour == 0 && chrono.min == 0 && chrono.sec == 0)
  // {
    bool condition = true;
    while(condition) {
      sleep(1);
      chrono.sec++;

      if(sec > 59) {
        chrono.min++;
        chrono.sec = 0;

      }

      if(min > 59) {
        chrono.hour++;
        chrono.sec = 0;
        chrono.min = 0;
      }
      if(chrono.sec == 10)
      {
        condition = false;
      }

      std::cout << "chrono: " << chrono << std::endl;

   }

  //}  

  return chrono;
}


Chronometer& Chronometer::finish_chrono(Chronometer& chrono)
{
    chrono.hour = 0;
    chrono.sec = 0;
    chrono.min = 0;

    return chrono;
}


std::ostream& operator<<(std::ostream& flux, Chronometer t)
{
    flux << t.hour << ":" << t.min << ":" << t.sec;
    return flux;
}

Chronometer& Chronometer::operator=(const Chronometer& other)
{
    // Guard self assignment
    if (this == &other)
        return *this;
}

Chronometer::~Chronometer(){}

mychrono.hpp

#include <time.h>
#include <iostream>
#include <sstream>

#ifndef mychrono_hpp
#define mychrono_hpp

class Chronometer
{
    private:
        
        //std::stringstream ss;
        //Chronometer chrono;

    public:
        int hour, min, sec;

        Chronometer();
        Chronometer& start_chrono(Chronometer& chrono);
        Chronometer& finish_chrono(Chronometer& chrono);
        friend std::ostream& operator<<(std::ostream& flux, Chronometer t);
        Chronometer& operator=(const Chronometer& other);
        ~Chronometer();

};


#endif

L'objectif étant que dans mon test.cpp je puisse lancer ou arreter des chrono de type Chronometer en parallèle de la boucle while. Par exemple lancer deux chrono de type Chronometer avec start_chrono puis de pouvoir exécuter en parallèle des instructions comme print un simple message hello-world, puis arreter l'un des deux chronos par exemple pour en récupérer le résultat final.

Le problème étant que dans les tests que j'ai fait soit mon chrono se lance de facon synchrone soit mon programme finit par crasher soit des erreurs syntaxiques. Etant nouveau en c++ et encore plus dans les threads je ne parviens pas depuis plusieurs jours à comprendre et finaliser ce que je souhaite.

J'ai déjà posté mon problème ailleurs mais je ne trouve pas de solutions :

https://stackoverflow.com/questions/68909406/terminate-called-after-throwing-an-instance-of-stdsystem-error/68911388#68911388

https://stackoverflow.com/questions/68906234/error-no-matching-function-for-call-to-stdthread-invokerstdtuple/68906450#68906450

Si quelqu'un s'y connait bien en thread je veux bien de l'aide.

Salut,

Je peux déjà te donner quelques conseils hormis le bug dont tu nous parles pour améliorer tes futurs codes.

- N'utilise pas 'using namespace std;' c'est une mauvaise pratique: préfère prefixer std:: devant les objets/classes/fonctions de la bibliothèque standard.

- Si un pointeur doit avoir l'ownership sur la ressource pointée alors tu devrais plutôt utiliser std::unique_ptr<T> qui se chargera de supprimer la ressource pointée le moment venu. Là tu utilise 'new' mais il n'y a nulle part de 'delete' donc tu as une fuite de mémoire potentielle (ou alors j'ai mal lu ton code).

-
Edité par Warren79 25 août 2021 à 14:08:38