C++ srcML
Language Element | Elements | Subelements |
---|---|---|
FIXME: Not sorted! | ||
Array Access | <name> | <name>, <index> |
Function Call | <call> | <name>, <argument_list>, <argument> |
Member Access | <expr> | <name>, <op:operator> |
Dereference Member Access | <expr> | <name>, <op:operator> |
sizeof | <sizeof> | <argument_list>, <argument> |
Cast | <op:operator> | <name> |
Variable Declaration | <decl> | <init> |
Variable Declaration Statement | <decl_stmt> | |
const | <specifier> | |
const Funciton | <specifier> | |
extern Block | <extern> | <lit:literal>, <block> |
extern Specifier | <specifier> | <lit:literal>, <decl_stmt>, <function_stmt>, <block> |
auto Specifier | <specifier> | |
auto Type | <name> | |
static | <specifier> | |
typedef | <typedef> | <type>, <name>, <function_decl> |
register | <name> | |
restrict | <specifier> | |
volatile | <specifier> | |
inline | <specifier> | |
struct Definition | <struct> | <name>, <super> |
struct Declaration | <struct_decl> | |
Bitfield | <range> | <lit:literal>, <name> |
struct Varaiable Initialization | <decl_stmt> | <decl>, <init>, <block> |
union Declaration | <union_decl> | <name> |
union Definition | <union> | <name>, <block> |
enum Declaration | <enum> | <name>, <block> |
Array Declaration | <decl> | <name>, <index> |
Array Declaration Initialization | <init> | <block> |
Pointer Declaration | <type:modifier> | |
Function Declaration | <function_decl> | <name>, <parameter_list>, <param> |
Function Definition | <function> | <name>, <parameter_list>, <param> |
Function Call | <call> | <name>, <argument_list>, <argument> |
break | <break> | |
Block | <block> | |
continue Statement | <continue> | |
do while Statement | <do> | <block>, <condition> |
for Statement | <for> | <init>, <condition>, <incr>, <block> |
goto Statement | <goto> | <name> |
Label Statement | <label> | <name> |
if Statement | <if> | <else>, <elseif>, <condition>, <block>, <then> |
Empty Statement | <empty_stmt> | |
return | <return> | |
switch Statements | <switch> | <case>, <condition>, <block> |
case Statements | <case> | <expr> |
while Statement | <while> | <condition>, <block> |
new | <op:operator> | |
Reference Declaration | <type:modifier> | |
static_cast | <call> | <argument_list>, <argument> |
dynamic_cast | <call> | <argument_list>, <argument> |
reinterpret_cast | <call> | <argument_list>, <argument> |
delete | <op:operator> | |
typeid | <call> | <argument_list>, <argument> |
noexcept | <noexcept> | <argument_list>, <argument> |
alignof | <alignof> | <argument_list>, <argument> |
constexpr | <specifier> | |
alignas | <alignas> | <argument_list>, <argument> |
namespace | <namespace> | <name>, <block> |
thread_local | <specifier> | |
decltype | <decltype> | <argument_list>, <argument> |
Type Aliasing | <using> | |
Attribute | <attribute> | <expr> |
Initialization with an initialization_list | <call> | <block> |
Default Function Arguments | <init> | <expr> |
RValue Reference | <type:modifier> | |
Lamda Expression | <lambda> | <parameter_list>, <param>, <capture>, <argument>, <block> |
throw | <throw> | <expr> |
try | <try> | <block>, <catch> |
catch | <catch> | <parameter_list>, <param> |
Function try-catch | <try> | <catch>, <block>, <member_list> |
Variadic Type Modifier | <type:modifier> | |
final | <specifier> | |
override | <specifier> | |
class | <class> | <name> |
class Declaration | <class_decl> | <name> |
Constructor | <constructor> | <name>, <parameter_list>, <param>, <member_list>, <block> |
Constructor Declaration | <constructor_decl> | <name>, <parameter_list>, <param>, <member_list>, <block> |
Destructor | <destructor> | <name> |
Destructor Declaration | <destructor_decl> | <name> |
friend | <specifier> | |
using | <using> | <name> |
static_assert | <call> | <argument_list>, <argument> |
virtual | <specifier> | |
Abstract Function | <lit:literal type="number"> | |
this | <name> | |
Deleted Function | <specifier> | |
Default Function Implementation | <specifier> | |
Operator Overloading Declaration | <function_decl> | <name>, <parameter_list>, <parm> |
Operator Overloading Definition | <function> | <name>, <parameter_list>, <parm> |
Implicit Conversion Operator Definition | <function> | <name>, <parameter_list>, <parm> |
Implicit Conversion Operator Declaration | <function> | <name>, <parameter_list>, <parm> |
Explicit Conversion Operator Declaration | <function_decl> | <specifier>, <name>, <parameter_list>, <parm> |
Explicit Conversion Operator Definition | <function> | <specifier>, <name>, <parameter_list>, <parm> |
explict | <specifier> | |
template | <template> | <parameter_list>, <parameter>, <typename> |
template Specifier | <specifier> | <parameter_list>, <parameter>, <typename> |
Template Parameters | <parameter_list> | <param> |
enum class | <enum> | |
Default public Visibility | <public type="default"> | |
public Visibility | <public> | |
Default private Visibility | <private type="default"> | |
private Visibility | <private> | |
protected Visibility | <protected> | |
protected Inheritance Specifier | <specifier> | |
private Inheritance Specifier | <specifier> | |
public Inheritance Specifier | <specifier> | |
Inheritance List | <super> | <name> |
Operators | ||
operators | <op:operator> |
Array Access
Element
- <name>
SubElements
- <name>
- <index>
Example
a = x[5];
val = matrix[x][y];
<expr_stmt><expr><name>a</name> <op:operator>=</op:operator> <name><name>x</name><index>[<expr><lit:literal type="number">5</lit:literal></expr>]</index></name></expr>;</expr_stmt>
<expr_stmt><expr><name>val</name> <op:operator>=</op:operator> <name><name>matrix</name><index>[<expr><name>x</name></expr>]</index><index>[<expr><name>y</name></expr>]</index></name></expr>;</expr_stmt>
Function Call
Element
- <call>
SubElements
- <name>
- <argument_list>
- <argument>
Examples
Typical Function Call
int x = atoi("50");
<decl_stmt><decl><type><name>int</name></type> <name>x</name> <init>= <expr><call><name>atoi</name><argument_list>(<argument><expr><lit:literal type="string">"50"</lit:literal></expr></argument>)</argument_list></call></expr></init></decl>;</decl_stmt>
Explicit Operator Call
x = operator new(NewCapacityInBytes);
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <call><name>operator new</name><argument_list>(<argument><expr><name>NewCapacityInBytes</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
Member Access
Element
- <expr>
SubElements
- <name>
-
<op:operator>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --operator
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Example
t.tm_sec;
<expr_stmt><expr><name><name>t</name><op:operator>.</op:operator><name>tm_sec</name></name></expr>;</expr_stmt>
Dereference Member Access
Element
- <expr>
SubElements
- <name>
-
<op:operator>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --operator
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Example
t->tm_sec;
<expr_stmt><expr><name><name>t</name><op:operator>-></op:operator><name>tm_sec</name></name></expr>;</expr_stmt>
sizeof
Element
- <sizeof>
SubElements
- <argument_list>
- <argument>
Examples
1
sizeof(struct type);
<expr_stmt><expr><sizeof>sizeof<argument_list>(<argument>struct <expr><name>type</name></expr></argument>)</argument_list></sizeof></expr>;</expr_stmt>
2
sizeof...(Args);
<expr_stmt><expr><sizeof>sizeof...<argument_list>(<argument><expr><name>Args</name></expr></argument>)</argument_list></sizeof></expr>;</expr_stmt>
Cast
Element
-
<op:operator>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --operator
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
SubElement
- <name>
Example
double x = 0.0;
int y = (int)x;
<decl_stmt><decl><type><name>double</name></type> <name>x</name> <init>= <expr><lit:literal type="number">0.0</lit:literal></expr></init></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>y</name> <init>= <expr><op:operator>(</op:operator><name>int</name><op:operator>)</op:operator><name>x</name></expr></init></decl>;</decl_stmt>
Variable Declaration
Element
- <decl>
SubElement
-
<init>
- Only used when variable is initialized at declaration. See initialization examples for more details.
Examples
A Trivial Example
int x;
<decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>
struct, union and enum declarations
struct X y;
union X y;
enum X y;
<decl_stmt><decl><type>struct <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>union <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>enum <name>X</name></type> <name>y</name></decl>;</decl_stmt>
Variable Declaration Statement
Element
- <decl_stmt>
Examples
A Trivial Example
int x;
<decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>
struct, union and enum declarations
struct X y;
union X y;
enum X y;
<decl_stmt><decl><type>struct <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>union <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>enum <name>X</name></type> <name>y</name></decl>;</decl_stmt>
const
Element
- <specifier>
Examples
1
const int x;
const X y;
<decl_stmt><decl><type><specifier>const</specifier> <name>int</name></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><specifier>const</specifier> <name>X</name></type> <name>y</name></decl>;</decl_stmt>
2
int const x;
X const y;
<decl_stmt><decl><type><name>int</name> <specifier>const</specifier></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>X</name> <specifier>const</specifier></type> <name>y</name></decl>;</decl_stmt>
const Funciton
Element
- <specifier>
Example
int foo() const;
<function_decl><type><name>int</name></type> <name>foo</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>
extern Block
Element
- <extern>
SubElements
-
<lit:literal>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --literal
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- <block>
Example
Extern Block with Linkage Specifier
extern "C" { }
<extern>extern <lit:literal type="string">"C"</lit:literal> <block>{ }</block></extern>
extern Specifier
Element
- <specifier>
SubElements
-
<lit:literal>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --literal
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- <decl_stmt>
- <function_stmt>
- <block>
Examples
External Variable
extern int X;
<decl_stmt><decl><type><specifier>extern</specifier> <name>int</name></type> <name>X</name></decl>;</decl_stmt>
External Structure
extern struct Z X;
<decl_stmt><decl><type><specifier>extern</specifier> struct <name>Z</name></type> <name>X</name></decl>;</decl_stmt>
External Function
extern void foo();
<function_decl><type><specifier>extern</specifier> <name>void</name></type> <name>foo</name><parameter_list>()</parameter_list>;</function_decl>
External Function with Linkage Specifier
extern "C" void foo();
<extern>extern <lit:literal type="string">"C"</lit:literal> <function_decl><type><name>void</name></type> <name>foo</name><parameter_list>()</parameter_list>;</function_decl></extern>
Extern Structure with Linkage Specifier
extern "C" struct Z X;
<extern>extern <lit:literal type="string">"C"</lit:literal> <decl_stmt><decl><type>struct <name>Z</name></type> <name>X</name></decl>;</decl_stmt></extern>
Extern Variable with Linkage Specifier
extern "C" int X;
<extern>extern <lit:literal type="string">"C"</lit:literal> <decl_stmt><decl><type><name>int</name></type> <name>X</name></decl>;</decl_stmt></extern>
auto Specifier
Element
- <specifier>
Example
auto int x;
<decl_stmt><decl><type><specifier>auto</specifier> <name>int</name></type> <name>x</name></decl>;</decl_stmt>
auto Type
Element
- <name>
Examples
1
auto temp() -> int { }
<function><type><name>auto</name></type> <name>temp</name><parameter_list>()</parameter_list> -> <type><name>int</name></type> <block>{ }</block></function>
2
auto i = 5;
<decl_stmt><decl><type><name>auto</name></type> <name>i</name> <init>= <expr><lit:literal type="number">5</lit:literal></expr></init></decl>;</decl_stmt>
static
Element
- <specifier>
Examples
1
static int x;
<decl_stmt><decl><type><specifier>static</specifier> <name>int</name></type> <name>x</name></decl>;</decl_stmt>
2
static void foo();
<function_decl><type><specifier>static</specifier> <name>void</name></type> <name>foo</name><parameter_list>()</parameter_list>;</function_decl>
typedef
Element
- <typedef>
SubElements
- <type>
- <name>
- <function_decl>
Examples
1
typedef char C;
typedef unsigned int WORD;
typedef char * pChar;
typedef char field [50];
typedef char field, *field2;
<typedef>typedef <type><name>char</name></type> <name>C</name>;</typedef>
<typedef>typedef <type><name>unsigned</name> <name>int</name></type> <name>WORD</name>;</typedef>
<typedef>typedef <type><name>char</name> <type:modifier>*</type:modifier></type> <name>pChar</name>;</typedef>
<typedef>typedef <type><name>char</name></type> <name><name>field</name> <index>[<expr><lit:literal type="number">50</lit:literal></expr>]</index></name>;</typedef>
<typedef>typedef <type><name>char</name></type> <name>field</name><op:operator>,</op:operator> <type:modifier>*</type:modifier><name>field2</name>;</typedef>
2
typedef struct club
{
char name[30];
int size, year;
} GROUP;
<typedef>typedef <type><struct>struct <name>club</name>
<block>{<public type="default">
<decl_stmt><decl><type><name>char</name></type> <name><name>name</name><index>[<expr><lit:literal type="number">30</lit:literal></expr>]</index></name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>size</name></decl><op:operator>,</op:operator> <name>year</name>;</decl_stmt>
</public>}</block></struct></type> <name>GROUP</name>;</typedef>
3
typedef void DRAWF( int, int );
<typedef>typedef <function_decl><type><name>void</name></type> <name>DRAWF</name><parameter_list>( <param><decl><type><name>int</name></type></decl></param>, <param><decl><type><name>int</name></type></decl></param> )</parameter_list>;</function_decl></typedef>
4
typedef void (*DRAWF)( int, int );
<typedef>typedef <function_decl><type><name>void</name></type> (<type:modifier>*</type:modifier><name>DRAWF</name>)<parameter_list>( <param><decl><type><name>int</name></type></decl></param>, <param><decl><type><name>int</name></type></decl></param> )</parameter_list>;</function_decl></typedef>
register
Element
- <name>
Example
register int x;
register float y;
<decl_stmt><decl><type><name>register</name> <name>int</name></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>register</name> <name>float</name></type> <name>y</name></decl>;</decl_stmt>
restrict
Element
- <specifier>
Example
restrict double* x;
restrict union Z* x;
<decl_stmt><decl><type><specifier>restrict</specifier> <name>double</name><type:modifier>*</type:modifier></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><specifier>restrict</specifier> union <name>Z</name><type:modifier>*</type:modifier></type> <name>x</name></decl>;</decl_stmt>
volatile
Element
- <specifier>
Example
volatile int foo;
int volatile foo;
<decl_stmt><decl><type><specifier>volatile</specifier> <name>int</name></type> <name>foo</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name> <specifier>volatile</specifier></type> <name>foo</name></decl>;</decl_stmt>
inline
Element
- <specifier>
Examples
1
inline void swapValues(int* a,int* b);
<function_decl><type><specifier>inline</specifier> <name>void</name></type> <name>swapValues</name><parameter_list>(<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>a</name></decl></param>,<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>b</name></decl></param>)</parameter_list>;</function_decl>
2
inline namespace ns { }
<namespace><specifier>inline</specifier> namespace <name>ns</name> <block>{ }</block></namespace>
struct Definition
See Class for more examples.
Element
- <struct>
SubElements
- <name>
- <super>
Examples
Trivial Declaration
struct a {
int x;
double y;
float z;
};
<struct>struct <name>a</name> <block>{<public type="default">
<decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>double</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>float</name></type> <name>z</name></decl>;</decl_stmt>
</public>}</block>;</struct>
Variable Of An Anonymous Struct Type
struct
{
int x;
int y;
} mystruct;
<struct>struct
<block>{<public type="default">
<decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>y</name></decl>;</decl_stmt>
</public>}</block> <decl><name>mystruct</name></decl>;</struct>
Declaring A Struct And Instance
struct employee
{
char name[20];
int id;
long class;
} temp;
<struct>struct <name>employee</name>
<block>{<public type="default">
<decl_stmt><decl><type><name>char</name></type> <name><name>name</name><index>[<expr><lit:literal type="number">20</lit:literal></expr>]</index></name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>id</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>long</name></type> <name>class</name></decl>;</decl_stmt>
</public>}</block> <decl><name>temp</name></decl>;</struct>
struct Declaration
Element
- <struct_decl>
Example
Forward Declaration
struct employee;
<struct_decl>struct <name>employee</name>;</struct_decl>
Bitfield
Element
- <range>
SubElements
-
<lit:literal>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --literal
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- <name>
Example
struct mybitfields
{
int a : 5;
} test;
<struct>struct <name>mybitfields</name>
<block>{<public type="default">
<decl_stmt><decl><type><name>int</name></type> <name>a</name> <range>: <expr><lit:literal type="number">5</lit:literal></expr></range></decl>;</decl_stmt>
</public>}</block> <decl><name>test</name></decl>;</struct>
struct Varaiable Initialization
Element
- <decl_stmt>
SubElements
- <decl>
- <init>
- <block>
Examples
1
MY_TYPE a = { false, 234, 1.234 };
<decl_stmt><decl><type><name>MY_TYPE</name></type> <name>a</name> <init>= <expr><block>{ <expr><lit:literal type="boolean">false</lit:literal></expr>, <expr><lit:literal type="number">234</lit:literal></expr>, <expr><lit:literal type="number">1.234</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>
2
MY_TYPE b = (MY_TYPE) { false, 234, 1.234 };
<decl_stmt><decl><type><name>MY_TYPE</name></type> <name>b</name> <init>= <expr><op:operator>(</op:operator><name>MY_TYPE</name><op:operator>)</op:operator> <block>{ <expr><lit:literal type="boolean">false</lit:literal></expr>, <expr><lit:literal type="number">234</lit:literal></expr>, <expr><lit:literal type="number">1.234</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>
3
MY_TYPE c = { .flag = true, .value = 123, .stuff = 0.456 };
<decl_stmt><decl><type><name>MY_TYPE</name></type> <name>c</name> <init>= <expr><block>{ <expr><op:operator>.</op:operator><name>flag</name> <op:operator>=</op:operator> <lit:literal type="boolean">true</lit:literal></expr>, <expr><op:operator>.</op:operator><name>value</name> <op:operator>=</op:operator> <lit:literal type="number">123</lit:literal></expr>, <expr><op:operator>.</op:operator><name>stuff</name> <op:operator>=</op:operator> <lit:literal type="number">0.456</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>
union Declaration
Element
- <union_decl>
SubElement
- <name>
Example
union X;
<union_decl>union <name>X</name>;</union_decl>
union Definition
Element
- <union>
SubElements
- <name>
- <block>
Example
union sign
{
int svar;
unsigned uvar;
} number;
<union>union <name>sign</name>
<block>{<public type="default">
<decl_stmt><decl><type><name>int</name></type> <name>svar</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>unsigned</name></type> <name>uvar</name></decl>;</decl_stmt>
</public>}</block> <decl><name>number</name></decl>;</union>
enum Declaration
Element
- <enum>
SubElements
- <name>
- <block>
Examples
1
enum DAY {
sunday = 0,
monday,
tuesday,
wednesday,
thursday,
friday,
saturday,
};
<enum>enum <name>DAY</name> <block>{
<decl><name>sunday</name> <init>= <expr><lit:literal type="number">0</lit:literal></expr></init></decl><op:operator>,</op:operator>
<decl><name>monday</name></decl><op:operator>,</op:operator>
<decl><name>tuesday</name></decl><op:operator>,</op:operator>
<decl><name>wednesday</name></decl><op:operator>,</op:operator>
<decl><name>thursday</name></decl><op:operator>,</op:operator>
<decl><name>friday</name></decl><op:operator>,</op:operator>
<decl><name>saturday</name></decl><op:operator>,</op:operator>
}</block>;</enum>
2
enum DAY;
<enum>enum <name>DAY</name>;</enum>
3
enum { yes, no } response;
<enum>enum <block>{ <decl><name>yes</name></decl><op:operator>,</op:operator> <decl><name>no</name></decl> }</block> <decl><name>response</name></decl>;</enum>
Array Declaration
Element
- <decl>
SubElements
- <name>
- <index>
Examples
1
char A[2];
<decl_stmt><decl><type><name>char</name></type> <name><name>A</name><index>[<expr><lit:literal type="number">2</lit:literal></expr>]</index></name></decl>;</decl_stmt>
2
float matrix[10][15];
<decl_stmt><decl><type><name>float</name></type> <name><name>matrix</name><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index><index>[<expr><lit:literal type="number">15</lit:literal></expr>]</index></name></decl>;</decl_stmt>
3
struct {
float x, y;
} complex[100];
<struct>struct <block>{<public type="default">
<decl_stmt><decl><type><name>float</name></type> <name>x</name></decl><op:operator>,</op:operator> <decl><type ref="prev"/><name>y</name></decl>;</decl_stmt>
</public>}</block> <decl><name><name>complex</name><index>[<expr><lit:literal type="number">100</lit:literal></expr>]</index></name></decl>;</struct>
4
extern char *name[];
<decl_stmt><decl><type><specifier>extern</specifier> <name>char</name> <type:modifier>*</type:modifier></type><name><name>name</name><index>[]</index></name></decl>;</decl_stmt>
Array Declaration Initialization
Element
- <init>
SubElement
- <block>
Examples
1
int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
<decl_stmt><decl><type><name>int</name></type> <name><name>myArray</name><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index></name> <init>= <expr><block>{ <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>
2
int a[6] = { [4] = 29, [2] = 15 };
<decl_stmt><decl><type><name>int</name></type> <name><name>a</name><index>[<expr><lit:literal type="number">6</lit:literal></expr>]</index></name> <init>= <expr><block>{ <expr><index>[<expr><lit:literal type="number">4</lit:literal></expr>]</index> <op:operator>=</op:operator> <lit:literal type="number">29</lit:literal></expr>, <expr><index>[<expr><lit:literal type="number">2</lit:literal></expr>]</index> <op:operator>=</op:operator> <lit:literal type="number">15</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>
Pointer Declaration
Element
-
<type:modifier>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --modifier
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Examples
1
char *message;
<decl_stmt><decl><type><name>char</name> <type:modifier>*</type:modifier></type><name>message</name></decl>;</decl_stmt>
2
int *pointers[10];
<decl_stmt><decl><type><name>int</name> <type:modifier>*</type:modifier></type><name><name>pointers</name><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index></name></decl>;</decl_stmt>
3
int (*pointer)[10];
<expr_stmt><expr><call><name>int</name> <argument_list>(<argument><expr><op:operator>*</op:operator><name>pointer</name></expr></argument>)</argument_list></call><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index></expr>;</expr_stmt>
4
int const *x;
<decl_stmt><decl><type><name>int</name> <specifier>const</specifier> <type:modifier>*</type:modifier></type><name>x</name></decl>;</decl_stmt>
5
int(*X)(void);
int(*X)(int, float);
int(*X)(char const*,...);
<function_decl><type><name>int</name></type>(<type:modifier>*</type:modifier><name>X</name>)<parameter_list>(<param><decl><type><name>void</name></type></decl></param>)</parameter_list>;</function_decl>
<function_decl><type><name>int</name></type>(<type:modifier>*</type:modifier><name>X</name>)<parameter_list>(<param><decl><type><name>int</name></type></decl></param>, <param><decl><type><name>float</name></type></decl></param>)</parameter_list>;</function_decl>
<function_decl><type><name>int</name></type>(<type:modifier>*</type:modifier><name>X</name>)<parameter_list>(<param><decl><type><name>char</name> <specifier>const</specifier><type:modifier>*</type:modifier></type></decl></param>,<param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list>;</function_decl>
6
int volatile *const z = &some_object;
<decl_stmt><decl><type><name>int</name> <specifier>volatile</specifier> <type:modifier>*</type:modifier><specifier>const</specifier></type> <name>z</name> <init>= <expr><op:operator>&</op:operator><name>some_object</name></expr></init></decl>;</decl_stmt>
7
int *const volatile w = &some_object;
<decl_stmt><decl><type><name>int</name> <type:modifier>*</type:modifier><specifier>const</specifier> <specifier>volatile</specifier></type> <name>w</name> <init>= <expr><op:operator>&</op:operator><name>some_object</name></expr></init></decl>;</decl_stmt>
Function Declaration
Element
- <function_decl>
SubElements
- <name>
- <parameter_list>
- <param>
Examples
1
struct STUDENT sortstu( STUDENT a, STUDENT b );
void print(STUDENT a);
<function_decl><type>struct <name>STUDENT</name></type> <name>sortstu</name><parameter_list>( <param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>, <param><decl><type><name>STUDENT</name></type> <name>b</name></decl></param> )</parameter_list>;</function_decl>
<function_decl><type><name>void</name></type> <name>print</name><parameter_list>(<param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>)</parameter_list>;</function_decl>
2
void foo (int a[]);
<function_decl><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name></type> <name><name>a</name><index>[]</index></name></decl></param>)</parameter_list>;</function_decl>
3
void foo (int* a);
<function_decl><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>a</name></decl></param>)</parameter_list>;</function_decl>
4
int add_multiple_values (int number, ...);
<function_decl><type><name>int</name></type> <name>add_multiple_values</name> <parameter_list>(<param><decl><type><name>int</name></type> <name>number</name></decl></param>, <param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list>;</function_decl>
5
int func(a, b, c)
int a;
int b;
int c;
{ }
<function_decl><type><name>int</name></type> <name>func</name><parameter_list>(<param><decl><type><name>a</name></type></decl></param>, <param><decl><type><name>b</name></type></decl></param>, <param><decl><type><name>c</name></type></decl></param>)</parameter_list>
<decl_stmt><decl><type><name>int</name></type> <name>a</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>b</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>c</name></decl>;</decl_stmt>
<block>{ }</block></function_decl>
6
auto temp() -> int;
<function_decl><type><name>auto</name></type> <name>temp</name><parameter_list>()</parameter_list> -> <type><name>int</name></type>;</function_decl>
Function Definition
Element
- <function>
SubElements
- <name>
- <parameter_list>
- <param>
Examples
1
struct STUDENT sortstu( STUDENT a, STUDENT b ) {
struct STUDENT x;
return x;
}
<function><type>struct <name>STUDENT</name></type> <name>sortstu</name><parameter_list>( <param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>, <param><decl><type><name>STUDENT</name></type> <name>b</name></decl></param> )</parameter_list> <block>{
<decl_stmt><decl><type>struct <name>STUDENT</name></type> <name>x</name></decl>;</decl_stmt>
<return>return <expr><name>x</name></expr>;</return>
}</block></function>
2
void print(STUDENT a) { }
<function><type><name>void</name></type> <name>print</name><parameter_list>(<param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>)</parameter_list> <block>{ }</block></function>
3
void foo (int a[]) { }
<function><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name></type> <name><name>a</name><index>[]</index></name></decl></param>)</parameter_list> <block>{ }</block></function>
4
void foo (int* a) { }
<function><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>a</name></decl></param>)</parameter_list> <block>{ }</block></function>
5
int add_multiple_values (int number, ...) { }
<function><type><name>int</name></type> <name>add_multiple_values</name> <parameter_list>(<param><decl><type><name>int</name></type> <name>number</name></decl></param>, <param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{ }</block></function>
6
auto temp() -> int { }
<function><type><name>auto</name></type> <name>temp</name><parameter_list>()</parameter_list> -> <type><name>int</name></type> <block>{ }</block></function>
Function Call
Element
- <call>
SubElements
- <name>
- <argument_list>
- <argument>
Example
foo(x, y, z);
<expr_stmt><expr><call><name>foo</name><argument_list>(<argument><expr><name>x</name></expr></argument>, <argument><expr><name>y</name></expr></argument>, <argument><expr><name>z</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
break
Element
- <break>
Example
char c;
for(;;) {
printf_s( "\nPress any key, Q to quit: " );
// Convert to character value
scanf_s("%c", &c);
if (c == 'Q')
break;
}
<decl_stmt><decl><type><name>char</name></type> <name>c</name></decl>;</decl_stmt>
<for>for(<init>;</init><condition>;</condition><incr/>) <block>{
<expr_stmt><expr><call><name>printf_s</name><argument_list>( <argument><expr><lit:literal type="string">"\nPress any key, Q to quit: "</lit:literal></expr></argument> )</argument_list></call></expr>;</expr_stmt>
<comment type="line">// Convert to character value</comment>
<expr_stmt><expr><call><name>scanf_s</name><argument_list>(<argument><expr><lit:literal type="string">"%c"</lit:literal></expr></argument>, <argument><expr><op:operator>&</op:operator><name>c</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
<if>if <condition>(<expr><name>c</name> <op:operator>==</op:operator> <lit:literal type="char">'Q'</lit:literal></expr>)</condition><then>
<break>break;</break></then></if>
}</block></for>
Block
Element
- <block>
Example
{
line[i] = x;
x++;
i--;
}
<block>{
<expr_stmt><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <op:operator>=</op:operator> <name>x</name></expr>;</expr_stmt>
<expr_stmt><expr><name>x</name><op:operator>++</op:operator></expr>;</expr_stmt>
<expr_stmt><expr><name>i</name><op:operator>--</op:operator></expr>;</expr_stmt>
}</block>
continue Statement
Element
- <continue>
Example
while ( i-- > 0 )
{
x = f( i );
if ( x == 1 ) {
continue;
}
y += x * x;
}
<while>while <condition>( <expr><name>i</name><op:operator>--</op:operator> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition>
<block>{
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <call><name>f</name><argument_list>( <argument><expr><name>i</name></expr></argument> )</argument_list></call></expr>;</expr_stmt>
<if>if <condition>( <expr><name>x</name> <op:operator>==</op:operator> <lit:literal type="number">1</lit:literal></expr> )</condition><then> <block>{
<continue>continue;</continue>
}</block></then></if>
<expr_stmt><expr><name>y</name> <op:operator>+=</op:operator> <name>x</name> <op:operator>*</op:operator> <name>x</name></expr>;</expr_stmt>
}</block></while>
do while Statement
Element
- <do>
SubElements
- <block>
- <condition>
Examples
1
do {
y = f( x );
x--;
} while ( x > 0 );
<do>do <block>{
<expr_stmt><expr><name>y</name> <op:operator>=</op:operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr>;</expr_stmt>
<expr_stmt><expr><name>x</name><op:operator>--</op:operator></expr>;</expr_stmt>
}</block> while <condition>( <expr><name>x</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition>;</do>
2
do x--; while ( x > 0 );
<do>do <expr_stmt><expr><name>x</name><op:operator>--</op:operator></expr>;</expr_stmt> while <condition>( <expr><name>x</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition>;</do>
for Statement
Element
- <for>
SubElements
- <init>
- <condition>
- <incr>
- <block>
Examples
1
for( ;; ) { }
<for>for( <init>;</init><condition>;</condition> <incr/>) <block>{ }</block></for>
2
for (i = 0; i < max; i++ )
{
if ( line[i] == ' ' )
{
space++;
}
if ( line[i] == '\t' )
{
tab++;
}
}
<for>for (<init><expr><name>i</name> <op:operator>=</op:operator> <lit:literal type="number">0</lit:literal></expr>;</init> <condition><expr><name>i</name> <op:operator><</op:operator> <name>max</name></expr>;</condition> <incr><expr><name>i</name><op:operator>++</op:operator></expr></incr> )
<block>{
<if>if <condition>( <expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <op:operator>==</op:operator> <lit:literal type="char">' '</lit:literal></expr> )</condition><then>
<block>{
<expr_stmt><expr><name>space</name><op:operator>++</op:operator></expr>;</expr_stmt>
}</block></then></if>
<if>if <condition>( <expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <op:operator>==</op:operator> <lit:literal type="char">'\t'</lit:literal></expr> )</condition><then>
<block>{
<expr_stmt><expr><name>tab</name><op:operator>++</op:operator></expr>;</expr_stmt>
}</block></then></if>
}</block></for>
3
for(int i =0; i < 10;++i)
a += x[i];
<for>for(<init><decl><type><name>int</name></type> <name>i</name> <init>=<expr><lit:literal type="number">0</lit:literal></expr></init></decl>;</init> <condition><expr><name>i</name> <op:operator><</op:operator> <lit:literal type="number">10</lit:literal></expr>;</condition><incr><expr><op:operator>++</op:operator><name>i</name></expr></incr>)
<expr_stmt><expr><name>a</name> <op:operator>+=</op:operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt></for>
4
for (int i : v)
std::cout << i << ' ';
<for>for (<init><decl><type><name>int</name></type> <name>i</name> <range>: <expr><name>v</name></expr></range></decl></init>)
<expr_stmt><expr><name><name>std</name><op:operator>::</op:operator><name>cout</name></name> <op:operator><<</op:operator> <name>i</name> <op:operator><<</op:operator> <lit:literal type="char">' '</lit:literal></expr>;</expr_stmt></for>
goto Statement
Element
- <goto>
SubElement
- <name>
Example
goto stop;
<goto>goto <name>stop</name>;</goto>
Label Statement
Element
- <label>
SubElement
- <name>
Example
stop:
<label><name>stop</name>:</label>
if Statement
Element
- <if>
SubElements
- <else>
- <elseif>
- <condition>
- <block>
- <then>
Examples
1
if(x > 5)
y+=4
<if>if<condition>(<expr><name>x</name> <op:operator>></op:operator> <lit:literal type="number">5</lit:literal></expr>)</condition><then>
<expr_stmt><expr><name>y</name><op:operator>+=</op:operator><lit:literal type="number">4</lit:literal></expr></expr_stmt></then></if>
2
if ( i > 0 ) {
y = x / i;
}
<if>if <condition>( <expr><name>i</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then> <block>{
<expr_stmt><expr><name>y</name> <op:operator>=</op:operator> <name>x</name> <op:operator>/</op:operator> <name>i</name></expr>;</expr_stmt>
}</block></then></if>
3
if ( i > 0 )
y = x / i;
else
{
x = i;
y = f( x );
}
<if>if <condition>( <expr><name>i</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then>
<expr_stmt><expr><name>y</name> <op:operator>=</op:operator> <name>x</name> <op:operator>/</op:operator> <name>i</name></expr>;</expr_stmt></then>
<else>else
<block>{
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>i</name></expr>;</expr_stmt>
<expr_stmt><expr><name>y</name> <op:operator>=</op:operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr>;</expr_stmt>
}</block></else></if>
4
if ( i > 0 ) /* Without braces */
if ( j > i )
x = j;
else
x = i;
<if>if <condition>( <expr><name>i</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then> <comment type="block">/* Without braces */</comment>
<if>if <condition>( <expr><name>j</name> <op:operator>></op:operator> <name>i</name></expr> )</condition><then>
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>j</name></expr>;</expr_stmt></then>
<else>else
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>i</name></expr>;</expr_stmt></else></if></then></if>
5
if ( i > 0 )
{ /* With braces */
if ( j > i )
x = j;
}
else
x = i;
<if>if <condition>( <expr><name>i</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then>
<block>{ <comment type="block">/* With braces */</comment>
<if>if <condition>( <expr><name>j</name> <op:operator>></op:operator> <name>i</name></expr> )</condition><then>
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>j</name></expr>;</expr_stmt></then></if>
}</block></then>
<else>else
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>i</name></expr>;</expr_stmt></else></if>
6
if ( i > 0 )
{
x = i;
}
else if( i < 0)
x = q;
else
x = j;
<if>if <condition>( <expr><name>i</name> <op:operator>></op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then>
<block>{
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>i</name></expr>;</expr_stmt>
}</block></then>
<elseif>else <if>if<condition>( <expr><name>i</name> <op:operator><</op:operator> <lit:literal type="number">0</lit:literal></expr>)</condition><then>
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>q</name></expr>;</expr_stmt></then></if></elseif>
<else>else
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>j</name></expr>;</expr_stmt></else></if>
Empty Statement
Element
- <empty_stmt>
Example
;
<empty_stmt>;</empty_stmt>
return
Element
- <return>
Examples
1
return( s * (long long)s );
<return>return<expr><op:operator>(</op:operator> <name>s</name> <op:operator>*</op:operator> <op:operator>(</op:operator><name>long</name> <name>long</name><op:operator>)</op:operator><name>s</name> <op:operator>)</op:operator></expr>;</return>
2
return;
<return>return;</return>
switch Statements
Element
- <switch>
SubElements
- <case>
- <condition>
- <block>
Examples
1
switch( c )
{
case 'A':
capa++;
case 'a':
lettera++;
default :
total++;
}
<switch>switch<condition>( <expr><name>c</name></expr> )</condition>
<block>{
<case>case <expr><lit:literal type="char">'A'</lit:literal></expr>:
<expr_stmt><expr><name>capa</name><op:operator>++</op:operator></expr>;</expr_stmt>
</case><case>case <expr><lit:literal type="char">'a'</lit:literal></expr>:
<expr_stmt><expr><name>lettera</name><op:operator>++</op:operator></expr>;</expr_stmt>
</case><default>default :
<expr_stmt><expr><name>total</name><op:operator>++</op:operator></expr>;</expr_stmt>
</default>}</block></switch>
2
switch( i )
{
case -1:
n++;
break;
case 0 :
z++;
break;
case 1 :
p++;
break;
}
<switch>switch<condition>( <expr><name>i</name></expr> )</condition>
<block>{
<case>case <expr><op:operator>-</op:operator><lit:literal type="number">1</lit:literal></expr>:
<expr_stmt><expr><name>n</name><op:operator>++</op:operator></expr>;</expr_stmt>
<break>break;</break>
</case><case>case <expr><lit:literal type="number">0</lit:literal></expr> :
<expr_stmt><expr><name>z</name><op:operator>++</op:operator></expr>;</expr_stmt>
<break>break;</break>
</case><case>case <expr><lit:literal type="number">1</lit:literal></expr> :
<expr_stmt><expr><name>p</name><op:operator>++</op:operator></expr>;</expr_stmt>
<break>break;</break>
</case>}</block></switch>
case Statements
Element
- <case>
SubElement
- <expr>
Example
case THREE:
<case>case <expr><name>THREE</name></expr>:</case>
while Statement
Element
- <while>
SubElements
- <condition>
- <block>
Example
while ( i >= 0 )
{
string1[i] = string2[i];
i--;
}
<while>while <condition>( <expr><name>i</name> <op:operator>>=</op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition>
<block>{
<expr_stmt><expr><name><name>string1</name><index>[<expr><name>i</name></expr>]</index></name> <op:operator>=</op:operator> <name><name>string2</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt>
<expr_stmt><expr><name>i</name><op:operator>--</op:operator></expr>;</expr_stmt>
}</block></while>
new
Element
-
<op:operator>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --operator
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Examples
Regular new
new foo();
<expr_stmt><expr><op:operator>new</op:operator> <call><name>foo</name><argument_list>()</argument_list></call></expr>;</expr_stmt>
Array new 1
new foo[5];
<expr_stmt><expr><op:operator>new</op:operator> <name><name>foo</name><index>[<expr><lit:literal type="number">5</lit:literal></expr>]</index></name></expr>;</expr_stmt>
Array new 2
new foo[5]();
<expr_stmt><expr><op:operator>new</op:operator> <name><name>foo</name><index>[<expr><lit:literal type="number">5</lit:literal></expr>]</index></name><op:operator>(</op:operator><op:operator>)</op:operator></expr>;</expr_stmt>
std::nothrow new
new (std::nothrow) char [50000000];
<expr_stmt><expr><op:operator>new</op:operator> <op:operator>(</op:operator><name><name>std</name><op:operator>::</op:operator><name>nothrow</name></name><op:operator>)</op:operator> <name><name>char</name> <index>[<expr><lit:literal type="number">50000000</lit:literal></expr>]</index></name></expr>;</expr_stmt>
Placement new
new (place) int;
<expr_stmt><expr><op:operator>new</op:operator> <op:operator>(</op:operator><name>place</name><op:operator>)</op:operator> <name>int</name></expr>;</expr_stmt>
Reference Declaration
Element
-
<type:modifier>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --modifier
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Example
int& x;
<decl_stmt><decl><type><name>int</name><type:modifier>&</type:modifier></type> <name>x</name></decl>;</decl_stmt>
static_cast
Element
- <call>
SubElements
- <argument_list>
- <argument>
Example
static_cast<node*>(ptr);
<expr_stmt><expr><call><name><name>static_cast</name><argument_list><<argument><expr><name>node</name><op:operator>*</op:operator></expr></argument>></argument_list></name><argument_list>(<argument><expr><name>ptr</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
dynamic_cast
Element
- <call>
SubElements
- <argument_list>
- <argument>
Example
dynamic_cast<Square*>(boxPtr);
<expr_stmt><expr><call><name><name>dynamic_cast</name><argument_list><<argument><expr><name>Square</name><op:operator>*</op:operator></expr></argument>></argument_list></name><argument_list>(<argument><expr><name>boxPtr</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
reinterpret_cast
Element
- <call>
SubElements
- <argument_list>
- <argument>
Example
reinterpret_cast<double>(number);
<expr_stmt><expr><call><name><name>reinterpret_cast</name><argument_list><<argument><expr><name>double</name></expr></argument>></argument_list></name><argument_list>(<argument><expr><name>number</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
delete
Element
-
<op:operator>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --operator
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Examples
Regular delete
delete x;
<expr_stmt><expr><op:operator>delete</op:operator> <name>x</name></expr>;</expr_stmt>
Array delete
delete [] x;
<expr_stmt><expr><op:operator>delete</op:operator> <index>[]</index> <name>x</name></expr>;</expr_stmt>
typeid
Element
- <call>
SubElements
- <argument_list>
- <argument>
Example
typeid(x);
<expr_stmt><expr><call><name>typeid</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
noexcept
Element
- <noexcept>
SubElements
- <argument_list>
- <argument>
Examples
1
noexcept (foo(x));
<expr_stmt><expr><noexcept>noexcept <argument_list>(<argument><expr><call><name>foo</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></argument>)</argument_list></noexcept></expr>;</expr_stmt>
2
void no_throw() noexcept { }
<function><type><name>void</name></type> <name>no_throw</name><parameter_list>()</parameter_list> <noexcept>noexcept</noexcept> <block>{ }</block></function>
alignof
Element
- <alignof>
SubElements
- <argument_list>
- <argument>
Example
alignof(T);
<expr_stmt><expr><alignof>alignof<argument_list>(<argument><expr><name>T</name></expr></argument>)</argument_list></alignof></expr>;</expr_stmt>
constexpr
Element
- <specifier>
Examples
1
constexpr const int* xp = addr(x);
<decl_stmt><decl><type><specifier>constexpr</specifier> <specifier>const</specifier> <name>int</name><type:modifier>*</type:modifier></type> <name>xp</name> <init>= <expr><call><name>addr</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></init></decl>;</decl_stmt>
2
constexpr const int* addr(const int& ir) { return &ir; }
<function><type><specifier>constexpr</specifier> <specifier>const</specifier> <name>int</name><type:modifier>*</type:modifier></type> <name>addr</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>int</name><type:modifier>&</type:modifier></type> <name>ir</name></decl></param>)</parameter_list> <block>{ <return>return <expr><op:operator>&</op:operator><name>ir</name></expr>;</return> }</block></function>
alignas
Element
- <alignas>
SubElements
- <argument_list>
- <argument>
Example
alignas(MyType);
<decl_stmt><decl><type><alignas>alignas<argument_list>(<argument><expr><name>MyType</name></expr></argument>)</argument_list></alignas></type></decl>;</decl_stmt>
namespace
Element
- <namespace>
SubElements
- <name>
- <block>
Examples
1
namespace ns { }
<namespace>namespace <name>ns</name> <block>{ }</block></namespace>
2
inline namespace ns { }
<namespace><specifier>inline</specifier> namespace <name>ns</name> <block>{ }</block></namespace>
3
namespace ns;
<namespace>namespace <name>ns</name>;</namespace>
4
using namespace ns;
<using>using namespace <name>ns</name>;</using>
5
namespace new_name = ns;
<namespace>namespace <name>new_name</name> = <name>ns</name>;</namespace>
6
namespace { }
<namespace>namespace <block>{ }</block></namespace>
thread_local
Element
- <specifier>
Example
thread_local int i;
<decl_stmt><decl><type><specifier>thread_local</specifier> <name>int</name></type> <name>i</name></decl>;</decl_stmt>
decltype
Element
- <decltype>
SubElements
- <argument_list>
- <argument>
Examples
1
decltype(int) i;
<decl_stmt><decl><type><decltype>decltype<argument_list>(<argument><expr><name>int</name></expr></argument>)</argument_list></decltype></type> <name>i</name></decl>;</decl_stmt>
2
decltype(int)
decltype<expr_stmt><expr><op:operator>(</op:operator><name>int</name><op:operator>)</op:operator></expr></expr_stmt>
Type Aliasing
Element
- <using>
Example
template<class T> using Vec = vector<T, Alloc<T>>;
<using><template>template<parameter_list><<param><type><name>class</name></type> <name>T</name></param>></parameter_list></template> using <name>Vec</name> <init>= <type><expr><name><name>vector</name><argument_list><<argument><expr><name>T</name></expr></argument>, <argument><expr><name><name>Alloc</name><argument_list><<argument><expr><name>T</name></expr></argument>></argument_list></name></expr></argument>></argument_list></name></expr></type></init>;</using>
Attribute
Element
- <attribute>
SubElement
- <expr>
Example
[[noreturn]] void std::exit() { }
<function><type><attribute>[[<expr><name>noreturn</name></expr>]]</attribute> <name>void</name></type> <name><name>std</name><op:operator>::</op:operator><name>exit</name></name><parameter_list>()</parameter_list> <block>{ }</block></function>
Initialization with an initialization_list
Element
- <call>
SubElement
- <block>
Example
T x{ arg };
<decl_stmt><decl><type><name>T</name></type> <name>x</name><argument_list>{ <argument><expr><name>arg</name></expr></argument> }</argument_list></decl>;</decl_stmt>
Default Function Arguments
Element
- <init>
SubElement
- <expr>
Example
void point(int x = 3, int y = 4);
<function_decl><type><name>void</name></type> <name>point</name><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name> <init>= <expr><lit:literal type="number">3</lit:literal></expr></init></decl></param>, <name>int</name> <name>y</name> <op:operator>=</op:operator> <lit:literal type="number">4</lit:literal>)</parameter_list>;</function_decl>
RValue Reference
Element
-
<type:modifier>
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --modifier
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Example
int&& x;
<decl_stmt><decl><type><name>int</name><type:modifier>&&</type:modifier></type> <name>x</name></decl>;</decl_stmt>
Lamda Expression
Element
- <lambda>
SubElements
- <parameter_list>
- <param>
- <capture>
- <argument>
- <block>
Examples
1
[](int x) { return 0;}
<expr_stmt><expr><lambda><capture>[]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt>
2
[] { return 0; }
<expr_stmt><expr><lambda><capture>[]</capture> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return> }</block></lambda></expr></expr_stmt>
3
[](int x) -> int { return 0;}
<expr_stmt><expr><lambda><capture>[]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> -> <type><name>int</name></type> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt>
4
[i](int x) { return i; }
<expr_stmt><expr><lambda><capture>[<argument><name>i</name></argument>]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><name>i</name></expr>;</return> }</block></lambda></expr></expr_stmt>
5
[=](int x) { return 0;}
<expr_stmt><expr><lambda><capture>[<argument><type:modifier>=</type:modifier></argument>]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt>
6
[&](int x) { return 0;}
<expr_stmt><expr><lambda><capture>[<argument><type:modifier>&</type:modifier></argument>]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt>
7
[=](int const& x) mutable { return 0;}
<expr_stmt><expr><lambda><capture>[<argument><type:modifier>=</type:modifier></argument>]</capture><parameter_list>(<param><decl><type><name>int</name> <specifier>const</specifier><type:modifier>&</type:modifier></type> <name>x</name></decl></param>)</parameter_list> <specifier>mutable</specifier> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt>
throw
Element
- <throw>
SubElement
- <expr>
Examples
1
throw;
<throw>throw;</throw>
2
throw std::runtime_error("msg");
<throw>throw <expr><call><name><name>std</name><op:operator>::</op:operator><name>runtime_error</name></name><argument_list>(<argument><expr><lit:literal type="string">"msg"</lit:literal></expr></argument>)</argument_list></call></expr>;</throw>
3
void f() throw(X, Y);
<function_decl><type><name>void</name></type> <name>f</name><parameter_list>()</parameter_list> <throw>throw<argument_list>(<argument><expr><name>X</name></expr></argument>, <argument><expr><name>Y</name></expr></argument>)</argument_list></throw>;</function_decl>
try
Element
- <try>
SubElements
- <block>
- <catch>
Example
try {
}
<try>try <block>{
}</block></try>
catch
Element
- <catch>
SubElements
- <parameter_list>
- <param>
Examples
1
try {
} catch(const std::exception& e) {
}
<try>try <block>{
}</block> <catch>catch<parameter_list>(<param><decl><type><specifier>const</specifier> <name><name>std</name><op:operator>::</op:operator><name>exception</name></name><type:modifier>&</type:modifier></type> <name>e</name></decl></param>)</parameter_list> <block>{
}</block></catch></try>
2
catch(...) {
}
<catch>catch<parameter_list>(<param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{
}</block></catch>
Function try-catch
Element
- <try>
SubElements
- <catch>
- <block>
- <member_list>
Examples
1
struct S {
S(const std::string& arg) try : m(arg) {
} catch(const std::exception& e) {
} // implicit throw; here
};
<struct>struct <name>S</name> <block>{<public type="default">
<constructor><name>S</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name><name>std</name><op:operator>::</op:operator><name>string</name></name><type:modifier>&</type:modifier></type> <name>arg</name></decl></param>)</parameter_list> <try>try <member_list>: <call><name>m</name><argument_list>(<argument><expr><name>arg</name></expr></argument>)</argument_list></call> </member_list><block>{
}</block> <catch>catch<parameter_list>(<param><decl><type><specifier>const</specifier> <name><name>std</name><op:operator>::</op:operator><name>exception</name></name><type:modifier>&</type:modifier></type> <name>e</name></decl></param>)</parameter_list> <block>{
}</block></catch></try></constructor> <comment type="line">// implicit throw; here</comment>
</public>}</block>;</struct>
2
int f(int n) try {
} catch(...) {
}
<function><type><name>int</name></type> <name>f</name><parameter_list>(<param><decl><type><name>int</name></type> <name>n</name></decl></param>)</parameter_list> <name>try</name> <block>{
}</block></function> <catch>catch<parameter_list>(<param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{
}</block></catch>
Variadic Type Modifier
Element
- <type:modifier>
Example
int x(f...);
<function_decl><type><name>int</name></type> <name>x</name><parameter_list>(<param><decl><type><name>f</name><type:modifier>...</type:modifier></type></decl></param>)</parameter_list>;</function_decl>
final
Element
- <specifier>
Examples
1
virtual void foo() final;
<function_decl><type><specifier>virtual</specifier> <name>void</name></type> <name>foo</name><parameter_list>()</parameter_list> <specifier>final</specifier>;</function_decl>
2
class X final { };
<class>class <name>X</name> <specifier>final</specifier> <block>{<private type="default"> </private>}</block>;</class>
override
Element
- <specifier>
Example
void foo() const override;
<function_decl><type><name>void</name></type> <name>foo</name><parameter_list>()</parameter_list> <specifier>const</specifier> <specifier>override</specifier>;</function_decl>
class
Element
- <class>
SubElement
- <name>
Examples
1
class Foo { };
<class>class <name>Foo</name> <block>{<private type="default"> </private>}</block>;</class>
2
class Foo;
<class_decl>class <name>Foo</name>;</class_decl>
3
class Foo
:public bar
{ };
<class>class <name>Foo</name>
<super>:<specifier>public</specifier> <name>bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>
4
class Foo {
public:
protected:
private:
};
<class>class <name>Foo</name> <block>{<private type="default">
</private><public>public:
</public><protected>protected:
</protected><private>private:
</private>}</block>;</class>
5
class Foo {
Foo() { }
};
<class>class <name>Foo</name> <block>{<private type="default">
<constructor><name>Foo</name><parameter_list>()</parameter_list> <block>{ }</block></constructor>
</private>}</block>;</class>
6
class Foo {
foo();
}
<class>class <name>Foo</name> <block>{<private type="default">
<constructor_decl><name>foo</name><parameter_list>()</parameter_list>;</constructor_decl>
</private>}</block><decl/></class>
7
class Foo {
~Foo() { }
};
<class>class <name>Foo</name> <block>{<private type="default">
<destructor><name>~<name>Foo</name></name><parameter_list>()</parameter_list> <block>{ }</block></destructor>
</private>}</block>;</class>
8
class Foo {
~Foo();
}
<class>class <name>Foo</name> <block>{<private type="default">
<destructor_decl><name>~<name>Foo</name></name><parameter_list>()</parameter_list>;</destructor_decl>
</private>}</block><decl/></class>
class Declaration
Element
- <class_decl>
SubElement
- <name>
Example
class Foo;
<class_decl>class <name>Foo</name>;</class_decl>
Constructor
Element
- <constructor>
SubElements
- <name>
- <parameter_list>
- <param>
- <member_list>
- <block>
Examples
1
class Foo{
Foo()
:x(5)
{ }
};
<class>class <name>Foo</name><block>{<private type="default">
<constructor><name>Foo</name><parameter_list>()</parameter_list>
<member_list>:<call><name>x</name><argument_list>(<argument><expr><lit:literal type="number">5</lit:literal></expr></argument>)</argument_list></call>
</member_list><block>{ }</block></constructor>
</private>}</block>;</class>
2
Foo::Foo()
:x(5)
{ }
<constructor><name><name>Foo</name><op:operator>::</op:operator><name>Foo</name></name><parameter_list>()</parameter_list>
<member_list>:<call><name>x</name><argument_list>(<argument><expr><lit:literal type="number">5</lit:literal></expr></argument>)</argument_list></call>
</member_list><block>{ }</block></constructor>
Constructor Declaration
Element
- <constructor_decl>
SubElements
- <name>
- <parameter_list>
- <param>
- <member_list>
- <block>
Example
class Foo {
Foo();
};
<class>class <name>Foo</name> <block>{<private type="default">
<constructor_decl><name>Foo</name><parameter_list>()</parameter_list>;</constructor_decl>
</private>}</block>;</class>
Destructor
Element
- <destructor>
SubElement
- <name>
Examples
1
class Foo {
~Foo() { }
};
<class>class <name>Foo</name> <block>{<private type="default">
<destructor><name>~<name>Foo</name></name><parameter_list>()</parameter_list> <block>{ }</block></destructor>
</private>}</block>;</class>
2
Foo::~Foo() { }
<destructor><name><name>Foo</name><op:operator>::</op:operator>~<name>Foo</name></name><parameter_list>()</parameter_list> <block>{ }</block></destructor>
Destructor Declaration
Element
- <destructor_decl>
SubElement
- <name>
Example
class Foo {
~Foo();
};
<class>class <name>Foo</name> <block>{<private type="default">
<destructor_decl><name>~<name>Foo</name></name><parameter_list>()</parameter_list>;</destructor_decl>
</private>}</block>;</class>
friend
Element
- <specifier>
Example
class Matrix {
friend Vector operator*(const Matrix&, const Vector&);
};
<class>class <name>Matrix</name> <block>{<private type="default">
<function_decl><type><specifier>friend</specifier> <name>Vector</name></type> <name>operator*</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>Matrix</name><type:modifier>&</type:modifier></type></decl></param>, <param><decl><type><specifier>const</specifier> <name>Vector</name><type:modifier>&</type:modifier></type></decl></param>)</parameter_list>;</function_decl>
</private>}</block>;</class>
using
Element
- <using>
SubElement
- <name>
Examples
1
using namespace std;
<using>using namespace <name>std</name>;</using>
2
using Base::reference;
<using>using <name><name>Base</name><op:operator>::</op:operator><name>reference</name></name>;</using>
static_assert
Element
- <call>
SubElements
- <argument_list>
- <argument>
Example
static_assert(cond, "msg");
<expr_stmt><expr><call><name>static_assert</name><argument_list>(<argument><expr><name>cond</name></expr></argument>, <argument><expr><lit:literal type="string">"msg"</lit:literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>
virtual
Element
- <specifier>
Example
virtual void dump() const;
<function_decl><type><specifier>virtual</specifier> <name>void</name></type> <name>dump</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>
Abstract Function
Element
-
<lit:literal type="number">
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- --literal
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Example
struct Foo {
virtual void dump() const = 0;
};
<struct>struct <name>Foo</name> <block>{<public type="default">
<function_decl><type><specifier>virtual</specifier> <name>void</name></type> <name>dump</name><parameter_list>()</parameter_list> <specifier>const</specifier> = <lit:literal type="number">0</lit:literal>;</function_decl>
</public>}</block>;</struct>
this
Element
- <name>
Example
this->x = 5;
<expr_stmt><expr><name><name>this</name><op:operator>-></op:operator><name>x</name></name> <op:operator>=</op:operator> <lit:literal type="number">5</lit:literal></expr>;</expr_stmt>
Deleted Function
Element
- <specifier>
Example
void dump() = delete;
<function_decl><type><name>void</name></type> <name>dump</name><parameter_list>()</parameter_list> = <specifier>delete</specifier>;</function_decl>
Default Function Implementation
Element
- <specifier>
Example
class Foo {
Foo() = default;
};
<class>class <name>Foo</name> <block>{<private type="default">
<constructor_decl><name>Foo</name><parameter_list>()</parameter_list> = <specifier>default</specifier>;</constructor_decl>
</private>}</block>;</class>
Operator Overloading Declaration
Element
- <function_decl>
SubElements
- <name>
- <parameter_list>
- <parm>
Example
Foo& operator=(Foo&& );
<function_decl><type><name>Foo</name><type:modifier>&</type:modifier></type> <name>operator=</name><parameter_list>(<param><decl><type><name>Foo</name><type:modifier>&&</type:modifier></type></decl></param> )</parameter_list>;</function_decl>
Operator Overloading Definition
Element
- <function>
SubElements
- <name>
- <parameter_list>
- <parm>
Example
bool operator==(Foo const&, Foo const& ) { }
<function><type><name>bool</name></type> <name>operator==</name><parameter_list>(<param><decl><type><name>Foo</name> <specifier>const</specifier><type:modifier>&</type:modifier></type></decl></param>, <param><decl><type><name>Foo</name> <specifier>const</specifier><type:modifier>&</type:modifier></type></decl></param> )</parameter_list> <block>{ }</block></function>
Implicit Conversion Operator Definition
Element
- <function>
SubElements
- <name>
- <parameter_list>
- <parm>
Example
operator Foo() const;
<function_decl><name>operator Foo</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>
Implicit Conversion Operator Declaration
Element
- <function>
SubElements
- <name>
- <parameter_list>
- <parm>
Example
operator Foo() const { return x->foo; }
<function><name>operator Foo</name><parameter_list>()</parameter_list> <specifier>const</specifier> <block>{ <return>return <expr><name><name>x</name><op:operator>-></op:operator><name>foo</name></name></expr>;</return> }</block></function>
Explicit Conversion Operator Declaration
Element
- <function_decl>
SubElements
- <specifier>
- <name>
- <parameter_list>
- <parm>
Example
explicit operator int*() const;
<function_decl><type><specifier>explicit</specifier></type> <name>operator int*</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>
Explicit Conversion Operator Definition
Element
- <function>
SubElements
- <specifier>
- <name>
- <parameter_list>
- <parm>
Example
explicit operator int*() const { return nullptr; }
<function><type><specifier>explicit</specifier></type> <name>operator int*</name><parameter_list>()</parameter_list> <specifier>const</specifier> <block>{ <return>return <expr><lit:literal type="null">nullptr</lit:literal></expr>;</return> }</block></function>
explict
Element
- <specifier>
Example
class Foo{
explicit Foo(X const& x);
};
<class>class <name>Foo</name><block>{<private type="default">
<constructor_decl><specifier>explicit</specifier> <name>Foo</name><parameter_list>(<param><decl><type><name>X</name> <specifier>const</specifier><type:modifier>&</type:modifier></type> <name>x</name></decl></param>)</parameter_list>;</constructor_decl>
</private>}</block>;</class>
template
Element
- <template>
SubElements
- <parameter_list>
- <parameter>
- <typename>
Examples
Templated Class
template<typename T>
class Foo {
};
<class><template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T</name></param>></parameter_list></template>
class <name>Foo</name> <block>{<private type="default">
</private>}</block>;</class>
Templated Function
template<typename T>
void swap(T& lhs, T& rhs);
<function_decl><template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T</name></param>></parameter_list></template>
<type><name>void</name></type> <name>swap</name><parameter_list>(<param><decl><type><name>T</name><type:modifier>&</type:modifier></type> <name>lhs</name></decl></param>, <param><decl><type><name>T</name><type:modifier>&</type:modifier></type> <name>rhs</name></decl></param>)</parameter_list>;</function_decl>
Partial Template Specialization
template<typename T>
class Foo<T, void>
{
};
<class><template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T</name></param>></parameter_list></template>
class <name><name>Foo</name><argument_list><<argument><expr><name>T</name></expr></argument>, <argument><expr><name>void</name></expr></argument>></argument_list></name>
<block>{<private type="default">
</private>}</block>;</class>
Template Member Function Template
template<typename T1>
template<typename T2>
int string<T1>::compare(const T2& s) { }
<function><template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T1</name></param>></parameter_list></template>
<template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T2</name></param>></parameter_list></template>
<type><name>int</name></type> <name><name><name>string</name><argument_list><<argument><expr><name>T1</name></expr></argument>></argument_list></name><op:operator>::</op:operator><name>compare</name></name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>T2</name><type:modifier>&</type:modifier></type> <name>s</name></decl></param>)</parameter_list> <block>{ }</block></function>
template Specifier
Element
- <specifier>
SubElements
- <parameter_list>
- <parameter>
- <typename>
Example
Template as a Specifier
typename t::template iterator<int>::value_type v;
<decl_stmt><decl><type><typename>typename</typename> <name><name>t</name><op:operator>::</op:operator><name><specifier>template</specifier> <name>iterator</name><argument_list><<argument><expr><name>int</name></expr></argument>></argument_list></name><op:operator>::</op:operator><name>value_type</name></name></type> <name>v</name></decl>;</decl_stmt>
Template Parameters
Element
- <parameter_list>
SubElement
- <param>
Examples
typename Parameter
template<typename T>
struct Foo { };
<struct><template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T</name></param>></parameter_list></template>
struct <name>Foo</name> <block>{<public type="default"> </public>}</block>;</struct>
class Parameter
template<class T>
struct Foo { };
<struct><template>template<parameter_list><<param><type><name>class</name></type> <name>T</name></param>></parameter_list></template>
struct <name>Foo</name> <block>{<public type="default"> </public>}</block>;</struct>
Default Template Parameter
template<typename T = Bar>
class Foo { };
<class><template>template<parameter_list><<param><type><typename>typename</typename></type> <name>T</name> <init>= <expr><name>Bar</name></expr></init></param>></parameter_list></template>
class <name>Foo</name> <block>{<private type="default"> </private>}</block>;</class>
Template Parameter Pack
template<class ... Types> struct Tuple {};
<struct><template>template<parameter_list><<param><type><name>class</name> <type:modifier>...</type:modifier></type> <name>Types</name></param>></parameter_list></template> struct <name>Tuple</name> <block>{<public type="default"/>}</block>;</struct>
Template Template Parameter
template<template<typename> class C>
class Foo { };
<class><template>template<parameter_list><<param><type><template>template<parameter_list><<param><type><typename>typename</typename></type></param>></parameter_list></template> <name>class</name></type> <name>C</name></param>></parameter_list></template>
class <name>Foo</name> <block>{<private type="default"> </private>}</block>;</class>
enum class
Element
- <enum>
Example
enum class Color {RED, GREEN, BLUE};
<enum>enum class <name>Color</name> <block>{<decl><name>RED</name></decl><op:operator>,</op:operator> <decl><name>GREEN</name></decl><op:operator>,</op:operator> <decl><name>BLUE</name></decl>}</block>;</enum>
Default public Visibility
Element
- <public type="default">
Example
struct Foo {
};
<struct>struct <name>Foo</name> <block>{<public type="default">
</public>}</block>;</struct>
public Visibility
Element
- <public>
Example
class Foo {
public:
};
<class>class <name>Foo</name> <block>{<private type="default">
</private><public>public:
</public>}</block>;</class>
Default private Visibility
Element
- <private type="default">
Example
class Foo
{
};
<class>class <name>Foo</name>
<block>{<private type="default">
</private>}</block>;</class>
private Visibility
Element
- <private>
Example
struct Foo {
private:
};
<struct>struct <name>Foo</name> <block>{<public type="default">
</public><private>private:
</private>}</block>;</struct>
protected Visibility
Element
- <protected>
Example
class Foo {
protected:
};
<class>class <name>Foo</name> <block>{<private type="default">
</private><protected>protected:
</protected>}</block>;</class>
protected Inheritance Specifier
Element
- <specifier>
Example
class Foo
:protected Bar
{ };
<class>class <name>Foo</name>
<super>:<specifier>protected</specifier> <name>Bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>
private Inheritance Specifier
Element
- <specifier>
Example
class Foo
:private Bar
{ };
<class>class <name>Foo</name>
<super>:<specifier>private</specifier> <name>Bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>
public Inheritance Specifier
Element
- <specifier>
Example
class Foo
:public Bar
{ };
<class>class <name>Foo</name>
<super>:<specifier>public</specifier> <name>Bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>
Inheritance List
Element
- <super>
SubElement
- <name>
Example
class Foo
:Bar1, OtherBar
{ };
<class>class <name>Foo</name>
<super>:<name>Bar1</name>, <name>OtherBar</name></super>
<block>{<private type="default"> </private>}</block>;</class>
Operators
Name | Operator | srcML |
---|---|---|
Pre Increment | ++ |
<op:operator>++</op:operator> |
Post Increment | ++ |
<op:operator>++</op:operator> |
Pre Decrement | -- |
<op:operator>--</op:operator> |
Post Decrement | -- |
<op:operator>--</op:operator> |
Address Of | & |
<op:operator>&</op:operator> |
Dereference | * |
<op:operator>*</op:operator> |
Unary Minus | - |
<op:operator>-</op:operator> |
Bitwise Not | ~ |
<op:operator>~</op:operator> |
Logical Not | ! |
<op:operator>!</op:operator> |
Multiplication | * |
<op:operator>*</op:operator> |
Division | / |
<op:operator>/</op:operator> |
Modulus | % |
<op:operator>%</op:operator> |
Addition | + |
<op:operator>+</op:operator> |
Subtraction | - |
<op:operator>-</op:operator> |
Left Shift | << |
<op:operator><<</op:operator> |
Right Shift | >> |
<op:operator>>></op:operator> |
Less Then | < |
<op:operator><</op:operator> |
Greater Then | > |
<op:operator>></op:operator> |
Less Then or Equal To | <= |
<op:operator><=</op:operator> |
Greater Then or Equal To | >= |
<op:operator>>=</op:operator> |
Equals | == |
<op:operator>==</op:operator> |
Not Equal | != |
<op:operator>!=</op:operator> |
Bitwise And | & |
<op:operator>&</op:operator> |
Bitwise XOr | ^ |
<op:operator>^</op:operator> |
Bitwise Or | | |
<op:operator>|</op:operator> |
Logical And | && |
<op:operator>&&</op:operator> |
Logical Or | || |
<op:operator>||</op:operator> |
Assignment | = |
<op:operator>=</op:operator> |
Multiply Assign | *= |
<op:operator>*=</op:operator> |
Divide Assign | /= |
<op:operator>/=</op:operator> |
Modulus Assign | %= |
<op:operator>%=</op:operator> |
Add Assign | += |
<op:operator>+=</op:operator> |
Subtract Assign | -= |
<op:operator>-=</op:operator> |
Left Shift Assign | <<= |
<op:operator><<=</op:operator> |
Right Shift Assign | >>= |
<op:operator>>>=</op:operator> |
Bitwise And Assign | &= |
<op:operator>&=</op:operator> |
Bitwise XOr Assign | ^= |
<op:operator>^=</op:operator> |
Bitwise Or Assign | |= |
<op:operator>|=</op:operator> |
Sceope | :: |
<op:operator>::</op:operator> |
Pointer To Member | .* |
<op:operator>.*</op:operator> |
Dereference Pointer To Member | ->* |
<op:operator>->*</op:operator> |
Comma | , |
<op:operator>,</op:operator> |
Conditional | ? : |
<op:operator>?</op:operator> <op:operator>:</op:operator>
|
Dot | . |
<op:operator>.</op:operator> |
Arrow | -> |
<op:operator>-></op:operator> |
NOTE: Operator mark up within srcML is not enabled by default and srcML must be run with the --operator command line option to enable it.