¿Detecta # # superfluos en C / C ++?

A menudo encuentro que la sección de encabezados de un archivo se hace cada vez más grande, pero nunca se vuelve más pequeña. A lo largo de la vida de un archivo fuente, las clases pueden haberse movido y refactorizado y es muy posible que haya bastantes #includesque ya no necesiten estar allí. Dejarlos allí solo prolonga el tiempo de compilación y agrega dependencias de compilación innecesarias. Tratar de descubrir cuáles son todavía necesarios puede ser bastante tedioso.

¿Existe algún tipo de herramienta que pueda detectar directivas #incluidas superfluas y sugerir cuáles puedo eliminar con seguridad?
¿Pelusa hace esto quizás?

No es automático, pero doxygen producirá diagramas de dependencia para los #includedarchivos. Tendrá que revisarlos visualmente, pero pueden ser muy útiles para obtener una imagen de qué está usando qué.

El cppclean de Google (enlaces a: descarga , documentación ) puede encontrar varias categorías de problemas de C ++, y ahora puede encontrar #incluidos superfluos.

También hay una herramienta basada en Clang, que incluye lo que usa , que puede hacer esto. include-what-you-use puede incluso sugerir declaraciones reenviadas (para que no tenga que #incluir demasiado) y, opcionalmente, limpiar sus #include por usted.

Las versiones actuales de Eclipse CDT también tienen esta funcionalidad incorporada: ir al menú Fuente y hacer clic en Organizar incluye ordenará alfabéticamente sus # inclusiones, agregará los encabezados que Eclipse cree que está usando sin incluirlos directamente y comentará los encabezados que no No creo que necesites. Sin embargo, esta característica no es 100% confiable.

También revisa include-what-you-use , que resuelve un problema similar.

El problema con la detección de superfluos incluye es que no puede ser solo un verificador de dependencia de tipo. Una inclusión superflua es un archivo que no aporta nada de valor a la compilación y no altera otro elemento del que dependen otros archivos. Hay muchas formas en que un archivo de encabezado puede alterar una compilación, por ejemplo, definiendo una constante, redefiniendo y / o eliminando una macro usada, agregando un espacio de nombre que altera la búsqueda de un nombre en algún momento. Para detectar elementos como el espacio de nombres, necesita mucho más que un preprocesador, de hecho, casi necesita un compilador completo.

Lint es más un corrector de estilo y ciertamente no tendrá esta capacidad completa.

Creo que encontrará la única forma de detectar una inclusión superflua es eliminar, compilar y ejecutar suites.

Pensé que PCLint haría esto, pero han pasado algunos años desde que lo vi. Deberías revisarlo.

Miré este blog y el autor habló un poco sobre la configuración de PCLint para encontrar las inclusiones no utilizadas. Podría valer la pena echarle un vistazo.

El navegador de refactorización CScout puede detectar directivas de inclusión superfluas en código C (desafortunadamente no C ++). Puede encontrar una descripción de cómo funciona en este artículo de la revista.

Puede escribir una secuencia de comandos rápida que borre una sola directiva #include, compile los proyectos y registre el nombre en #include y el archivo del que se eliminó en caso de que no ocurrieran errores de compilación.

Deje que se ejecute durante la noche, y al día siguiente tendrá una lista 100% correcta de archivos de inclusión que puede eliminar.

A veces la fuerza bruta simplemente funciona :-)

editar: y a veces no :-). Aquí hay un poco de información de los comentarios:

1. A veces puede eliminar dos archivos de encabezado por separado, pero no ambos juntos. Una solución es eliminar los archivos de encabezado durante la ejecución y no recuperarlos. Esto encontrará una lista de archivos que puede eliminar de forma segura, aunque puede haber una solución con más archivos para eliminar que este algoritmo no encontrará. (es una búsqueda ambiciosa en el espacio de archivos de inclusión para eliminar. Solo encontrará un máximo local)
2. Puede haber cambios sutiles en el comportamiento si tiene algunas macros redefinidas de manera diferente dependiendo de algunos #ifdefs. Creo que estos son casos muy raros, y las pruebas unitarias que forman parte de la construcción deberían detectar estos cambios.

Lamento (re) publicar aquí, la gente a menudo no expande los comentarios.

Consulte mi comentario en crashmstr, FlexeLint / PC-Lint lo hará por usted. Mensaje informativo 766. La Sección 11.8.1 de mi manual (versión 8.0) discute esto.

Además, y esto es importante, siga iterando hasta que el mensaje desaparezca . En otras palabras, después de eliminar los encabezados no utilizados, vuelva a ejecutar la pelusa, es posible que se hayan "innecesario" más archivos de encabezado una vez que elimine algunos encabezados innecesarios. (Eso puede sonar tonto, léelo lentamente y analícelo, tiene sentido).

Nunca he encontrado una herramienta completa que logre lo que estás pidiendo. Lo más parecido que he usado es IncludeManager , que representa gráficamente el árbol de inclusión de encabezado para que pueda detectar visualmente cosas como encabezados incluidos en un solo archivo e inclusiones de encabezado circular.

Intenté usar Flexelint (la versión unix de PC-Lint) y obtuve resultados algo mixtos. Esto es probable porque estoy trabajando en una base de código muy grande y nudosa. Recomiendo examinar cuidadosamente cada archivo que se informa como no utilizado.

La principal preocupación son los falsos positivos. Múltiples inclusiones del mismo encabezado se informan como un encabezado innecesario. Esto es malo ya que Flexelint no le dice en qué línea se incluye el encabezado o dónde se incluyó antes.

Una de las formas en que las herramientas automatizadas pueden equivocarse:

En A.hpp:

class A { 
  // ...
};

En B.hpp:

#include "A.hpp

class B {
    public:
        A foo;
};

En C.cpp:

#include "C.hpp"  

#include "B.hpp"  // <-- Unneeded, but lint reports it as needed
#include "A.hpp"  // <-- Needed, but lint reports it as unneeded

Si sigue ciegamente los mensajes de Flexelint, acumulará sus # dependencias incluidas. Hay más casos patológicos, pero básicamente necesitará inspeccionar los encabezados usted mismo para obtener mejores resultados.

Recomiendo este artículo sobre Estructura física y C ++ del blog Juegos desde dentro. Recomiendan un enfoque integral para limpiar el desorden #include:

Pautas

Aquí hay un conjunto de pautas destiladas del libro de Lakos que minimizan la cantidad de dependencias físicas entre archivos. Los he estado usando durante años y siempre he estado muy contento con los resultados.

1. Cada archivo cpp incluye su propio archivo de encabezado primero. [recorte]
2. Un archivo de encabezado debe incluir todos los archivos de encabezado necesarios para analizarlo. [recorte]
3. Un archivo de encabezado debe tener el número mínimo de archivos de encabezado necesarios para analizarlo. [recorte]

Si está utilizando Eclipse CDT, puede probar http://includator.com, que es gratuito para los probadores beta (en el momento de escribir este artículo) y elimina automáticamente #incluidos superfluos o agrega los que faltan. Para aquellos usuarios que tienen FlexeLint o PC-Lint y están usando Elicpse CDT, http://linticator.com podría ser una opción (también gratuita para la prueba beta). Si bien utiliza el análisis de Lint, proporciona soluciones rápidas para eliminar automáticamente las declaraciones superincluidas #include.

Este artículo explica una técnica de eliminación #include mediante el análisis de Doxygen. Eso es solo un script perl, por lo que es bastante fácil de usar.

Tal vez un poco tarde, pero una vez encontré un script perl de WebKit que hacía exactamente lo que querías. Creo que necesitará un poco de adaptación (no estoy muy versado en perl), pero debería ser el truco:

http://trac.webkit.org/browser/branches/old/safari-3-2-branch/WebKitTools/Scripts/find-extra-includes

(esta es una rama vieja porque el tronco ya no tiene el archivo)

Hay una herramienta gratuita que incluye el Observador de dependencias de archivos que se puede integrar en el estudio visual. Muestra superfluos #incluye en rojo.

Hay dos tipos de archivos #include superfluos:

1. En realidad, el módulo no necesita un archivo de encabezado (.c, .cpp)
2. El módulo necesita un archivo de encabezado, pero se incluye más de una vez, directa o indirectamente.

Hay 2 formas en mi experiencia que funcionan bien para detectarlo:

• gcc -H o cl.exe / showincludes (resuelve el problema 2)

  En el mundo real, puede exportar CFLAGS = -H antes de hacer, si todos los Makefile no anulan las opciones de CFLAGS. O como solía, puede crear un contenedor cc / g ++ para agregar opciones -H a la fuerza a cada invocación de $ (CC) y $ (CXX). y anteponga el directorio del contenedor a la variable $ PATH, entonces su make utilizará su comando de contenedor en su lugar. Por supuesto, su contenedor debe invocar el compilador gcc real. Estos trucos deben cambiar si su Makefile usa gcc directamente. en lugar de $ (CC) o $ (CXX) o por reglas implícitas.

  También puede compilar un solo archivo ajustando con la línea de comando. Pero si quieres limpiar los encabezados de todo el proyecto. Puede capturar toda la salida de la siguiente manera:

  hacer limpia

  hacer 2> y 1 | tee result.txt

• PC-Lint / FlexeLint (resuelva el problema tanto 1 como 2)

  asegúrese de agregar las opciones + e766, esta advertencia trata sobre: ​​archivos de encabezado no utilizados.

  pclint / flint -vf ...

  Esto hará que la salida de pclint incluya archivos de encabezado, los archivos de encabezado anidados se sangrarán adecuadamente.

Para finalizar esta discusión: el preprocesador de c ++ se está completando. Es una propiedad semántica, si una inclusión es superflua. Por lo tanto, del teorema de Rice se deduce que es indecidible si una inclusión es superflua o no. NO PUEDE haber un programa que (siempre correctamente) detecte si una inclusión es superflua.

Aquí hay una forma simple de fuerza bruta de identificar encabezado superfluo incluye . No es perfecto, pero elimina los "obvios" innecesarios incluye. Deshacerse de estos ayuda mucho a limpiar el código.

Se puede acceder a los scripts directamente en GitHub.

PC Lint de Gimpel Software puede informar sobre cuándo un archivo de inclusión se ha incluido más de una vez en una unidad de compilación , pero no puede encontrar archivos de inclusión que no sean necesarios de la manera que está buscando.

Editar: puede. Ver la respuesta de itsmatt

CLion , el IDE de C / C ++ de JetBrains, detecta los redundantes incluidos de fábrica . Estos están en gris en el editor, pero también hay funciones para optimizar las inclusiones en el archivo actual o en todo el proyecto .

Sin embargo, he descubierto que paga por esta funcionalidad; CLion tarda un tiempo en escanear y analizar su proyecto cuando se carga por primera vez.