Attribute

Node describing an "attribute" as it appeared in the source. For example:
int x __attribute__ ((unused)); // Declaration with an Attribute

Anchor
AttributeArgument AttributeArgument

Attribute Argument

Node describing the arguments of an attribute. For example:

void f() __attribute__ ((interrupt("IRQ"))); // Attribute Argument "interruptValue is "\"IRQ\""

If the argument of an attribute is an expression that is evaluated to a constant, the value of the attribute is that constant converted to a string. For example:

alignas(sizeof(int)*2) int g; // Value is "8" - when sizeof(int) equals 4

If the argument of an attribute is a type name, the attribute value is the full name of that type. For example:

alignas(long long) int g; // Value is "long long"

Attribute Group

Node describing an attribute group. For example:

void fx1() { /* ... */; }
void fx2() __attribute__((weak, alias("fx1")));// Both attributes have the same Attribute Group

Integer Constant

Constant integer expression. For example:

int i = 10; // Integer Constant, Value is 10

Real Constant

Constant expression that is a real number. For example:
double d = 34.75; // Real Constant, Representation is "34.75"

String Constant

Constant string expression. For example:

char *pc = "John Doe"; // String Constant, Value is "John Doe"

Template Parameter Constant

A constant template parameter in template class declaration. For example:

template <unsigned N> class Temp{}; // Template Parameter Constant: N

bool Constant

A constant value of true or false.

enum Constant

An enum identifier declared in body of enum declaration. For example:

enum E { A, B, C};    // enum Constant: A, B, C

nullptr constant

A pointer literal of type std::nullptr_t. ExampleFor example:

int* pi = nullptr; // nullptr constantbool b = (pi == nullptr); // nullptr constant= nullptr; // nullptr constant

bool b = (pi == nullptr); // nullptr constant

Imaginary Unit Constant

Macros that expand to constant expression of type const float _Complex, with the value of the imaginary unit. For example:

#include <complex.h>
void f1( void )
{
  I;            // Imaginary Unit Constant
  _Complex_I;   // Imaginary Unit Constant
}

Complex

Non-primitive types. This category contains the following types:

Array

Array type. For example:

char buf[1024];   
      // buf is Variable of Type Array or Type char.

Builtin

Non-primitive type builtin for a given compiler.

Class

User-defined class type. For example:

class Foo { }; // class

Anchor
Decltype Decltype

Decltype

Type defined with the decltype specifier. For example:

int i;
decltype(i) k;            // k is Variable of Type Decltype to Type int.

Enum

User-defined enum type. For example:

enum E { }; //Enum type

Function

Function type. Used for function pointers. For example:

void foo(void (*ptr)(int)) {   // ptr is Pointer of Type Function
    ptr(3);
}

Reference

Reference type. Used for passing by reference. For example:

void func(int &i) {  // i is Parameter of Type Reference to Type int
   i = 3;
}

struct

Struct type. For example:

struct Foo { }; // struct

Template Parameter

A template parameter in template class declaration. For example:

template <typename T> class Temp{}; // Template Parameter: T

Typedef

Typedef type. For example:

typedef int INT;
INT x;            
      // x is Variable of Type Typedef to Type int.

Union

Union type. For example":

union MyUnion {   // union
    int x;
    char *y;
};

Primitive

All primitive types. This category contains the following types:

bool

Primitive type bool. For example:

bool b; // b is Variable of Type bool

char

Primitive type char. For example:

char c; // c is Variable of Type char

double

Primitive type double. For example:

double d; // d is Variable of Type double

double complex

Type double _Complex. For example:

double _Complex fd;   // fd is Variable of Type

 double _Complex

float

Primitive type doublefloat. For example:

double dfloat f; // d f is Variable of Type doublefloat

float complex

Primitive type Type float _Complex. For example:

float

 _Complex fc;   //

 fc is Variable of Type float _Complex

int

Primitive type int. For example:

int i; // i is Variable of Type int

long

Primitive type long. For example:

long x; // x is Variable of Type long

long double

Primitive type long double. For example:

long double d; // d is Variable of Type long double

long double complex

Type long double _Complex. For example:

long double _Complex fd;   // fd is Variable of Type long double _Complex

pointer

Pointer type. For example:

char * name; 
 // name is Variable of Type pointer to type char.

short

Primitive type short. For example:

short x; // x is Variable of Type short

void

Primitive type void. Used for void pointers. For example:

void * p; 
 // p is Variable of Type pointer to type void.

wchar_t

Primitive type wchar_t. For example:

wchar_t c; // c is Variable of Type wchar_t

std::nullptr_t

The type of pointer literal. Example:

decltype(nullptr) t; // variable of std::nullptr_t type