lcov signale que la ligne dans les variables membres statiques destructor n'est pas exécutée

Question

J'ai une structure qui contient une variable membre statique. Une des lignes dans le destructeur de cette variable membre est prétendument jamais exécutée, ceci est rapporté par lcov. Cette ligne ne doit être exécutée que lorsque le programme se termine. Donc je suppose que c'est juste lcov qui n'est pas capable de le compter. Valgrind peut révéler que la ligne est bien sûr exécutée comme prévu.

Est-il possible que lcov compte cette ligne?

Voici le code:

#include <cstdint> // uintX_t 
#include <map>  // std::map 
#include <deque> // std::deque 

struct foo 
{ 
    struct bar 
    { 
     uint8_t* p; 

     bar(uint8_t* const p_in) : p(p_in) {} 
     ~bar() 
     { 
      if (p != nullptr) 
      { 
       delete[] p; // This line is allegedly never executed, reported by lcov 
      } 
     } 

     bar(const bar&) = delete; 
     bar& operator=(const bar&) = delete; 

     uint8_t* get_p() 
     { 
      uint8_t* const tmp = p; 
      p = nullptr; 
      return tmp; 
     } 
    }; 

    static std::map<uint64_t, std::deque<bar>> storage; 

    const uint32_t N; 
    uint8_t* P; 

    foo(const uint32_t n) : N(n) 
    { 
     if (storage[N].size() == 0) 
     { 
      P = new uint8_t[N]; 
     } 
     else 
     { 
      uint8_t* const p = storage[N].back().get_p(); 
      storage[N].pop_back(); 
      P = p; 
     } 
    } 

    ~foo() 
    { 
     storage[N].emplace_back(P); 
    } 
}; 

std::map<uint64_t, std::deque<typename foo::bar>> foo::storage; 

int main() 
{ 
    for (int i = 0; i < 2; ++i) 
    { 
     foo a(3); 
     foo b(3); 
    } 
} 

Answer 1

gcov/lcov n'est pas en mesure de surveiller la construction et la destruction des variables membres statiques (et variables globales). Ils sont cependant capables de surveiller les variables statiques dans les fonctions.