就业培训     下载中心     Wiki     联络 登录   注册

---

If a variable is declared but not used this will trigger a compile warning. This warning can be suppressed with this function:

• maxon::UseVariable(): Uses the given variable.

注意

Using maxon::UseVariable() will not cause any performance penalty.

Program Flow and Structure

These macros are used to mark certain parts of the source code:

• MAXON_SCOPE : Marks a block of code that is scoped for a certain reason.
• MAXON_UNLIKELY : Marks an unlikely branch for branch prediction.
• MAXON_LIKELY : Marks a likely branch for branch prediction.

// This example uses the MAXON_UNLIKELY to mark an unlikely case.

Switch-case statements can be improved with:

• MAXON_SWITCH_CHECKALLENUMS_BEGIN : Enables a check if a switch-statement checks all elements of an enumeration.
• MAXON_SWITCH_CHECKALLENUMS_END : Disables above check.

Finally

The code defined in a "finally" block is executed when the program flow leaves the current scope.

• finally : Defines a code block which is executed when the scope is left.
• finally_once : Returns a maxon::FinallyOnce object that can be used to disable the code block execution.

Enummerations

• MAXON_ENUM_LIST() : Used to handle generic enummerations.
• MAXON_ENUM_FLAGS() : Used to handle bit flag enummerations.

//---------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------- enum class PRIMARY_COLOR { RED = 1, GREEN = 2, BLUE = 3 } MAXON_ENUM_LIST (PRIMARY_COLOR);

//---------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------- enum class QUALITY { NONE = 0, A = (1 << 0), B = (1 << 1), C = (1 << 2), D = (1 << 3), } MAXON_ENUM_FLAGS (QUALITY);

// This example shows how enumeration values are used.

// use simple enumeration

// set color const PRIMARY_COLOR color = PRIMARY_COLOR::RED ;

// check color if (color == PRIMARY_COLOR::RED ) DiagnosticOutput ( "Red" ); if (color != PRIMARY_COLOR::BLUE ) DiagnosticOutput ( "Color is not blue." );

// use bit flags

// define qualities const QUALITY qualities = QUALITY::A | QUALITY::B;

// check qualities

类和函数

The following macros are used to declare classes and their functions:

• MAXON_IMPLICIT : Marks a constructor that is used for implicit construction.
• MAXON_NONCONST_COUNTERPART : Utility to simplify the implementation of a non-const counterpart of a const member function.
• MAXON_ATTRIBUTE_FORCE_INLINE : Forces the compiler to use the function inline.
• MAXON_DISALLOW_COPY_AND_ASSIGN : Makes sure an instance of the class cannot be copied.
• MAXON_COPY_MEMBERS : Defines the members copied in a copy constructor.
• MAXON_MOVE_MEMBERS : Defines the members copied in a move constructor.

These macros are used to implement certain operators automatically:

• MAXON_OPERATOR_EQUALITY : Defines operator "==" and operator "!=" based on the equality operators for the given class members.
• MAXON_OPERATOR_COMPARISON : Defines member operators "!=", ">", "<=" and ">=" based on the member operators "==" and "<".
• MAXON_OPERATOR_INEQUALITY : Defines member operators ">", "<=" and ">=" based on the member operator "<".
• MAXON_OPERATOR_EQUALITY_HASHCODE : Utility that defines the "==" and "!=" operators and a GetHashCode() 方法。
• MAXON_OPERATOR_COPY_ASSIGNMENT : Creates a copy assignment operator from an existing copy constructor.
• MAXON_OPERATOR_MOVE_ASSIGNMENT : Creates a move assignment operator from an existing move constructor.

// define copy constructor NumberClass( const NumberClass& src ) : MAXON_COPY_MEMBERS (_number) { }

// define assign operator "=" from copy constructor MAXON_OPERATOR_COPY_ASSIGNMENT (NumberClass);

// define "==", "!=" operators and GetHashCode() MAXON_OPERATOR_EQUALITY_HASHCODE (NumberClass, _number);

// accessors const maxon::Int * GetNumber() const { return &_number; } maxon::Int * GetNumber() { return MAXON_NONCONST_COUNTERPART (GetNumber()); } private : maxon::Int _number; };

// This example uses a class defined with various macros to implement // a non-const access function and GetHashCode(). NumberClass someNumber(1);

// edit maxon::Int * const number = someNumber.GetNumber(); *number = *number + 1;

// print const maxon::Int * const res = someNumber.GetNumber(); DiagnosticOutput ( "Number: @" , *res);

// hash const maxon::UInt hash = someNumber.GetHashCode(); DiagnosticOutput ( "Hash: @" , hash);

// copy NumberClass someOtherNumber(0); someOtherNumber = someNumber;

Utility

Other utility macros exist:

• MAXON_STRINGIFY(): Turns the given symbol into a string.
• MAXON_FUNCTIONNAME : Returns the name of the current function as a maxon::Id .
• MAXON_HASHCODE : Calculates a hash code for the given arguments.
• MAXON_DEPRECATED_ENUMVALUE : Marks an entry in an enumeration as deprecated.

// prints the value of the macro SOME_VALUE const maxon::String value(MAXON_STRINGIFY(SOME_VALUE)); DiagnosticOutput ( "Some Value: @" , value);

// print the hash of the given values const maxon::Int i = 123; const maxon::Float f = 132.0; const maxon::UInt hash = MAXON_HASHCODE (i, f); DiagnosticOutput ( "Hash: @" , hash);

延伸阅读

• C++ 技术
• Debug and Output Functions