Explicit and implicit class declarations

Even if a class has no explicit constructor, pygccxml will provide a constructor declaration. This is due to CastXML and GCC-XML generating implicit constructors (for example copy constructors) in their XML output. The same thing holds for assignment operators and destructors.

To be able to discriminate between the different types of declarations, the decl.is_artificial attribute can be used.

Let’s consider the following c++ file (example.hpp):

namespace ns{
    class Test {
       public:
         Test();  // This is the constructor
    };
}

In this example, the constructor is explicitly defined. The declaration tree will contain two constructors. The first one is the one we defined explicitly, and is not marked as artificial. The second one is the copy constructor, which was implicitly added, and is marked as artificial.

from pygccxml import utils
from pygccxml import declarations
from pygccxml import parser

# Find out the c++ parser
generator_path, generator_name = utils.find_xml_generator()

# Configure the xml generator
xml_generator_config = parser.xml_generator_configuration_t(
    xml_generator_path=generator_path,
    xml_generator=generator_name)

# The c++ file we want to parse
filename = "example.hpp"

decls = parser.parse([filename], xml_generator_config)
global_namespace = declarations.get_global_namespace(decls)
ns = global_namespace.namespace("ns")

# We have just one declaration in ns, which is our Test class:
classTest = ns.declarations[0]
print(classTest.name, type(classTest))
# > 'Test', <class 'pygccxml.declarations.class_declaration.class_t'

# Loop over the two constructors:
for constructor in classTest.constructors():
    print(str(constructor), constructor.is_artificial)
# > ns::Test::Test() [constructor], False
# > ns::Test::Test(ns::Test const & arg0) [constructor], True