Comportement probablement non défini mais pourquoi?

Question

J'ai ajouté une nouvelle classe à une DLL qui fait partie de la solution. Tout fonctionnait bien jusqu'à ce que j'ai commencé à obtenir l'erreur discuté dans this question quand je voudrais lancer la solution avec le débogueur. Cela signifie que le débogueur était en train d'attraper quelque chose de mal, probablement de la corruption de tas bien qu'il ne soit pas précisé exactement où.

J'ai réduit le problème à ma classe ajoutée, si je l'enlève, la solution débogue bien, pas d'erreurs. Mais apparemment, il n'y a rien de mal avec la classe que j'ai ajouté!

J'ai donc commenté ma classe et ajouté une nouvelle classe simple (fictive) Book juste pour voir si elle produira la même erreur mais ce n'est pas le cas! Ensuite, je l'ai fait ressembler à ma classe ajoutée (dérivé de ofstream) et encore il va déboguer correctement, pas d'erreurs. Je l'ai commenté et décommenté ma classe originale, encore une fois l'erreur apparaît quand je le débogue! J'ai écrémé cette classe et laissé seulement le constructeur/destructeur maintenant je peux le déboguer, l'erreur disparaît ici aussi. J'ai ramené le code de suppression (en utilisant annuler ainsi pour restaurer exactement) et cette fois cela fonctionne (quand il n'était pas avant) et débogera bien sans jeter cette erreur de corruption!

Cela ressemble beaucoup à un comportement non défini, mais c'est une classe autonome très légère qui est instanciée correctement, donc un comportement indéfini est-il toujours suspect? Si oui, pourquoi cela provoquerait-il ce comportement dans ce cas?

Voici mes .h et les fichiers .cpp pour référence

class lfstream : public std::ofstream 
{ 
public: 
    lfstream(); 
    ~lfstream(); 

    void log(const std::string &text, int threadID); 
}; 

#ifdef _LOGDLL 
    #define API __declspec(dllexport) 
#else 
    #define API __declspec(dllimport) 
#endif 

API extern lfstream logstream; 

/* 
class Book : public std::ofstream 
{ 
public: 
    Book(); 
    ~Book(); 
    int WordCount(); 
}; 

API extern Book book; 
*/ 

Le fichier .cpp

static char logfname[] = "debug.txt"; 

lfstream::lfstream(): std::ofstream(logfname) 
{ 
} 

lfstream::~lfstream() 
{ 
} 

void lfstream::log(const std::string &text, int threadID) 
{ 
    const time_t ctt = time(0); 
    *this << std::setw(40) << std::left << text << " thread id = " << threadID << "\t" << asctime(localtime(&ctt)); // << std::endl; 
} 

lfstream logstream; 

/* 
Book::Book() : std::ofstream("crash.txt") 
{ 
} 
Book::~Book() 
{ 
} 

int Book::WordCount() 
{ 
    return 50; 
} 

Book book; 
*/ 

Answer 1

Votre code montre que vous attendez d'être appelé sur différents threads.

Nous ne voyons nulle part dans le code la synchronisation de threads ou les sections critiques.

Vous devez protéger contre les conditions de course en utilisant des sections critiques. Avoir une condition de course est Undefined Behaviour.

La solution C++ standard la plus courante utilise un std::mutex avec std::lock_guard pour s'assurer qu'un seul thread peut se trouver dans (a) les sections critiques de votre code.

Sample/idée:

#include <mutex> 
// .... 


static std::mutex s_log_mutex; 

void lfstream::log(const std::string &text, int threadID) 
{ 
    std::lock_guard<std::mutex> lock(s_log_mutex); 
    const time_t ctt = time(0); 
    *this << std::setw(40) << std::left << text << " thread id = " << threadID << "\t" << asctime(localtime(&ctt)); // << std::endl; 
}