readability-identifier-naming¶

Checks for identifiers naming style mismatch.

This check will try to enforce coding guidelines on the identifiers naming. It supports one of the following casing types and tries to convert from one to another if a mismatch is detected

Casing types include:

lower_case,

UPPER_CASE,

camelBack,

CamelCase,

camel_Snake_Back,

Camel_Snake_Case,

aNy_CasE.

It also supports a fixed prefix and suffix that will be prepended or appended to the identifiers, regardless of the casing.

Many configuration options are available, in order to be able to create different rules for different kinds of identifiers. In general, the rules are falling back to a more generic rule if the specific case is not configured.

The naming of virtual methods is reported where they occur in the base class, but not where they are overridden, as it can’t be fixed locally there. This also applies for pseudo-override patterns like CRTP.

Options¶

The following options are describe below:

AbstractClassCase, AbstractClassPrefix, AbstractClassSuffix, AbstractClassIgnoredRegexp

AggressiveDependentMemberLookup

ClassCase, ClassPrefix, ClassSuffix, ClassIgnoredRegexp

ClassConstantCase, ClassConstantPrefix, ClassConstantSuffix, ClassConstantIgnoredRegexp

ClassMemberCase, ClassMemberPrefix, ClassMemberSuffix, ClassMemberIgnoredRegexp

ClassMethodCase, ClassMethodPrefix, ClassMethodSuffix, ClassMethodIgnoredRegexp

ConstantCase, ConstantPrefix, ConstantSuffix, ConstantIgnoredRegexp

ConstantMemberCase, ConstantMemberPrefix, ConstantMemberSuffix, ConstantMemberIgnoredRegexp

ConstantParameterCase, ConstantParameterPrefix, ConstantParameterSuffix, ConstantParameterIgnoredRegexp

ConstantPointerParameterCase, ConstantPointerParameterPrefix, ConstantPointerParameterSuffix, ConstantPointerParameterIgnoredRegexp

ConstexprFunctionCase, ConstexprFunctionPrefix, ConstexprFunctionSuffix, ConstexprFunctionIgnoredRegexp

ConstexprMethodCase, ConstexprMethodPrefix, ConstexprMethodSuffix, ConstexprMethodIgnoredRegexp

ConstexprVariableCase, ConstexprVariablePrefix, ConstexprVariableSuffix, ConstexprVariableIgnoredRegexp

EnumCase, EnumPrefix, EnumSuffix, EnumIgnoredRegexp

EnumConstantCase, EnumConstantPrefix, EnumConstantSuffix, EnumConstantIgnoredRegexp

FunctionCase, FunctionPrefix, FunctionSuffix, FunctionIgnoredRegexp

GetConfigPerFile

GlobalConstantCase, GlobalConstantPrefix, GlobalConstantSuffix, GlobalConstantIgnoredRegexp

GlobalConstantPointerCase, GlobalConstantPointerPrefix, GlobalConstantPointerSuffix, GlobalConstantPointerIgnoredRegexp

GlobalFunctionCase, GlobalFunctionPrefix, GlobalFunctionSuffix, GlobalFunctionIgnoredRegexp

GlobalPointerCase, GlobalPointerPrefix, GlobalPointerSuffix, GlobalPointerIgnoredRegexp

GlobalVariableCase, GlobalVariablePrefix, GlobalVariableSuffix, GlobalVariableIgnoredRegexp

IgnoreMainLikeFunctions

InlineNamespaceCase, InlineNamespacePrefix, InlineNamespaceSuffix, InlineNamespaceIgnoredRegexp

LocalConstantCase, LocalConstantPrefix, LocalConstantSuffix, LocalConstantIgnoredRegexp

LocalConstantPointerCase, LocalConstantPointerPrefix, LocalConstantPointerSuffix, LocalConstantPointerIgnoredRegexp

LocalPointerCase, LocalPointerPrefix, LocalPointerSuffix, LocalPointerIgnoredRegexp

LocalVariableCase, LocalVariablePrefix, LocalVariableSuffix, LocalVariableIgnoredRegexp

MacroDefinitionCase, MacroDefinitionPrefix, MacroDefinitionSuffix, MacroDefinitionIgnoredRegexp

MemberCase, MemberPrefix, MemberSuffix, MemberIgnoredRegexp

MethodCase, MethodPrefix, MethodSuffix, MethodIgnoredRegexp

NamespaceCase, NamespacePrefix, NamespaceSuffix, NamespaceIgnoredRegexp

ParameterCase, ParameterPrefix, ParameterSuffix, ParameterIgnoredRegexp

ParameterPackCase, ParameterPackPrefix, ParameterPackSuffix, ParameterPackIgnoredRegexp

PointerParameterCase, PointerParameterPrefix, PointerParameterSuffix, PointerParameterIgnoredRegexp

PrivateMemberCase, PrivateMemberPrefix, PrivateMemberSuffix, PrivateMemberIgnoredRegexp

PrivateMethodCase, PrivateMethodPrefix, PrivateMethodSuffix, PrivateMethodIgnoredRegexp

ProtectedMemberCase, ProtectedMemberPrefix, ProtectedMemberSuffix, ProtectedMemberIgnoredRegexp

ProtectedMethodCase, ProtectedMethodPrefix, ProtectedMethodSuffix, ProtectedMethodIgnoredRegexp

PublicMemberCase, PublicMemberPrefix, PublicMemberSuffix, PublicMemberIgnoredRegexp

PublicMethodCase, PublicMethodPrefix, PublicMethodSuffix, PublicMethodIgnoredRegexp

ScopedEnumConstantCase, ScopedEnumConstantPrefix, ScopedEnumConstantSuffix, ScopedEnumConstantIgnoredRegexp

StaticConstantCase, StaticConstantPrefix, StaticConstantSuffix, StaticConstantIgnoredRegexp

StaticVariableCase, StaticVariablePrefix, StaticVariableSuffix, StaticVariableIgnoredRegexp

StructCase, StructPrefix, StructSuffix, StructIgnoredRegexp

TemplateParameterCase, TemplateParameterPrefix, TemplateParameterSuffix, TemplateParameterIgnoredRegexp

TemplateTemplateParameterCase, TemplateTemplateParameterPrefix, TemplateTemplateParameterSuffix, TemplateTemplateParameterIgnoredRegexp

TypeAliasCase, TypeAliasPrefix, TypeAliasSuffix, TypeAliasIgnoredRegexp

TypedefCase, TypedefPrefix, TypedefSuffix, TypedefIgnoredRegexp

TypeTemplateParameterCase, TypeTemplateParameterPrefix, TypeTemplateParameterSuffix, TypeTemplateParameterIgnoredRegexp

UnionCase, UnionPrefix, UnionSuffix, UnionIgnoredRegexp

ValueTemplateParameterCase, ValueTemplateParameterPrefix, ValueTemplateParameterSuffix, ValueTemplateParameterIgnoredRegexp

VariableCase, VariablePrefix, VariableSuffix, VariableIgnoredRegexp

VirtualMethodCase, VirtualMethodPrefix, VirtualMethodSuffix, VirtualMethodIgnoredRegexp

AbstractClassCase¶: When defined, the check will ensure abstract class names conform to the selected casing.

AbstractClassPrefix¶: When defined, the check will ensure abstract class names will add the prefixed with the given value (regardless of casing).

AbstractClassIgnoredRegexp¶: Identifier naming checks won’t be enforced for abstract class names matching this regular expression.

AbstractClassSuffix¶: When defined, the check will ensure abstract class names will add the suffix with the given value (regardless of casing).

For example using values of:

AbstractClassCase of lower_case

AbstractClassPrefix of pre_

AbstractClassSuffix of _post

Identifies and/or transforms abstract class names as follows:

Before:

class ABSTRACT_CLASS {
public:
  ABSTRACT_CLASS();
};

After:

class pre_abstract_class_post {
public:
  pre_abstract_class_post();
};

AggressiveDependentMemberLookup¶: When set to true the check will look in dependent base classes for dependent member references that need changing. This can lead to errors with template specializations so the default value is false.

For example using values of:

ClassMemberCase of lower_case

Before:

template <typename T>
struct Base {
  T BadNamedMember;
};

template <typename T>
struct Derived : Base<T> {
  void reset() {
    this->BadNamedMember = 0;
  }
};

After if AggressiveDependentMemberLookup is false:

template <typename T>
struct Base {
  T bad_named_member;
};

template <typename T>
struct Derived : Base<T> {
  void reset() {
    this->BadNamedMember = 0;
  }
};

After if AggressiveDependentMemberLookup is true:

template <typename T>
struct Base {
  T bad_named_member;
};

template <typename T>
struct Derived : Base<T> {
  void reset() {
    this->bad_named_member = 0;
  }
};

ClassCase¶: When defined, the check will ensure class names conform to the selected casing.

ClassPrefix¶: When defined, the check will ensure class names will add the prefixed with the given value (regardless of casing).

ClassIgnoredRegexp¶: Identifier naming checks won’t be enforced for class names matching this regular expression.

ClassSuffix¶: When defined, the check will ensure class names will add the suffix with the given value (regardless of casing).

For example using values of:

ClassCase of lower_case

ClassPrefix of pre_

ClassSuffix of _post

Identifies and/or transforms class names as follows:

Before:

class FOO {
public:
  FOO();
  ~FOO();
};

After:

class pre_foo_post {
public:
  pre_foo_post();
  ~pre_foo_post();
};

ClassConstantCase¶: When defined, the check will ensure class constant names conform to the selected casing.

ClassConstantPrefix¶: When defined, the check will ensure class constant names will add the prefixed with the given value (regardless of casing).

ClassConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for class constant names matching this regular expression.

ClassConstantSuffix¶: When defined, the check will ensure class constant names will add the suffix with the given value (regardless of casing).

For example using values of:

ClassConstantCase of lower_case

ClassConstantPrefix of pre_

ClassConstantSuffix of _post

Identifies and/or transforms class constant names as follows:

Before:

class FOO {
public:
  static const int CLASS_CONSTANT;
};

After:

class FOO {
public:
  static const int pre_class_constant_post;
};

ClassMemberCase¶: When defined, the check will ensure class member names conform to the selected casing.

ClassMemberPrefix¶: When defined, the check will ensure class member names will add the prefixed with the given value (regardless of casing).

ClassMemberIgnoredRegexp¶: Identifier naming checks won’t be enforced for class member names matching this regular expression.

ClassMemberSuffix¶: When defined, the check will ensure class member names will add the suffix with the given value (regardless of casing).

For example using values of:

ClassMemberCase of lower_case

ClassMemberPrefix of pre_

ClassMemberSuffix of _post

Identifies and/or transforms class member names as follows:

Before:

class FOO {
public:
  static int CLASS_CONSTANT;
};

After:

class FOO {
public:
  static int pre_class_constant_post;
};

ClassMethodCase¶: When defined, the check will ensure class method names conform to the selected casing.

ClassMethodPrefix¶: When defined, the check will ensure class method names will add the prefixed with the given value (regardless of casing).

ClassMethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for class method names matching this regular expression.

ClassMethodSuffix¶: When defined, the check will ensure class method names will add the suffix with the given value (regardless of casing).

For example using values of:

ClassMethodCase of lower_case

ClassMethodPrefix of pre_

ClassMethodSuffix of _post

Identifies and/or transforms class method names as follows:

Before:

class FOO {
public:
  int CLASS_MEMBER();
};

After:

class FOO {
public:
  int pre_class_member_post();
};

ConstantCase¶: When defined, the check will ensure constant names conform to the selected casing.

ConstantPrefix¶: When defined, the check will ensure constant names will add the prefixed with the given value (regardless of casing).

ConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for constant names matching this regular expression.

ConstantSuffix¶: When defined, the check will ensure constant names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstantCase of lower_case

ConstantPrefix of pre_

ConstantSuffix of _post

Identifies and/or transforms constant names as follows:

Before:

void function() { unsigned const MyConst_array[] = {1, 2, 3}; }

After:

void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; }

ConstantMemberCase¶: When defined, the check will ensure constant member names conform to the selected casing.

ConstantMemberPrefix¶: When defined, the check will ensure constant member names will add the prefixed with the given value (regardless of casing).

ConstantMemberIgnoredRegexp¶: Identifier naming checks won’t be enforced for constant member names matching this regular expression.

ConstantMemberSuffix¶: When defined, the check will ensure constant member names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstantMemberCase of lower_case

ConstantMemberPrefix of pre_

ConstantMemberSuffix of _post

Identifies and/or transforms constant member names as follows:

Before:

class Foo {
  char const MY_ConstMember_string[4] = "123";
}

After:

class Foo {
  char const pre_my_constmember_string_post[4] = "123";
}

ConstantParameterCase¶: When defined, the check will ensure constant parameter names conform to the selected casing.

ConstantParameterPrefix¶: When defined, the check will ensure constant parameter names will add the prefixed with the given value (regardless of casing).

ConstantParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for constant parameter names matching this regular expression.

ConstantParameterSuffix¶: When defined, the check will ensure constant parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstantParameterCase of lower_case

ConstantParameterPrefix of pre_

ConstantParameterSuffix of _post

Identifies and/or transforms constant parameter names as follows:

Before:

void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);

After:

void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);

ConstantPointerParameterCase¶: When defined, the check will ensure constant pointer parameter names conform to the selected casing.

ConstantPointerParameterPrefix¶: When defined, the check will ensure constant pointer parameter names will add the prefixed with the given value (regardless of casing).

ConstantPointerParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for constant pointer parameter names matching this regular expression.

ConstantPointerParameterSuffix¶: When defined, the check will ensure constant pointer parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstantPointerParameterCase of lower_case

ConstantPointerParameterPrefix of pre_

ConstantPointerParameterSuffix of _post

Identifies and/or transforms constant pointer parameter names as follows:

Before:

void GLOBAL_FUNCTION(int const *CONST_parameter);

After:

void GLOBAL_FUNCTION(int const *pre_const_parameter_post);

ConstexprFunctionCase¶: When defined, the check will ensure constexpr function names conform to the selected casing.

ConstexprFunctionPrefix¶: When defined, the check will ensure constexpr function names will add the prefixed with the given value (regardless of casing).

ConstexprFunctionIgnoredRegexp¶: Identifier naming checks won’t be enforced for constexpr function names matching this regular expression.

ConstexprFunctionSuffix¶: When defined, the check will ensure constexpr function names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstexprFunctionCase of lower_case

ConstexprFunctionPrefix of pre_

ConstexprFunctionSuffix of _post

Identifies and/or transforms constexpr function names as follows:

Before:

constexpr int CE_function() { return 3; }

After:

constexpr int pre_ce_function_post() { return 3; }

ConstexprMethodCase¶: When defined, the check will ensure constexpr method names conform to the selected casing.

ConstexprMethodPrefix¶: When defined, the check will ensure constexpr method names will add the prefixed with the given value (regardless of casing).

ConstexprMethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for constexpr method names matching this regular expression.

ConstexprMethodSuffix¶: When defined, the check will ensure constexpr method names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstexprMethodCase of lower_case

ConstexprMethodPrefix of pre_

ConstexprMethodSuffix of _post

Identifies and/or transforms constexpr method names as follows:

Before:

class Foo {
public:
  constexpr int CST_expr_Method() { return 2; }
}

After:

class Foo {
public:
  constexpr int pre_cst_expr_method_post() { return 2; }
}

ConstexprVariableCase¶: When defined, the check will ensure constexpr variable names conform to the selected casing.

ConstexprVariablePrefix¶: When defined, the check will ensure constexpr variable names will add the prefixed with the given value (regardless of casing).

ConstexprVariableIgnoredRegexp¶: Identifier naming checks won’t be enforced for constexpr variable names matching this regular expression.

ConstexprVariableSuffix¶: When defined, the check will ensure constexpr variable names will add the suffix with the given value (regardless of casing).

For example using values of:

ConstexprVariableCase of lower_case

ConstexprVariablePrefix of pre_

ConstexprVariableSuffix of _post

Identifies and/or transforms constexpr variable names as follows:

Before:

constexpr int ConstExpr_variable = MyConstant;

After:

constexpr int pre_constexpr_variable_post = MyConstant;

EnumCase¶: When defined, the check will ensure enumeration names conform to the selected casing.

EnumPrefix¶: When defined, the check will ensure enumeration names will add the prefixed with the given value (regardless of casing).

EnumIgnoredRegexp¶: Identifier naming checks won’t be enforced for enumeration names matching this regular expression.

EnumSuffix¶: When defined, the check will ensure enumeration names will add the suffix with the given value (regardless of casing).

For example using values of:

EnumCase of lower_case

EnumPrefix of pre_

EnumSuffix of _post

Identifies and/or transforms enumeration names as follows:

Before:

enum FOO { One, Two, Three };

After:

enum pre_foo_post { One, Two, Three };

EnumConstantCase¶: When defined, the check will ensure enumeration constant names conform to the selected casing.

EnumConstantPrefix¶: When defined, the check will ensure enumeration constant names will add the prefixed with the given value (regardless of casing).

EnumConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for enumeration constant names matching this regular expression.

EnumConstantSuffix¶: When defined, the check will ensure enumeration constant names will add the suffix with the given value (regardless of casing).

For example using values of:

EnumConstantCase of lower_case

EnumConstantPrefix of pre_

EnumConstantSuffix of _post

Identifies and/or transforms enumeration constant names as follows:

Before:

enum FOO { One, Two, Three };

After:

enum FOO { pre_One_post, pre_Two_post, pre_Three_post };

FunctionCase¶: When defined, the check will ensure function names conform to the selected casing.

FunctionPrefix¶: When defined, the check will ensure function names will add the prefixed with the given value (regardless of casing).

FunctionIgnoredRegexp¶: Identifier naming checks won’t be enforced for function names matching this regular expression.

FunctionSuffix¶: When defined, the check will ensure function names will add the suffix with the given value (regardless of casing).

For example using values of:

FunctionCase of lower_case

FunctionPrefix of pre_

FunctionSuffix of _post

Identifies and/or transforms function names as follows:

Before:

char MY_Function_string();

After:

char pre_my_function_string_post();

GetConfigPerFile¶: When true the check will look for the configuration for where an identifier is declared. Useful for when included header files use a different style. Default value is true.

GlobalConstantCase¶: When defined, the check will ensure global constant names conform to the selected casing.

GlobalConstantPrefix¶: When defined, the check will ensure global constant names will add the prefixed with the given value (regardless of casing).

GlobalConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for global constant names matching this regular expression.

GlobalConstantSuffix¶: When defined, the check will ensure global constant names will add the suffix with the given value (regardless of casing).

For example using values of:

GlobalConstantCase of lower_case

GlobalConstantPrefix of pre_

GlobalConstantSuffix of _post

Identifies and/or transforms global constant names as follows:

Before:

unsigned const MyConstGlobal_array[] = {1, 2, 3};

After:

unsigned const pre_myconstglobal_array_post[] = {1, 2, 3};

GlobalConstantPointerCase¶: When defined, the check will ensure global constant pointer names conform to the selected casing.

GlobalConstantPointerPrefix¶: When defined, the check will ensure global constant pointer names will add the prefixed with the given value (regardless of casing).

GlobalConstantPointerIgnoredRegexp¶: Identifier naming checks won’t be enforced for global constant pointer names matching this regular expression.

GlobalConstantPointerSuffix¶: When defined, the check will ensure global constant pointer names will add the suffix with the given value (regardless of casing).

For example using values of:

GlobalConstantPointerCase of lower_case

GlobalConstantPointerPrefix of pre_

GlobalConstantPointerSuffix of _post

Identifies and/or transforms global constant pointer names as follows:

Before:

int *const MyConstantGlobalPointer = nullptr;

After:

int *const pre_myconstantglobalpointer_post = nullptr;

GlobalFunctionCase¶: When defined, the check will ensure global function names conform to the selected casing.

GlobalFunctionPrefix¶: When defined, the check will ensure global function names will add the prefixed with the given value (regardless of casing).

GlobalFunctionIgnoredRegexp¶: Identifier naming checks won’t be enforced for global function names matching this regular expression.

GlobalFunctionSuffix¶: When defined, the check will ensure global function names will add the suffix with the given value (regardless of casing).

For example using values of:

GlobalFunctionCase of lower_case

GlobalFunctionPrefix of pre_

GlobalFunctionSuffix of _post

Identifies and/or transforms global function names as follows:

Before:

void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);

After:

void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);

GlobalPointerCase¶: When defined, the check will ensure global pointer names conform to the selected casing.

GlobalPointerPrefix¶: When defined, the check will ensure global pointer names will add the prefixed with the given value (regardless of casing).

GlobalPointerIgnoredRegexp¶: Identifier naming checks won’t be enforced for global pointer names matching this regular expression.

GlobalPointerSuffix¶: When defined, the check will ensure global pointer names will add the suffix with the given value (regardless of casing).

For example using values of:

GlobalPointerCase of lower_case

GlobalPointerPrefix of pre_

GlobalPointerSuffix of _post

Identifies and/or transforms global pointer names as follows:

Before:

int *GLOBAL3;

After:

int *pre_global3_post;

GlobalVariableCase¶: When defined, the check will ensure global variable names conform to the selected casing.

GlobalVariablePrefix¶: When defined, the check will ensure global variable names will add the prefixed with the given value (regardless of casing).

GlobalVariableIgnoredRegexp¶: Identifier naming checks won’t be enforced for global variable names matching this regular expression.

GlobalVariableSuffix¶: When defined, the check will ensure global variable names will add the suffix with the given value (regardless of casing).

For example using values of:

GlobalVariableCase of lower_case

GlobalVariablePrefix of pre_

GlobalVariableSuffix of _post

Identifies and/or transforms global variable names as follows:

Before:

int GLOBAL3;

After:

int pre_global3_post;

IgnoreMainLikeFunctions¶: When set to true functions that have a similar signature to main or wmain won’t enforce checks on the names of their parameters. Default value is false.

InlineNamespaceCase¶: When defined, the check will ensure inline namespaces names conform to the selected casing.

InlineNamespacePrefix¶: When defined, the check will ensure inline namespaces names will add the prefixed with the given value (regardless of casing).

InlineNamespaceIgnoredRegexp¶: Identifier naming checks won’t be enforced for inline namespaces names matching this regular expression.

InlineNamespaceSuffix¶: When defined, the check will ensure inline namespaces names will add the suffix with the given value (regardless of casing).

For example using values of:

InlineNamespaceCase of lower_case

InlineNamespacePrefix of pre_

InlineNamespaceSuffix of _post

Identifies and/or transforms inline namespaces names as follows:

Before:

namespace FOO_NS {
inline namespace InlineNamespace {
...
}
} // namespace FOO_NS

After:

namespace FOO_NS {
inline namespace pre_inlinenamespace_post {
...
}
} // namespace FOO_NS

LocalConstantCase¶: When defined, the check will ensure local constant names conform to the selected casing.

LocalConstantPrefix¶: When defined, the check will ensure local constant names will add the prefixed with the given value (regardless of casing).

LocalConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for local constant names matching this regular expression.

LocalConstantSuffix¶: When defined, the check will ensure local constant names will add the suffix with the given value (regardless of casing).

For example using values of:

LocalConstantCase of lower_case

LocalConstantPrefix of pre_

LocalConstantSuffix of _post

Identifies and/or transforms local constant names as follows:

Before:

void foo() { int const local_Constant = 3; }

After:

void foo() { int const pre_local_constant_post = 3; }

LocalConstantPointerCase¶: When defined, the check will ensure local constant pointer names conform to the selected casing.

LocalConstantPointerPrefix¶: When defined, the check will ensure local constant pointer names will add the prefixed with the given value (regardless of casing).

LocalConstantPointerIgnoredRegexp¶: Identifier naming checks won’t be enforced for local constant pointer names matching this regular expression.

LocalConstantPointerSuffix¶: When defined, the check will ensure local constant pointer names will add the suffix with the given value (regardless of casing).

For example using values of:

LocalConstantPointerCase of lower_case

LocalConstantPointerPrefix of pre_

LocalConstantPointerSuffix of _post

Identifies and/or transforms local constant pointer names as follows:

Before:

void foo() { int const *local_Constant = 3; }

After:

void foo() { int const *pre_local_constant_post = 3; }

LocalPointerCase¶: When defined, the check will ensure local pointer names conform to the selected casing.

LocalPointerPrefix¶: When defined, the check will ensure local pointer names will add the prefixed with the given value (regardless of casing).

LocalPointerIgnoredRegexp¶: Identifier naming checks won’t be enforced for local pointer names matching this regular expression.

LocalPointerSuffix¶: When defined, the check will ensure local pointer names will add the suffix with the given value (regardless of casing).

For example using values of:

LocalPointerCase of lower_case

LocalPointerPrefix of pre_

LocalPointerSuffix of _post

Identifies and/or transforms local pointer names as follows:

Before:

void foo() { int *local_Constant; }

After:

void foo() { int *pre_local_constant_post; }

LocalVariableCase¶: When defined, the check will ensure local variable names conform to the selected casing.

LocalVariablePrefix¶: When defined, the check will ensure local variable names will add the prefixed with the given value (regardless of casing).

LocalVariableIgnoredRegexp¶: Identifier naming checks won’t be enforced for local variable names matching this regular expression.

For example using values of:

LocalVariableCase of CamelCase

LocalVariableIgnoredRegexp of \w{1,2}

Will exclude variables with a length less than or equal to 2 from the camel case check applied to other variables.

LocalVariableSuffix¶: When defined, the check will ensure local variable names will add the suffix with the given value (regardless of casing).

For example using values of:

LocalVariableCase of lower_case

LocalVariablePrefix of pre_

LocalVariableSuffix of _post

Identifies and/or transforms local variable names as follows:

Before:

void foo() { int local_Constant; }

After:

void foo() { int pre_local_constant_post; }

MacroDefinitionCase¶: When defined, the check will ensure macro definitions conform to the selected casing.

MacroDefinitionPrefix¶: When defined, the check will ensure macro definitions will add the prefixed with the given value (regardless of casing).

MacroDefinitionIgnoredRegexp¶: Identifier naming checks won’t be enforced for macro definitions matching this regular expression.

MacroDefinitionSuffix¶: When defined, the check will ensure macro definitions will add the suffix with the given value (regardless of casing).

For example using values of:

MacroDefinitionCase of lower_case

MacroDefinitionPrefix of pre_

MacroDefinitionSuffix of _post

Identifies and/or transforms macro definitions as follows:

Before:

#define MY_MacroDefinition

After:

#define pre_my_macro_definition_post

Note: This will not warn on builtin macros or macros defined on the command line using the -D flag.

MemberCase¶: When defined, the check will ensure member names conform to the selected casing.

MemberPrefix¶: When defined, the check will ensure member names will add the prefixed with the given value (regardless of casing).

MemberIgnoredRegexp¶: Identifier naming checks won’t be enforced for member names matching this regular expression.

MemberSuffix¶: When defined, the check will ensure member names will add the suffix with the given value (regardless of casing).

For example using values of:

MemberCase of lower_case

MemberPrefix of pre_

MemberSuffix of _post

Identifies and/or transforms member names as follows:

Before:

class Foo {
  char MY_ConstMember_string[4];
}

After:

class Foo {
  char pre_my_constmember_string_post[4];
}

MethodCase¶: When defined, the check will ensure method names conform to the selected casing.

MethodPrefix¶: When defined, the check will ensure method names will add the prefixed with the given value (regardless of casing).

MethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for method names matching this regular expression.

MethodSuffix¶: When defined, the check will ensure method names will add the suffix with the given value (regardless of casing).

For example using values of:

MethodCase of lower_case

MethodPrefix of pre_

MethodSuffix of _post

Identifies and/or transforms method names as follows:

Before:

class Foo {
  char MY_Method_string();
}

After:

class Foo {
  char pre_my_method_string_post();
}

NamespaceCase¶: When defined, the check will ensure namespace names conform to the selected casing.

NamespacePrefix¶: When defined, the check will ensure namespace names will add the prefixed with the given value (regardless of casing).

NamespaceIgnoredRegexp¶: Identifier naming checks won’t be enforced for namespace names matching this regular expression.

NamespaceSuffix¶: When defined, the check will ensure namespace names will add the suffix with the given value (regardless of casing).

For example using values of:

NamespaceCase of lower_case

NamespacePrefix of pre_

NamespaceSuffix of _post

Identifies and/or transforms namespace names as follows:

Before:

namespace FOO_NS {
...
}

After:

namespace pre_foo_ns_post {
...
}

ParameterCase¶: When defined, the check will ensure parameter names conform to the selected casing.

ParameterPrefix¶: When defined, the check will ensure parameter names will add the prefixed with the given value (regardless of casing).

ParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for parameter names matching this regular expression.

ParameterSuffix¶: When defined, the check will ensure parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

ParameterCase of lower_case

ParameterPrefix of pre_

ParameterSuffix of _post

Identifies and/or transforms parameter names as follows:

Before:

void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);

After:

void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);

ParameterPackCase¶: When defined, the check will ensure parameter pack names conform to the selected casing.

ParameterPackPrefix¶: When defined, the check will ensure parameter pack names will add the prefixed with the given value (regardless of casing).

ParameterPackIgnoredRegexp¶: Identifier naming checks won’t be enforced for parameter pack names matching this regular expression.

ParameterPackSuffix¶: When defined, the check will ensure parameter pack names will add the suffix with the given value (regardless of casing).

For example using values of:

ParameterPackCase of lower_case

ParameterPackPrefix of pre_

ParameterPackSuffix of _post

Identifies and/or transforms parameter pack names as follows:

Before:

template <typename... TYPE_parameters> {
  void FUNCTION(int... TYPE_parameters);
}

After:

template <typename... TYPE_parameters> {
  void FUNCTION(int... pre_type_parameters_post);
}

PointerParameterCase¶: When defined, the check will ensure pointer parameter names conform to the selected casing.

PointerParameterPrefix¶: When defined, the check will ensure pointer parameter names will add the prefixed with the given value (regardless of casing).

PointerParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for pointer parameter names matching this regular expression.

PointerParameterSuffix¶: When defined, the check will ensure pointer parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

PointerParameterCase of lower_case

PointerParameterPrefix of pre_

PointerParameterSuffix of _post

Identifies and/or transforms pointer parameter names as follows:

Before:

void FUNCTION(int *PARAMETER);

After:

void FUNCTION(int *pre_parameter_post);

PrivateMemberCase¶: When defined, the check will ensure private member names conform to the selected casing.

PrivateMemberPrefix¶: When defined, the check will ensure private member names will add the prefixed with the given value (regardless of casing).

PrivateMemberIgnoredRegexp¶: Identifier naming checks won’t be enforced for private member names matching this regular expression.

PrivateMemberSuffix¶: When defined, the check will ensure private member names will add the suffix with the given value (regardless of casing).

For example using values of:

PrivateMemberCase of lower_case

PrivateMemberPrefix of pre_

PrivateMemberSuffix of _post

Identifies and/or transforms private member names as follows:

Before:

class Foo {
private:
  int Member_Variable;
}

After:

class Foo {
private:
  int pre_member_variable_post;
}

PrivateMethodCase¶: When defined, the check will ensure private method names conform to the selected casing.

PrivateMethodPrefix¶: When defined, the check will ensure private method names will add the prefixed with the given value (regardless of casing).

PrivateMethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for private method names matching this regular expression.

PrivateMethodSuffix¶: When defined, the check will ensure private method names will add the suffix with the given value (regardless of casing).

For example using values of:

PrivateMethodCase of lower_case

PrivateMethodPrefix of pre_

PrivateMethodSuffix of _post

Identifies and/or transforms private method names as follows:

Before:

class Foo {
private:
  int Member_Method();
}

After:

class Foo {
private:
  int pre_member_method_post();
}

ProtectedMemberCase¶: When defined, the check will ensure protected member names conform to the selected casing.

ProtectedMemberPrefix¶: When defined, the check will ensure protected member names will add the prefixed with the given value (regardless of casing).

ProtectedMemberIgnoredRegexp¶: Identifier naming checks won’t be enforced for protected member names matching this regular expression.

ProtectedMemberSuffix¶: When defined, the check will ensure protected member names will add the suffix with the given value (regardless of casing).

For example using values of:

ProtectedMemberCase of lower_case

ProtectedMemberPrefix of pre_

ProtectedMemberSuffix of _post

Identifies and/or transforms protected member names as follows:

Before:

class Foo {
protected:
  int Member_Variable;
}

After:

class Foo {
protected:
  int pre_member_variable_post;
}

ProtectedMethodCase¶: When defined, the check will ensure protected method names conform to the selected casing.

ProtectedMethodPrefix¶: When defined, the check will ensure protected method names will add the prefixed with the given value (regardless of casing).

ProtectedMethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for protected method names matching this regular expression.

ProtectedMethodSuffix¶: When defined, the check will ensure protected method names will add the suffix with the given value (regardless of casing).

For example using values of:

ProtectedMethodCase of lower_case

ProtectedMethodPrefix of pre_

ProtectedMethodSuffix of _post

Identifies and/or transforms protect method names as follows:

Before:

class Foo {
protected:
  int Member_Method();
}

After:

class Foo {
protected:
  int pre_member_method_post();
}

PublicMemberCase¶: When defined, the check will ensure public member names conform to the selected casing.

PublicMemberPrefix¶: When defined, the check will ensure public member names will add the prefixed with the given value (regardless of casing).

PublicMemberIgnoredRegexp¶: Identifier naming checks won’t be enforced for public member names matching this regular expression.

PublicMemberSuffix¶: When defined, the check will ensure public member names will add the suffix with the given value (regardless of casing).

For example using values of:

PublicMemberCase of lower_case

PublicMemberPrefix of pre_

PublicMemberSuffix of _post

Identifies and/or transforms public member names as follows:

Before:

class Foo {
public:
  int Member_Variable;
}

After:

class Foo {
public:
  int pre_member_variable_post;
}

PublicMethodCase¶: When defined, the check will ensure public method names conform to the selected casing.

PublicMethodPrefix¶: When defined, the check will ensure public method names will add the prefixed with the given value (regardless of casing).

PublicMethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for public method names matching this regular expression.

PublicMethodSuffix¶: When defined, the check will ensure public method names will add the suffix with the given value (regardless of casing).

For example using values of:

PublicMethodCase of lower_case

PublicMethodPrefix of pre_

PublicMethodSuffix of _post

Identifies and/or transforms public method names as follows:

Before:

class Foo {
public:
  int Member_Method();
}

After:

class Foo {
public:
  int pre_member_method_post();
}

ScopedEnumConstantCase¶: When defined, the check will ensure scoped enum constant names conform to the selected casing.

ScopedEnumConstantPrefix¶: When defined, the check will ensure scoped enum constant names will add the prefixed with the given value (regardless of casing).

ScopedEnumConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for scoped enum constant names matching this regular expression.

ScopedEnumConstantSuffix¶: When defined, the check will ensure scoped enum constant names will add the suffix with the given value (regardless of casing).

For example using values of:

ScopedEnumConstantCase of lower_case

ScopedEnumConstantPrefix of pre_

ScopedEnumConstantSuffix of _post

Identifies and/or transforms enumeration constant names as follows:

Before:

enum class FOO { One, Two, Three };

After:

enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };

StaticConstantCase¶: When defined, the check will ensure static constant names conform to the selected casing.

StaticConstantPrefix¶: When defined, the check will ensure static constant names will add the prefixed with the given value (regardless of casing).

StaticConstantIgnoredRegexp¶: Identifier naming checks won’t be enforced for static constant names matching this regular expression.

StaticConstantSuffix¶: When defined, the check will ensure static constant names will add the suffix with the given value (regardless of casing).

For example using values of:

StaticConstantCase of lower_case

StaticConstantPrefix of pre_

StaticConstantSuffix of _post

Identifies and/or transforms static constant names as follows:

Before:

static unsigned const MyConstStatic_array[] = {1, 2, 3};

After:

static unsigned const pre_myconststatic_array_post[] = {1, 2, 3};

StaticVariableCase¶: When defined, the check will ensure static variable names conform to the selected casing.

StaticVariablePrefix¶: When defined, the check will ensure static variable names will add the prefixed with the given value (regardless of casing).

StaticVariableIgnoredRegexp¶: Identifier naming checks won’t be enforced for static variable names matching this regular expression.

StaticVariableSuffix¶: When defined, the check will ensure static variable names will add the suffix with the given value (regardless of casing).

For example using values of:

StaticVariableCase of lower_case

StaticVariablePrefix of pre_

StaticVariableSuffix of _post

Identifies and/or transforms static variable names as follows:

Before:

static unsigned MyStatic_array[] = {1, 2, 3};

After:

static unsigned pre_mystatic_array_post[] = {1, 2, 3};

StructCase¶: When defined, the check will ensure struct names conform to the selected casing.

StructPrefix¶: When defined, the check will ensure struct names will add the prefixed with the given value (regardless of casing).

StructIgnoredRegexp¶: Identifier naming checks won’t be enforced for struct names matching this regular expression.

StructSuffix¶: When defined, the check will ensure struct names will add the suffix with the given value (regardless of casing).

For example using values of:

StructCase of lower_case

StructPrefix of pre_

StructSuffix of _post

Identifies and/or transforms struct names as follows:

Before:

struct FOO {
  FOO();
  ~FOO();
};

After:

struct pre_foo_post {
  pre_foo_post();
  ~pre_foo_post();
};

TemplateParameterCase¶: When defined, the check will ensure template parameter names conform to the selected casing.

TemplateParameterPrefix¶: When defined, the check will ensure template parameter names will add the prefixed with the given value (regardless of casing).

TemplateParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for template parameter names matching this regular expression.

TemplateParameterSuffix¶: When defined, the check will ensure template parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

TemplateParameterCase of lower_case

TemplateParameterPrefix of pre_

TemplateParameterSuffix of _post

Identifies and/or transforms template parameter names as follows:

Before:

template <typename T> class Foo {};

After:

template <typename pre_t_post> class Foo {};

TemplateTemplateParameterCase¶: When defined, the check will ensure template template parameter names conform to the selected casing.

TemplateTemplateParameterPrefix¶: When defined, the check will ensure template template parameter names will add the prefixed with the given value (regardless of casing).

TemplateTemplateParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for template template parameter names matching this regular expression.

TemplateTemplateParameterSuffix¶: When defined, the check will ensure template template parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

TemplateTemplateParameterCase of lower_case

TemplateTemplateParameterPrefix of pre_

TemplateTemplateParameterSuffix of _post

Identifies and/or transforms template template parameter names as follows:

Before:

template <template <typename> class TPL_parameter, int COUNT_params,
          typename... TYPE_parameters>

After:

template <template <typename> class pre_tpl_parameter_post, int COUNT_params,
          typename... TYPE_parameters>

TypeAliasCase¶: When defined, the check will ensure type alias names conform to the selected casing.

TypeAliasPrefix¶: When defined, the check will ensure type alias names will add the prefixed with the given value (regardless of casing).

TypeAliasIgnoredRegexp¶: Identifier naming checks won’t be enforced for type alias names matching this regular expression.

TypeAliasSuffix¶: When defined, the check will ensure type alias names will add the suffix with the given value (regardless of casing).

For example using values of:

TypeAliasCase of lower_case

TypeAliasPrefix of pre_

TypeAliasSuffix of _post

Identifies and/or transforms type alias names as follows:

Before:

using MY_STRUCT_TYPE = my_structure;

After:

using pre_my_struct_type_post = my_structure;

TypedefCase¶: When defined, the check will ensure typedef names conform to the selected casing.

TypedefPrefix¶: When defined, the check will ensure typedef names will add the prefixed with the given value (regardless of casing).

TypedefIgnoredRegexp¶: Identifier naming checks won’t be enforced for typedef names matching this regular expression.

TypedefSuffix¶: When defined, the check will ensure typedef names will add the suffix with the given value (regardless of casing).

For example using values of:

TypedefCase of lower_case

TypedefPrefix of pre_

TypedefSuffix of _post

Identifies and/or transforms typedef names as follows:

Before:

typedef int MYINT;

After:

typedef int pre_myint_post;

TypeTemplateParameterCase¶: When defined, the check will ensure type template parameter names conform to the selected casing.

TypeTemplateParameterPrefix¶: When defined, the check will ensure type template parameter names will add the prefixed with the given value (regardless of casing).

TypeTemplateParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for type template names matching this regular expression.

TypeTemplateParameterSuffix¶: When defined, the check will ensure type template parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

TypeTemplateParameterCase of lower_case

TypeTemplateParameterPrefix of pre_

TypeTemplateParameterSuffix of _post

Identifies and/or transforms type template parameter names as follows:

Before:

template <template <typename> class TPL_parameter, int COUNT_params,
          typename... TYPE_parameters>

After:

template <template <typename> class TPL_parameter, int COUNT_params,
          typename... pre_type_parameters_post>

UnionCase¶: When defined, the check will ensure union names conform to the selected casing.

UnionPrefix¶: When defined, the check will ensure union names will add the prefixed with the given value (regardless of casing).

UnionIgnoredRegexp¶: Identifier naming checks won’t be enforced for union names matching this regular expression.

UnionSuffix¶: When defined, the check will ensure union names will add the suffix with the given value (regardless of casing).

For example using values of:

UnionCase of lower_case

UnionPrefix of pre_

UnionSuffix of _post

Identifies and/or transforms union names as follows:

Before:

union FOO {
  int a;
  char b;
};

After:

union pre_foo_post {
  int a;
  char b;
};

ValueTemplateParameterCase¶: When defined, the check will ensure value template parameter names conform to the selected casing.

ValueTemplateParameterPrefix¶: When defined, the check will ensure value template parameter names will add the prefixed with the given value (regardless of casing).

ValueTemplateParameterIgnoredRegexp¶: Identifier naming checks won’t be enforced for value template parameter names matching this regular expression.

ValueTemplateParameterSuffix¶: When defined, the check will ensure value template parameter names will add the suffix with the given value (regardless of casing).

For example using values of:

ValueTemplateParameterCase of lower_case

ValueTemplateParameterPrefix of pre_

ValueTemplateParameterSuffix of _post

Identifies and/or transforms value template parameter names as follows:

Before:

template <template <typename> class TPL_parameter, int COUNT_params,
          typename... TYPE_parameters>

After:

template <template <typename> class TPL_parameter, int pre_count_params_post,
          typename... TYPE_parameters>

VariableCase¶: When defined, the check will ensure variable names conform to the selected casing.

VariablePrefix¶: When defined, the check will ensure variable names will add the prefixed with the given value (regardless of casing).

VariableIgnoredRegexp¶: Identifier naming checks won’t be enforced for variable names matching this regular expression.

VariableSuffix¶: When defined, the check will ensure variable names will add the suffix with the given value (regardless of casing).

For example using values of:

VariableCase of lower_case

VariablePrefix of pre_

VariableSuffix of _post

Identifies and/or transforms variable names as follows:

Before:

unsigned MyVariable;

After:

unsigned pre_myvariable_post;

VirtualMethodCase¶: When defined, the check will ensure virtual method names conform to the selected casing.

VirtualMethodPrefix¶: When defined, the check will ensure virtual method names will add the prefixed with the given value (regardless of casing).

VirtualMethodIgnoredRegexp¶: Identifier naming checks won’t be enforced for virtual method names matching this regular expression.

VirtualMethodSuffix¶: When defined, the check will ensure virtual method names will add the suffix with the given value (regardless of casing).

For example using values of:

VirtualMethodCase of lower_case

VirtualMethodPrefix of pre_

VirtualMethodSuffix of _post

Identifies and/or transforms virtual method names as follows:

Before:

class Foo {
public:
  virtual int MemberFunction();
}

After:

class Foo {
public:
  virtual int pre_member_function_post();
}

Extra Clang Tools 13 documentation

clang-tidy - readability-identifier-naming

readability-identifier-naming¶

Options¶