Des outils pour trouver les en-têtes inclus qui ne sont pas utilisés?

Question

Je sais PC-Lint peux vous dire sur les en-têtes qui sont inclus, mais pas utilisé. Existe-il d'autres outils qui peuvent le faire, de préférence sur linux?

Nous avons une grande base de code, qu'à travers les 15 dernières années a vu beaucoup de fonctionnalités de se déplacer, mais il est rare que les restes de directives #include obtenir supprimée lorsque la fonctionnalité de passe d'un fichier de mise en oeuvre à l'autre, nous laissant avec une assez bonne désordre en ce point. Je peux évidemment faire le laborieux chose de suppression de toutes les directives #include et de laisser le compilateur me dire lesquels reinclude, mais je préfère résoudre le problème en sens inverse: trouver le inutilisés - plutôt que de reconstruire une liste d'.

Answer 1

AVERTISSEMENT: Mon travail de jour est de travailler pour une entreprise qui développe les outils d'analyse statique.

Je serais surpris si la plupart (si pas tous) les outils d'analyse statique n'avait pas une certaine forme de tête de vérification d'utilisation. Vous pouvez utiliser cette page de wikipedia pour obtenir une liste des outils disponibles et les e-mails des entreprises pour leur demander.

Quelques points à considérer lorsque vous êtes à l'évaluation d'un outil:

Pour la fonction surcharges, vous voulez tous les en-têtes contenant des surcharges pour être visible, pas seulement l'en-tête qui contient la fonction qui a été sélectionné par la résolution de surcharge:

// f1.h
void foo (char);

// f2.h
void foo (int);


// bar.cc
#include "f1.h"
#include "f2.h"

int main ()
{
  foo (0);  // Calls 'foo(int)' but all functions were in overload set
}

Si vous prenez l'approche par force brute, d'abord supprimer tous les en-têtes, puis rajoutez-les jusqu'à ce qu'il compile, si f1,.h' est ajouté en premier puis le code de la compilation, mais la sémantique du programme ont été modifiées.

Une règle similaire s'applique lorsque vous avez partielle et de spécialisations. Il n'a pas d'importance si la spécialisation est sélectionné ou non, vous devez vous assurer que toutes les spécialisations sont visibles:

// f1.h
template <typename T>
void foo (T);

// f2.h
template <>
void foo (int);

// bar.cc
#include "f1.h"
#include "f2.h"


int main ()
{
  foo (0);  // Calls specialization 'foo<int>(int)'
}

Comme pour la surcharge exemple, l'approche par force brute peut entraîner un programme qui encore compile mais a des comportements différents.

Un autre type d'analyse que vous pouvez regarder dehors pour est de vérifier si les types peuvent être transmises déclaré. Considérez les points suivants:

// A.h
class A { };

// foo.h
#include "A.h"
void foo (A const &);

// bar.cc
#include "foo.h"

void bar (A const & a)
{
  foo (a);
}

Dans l'exemple ci-dessus, la définition de " A " n'est pas nécessaire, et donc le fichier d'en-tête 'foo.h' peut être modifié de sorte qu'il a une déclaration anticipée uniquement pour la "Une":

// foo.h
class A;
void foo (A const &);

Ce genre de vérifier également réduit l'en-tête de dépendances.

Answer 2

Voici un script qui le fait:

 #!/bin/bash
# prune include files one at a time, recompile, and put them back if it doesn't compile
# arguments are list of files to check
removeinclude() {
    file=$1
    header=$2
    perl -i -p -e 's+([ \t]*#include[ \t][ \t]*[\"\<]'$2'[\"\>])+//REMOVEINCLUDE $1+' $1
}
replaceinclude() {
   file=$1
   perl -i -p -e 's+//REMOVEINCLUDE ++' $1
}

for file in $*
do
    includes=`grep "^[ \t]*#include" $file | awk '{print $2;}' | sed 's/[\"\<\>]//g'`
    echo $includes
    for i in $includes
    do
        touch $file # just to be sure it recompiles
        removeinclude $file $i
        if make -j10 >/dev/null  2>&1;
        then
            grep -v REMOVEINCLUDE $file > tmp && mv tmp $file
            echo removed $i from $file
        else
            replaceinclude $file
            echo $i was needed in $file
        fi
    done
done
 

Answer 3

Regardez Dehydra .

Sur le site:

Dehydra est un outil d'analyse statique léger, scriptable et à usage général, capable d'analyser du code C ++ spécifique à l'application. Dans le sens le plus simple, Dehydra peut être considéré comme un outil sémantique de grep.

Il devrait être possible de créer un script qui recherche les fichiers #include inutilisés.

Answer 4

Cppclean de Google semble faire un travail décent de trouver des fichiers d'en-tête inutilisés. Je viens de commencer à l'utiliser. Cela produit quelques faux positifs. Il y aura souvent des inclus inutiles dans les fichiers d’en-tête, mais cela ne vous dira pas qu’il faut une déclaration en aval de la classe associée et que l’inclusion doit être déplacé vers le fichier source associé.

Answer 5

Si vous utilisez Eclipse CDT, vous pouvez essayer Includator, qui est gratuit pour les bêta-testeurs (au moment de la rédaction de cet article) et supprime automatiquement les #includes superflues ou ajoute les éléments manquants.

Disclaimer: Je travaille pour la société qui développe Includator et l'utilise depuis quelques mois. Cela fonctionne assez bien pour moi, alors essayez-le :-)