Interpretation of source code by C++-to-UML transformations

By default, the transformation generates UML elements that have the same name and visibility as the source C++ elements. If the transformation cannot transform a C++ element, it ignores the element. The following table lists the output that the transformation generates when it transforms C++ code elements into UML model elements.

Global variables and global functions

The transformation does not transform global variables and global functions in the C++ code because these C++ elements cannot be represented in UML.

Preprocessor directives

The transformation does not transform preprocessor directives in the C++ code because these C++ elements cannot be represented in UML. You must specify user-defined preprocessor directives in the user-defined section in the C++ source files.

C++ template classes

If the source CDT project includes a template instantiation that instantiates a class that does not exist in the source CDT project, the transformation transforms the template instantiation into a UML primitive type. The transformation transforms the references to the template instantiation into the appropriate reference to the UML primitive type in the target model.

The following table lists how the C++-to-UML transformation transforms template classes when the template instantiation instantiates a class in the source project.

C++ template class	UML element
Template class definition	Parameterized class, if the template parameter is of type Class The transformation ignores all other template parameters, and also ignores partial template classes The following example demonstrates how the transformation transforms a template class definition into a UML parameterized class: template <class T=""> class stack { public: void push(T ob); T pop(); }; The transformation generates the following UML parameterized class:
Template class instantiation in a typedef definition	Class with the same name as the typedef declaration The transformation generates a binding relationship that points from the template class instantiation to the UML parameterized class; for example, the transformation transforms the typedef declaration typedef stack<A> myStackA; into the following UML class called myStackA, and creates a binding relationship to the stack class:
Template class instantiation not in a typedef definition	Class in the template instantiation folder of the target UML model The transformation generates a binding relationship that points from the template class instantiation to the UML parameterized class The UML class that the transformation generates in the template instantiation folder has the naming scheme shown in the diagram below, and corresponds to the template instantiation in the source C++ file The following example demonstrates how the transformation transforms a template class instantiation that is not in a typedef definition. class B { stack<A> stackA; }; The transformation generates the following UML class named stack_A, and generates a binding relationship to the stack class:

C++ member variables in a class, struct, or union

class Class2{
};

class Class3{
Class2 x1;
};

The example in the following table lists how the transformation sets the value of the UML Type property when the type of the C++ member variable references a type that is defined in a different C/C++ Development Tools (CDT) project.

#include "CDTProject1/Class1"
class Class2{
	Class1 x;
};

The following table lists additional information that the transformation generates for specific member variables.

C++ member functions in a class, struct, or union

The transformation transforms a C++ member function in a class, struct, or union into a UML operation in the corresponding UML class. The UML operation that the transformation generates has the same name and visibility as the C++ member function. The following table lists the additional information that the transformation generates for specific function parameters.

C++ function parameters

Type modifiers

C++ member variables, member functions, and parameters might specify type modifiers, such as pointers to types, reference types, and array types. These type modifiers cannot be represented in UML. The following table lists how the transformation transforms type modifiers.

Type modifier	Transformation output
Pointer to a C++ type	The transformation applies the «cpp_type» stereotype to the UML parameter or property that it generates, and sets the qualifier attribute to a pointer operator. Consider the following C++ code: class MyClass { private: char* name; }; The transformation generates a UML class named MyClass that contains a name variable with the following properties:
Reference to a C++ type	The transformation sets the qualifier attribute to a reference operator. The transformation only applies the «cpp_type» stereotype when it transforms multiple reference types in the source code. If the transformation transforms a C++ parameter that is a reference type, it sets the direction attribute of the UML parameter to inout. Consider the following C++ code: class MyClassClone { private: MyClassClone clone(MyClassClone& copy); }; The transformation generates a UML class named MyClassClone that contains a return parameter with the following properties:
Array	For a single-dimension array, the transformation sets the multiplicity of the UML parameter or property as equal to the value of the single dimension. The transformation only applies the «cpp_type» stereotype when it transforms multiple dimensional arrays in the source code. The following example shows how the transformation sets the multiplicity for an attribute of type int x[10]: The transformation sets the lower and upper bound of the multiplicity property to the value of the single dimension of the attribute.