กำลังตรวจจับ #includes ที่ฟุ่มเฟือยใน C / C ++?

ฉันมักจะพบว่าส่วนหัวของไฟล์มีขนาดใหญ่ขึ้นเรื่อย ๆ ตลอดเวลา แต่ก็ไม่เคยเล็กลง ตลอดอายุการใช้งานของคลาสไฟล์ต้นฉบับอาจมีการย้ายและถูกปรับโครงสร้างใหม่และเป็นไปได้มากที่มีจำนวนไม่มาก#includesที่ไม่จำเป็นต้องอยู่ที่นั่นอีกต่อไป ปล่อยให้พวกเขามีเพียงเวลาในการรวบรวมและเพิ่มการพึ่งพาการรวบรวมที่ไม่จำเป็น การพยายามคิดให้ได้ว่าอะไรที่ยังต้องการอยู่นั้นค่อนข้างน่าเบื่อ

มีเครื่องมือบางชนิดที่สามารถตรวจจับคำสั่ง #include ที่ฟุ่มเฟือยและแนะนำเครื่องมือที่ฉันสามารถลบได้อย่างปลอดภัยหรือไม่?
ผ้าสำลีทำสิ่งนี้ได้ไหม?

มันไม่อัตโนมัติ แต่doxygenจะสร้างไดอะแกรมการพึ่งพาสำหรับ#includedไฟล์ คุณจะต้องผ่านมันไปด้วยสายตา แต่มันจะมีประโยชน์มากสำหรับการถ่ายรูปสิ่งที่กำลังใช้

cppclean Google (เชื่อมโยงไปยัง: ดาวน์โหลด , เอกสาร ) สามารถค้นหาหลายประเภทของปัญหา C ++ และตอนนี้ก็สามารถหา #includes ฟุ่มเฟือย

นอกจากนี้ยังมีเครื่องมือที่ใช้เสียงดังกราวรวมถึงสิ่งที่คุณใช้ซึ่งสามารถทำได้ รวมถึงสิ่งที่คุณใช้งานยังสามารถแนะนำการประกาศล่วงหน้า (ดังนั้นคุณไม่ต้อง #include มาก) และเลือกที่จะล้าง #includes ให้คุณ

เวอร์ชันปัจจุบันของEclipse CDTยังมีฟังก์ชันนี้อยู่ภายใน: ไปที่เมนูแหล่งที่มาและการคลิกจัดระเบียบการรวมจะเรียงลำดับ # รวมของคุณตามตัวอักษรเพิ่มส่วนหัวใด ๆ ที่ Eclipse คิดว่าคุณกำลังใช้โดยไม่รวมถึงพวกเขาโดยตรง คิดว่าคุณต้องการ อย่างไรก็ตามคุณลักษณะนี้ไม่น่าเชื่อถือ 100%

นอกจากนี้ตรวจสอบรวมถึงสิ่งที่คุณใช้ซึ่งแก้ไขปัญหาที่คล้ายกัน

ปัญหาเกี่ยวกับการตรวจจับการรวมฟุ่มเฟือยคือมันไม่สามารถเป็นแค่ตัวตรวจสอบการพึ่งพาประเภท การรวมฟุ่มเฟือยเป็นไฟล์ที่ไม่มีค่าใด ๆ ในการรวบรวมและไม่เปลี่ยนแปลงรายการอื่นที่ไฟล์อื่น ๆ พึ่งพา มีหลายวิธีที่ไฟล์ส่วนหัวสามารถแก้ไขการคอมไพล์พูดโดยกำหนดค่าคงที่กำหนดใหม่และ / หรือลบมาโครที่ใช้แล้วเพิ่มเนมสเปซซึ่งจะเปลี่ยนแปลงการค้นหาชื่อในแบบลงบรรทัด ในการตรวจจับรายการเช่นเนมสเปซที่คุณต้องการมากกว่าตัวประมวลผลล่วงหน้าคุณอันที่จริงแล้วคุณต้องการคอมไพเลอร์แบบเต็ม

ผ้าสำลีเป็นเครื่องตรวจสอบสไตล์มากกว่าและแน่นอนว่าจะไม่มีความสามารถเต็มที่

ฉันคิดว่าคุณจะพบวิธีเดียวในการตรวจสอบการรวมฟุ่มเฟือยคือการลบรวบรวมและเรียกใช้ชุด

ฉันคิดว่าPCLintจะทำเช่นนี้ แต่ไม่กี่ปีที่ผ่านมาตั้งแต่ฉันได้ดู คุณอาจลองดู

ฉันดูที่บล็อกนี้และผู้เขียนพูดคุยเล็กน้อยเกี่ยวกับการกำหนดค่า PCLint เพื่อค้นหาสิ่งที่ไม่ได้ใช้ อาจจะคุ้มค่าดู

CScoutเบราว์เซอร์ refactoring สามารถตรวจสอบฟุ่มเฟือยรวมถึงแนวทางใน C (น่าเสียดายที่ไม่ C ++) รหัส คุณสามารถค้นหารายละเอียดของวิธีการทำงานในนี้บทความวารสาร

คุณสามารถเขียนสคริปต์ด่วนที่จะลบคำสั่ง #include เดียวคอมไพล์โปรเจ็กต์และบันทึกชื่อใน #include และไฟล์ที่ถูกลบออกจากในกรณีที่ไม่มีข้อผิดพลาดในการรวบรวมเกิดขึ้น

ปล่อยให้มันรันในตอนกลางคืนและในวันถัดไปคุณจะมีรายการรวม 100 ไฟล์ที่ถูกต้องซึ่งคุณสามารถลบได้

บางครั้งกำลังดุร้ายก็ใช้งานได้ :-)

แก้ไข:และบางครั้งก็ไม่ :-) นี่เป็นข้อมูลเล็กน้อยจากความคิดเห็น:

1. บางครั้งคุณสามารถลบไฟล์ส่วนหัวสองไฟล์แยกกัน แต่ไม่ใช่ทั้งสองอย่างพร้อมกัน ทางออกคือการลบไฟล์ส่วนหัวในระหว่างการทำงานและไม่นำพวกเขากลับมา นี่จะค้นหารายการไฟล์ที่คุณสามารถลบได้อย่างปลอดภัยแม้ว่าอาจมีวิธีแก้ไขที่มีไฟล์จำนวนมากที่จะลบซึ่งอัลกอริทึมนี้จะไม่พบ (เป็นการค้นหาโลภในพื้นที่รวมไฟล์ที่จะลบซึ่งจะค้นหาได้สูงสุดในเครื่องเท่านั้น)
2. อาจมีการเปลี่ยนแปลงเล็กน้อยในพฤติกรรมหากคุณมีมาโครบางตัวที่นิยามใหม่แตกต่างกันไปขึ้นอยู่กับ #ifdef บางตัว ฉันคิดว่าสิ่งเหล่านี้เป็นกรณีที่หายากมากและการทดสอบหน่วยซึ่งเป็นส่วนหนึ่งของโครงสร้างควรเป็นไปตามการเปลี่ยนแปลงเหล่านี้

ขออภัยที่ (อีกครั้ง) โพสต์ที่นี่คนมักจะไม่ขยายความคิดเห็น

ตรวจสอบความคิดเห็นของฉันเพื่อ crashmstr, FlexeLint / PC-Lint จะทำเพื่อคุณ ข้อความแสดงข้อมูล 766 ส่วน 11.8.1 ของคู่มือของฉัน (เวอร์ชัน 8.0) กล่าวถึงเรื่องนี้

นอกจากนี้และนี่เป็นสิ่งที่สำคัญให้ iterating จนกว่าจะมีข้อความออกไป กล่าวอีกนัยหนึ่งหลังจากลบส่วนหัวที่ไม่ได้ใช้ให้เรียกใช้ขุยใหม่ไฟล์ส่วนหัวอื่น ๆ อาจกลายเป็น "ไม่จำเป็น" เมื่อคุณลบส่วนหัวที่ไม่ต้องการออก (นั่นอาจฟังดูตลกอ่านช้าๆและแยกวิเคราะห์มันสมเหตุสมผล)

ฉันไม่เคยพบเครื่องมือที่สมบูรณ์แบบที่จะบรรลุสิ่งที่คุณต้องการ สิ่งที่ฉันใช้มากที่สุดคือIncludeManagerซึ่งทำกราฟแผนภูมิการรวมส่วนหัวของคุณเพื่อให้คุณสามารถมองเห็นสิ่งต่าง ๆ เช่นส่วนหัวที่รวมอยู่ในไฟล์เดียวและการรวมส่วนหัวแบบวงกลม

ฉันลองใช้ Flexelint (PC-Lint เวอร์ชั่น unix) และได้ผลลัพธ์ที่ค่อนข้างหลากหลาย อาจเป็นเพราะฉันกำลังทำงานบนฐานรหัสที่มีขนาดใหญ่และมีปมมาก ฉันขอแนะนำให้ตรวจสอบแต่ละไฟล์ที่รายงานว่าไม่ได้ใช้อย่างระมัดระวัง

ความกังวลหลักคือผลบวกผิด ๆ การรวมหลายส่วนของส่วนหัวเดียวกันถูกรายงานว่าเป็นส่วนหัวที่ไม่จำเป็น สิ่งนี้ไม่ดีเนื่องจาก Flexelint ไม่ได้บอกคุณว่าส่วนหัวของบรรทัดนั้นรวมอยู่ที่ใดหรือรวมอยู่ที่ไหนก่อน

หนึ่งในวิธีที่เครื่องมืออัตโนมัติอาจผิด:

ใน A.hpp:

class A { 
  // ...
};

ใน B.hpp:

#include "A.hpp

class B {
    public:
        A foo;
};

ใน 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

หากคุณติดตามข้อความจาก Flexelint อย่างสุ่มตัวอย่างคุณจะทำลาย #include การพึ่งพาของคุณ มีกรณีทางพยาธิวิทยามากขึ้น แต่โดยทั่วไปคุณจะต้องตรวจสอบส่วนหัวของคุณเองเพื่อผลลัพธ์ที่ดีที่สุด

ฉันขอแนะนำบทความเกี่ยวกับโครงสร้างทางกายภาพและ C ++จากบล็อกเกมจากภายใน พวกเขาแนะนำวิธีการที่ครอบคลุมในการทำความสะอาด #include:

แนวทาง

นี่คือชุดแนวทางที่กลั่นจากหนังสือของ Lakos ที่ลดจำนวนการพึ่งพาทางกายภาพระหว่างไฟล์ต่างๆ ฉันใช้มันมาหลายปีแล้วและฉันก็มีความสุขกับผลลัพธ์ที่ได้เสมอ

1. ไฟล์ cpp ทุกไฟล์จะมีไฟล์ส่วนหัวของตัวเองก่อน [snip]
2. ไฟล์ส่วนหัวจะต้องมีไฟล์ส่วนหัวทั้งหมดที่จำเป็นในการแยกมัน [snip]
3. ไฟล์ส่วนหัวควรมีจำนวนไฟล์ขั้นต่ำเปล่าที่จำเป็นในการแยกวิเคราะห์ [snip]

หากคุณใช้ Eclipse CDT คุณสามารถลองhttp://includator.comซึ่งฟรีสำหรับผู้ทดสอบเบต้า (ในขณะที่เขียนนี้) และลบ #includes ที่ไม่จำเป็นออกโดยอัตโนมัติหรือเพิ่มสิ่งที่ขาดหายไป สำหรับผู้ใช้ที่มี FlexeLint หรือ PC-Lint และใช้ Elicpse CDT, http://linticator.comอาจเป็นตัวเลือก (ฟรีสำหรับการทดสอบเบต้า) แม้ว่ามันจะใช้การวิเคราะห์ของ Lint แต่ก็มีการแก้ไขอย่างรวดเร็วเพื่อลบคำสั่ง #include ที่ไม่จำเป็นออกโดยอัตโนมัติ

บทความนี้อธิบายเทคนิคการ #include เอาโดยใช้การแยกวิเคราะห์ของ Doxygen นั่นเป็นเพียงสคริปต์ Perl ดังนั้นจึงค่อนข้างใช้งานง่าย

อาจจะสายไปหน่อย แต่ฉันเคยพบสคริปต์ของ WebKit ที่ทำในสิ่งที่คุณต้องการ มันจะต้องมีการปรับตัวบางอย่างที่ฉันเชื่อว่า (ฉันไม่รอบรู้ใน perl) แต่ควรทำเคล็ดลับ:

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

(นี่เป็นสาขาเก่าเพราะลำต้นไม่มีไฟล์อีกต่อไป)

มีเครื่องมือฟรีรวมถึงการอ้างอิงไฟล์ที่สามารถบูรณาการในสตูดิโอภาพ มันแสดง #includes ที่ฟุ่มเฟือยในสีแดง

มีไฟล์ #include ที่ฟุ่มเฟือยสองประเภท:

1. ไฟล์ส่วนหัวไม่จำเป็นจริง ๆ โดยโมดูล (.c, .cpp) เลย
2. โมดูลส่วนหัวต้องการโมดูล แต่มีการรวมมากกว่าหนึ่งครั้งไม่ว่าโดยตรงหรือโดยอ้อม

ประสบการณ์ของฉันมีสองวิธีที่ใช้งานได้ดีในการตรวจจับ:

• gcc -H หรือ cl.exe / showincludes (แก้ไขปัญหาที่ 2)

  ในโลกแห่งความจริงคุณสามารถส่งออก CFLAGS = -H ก่อนที่จะทำการถ้าตัวเลือก Makefile ไม่ได้แทนที่ตัวเลือก CFLAGS หรืออย่างที่ฉันเคยใช้คุณสามารถสร้างกระดาษห่อหุ้ม cc / g ++ เพื่อเพิ่มตัวเลือก -H บังคับให้เรียกใช้แต่ละ $ (CC) และ $ (CXX) และเพิ่มไดเรกทอรีของ wrapper ไปที่ตัวแปร $ PATH จากนั้น make ทั้งหมดของคุณจะใช้คำสั่ง wrapper แทน แน่นอน wrapper ของคุณควรเรียกใช้คอมไพเลอร์ gcc จริง เทคนิคนี้จำเป็นต้องเปลี่ยนหาก Makefile ของคุณใช้ gcc โดยตรง แทน $ (CC) หรือ $ (CXX) หรือตามกฎโดยนัย

  นอกจากนี้คุณยังสามารถรวบรวมไฟล์เดียวโดยปรับแต่งด้วยบรรทัดคำสั่ง แต่ถ้าคุณต้องการทำความสะอาดส่วนหัวสำหรับโครงการทั้งหมด คุณสามารถจับภาพเอาต์พุตทั้งหมดโดย:

  ทำความสะอาด

  ทำ 2> & 1 | ทีผลลัพธ์. txt

• PC-Lint / FlexeLint (แก้ไขปัญหาทั้ง 1 และ 2)

  ตรวจสอบให้แน่ใจว่าเพิ่มตัวเลือก + e766 คำเตือนนี้เกี่ยวกับ: ไฟล์ส่วนหัวที่ไม่ได้ใช้

  pclint / หิน -vf ...

  สิ่งนี้จะทำให้ pclint เอาต์พุตรวมไฟล์ส่วนหัวไฟล์ส่วนหัวที่ซ้อนกันจะถูกเยื้องอย่างเหมาะสม

หากต้องการสิ้นสุดการสนทนานี้: ตัวประมวลผลล่วงหน้า c ++ กำลังทำให้สมบูรณ์ มันเป็นคุณสมบัติความหมายไม่ว่าจะรวมถึงฟุ่มเฟือย ดังนั้นจึงเป็นไปตามทฤษฎีบทของไรซ์ว่าไม่สามารถบอกได้ว่าการรวมกันนั้นไม่จำเป็นหรือไม่ ไม่สามารถเป็นโปรแกรมได้ (ตรวจสอบว่าถูกต้องเสมอ) รวมอยู่หรือไม่

นี่คือการที่ง่ายวิธีการระบุส่วนหัวของฟุ่มเฟือยรวมถึงแรงเดรัจฉาน มันไม่สมบูรณ์แบบ แต่กำจัดสิ่งที่ไม่จำเป็น "ชัดเจน" ออกไป การกำจัดสิ่งเหล่านี้ไปไกลในการทำความสะอาดรหัส

สคริปต์สามารถเข้าถึงได้โดยตรงบน GitHub

PC Lintของ Gimpel Software สามารถรายงานเมื่อไฟล์รวมถูกรวมไว้มากกว่าหนึ่งครั้งในคอมไพล์ยูนิตแต่ไม่สามารถหาไฟล์ include ซึ่งไม่จำเป็นในแบบที่คุณต้องการ

แก้ไข:มันสามารถ ดูคำตอบของมันแมตต์

CLion , C / C ++ IDE จาก JetBrains ตรวจจับสิ่งที่ซ้ำซ้อนรวมถึงสิ่งที่ไม่ควรทำ เหล่านี้เป็นสีเทาออกในการแก้ไข แต่ยังมีฟังก์ชั่นเพื่อเพิ่มประสิทธิภาพรวมถึงในแฟ้มปัจจุบันหรือโครงการทั้งหมด

ฉันพบว่าคุณจ่ายสำหรับฟังก์ชั่นนี้ แต่; CLion ใช้เวลาสักครู่ในการสแกนและวิเคราะห์โครงการของคุณเมื่อโหลดครั้งแรก