寻求可解析C++类信息至JSON/XML的工具或自动检测编译单元中类定义不一致的工具

Great question—this is a tricky but super common pitfall when dealing with macro-heavy C++ code. Let’s break down your options, starting with the easiest wins first, then moving to tools that can handle your custom parsing needs.

First: Use Compiler Warnings (Fastest Fix) #

You don’t need fancy tools to catch this—GCC and Clang both have a built-in warning specifically for this scenario: -Wmismatched-tags. When enabled, it’ll flag cases where the same class/struct/union has different definitions across compilation units (exactly the macro-induced issue you’re seeing).

To use it, just add the flag to your project’s compile settings:

• For CMake: add_compile_options(-Wmismatched-tags)
• For Makefiles: CXXFLAGS += -Wmismatched-tags

Recompile your entire project, and the compiler will point you straight to the mismatched class definitions. Pair this with -Wredundant-decls (also supported by both compilers) to catch redundant declarations that hint at inconsistencies.

Ready-Made Static Analysis Tools #

If you want more comprehensive detection beyond basic compiler warnings, these tools can help:

• Clang Static Analyzer: This tool integrates with your compile database (compile_commands.json) to deep-dive into your code. Run it with scan-build make (or scan-build cmake --build . for CMake projects) and it’ll generate a report highlighting class definition mismatches, among other issues.
• Cppcheck: A lightweight, open-source static analyzer that includes checks for mismatched class declarations and definitions. Run it with cppcheck --enable=style,performance your_project_dir to catch these inconsistencies without needing a full compile setup.

Tools to Parse C++ Classes into JSON/XML (For Custom Checks) #

If you still need to implement your third step—extracting class metadata for custom comparison—here are the best tools for the job:

CastXML #

CastXML is a Clang-based tool designed specifically to convert C/C++ code into structured XML (or JSON) output. It works seamlessly with compile databases, and its output includes all the details you need: class members, types, alignment, size, and more.

Example command (using your existing compile database):

# Generate XML for a single file
castxml -c -x c++ --castxml-gccxml -o class_info.xml your_source.cpp

You can then write a simple script (using Python’s lxml or json libraries) to parse these files and compare class structures across compilation units.

LibClang Python Bindings #

For full control over parsing, use the Python bindings for LibClang. This lets you write custom scripts to traverse the AST (Abstract Syntax Tree) of each compiled file, extract exactly the class metadata you care about, and dump it to JSON for comparison.

Here’s a quick snippet to get you started:

import clang.cindex
import json

# Initialize Clang index
index = clang.cindex.Index.create()
# Load your compile database
compilation_db = clang.cindex.CompilationDatabase.from_directory('.')

# Iterate over all files in the database
for src_file in compilation_db.get_files():
    # Get compile arguments for the file
    compile_args = compilation_db.get_compile_command(src_file)[0].arguments
    # Parse the file into an AST
    translation_unit = index.parse(src_file, args=compile_args)
    
    # Traverse the AST to find class definitions
    for node in translation_unit.cursor.walk_preorder():
        if node.kind == clang.cindex.CursorKind.CXX_RECORD_DECL:
            class_data = {
                "class_name": node.spelling,
                "size": node.type.get_size(),
                "alignment": node.type.get_alignment(),
                "members": []
            }
            # Extract class members
            for child in node.get_children():
                if child.kind == clang.cindex.CursorKind.FIELD_DECL:
                    class_data["members"].append({
                        "name": child.spelling,
                        "type": child.type.spelling
                    })
            # Save to JSON (or store in memory for later comparison)
            with open(f"{src_file}_class_info.json", 'w') as f:
                json.dump(class_data, f, indent=2)

Doxygen XML Output #

If you already use Doxygen for documentation, you can leverage its XML output. Enable the GENERATE_XML option in your Doxyfile, and Doxygen will generate detailed XML files containing class structures, members, and types. You can then parse these XML files with a script to compare class definitions across units. It’s not purpose-built for this, but it’s a great option if you’re already using Doxygen.

Final Recommendation #

Start with -Wmismatched-tags—it’s the fastest way to catch your immediate problem. If you need broader detection, use the Clang Static Analyzer. If you must build a custom checker, CastXML is the easiest out-of-the-box solution, while LibClang gives you full flexibility.

内容的提问来源于stack exchange，提问作者Vlad