readability-identifier-naming

检查标识符命名风格是否一致。

此检查将尝试对标识符命名强制执行编码指南。它支持以下其中一种大小写类型，并尝试在检测到不匹配时从一种转换为另一种

大小写类型包括

  • lower_case

  • UPPER_CASE

  • camelBack

  • CamelCase

  • camel_Snake_Back

  • Camel_Snake_Case

  • aNy_CasE

  • Leading_upper_snake_case

它还支持一个固定的前缀和后缀，无论大小写如何，这些前缀和后缀将被附加到标识符之前或之后。

为了能够为不同类型的标识符创建不同的规则，提供了许多配置选项。一般来说，如果未配置特定情况，则规则会回退到更通用的规则。

虚拟方法的命名将在它们出现在基类中时报告，但不会在它们被重写时报告，因为它无法在该处进行局部修复。这也适用于类似 CRTP 的伪重写模式。

Leading_upper_snake_case 是一种命名约定，其中第一个单词大写，后面跟着由下划线 '\_' 分隔的小写单词。示例包括：Cap_snake_case、Cobra_case、Foo_bar_baz 和 Master_copy_8gb。

匈牙利命名法可以使用不同的 HungarianPrefix 设置进行自定义。选项及其对应值如下

  • Off - 默认设置

  • On - 例如：int iVariable

  • LowerCase - 例如：int i_Variable

  • CamelCase - 例如：int IVariable

选项

以下选项在下面描述

AbstractClassCase

当定义时，检查将确保抽象类名称符合所选大小写。

AbstractClassPrefix

当定义时，检查将确保抽象类名称将添加给定值的词缀（无论大小写）。

AbstractClassIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的抽象类名称执行。

AbstractClassSuffix

当定义时，检查将确保抽象类名称将添加给定值的词缀（无论大小写）。

AbstractClassHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 抽象类案例 lower_case

  • 抽象类前缀 pre_

  • 抽象类后缀 _post

  • 抽象类匈牙利前缀 On

识别和/或转换抽象类名如下

之前

class ABSTRACT_CLASS {
public:
  ABSTRACT_CLASS();
};

之后

class pre_abstract_class_post {
public:
  pre_abstract_class_post();
};
AggressiveDependentMemberLookup

当设置为 true 时，检查将查找依赖基类中需要更改的依赖成员引用。这可能导致模板特化的错误，因此默认值为 false。

例如，使用以下值：

  • 类成员案例 lower_case

之前

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

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

如果 AggressiveDependentMemberLookup 为 false 后的

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

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

如果 AggressiveDependentMemberLookup 为 true 后的

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

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

当设置为 true 时，匿名记录（即匿名联合和结构体）中的字段将被视为封闭范围内的名称，而不是匿名记录的公共成员，用于名称检查。

例如

class Foo {
private:
  union {
    int iv_;
    float fv_;
  };
};

如果 CheckAnonFieldInParent 为 false，您可能会收到警告，提示 iv_ 和 fv_ 与公共成员名称不一致，因为 iv_ 和 fv_ 是匿名联合的公共成员。当 CheckAnonFieldInParent 为 true 时，iv_ 和 fv_ 将被视为 Foo 的私有数据成员，用于名称检查，因此不会发出警告。

ClassCase

当定义时，检查将确保类名符合所选的大小写。

ClassPrefix

当定义时，检查将确保类名前缀为给定值（不考虑大小写）。

ClassIgnoredRegexp

对于匹配此正则表达式的类名，标识符命名检查将不会强制执行。

ClassSuffix

当定义时，检查将确保类名后缀为给定值（不考虑大小写）。

ClassHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 类案例 lower_case

  • 类前缀 pre_

  • 类后缀 _post

  • 类匈牙利前缀 On

识别和/或转换类名如下

之前

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

之后

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

当定义时，检查将确保类常量名符合所选的大小写。

ClassConstantPrefix

当定义时，检查将确保类常量名前缀为给定值（不考虑大小写）。

ClassConstantIgnoredRegexp

对于匹配此正则表达式的类常量名，标识符命名检查将不会强制执行。

ClassConstantSuffix

当定义时，检查将确保类常量名后缀为给定值（不考虑大小写）。

ClassConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 类常量案例 lower_case

  • 类常量前缀 pre_

  • 类常量后缀 _post

  • 类常量匈牙利前缀 On

识别和/或转换类常量名如下

之前

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

之后

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

当定义时，检查将确保类成员名符合所选的大小写。

ClassMemberPrefix

当定义时，检查将确保类成员名前缀为给定值（不考虑大小写）。

ClassMemberIgnoredRegexp

对于匹配此正则表达式的类成员名，标识符命名检查将不会强制执行。

ClassMemberSuffix

当定义时，检查将确保类成员名后缀为给定值（不考虑大小写）。

ClassMemberHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 类成员案例 lower_case

  • 类成员前缀 pre_

  • 类成员后缀 _post

  • 类成员匈牙利前缀 On

识别和/或转换类成员名如下

之前

class FOO {
public:
  static int CLASS_CONSTANT;
};

之后

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

当定义时，检查将确保类方法名符合所选的大小写。

ClassMethodPrefix

当定义时，检查将确保类方法名前缀为给定值（不考虑大小写）。

ClassMethodIgnoredRegexp

对于匹配此正则表达式的类方法名，标识符命名检查将不会强制执行。

ClassMethodSuffix

当定义时，检查将确保类方法名后缀为给定值（不考虑大小写）。

例如，使用以下值：

  • 类方法案例 lower_case

  • 类方法前缀 pre_

  • 类方法后缀 _post

识别和/或转换类方法名如下

之前

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

之后

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

当定义时，检查将确保概念名符合所选的大小写。

ConceptPrefix

当定义时，检查将确保概念名前缀为给定值（不考虑大小写）。

ConceptIgnoredRegexp

对于匹配此正则表达式的概念名，标识符命名检查将不会强制执行。

ConceptSuffix

当定义时，检查将确保概念名后缀为给定值（不考虑大小写）。

例如，使用以下值：

  • 概念案例 CamelCase

  • 概念前缀 Pre

  • 概念后缀 Post

识别和/或转换概念名如下

之前

template<typename T> concept my_concept = requires (T t) { {t++}; };

之后

template<typename T> concept PreMyConceptPost = requires (T t) { {t++}; };
ConstantCase

当定义时，检查将确保常量名符合所选的大小写。

ConstantPrefix

当定义时，检查将确保常量名前缀为给定值（不考虑大小写）。

ConstantIgnoredRegexp

对于匹配此正则表达式的常量名，标识符命名检查将不会强制执行。

ConstantSuffix

当定义时，检查将确保常量名后缀为给定值（不考虑大小写）。

ConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 常量案例 lower_case

  • 常量前缀 pre_

  • 常量后缀 _post

  • 常量匈牙利前缀 On

识别和/或转换常量名如下

之前

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

之后

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

如果已定义，检查将确保常量成员名称符合所选大小写。

ConstantMemberPrefix

如果已定义，检查将确保常量成员名称添加指定的前缀（不考虑大小写）。

ConstantMemberIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的常量成员名称强制执行。

ConstantMemberSuffix

如果已定义，检查将确保常量成员名称添加指定的后缀（不考虑大小写）。

ConstantMemberHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ConstantMemberCase 为 lower_case

  • ConstantMemberPrefix 为 pre_

  • ConstantMemberSuffix 为 _post

  • ConstantMemberHungarianPrefix 为 On

识别和/或转换常量成员名称如下

之前

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

之后

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

如果已定义，检查将确保常量参数名称符合所选大小写。

ConstantParameterPrefix

如果已定义，检查将确保常量参数名称添加指定的前缀（不考虑大小写）。

ConstantParameterIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的常量参数名称强制执行。

ConstantParameterSuffix

如果已定义，检查将确保常量参数名称添加指定的后缀（不考虑大小写）。

ConstantParameterHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ConstantParameterCase 为 lower_case

  • ConstantParameterPrefix 为 pre_

  • ConstantParameterSuffix 为 _post

  • ConstantParameterHungarianPrefix 为 On

识别和/或转换常量参数名称如下

之前

void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);

之后

void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);
ConstantPointerParameterCase

如果已定义，检查将确保常量指针参数名称符合所选大小写。

ConstantPointerParameterPrefix

如果已定义，检查将确保常量指针参数名称添加指定的前缀（不考虑大小写）。

ConstantPointerParameterIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的常量指针参数名称强制执行。

ConstantPointerParameterSuffix

如果已定义，检查将确保常量指针参数名称添加指定的后缀（不考虑大小写）。

ConstantPointerParameterHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ConstantPointerParameterCase 为 lower_case

  • ConstantPointerParameterPrefix 为 pre_

  • ConstantPointerParameterSuffix 为 _post

  • ConstantPointerParameterHungarianPrefix 为 On

识别和/或转换常量指针参数名称如下

之前

void GLOBAL_FUNCTION(int const *CONST_parameter);

之后

void GLOBAL_FUNCTION(int const *pre_const_parameter_post);
ConstexprFunctionCase

如果已定义，检查将确保 constexpr 函数名称符合所选大小写。

ConstexprFunctionPrefix

如果已定义，检查将确保 constexpr 函数名称添加指定的前缀（不考虑大小写）。

ConstexprFunctionIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的 constexpr 函数名称强制执行。

ConstexprFunctionSuffix

如果已定义，检查将确保 constexpr 函数名称添加指定的后缀（不考虑大小写）。

例如，使用以下值：

  • ConstexprFunctionCase 为 lower_case

  • ConstexprFunctionPrefix 为 pre_

  • ConstexprFunctionSuffix 为 _post

识别和/或转换 constexpr 函数名称如下

之前

constexpr int CE_function() { return 3; }

之后

constexpr int pre_ce_function_post() { return 3; }
ConstexprMethodCase

如果已定义，检查将确保 constexpr 方法名称符合所选大小写。

ConstexprMethodPrefix

如果已定义，检查将确保 constexpr 方法名称添加指定的前缀（不考虑大小写）。

ConstexprMethodIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的 constexpr 方法名称强制执行。

ConstexprMethodSuffix

如果已定义，检查将确保 constexpr 方法名称添加指定的后缀（不考虑大小写）。

例如，使用以下值：

  • ConstexprMethodCase 为 lower_case

  • ConstexprMethodPrefix 为 pre_

  • ConstexprMethodSuffix 为 _post

识别和/或转换 constexpr 方法名称如下

之前

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

之后

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

如果已定义，检查将确保 constexpr 变量名称符合所选大小写。

ConstexprVariablePrefix

如果已定义，检查将确保 constexpr 变量名称添加指定的前缀（不考虑大小写）。

ConstexprVariableIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的 constexpr 变量名称强制执行。

ConstexprVariableSuffix

如果已定义，检查将确保 constexpr 变量名称添加指定的后缀（不考虑大小写）。

ConstexprVariableHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ConstexprVariableCase 为 lower_case

  • ConstexprVariablePrefix 为 pre_

  • ConstexprVariableSuffix 为 _post

  • ConstexprVariableHungarianPrefix 为 On

识别和/或转换 constexpr 变量名称如下

之前

constexpr int ConstExpr_variable = MyConstant;

之后

constexpr int pre_constexpr_variable_post = MyConstant;
EnumCase

如果已定义，检查将确保枚举名称符合所选大小写。

EnumPrefix

如果已定义，检查将确保枚举名称添加指定的前缀（不考虑大小写）。

EnumIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的枚举名称强制执行。

EnumSuffix

如果已定义，检查将确保枚举名称添加指定的后缀（不考虑大小写）。

例如，使用以下值：

  • EnumCase 为 lower_case

  • EnumPrefix 为 pre_

  • EnumSuffix 为 _post

识别和/或转换枚举名称如下

之前

enum FOO { One, Two, Three };

之后

enum pre_foo_post { One, Two, Three };
EnumConstantCase

如果已定义，检查将确保枚举常量名称符合所选大小写。

EnumConstantPrefix

如果已定义，检查将确保枚举常量名称添加指定的前缀（不考虑大小写）。

EnumConstantIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的枚举常量名称强制执行。

EnumConstantSuffix

如果已定义，检查将确保枚举常量名称添加指定的后缀（不考虑大小写）。

EnumConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 枚举常量的大小写为 lower_case

  • 枚举常量的前缀为 pre_

  • 枚举常量的后缀为 _post

  • 枚举常量匈牙利前缀为 On

识别和/或转换枚举常量名称如下

之前

enum FOO { One, Two, Three };

之后

enum FOO { pre_One_post, pre_Two_post, pre_Three_post };
FunctionCase

如果定义了，检查将确保函数名符合所选的大小写。

FunctionPrefix

如果定义了，检查将确保函数名以给定的值作为前缀（不考虑大小写）。

FunctionIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的函数名强制执行。

FunctionSuffix

如果定义了，检查将确保函数名以给定的值作为后缀（不考虑大小写）。

例如，使用以下值：

  • 函数大小写为 lower_case

  • 函数前缀为 pre_

  • 函数后缀为 _post

识别和/或转换函数名如下

之前

char MY_Function_string();

之后

char pre_my_function_string_post();
GetConfigPerFile

如果设置为 true，检查将查找声明标识符所在位置的配置。当包含的头文件使用不同的样式时很有用。默认值为 true。

GlobalConstantCase

如果定义了，检查将确保全局常量名符合所选的大小写。

GlobalConstantPrefix

如果定义了，检查将确保全局常量名以给定的值作为前缀（不考虑大小写）。

GlobalConstantIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的全局常量名强制执行。

GlobalConstantSuffix

如果定义了，检查将确保全局常量名以给定的值作为后缀（不考虑大小写）。

GlobalConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 全局常量大小写为 lower_case

  • 全局常量前缀为 pre_

  • 全局常量后缀为 _post

  • 全局常量匈牙利前缀为 On

识别和/或转换全局常量名如下

之前

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

之后

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

如果定义了，检查将确保全局常量指针名符合所选的大小写。

GlobalConstantPointerPrefix

如果定义了，检查将确保全局常量指针名以给定的值作为前缀（不考虑大小写）。

GlobalConstantPointerIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的全局常量指针名强制执行。

GlobalConstantPointerSuffix

如果定义了，检查将确保全局常量指针名以给定的值作为后缀（不考虑大小写）。

GlobalConstantPointerHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 全局常量指针大小写为 lower_case

  • 全局常量指针前缀为 pre_

  • 全局常量指针后缀为 _post

  • 全局常量指针匈牙利前缀为 On

识别和/或转换全局常量指针名如下

之前

int *const MyConstantGlobalPointer = nullptr;

之后

int *const pre_myconstantglobalpointer_post = nullptr;
GlobalFunctionCase

如果定义了，检查将确保全局函数名符合所选的大小写。

GlobalFunctionPrefix

如果定义了，检查将确保全局函数名以给定的值作为前缀（不考虑大小写）。

GlobalFunctionIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的全局函数名强制执行。

GlobalFunctionSuffix

如果定义了，检查将确保全局函数名以给定的值作为后缀（不考虑大小写）。

例如，使用以下值：

  • 全局函数大小写为 lower_case

  • 全局函数前缀为 pre_

  • 全局函数后缀为 _post

识别和/或转换全局函数名如下

之前

void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);

之后

void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);
GlobalPointerCase

如果定义了，检查将确保全局指针名符合所选的大小写。

GlobalPointerPrefix

如果定义了，检查将确保全局指针名以给定的值作为前缀（不考虑大小写）。

GlobalPointerIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的全局指针名强制执行。

GlobalPointerSuffix

如果定义了，检查将确保全局指针名以给定的值作为后缀（不考虑大小写）。

GlobalPointerHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 全局指针大小写为 lower_case

  • 全局指针前缀为 pre_

  • 全局指针后缀为 _post

  • 全局指针匈牙利前缀为 On

识别和/或转换全局指针名如下

之前

int *GLOBAL3;

之后

int *pre_global3_post;
GlobalVariableCase

如果定义了，检查将确保全局变量名符合所选的大小写。

GlobalVariablePrefix

如果定义了，检查将确保全局变量名以给定的值作为前缀（不考虑大小写）。

GlobalVariableIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的全局变量名强制执行。

GlobalVariableSuffix

如果定义了，检查将确保全局变量名以给定的值作为后缀（不考虑大小写）。

GlobalVariableHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • 全局变量大小写为 lower_case

  • 全局变量前缀为 pre_

  • 全局变量后缀为 _post

  • 全局变量匈牙利前缀为 On

识别和/或转换全局变量名如下

之前

int GLOBAL3;

之后

int pre_global3_post;
IgnoreMainLikeFunctions

如果设置为 true，则类似于 main 或 wmain 的函数不会对参数名称进行检查。默认值为 false。

InlineNamespaceCase

如果定义了，检查将确保内联命名空间名符合所选的大小写。

InlineNamespacePrefix

如果定义了，检查将确保内联命名空间名以给定的值作为前缀（不考虑大小写）。

InlineNamespaceIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的内联命名空间名强制执行。

InlineNamespaceSuffix

如果定义了，检查将确保内联命名空间名以给定的值作为后缀（不考虑大小写）。

例如，使用以下值：

  • 内联命名空间大小写为 lower_case

  • 内联命名空间前缀为 pre_

  • 内联命名空间后缀为 _post

识别和/或转换内联命名空间名称，如下所示

之前

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

之后

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

如果定义，则检查将确保本地常量名称符合所选的大小写规则。

LocalConstantPrefix

如果定义，则检查将确保本地常量名称以给定值作为前缀（不考虑大小写）。

LocalConstantIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的本地常量名称强制执行。

LocalConstantSuffix

如果定义，则检查将确保本地常量名称以给定值作为后缀（不考虑大小写）。

LocalConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • LocalConstantCase 为 lower_case

  • LocalConstantPrefix 为 pre_

  • LocalConstantSuffix 为 _post

  • LocalConstantHungarianPrefix 为 On

识别和/或转换本地常量名称，如下所示

之前

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

之后

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

如果定义，则检查将确保本地常量指针名称符合所选的大小写规则。

LocalConstantPointerPrefix

如果定义，则检查将确保本地常量指针名称以给定值作为前缀（不考虑大小写）。

LocalConstantPointerIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的本地常量指针名称强制执行。

LocalConstantPointerSuffix

如果定义，则检查将确保本地常量指针名称以给定值作为后缀（不考虑大小写）。

LocalConstantPointerHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • LocalConstantPointerCase 为 lower_case

  • LocalConstantPointerPrefix 为 pre_

  • LocalConstantPointerSuffix 为 _post

  • LocalConstantPointerHungarianPrefix 为 On

识别和/或转换本地常量指针名称，如下所示

之前

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

之后

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

如果定义，则检查将确保本地指针名称符合所选的大小写规则。

LocalPointerPrefix

如果定义，则检查将确保本地指针名称以给定值作为前缀（不考虑大小写）。

LocalPointerIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的本地指针名称强制执行。

LocalPointerSuffix

如果定义，则检查将确保本地指针名称以给定值作为后缀（不考虑大小写）。

LocalPointerHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • LocalPointerCase 为 lower_case

  • LocalPointerPrefix 为 pre_

  • LocalPointerSuffix 为 _post

  • LocalPointerHungarianPrefix 为 On

识别和/或转换本地指针名称，如下所示

之前

void foo() { int *local_Constant; }

之后

void foo() { int *pre_local_constant_post; }
LocalVariableCase

如果定义，则检查将确保本地变量名称符合所选的大小写规则。

LocalVariablePrefix

如果定义，则检查将确保本地变量名称以给定值作为前缀（不考虑大小写）。

LocalVariableIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的本地变量名称强制执行。

例如，使用以下值：

  • LocalVariableCase 为 CamelCase

  • LocalVariableIgnoredRegexp 为 \w{1,2}

将排除长度小于或等于 2 的变量，这些变量将不适用应用于其他变量的驼峰式命名检查。

LocalVariableSuffix

如果定义，则检查将确保本地变量名称以给定值作为后缀（不考虑大小写）。

LocalVariableHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • LocalVariableCase 为 lower_case

  • LocalVariablePrefix 为 pre_

  • LocalVariableSuffix 为 _post

  • LocalVariableHungarianPrefix 为 On

识别和/或转换本地变量名称，如下所示

之前

void foo() { int local_Constant; }

之后

void foo() { int pre_local_constant_post; }
MacroDefinitionCase

如果定义，则检查将确保宏定义符合所选的大小写规则。

MacroDefinitionPrefix

如果定义，则检查将确保宏定义以给定值作为前缀（不考虑大小写）。

MacroDefinitionIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的宏定义强制执行。

MacroDefinitionSuffix

如果定义，则检查将确保宏定义以给定值作为后缀（不考虑大小写）。

例如，使用以下值：

  • MacroDefinitionCase 为 lower_case

  • MacroDefinitionPrefix 为 pre_

  • MacroDefinitionSuffix 为 _post

识别和/或转换宏定义，如下所示

之前

#define MY_MacroDefinition

之后

#define pre_my_macro_definition_post

注意：这不会对内置宏或使用 -D 标记在命令行中定义的宏发出警告。

MemberCase

如果定义，则检查将确保成员名称符合所选的大小写规则。

MemberPrefix

如果定义，则检查将确保成员名称以给定值作为前缀（不考虑大小写）。

MemberIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的成员名称强制执行。

MemberSuffix

如果定义，则检查将确保成员名称以给定值作为后缀（不考虑大小写）。

MemberHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • MemberCase 为 lower_case

  • MemberPrefix 为 pre_

  • MemberSuffix 为 _post

  • MemberHungarianPrefix 为 On

识别和/或转换成员名称，如下所示

之前

class Foo {
  char MY_ConstMember_string[4];
}

之后

class Foo {
  char pre_my_constmember_string_post[4];
}
MethodCase

如果定义，则检查将确保方法名称符合所选的大小写规则。

MethodPrefix

如果定义，则检查将确保方法名称以给定值作为前缀（不考虑大小写）。

MethodIgnoredRegexp

标识符命名检查不会对匹配此正则表达式的成员名称强制执行。

MethodSuffix

如果定义，则检查将确保方法名称以给定值作为后缀（不考虑大小写）。

例如，使用以下值：

  • MethodCase 为 lower_case

  • MethodPrefix 为 pre_

  • 方法后缀为 _post

识别和/或转换方法名称，如下所示

之前

class Foo {
  char MY_Method_string();
}

之后

class Foo {
  char pre_my_method_string_post();
}
NamespaceCase

定义后，检查将确保命名空间名称符合所选大小写。

NamespacePrefix

定义后，检查将确保命名空间名称将添加给定值作为前缀（不区分大小写）。

NamespaceIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的命名空间名称执行。

NamespaceSuffix

定义后，检查将确保命名空间名称将添加给定值作为后缀（不区分大小写）。

例如，使用以下值：

  • NamespaceCase 为 lower_case

  • NamespacePrefix 为 pre_

  • NamespaceSuffix 为 _post

识别和/或转换命名空间名称，如下所示

之前

namespace FOO_NS {
...
}

之后

namespace pre_foo_ns_post {
...
}
ParameterCase

定义后，检查将确保参数名称符合所选大小写。

ParameterPrefix

定义后，检查将确保参数名称将添加给定值作为前缀（不区分大小写）。

ParameterIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的参数名称执行。

ParameterSuffix

定义后，检查将确保参数名称将添加给定值作为后缀（不区分大小写）。

ParameterHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ParameterCase 为 lower_case

  • ParameterPrefix 为 pre_

  • ParameterSuffix 为 _post

  • ParameterHungarianPrefix 为 On

识别和/或转换参数名称，如下所示

之前

void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);

之后

void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);
ParameterPackCase

定义后，检查将确保参数包名称符合所选大小写。

ParameterPackPrefix

定义后，检查将确保参数包名称将添加给定值作为前缀（不区分大小写）。

ParameterPackIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的参数包名称执行。

ParameterPackSuffix

定义后，检查将确保参数包名称将添加给定值作为后缀（不区分大小写）。

例如，使用以下值：

  • ParameterPackCase 为 lower_case

  • ParameterPackPrefix 为 pre_

  • ParameterPackSuffix 为 _post

识别和/或转换参数包名称，如下所示

之前

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

之后

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

定义后，检查将确保指针参数名称符合所选大小写。

PointerParameterPrefix

定义后，检查将确保指针参数名称将添加给定值作为前缀（不区分大小写）。

PointerParameterIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的指针参数名称执行。

PointerParameterSuffix

定义后，检查将确保指针参数名称将添加给定值作为后缀（不区分大小写）。

PointerParameterHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • PointerParameterCase 为 lower_case

  • PointerParameterPrefix 为 pre_

  • PointerParameterSuffix 为 _post

  • PointerParameterHungarianPrefix 为 On

识别和/或转换指针参数名称，如下所示

之前

void FUNCTION(int *PARAMETER);

之后

void FUNCTION(int *pre_parameter_post);
PrivateMemberCase

定义后，检查将确保私有成员名称符合所选大小写。

PrivateMemberPrefix

定义后，检查将确保私有成员名称将添加给定值作为前缀（不区分大小写）。

PrivateMemberIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的私有成员名称执行。

PrivateMemberSuffix

定义后，检查将确保私有成员名称将添加给定值作为后缀（不区分大小写）。

PrivateMemberHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • PrivateMemberCase 为 lower_case

  • PrivateMemberPrefix 为 pre_

  • PrivateMemberSuffix 为 _post

  • PrivateMemberHungarianPrefix 为 On

识别和/或转换私有成员名称，如下所示

之前

class Foo {
private:
  int Member_Variable;
}

之后

class Foo {
private:
  int pre_member_variable_post;
}
PrivateMethodCase

定义后，检查将确保私有方法名称符合所选大小写。

PrivateMethodPrefix

定义后，检查将确保私有方法名称将添加给定值作为前缀（不区分大小写）。

PrivateMethodIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的私有方法名称执行。

PrivateMethodSuffix

定义后，检查将确保私有方法名称将添加给定值作为后缀（不区分大小写）。

例如，使用以下值：

  • PrivateMethodCase 为 lower_case

  • PrivateMethodPrefix 为 pre_

  • PrivateMethodSuffix 为 _post

识别和/或转换私有方法名称，如下所示

之前

class Foo {
private:
  int Member_Method();
}

之后

class Foo {
private:
  int pre_member_method_post();
}
ProtectedMemberCase

定义后，检查将确保受保护的成员名称符合所选大小写。

ProtectedMemberPrefix

定义后，检查将确保受保护的成员名称将添加给定值作为前缀（不区分大小写）。

ProtectedMemberIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的受保护的成员名称执行。

ProtectedMemberSuffix

定义后，检查将确保受保护的成员名称将添加给定值作为后缀（不区分大小写）。

ProtectedMemberHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ProtectedMemberCase 为 lower_case

  • ProtectedMemberPrefix 为 pre_

  • ProtectedMemberSuffix 为 _post

  • ProtectedMemberHungarianPrefix 为 On

识别和/或转换受保护的成员名称，如下所示

之前

class Foo {
protected:
  int Member_Variable;
}

之后

class Foo {
protected:
  int pre_member_variable_post;
}
ProtectedMethodCase

定义后，检查将确保受保护的方法名称符合所选大小写。

ProtectedMethodPrefix

定义后，检查将确保受保护的方法名称将添加给定值作为前缀（不区分大小写）。

ProtectedMethodIgnoredRegexp

标识符命名检查将不会对与该正则表达式匹配的受保护的方法名称执行。

ProtectedMethodSuffix

定义后，检查将确保受保护的方法名称将添加给定值作为后缀（不区分大小写）。

例如，使用以下值：

  • ProtectedMethodCase 为 lower_case

  • ProtectedMethodPrefix 为 pre_

  • 受保护方法后缀为 _post

标识和/或转换受保护方法名称，如下所示

之前

class Foo {
protected:
  int Member_Method();
}

之后

class Foo {
protected:
  int pre_member_method_post();
}
PublicMemberCase

如果定义，则检查将确保公共成员名称符合所选的大小写。

PublicMemberPrefix

如果定义，则检查将确保公共成员名称将在前面加上给定值（不考虑大小写）。

PublicMemberIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的公共成员名称。

PublicMemberSuffix

如果定义，则检查将确保公共成员名称将添加后缀为给定值（不考虑大小写）。

PublicMemberHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • PublicMemberCase 为 lower_case

  • PublicMemberPrefix 为 pre_

  • PublicMemberSuffix 为 _post

  • PublicMemberHungarianPrefix 为 On

标识和/或转换公共成员名称，如下所示

之前

class Foo {
public:
  int Member_Variable;
}

之后

class Foo {
public:
  int pre_member_variable_post;
}
PublicMethodCase

如果定义，则检查将确保公共方法名称符合所选的大小写。

PublicMethodPrefix

如果定义，则检查将确保公共方法名称将在前面加上给定值（不考虑大小写）。

PublicMethodIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的公共方法名称。

PublicMethodSuffix

如果定义，则检查将确保公共方法名称将添加后缀为给定值（不考虑大小写）。

例如，使用以下值：

  • PublicMethodCase 为 lower_case

  • PublicMethodPrefix 为 pre_

  • PublicMethodSuffix 为 _post

标识和/或转换公共方法名称，如下所示

之前

class Foo {
public:
  int Member_Method();
}

之后

class Foo {
public:
  int pre_member_method_post();
}
ScopedEnumConstantCase

如果定义，则检查将确保作用域枚举常量名称符合所选的大小写。

ScopedEnumConstantPrefix

如果定义，则检查将确保作用域枚举常量名称将在前面加上给定值（不考虑大小写）。

ScopedEnumConstantIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的作用域枚举常量名称。

ScopedEnumConstantSuffix

如果定义，则检查将确保作用域枚举常量名称将添加后缀为给定值（不考虑大小写）。

ScopedEnumConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • ScopedEnumConstantCase 为 lower_case

  • ScopedEnumConstantPrefix 为 pre_

  • ScopedEnumConstantSuffix 为 _post

  • ScopedEnumConstantHungarianPrefix 为 On

识别和/或转换枚举常量名称如下

之前

enum class FOO { One, Two, Three };

之后

enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };
StaticConstantCase

如果定义，则检查将确保静态常量名称符合所选的大小写。

StaticConstantPrefix

如果定义，则检查将确保静态常量名称将在前面加上给定值（不考虑大小写）。

StaticConstantIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的静态常量名称。

StaticConstantSuffix

如果定义，则检查将确保静态常量名称将添加后缀为给定值（不考虑大小写）。

StaticConstantHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • StaticConstantCase 为 lower_case

  • StaticConstantPrefix 为 pre_

  • StaticConstantSuffix 为 _post

  • StaticConstantHungarianPrefix 为 On

标识和/或转换静态常量名称，如下所示

之前

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

之后

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

如果定义，则检查将确保静态变量名称符合所选的大小写。

StaticVariablePrefix

如果定义，则检查将确保静态变量名称将在前面加上给定值（不考虑大小写）。

StaticVariableIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的静态变量名称。

StaticVariableSuffix

如果定义，则检查将确保静态变量名称将添加后缀为给定值（不考虑大小写）。

StaticVariableHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • StaticVariableCase 为 lower_case

  • StaticVariablePrefix 为 pre_

  • StaticVariableSuffix 为 _post

  • StaticVariableHungarianPrefix 为 On

标识和/或转换静态变量名称，如下所示

之前

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

之后

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

如果定义，则检查将确保结构名称符合所选的大小写。

StructPrefix

如果定义，则检查将确保结构名称将在前面加上给定值（不考虑大小写）。

StructIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的结构名称。

StructSuffix

如果定义，则检查将确保结构名称将添加后缀为给定值（不考虑大小写）。

例如，使用以下值：

  • StructCase 为 lower_case

  • StructPrefix 为 pre_

  • StructSuffix 为 _post

标识和/或转换结构名称，如下所示

之前

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

之后

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

如果定义，则检查将确保模板参数名称符合所选的大小写。

TemplateParameterPrefix

如果定义，则检查将确保模板参数名称将在前面加上给定值（不考虑大小写）。

TemplateParameterIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的模板参数名称。

TemplateParameterSuffix

如果定义，则检查将确保模板参数名称将添加后缀为给定值（不考虑大小写）。

例如，使用以下值：

  • TemplateParameterCase 为 lower_case

  • TemplateParameterPrefix 为 pre_

  • TemplateParameterSuffix 为 _post

标识和/或转换模板参数名称，如下所示

之前

template <typename T> class Foo {};

之后

template <typename pre_t_post> class Foo {};
TemplateTemplateParameterCase

如果定义，则检查将确保模板模板参数名称符合所选的大小写。

TemplateTemplateParameterPrefix

如果定义，则检查将确保模板模板参数名称将在前面加上给定值（不考虑大小写）。

TemplateTemplateParameterIgnoredRegexp

标识符命名检查将不会强制执行与该正则表达式匹配的模板模板参数名称。

TemplateTemplateParameterSuffix

如果定义，则检查将确保模板模板参数名称将添加后缀为给定值（不考虑大小写）。

例如，使用以下值：

  • TemplateTemplateParameterCase 为 lower_case

  • TemplateTemplateParameterPrefix 为 pre_

  • 模板模板参数后缀为 _post

标识和/或转换模板模板参数名称，如下所示

之前

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

之后

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

如果定义了，则检查将确保类型别名名称符合所选的大小写。

TypeAliasPrefix

如果定义了，则检查将确保类型别名名称将添加前缀，其值为给定值（不区分大小写）。

TypeAliasIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的类型别名名称强制执行。

TypeAliasSuffix

如果定义了，则检查将确保类型别名名称将添加后缀，其值为给定值（不区分大小写）。

例如，使用以下值：

  • TypeAliasCase 为 lower_case

  • TypeAliasPrefix 为 pre_

  • TypeAliasSuffix 为 _post

标识和/或转换类型别名名称，如下所示

之前

using MY_STRUCT_TYPE = my_structure;

之后

using pre_my_struct_type_post = my_structure;
TypedefCase

如果定义了，则检查将确保 typedef 名称符合所选的大小写。

TypedefPrefix

如果定义了，则检查将确保 typedef 名称将添加前缀，其值为给定值（不区分大小写）。

TypedefIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的 typedef 名称强制执行。

TypedefSuffix

如果定义了，则检查将确保 typedef 名称将添加后缀，其值为给定值（不区分大小写）。

例如，使用以下值：

  • TypedefCase 为 lower_case

  • TypedefPrefix 为 pre_

  • TypedefSuffix 为 _post

标识和/或转换 typedef 名称，如下所示

之前

typedef int MYINT;

之后

typedef int pre_myint_post;
TypeTemplateParameterCase

如果定义了，则检查将确保类型模板参数名称符合所选的大小写。

TypeTemplateParameterPrefix

如果定义了，则检查将确保类型模板参数名称将添加前缀，其值为给定值（不区分大小写）。

TypeTemplateParameterIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的类型模板名称强制执行。

TypeTemplateParameterSuffix

如果定义了，则检查将确保类型模板参数名称将添加后缀，其值为给定值（不区分大小写）。

例如，使用以下值：

  • TypeTemplateParameterCase 为 lower_case

  • TypeTemplateParameterPrefix 为 pre_

  • TypeTemplateParameterSuffix 为 _post

标识和/或转换类型模板参数名称，如下所示

之前

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

之后

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

如果定义了，则检查将确保联合名称符合所选的大小写。

UnionPrefix

如果定义了，则检查将确保联合名称将添加前缀，其值为给定值（不区分大小写）。

UnionIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的联合名称强制执行。

UnionSuffix

如果定义了，则检查将确保联合名称将添加后缀，其值为给定值（不区分大小写）。

例如，使用以下值：

  • UnionCase 为 lower_case

  • UnionPrefix 为 pre_

  • UnionSuffix 为 _post

标识和/或转换联合名称，如下所示

之前

union FOO {
  int a;
  char b;
};

之后

union pre_foo_post {
  int a;
  char b;
};
ValueTemplateParameterCase

如果定义了，则检查将确保值模板参数名称符合所选的大小写。

ValueTemplateParameterPrefix

如果定义了，则检查将确保值模板参数名称将添加前缀，其值为给定值（不区分大小写）。

ValueTemplateParameterIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的值模板参数名称强制执行。

ValueTemplateParameterSuffix

如果定义了，则检查将确保值模板参数名称将添加后缀，其值为给定值（不区分大小写）。

例如，使用以下值：

  • ValueTemplateParameterCase 为 lower_case

  • ValueTemplateParameterPrefix 为 pre_

  • ValueTemplateParameterSuffix 为 _post

标识和/或转换值模板参数名称，如下所示

之前

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

之后

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

如果定义了，则检查将确保变量名称符合所选的大小写。

VariablePrefix

如果定义了，则检查将确保变量名称将添加前缀，其值为给定值（不区分大小写）。

VariableIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的变量名称强制执行。

VariableSuffix

如果定义了，则检查将确保变量名称将添加后缀，其值为给定值（不区分大小写）。

VariableHungarianPrefix

启用后，检查确保声明的标识符将根据声明的类型具有匈牙利符号前缀。

例如，使用以下值：

  • VariableCase 为 lower_case

  • VariablePrefix 为 pre_

  • VariableSuffix 为 _post

  • VariableHungarianPrefix 为 On

标识和/或转换变量名称，如下所示

之前

unsigned MyVariable;

之后

unsigned pre_myvariable_post;
VirtualMethodCase

如果定义了，则检查将确保虚拟方法名称符合所选的大小写。

VirtualMethodPrefix

如果定义了，则检查将确保虚拟方法名称将添加前缀，其值为给定值（不区分大小写）。

VirtualMethodIgnoredRegexp

标识符命名检查不会对与该正则表达式匹配的虚拟方法名称强制执行。

VirtualMethodSuffix

如果定义了，则检查将确保虚拟方法名称将添加后缀，其值为给定值（不区分大小写）。

例如，使用以下值：

  • VirtualMethodCase 为 lower_case

  • VirtualMethodPrefix 为 pre_

  • VirtualMethodSuffix 为 _post

标识和/或转换虚拟方法名称，如下所示

之前

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

之后

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

匈牙利命名法的默认映射表

在匈牙利命名法中，变量名以一组小写字母开头，这些字母是该变量类型或目的的助记符，后跟程序员选择的任何名称；这最后部分有时被称为给定名称。给定名称的第一个字符可以大写，以将其与类型指示符区分开来（另请参阅 CamelCase）。否则，该字符的大小写表示作用域。

下表是匈牙利命名法的默认映射表，它将 Decl 映射到其前缀字符串。您也可以在配置文件中拥有自己的样式。

基本类型

Microsoft 类型

类型

前缀

类型

前缀

类型

前缀

int8_t

i8

signed int

si

BOOL

b

int16_t

i16

signed short

ss

BOOLEAN

b

int32_t

i32

signed short int

ssi

BYTE

by

int64_t

i64

signed long long int

slli

CHAR

c

uint8_t

u8

signed long long

sll

UCHAR

uc

uint16_t

u16

signed long int

sli

SHORT

s

uint32_t

u32

signed long

sl

USHORT

us

uint64_t

u64

signed

s

WORD

w

char8_t

c8

unsigned long long int

ulli

DWORD

dw

char16_t

c16

unsigned long long

ull

DWORD32

dw32

char32_t

c32

unsigned long int

uli

DWORD64

dw64

float

f

unsigned long

ul

LONG

l

double

d

unsigned short int

usi

ULONG

ul

char

c

unsigned short

us

ULONG32

ul32

bool

b

unsigned int

ui

ULONG64

ul64

_Bool

b

unsigned char

uc

ULONGLONG

ull

int

i

unsigned

u

HANDLE

h

size_t

n

long long int

lli

INT

i

short

s

long double

ld

INT8

i8

signed

i

long long

ll

INT16

i16

unsigned

u

long int

li

INT32

i32

long

l

long

l

INT64

i64

long long

ll

ptrdiff_t

p

UINT

ui

unsigned long

ul

void

none

UINT8

u8

long double

ld

UINT16

u16

ptrdiff_t

p

UINT32

u32

wchar_t

wc

UINT64

u64

short int

si

PVOID

p

short

s

匈牙利命名法还有更多简单的选项

HungarianNotation.General.*

这些选项不属于任何特定的声明。

HungarianNotation.CString.*

用于以 NULL 结尾的字符串的选项。

HungarianNotation.DerivedType.*

用于派生类型的选项。

HungarianNotation.PrimitiveType.*

用于基本类型的选项。

HungarianNotation.UserDefinedType.*

用于用户定义类型的选项。

匈牙利命名法选项

HungarianNotation.General.TreatStructAsClass

当定义时，检查将把结构的命名视为类。默认值为 false。

HungarianNotation.DerivedType.Array

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 a。

HungarianNotation.DerivedType.Pointer

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 p。

HungarianNotation.DerivedType.FunctionPointer

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 fn。

之前

// Array
int DataArray[2] = {0};

// Pointer
void *DataBuffer = NULL;

// FunctionPointer
typedef void (*FUNC_PTR)();
FUNC_PTR FuncPtr = NULL;

之后

// Array
int aDataArray[2] = {0};

// Pointer
void *pDataBuffer = NULL;

// FunctionPointer
typedef void (*FUNC_PTR)();
FUNC_PTR fnFuncPtr = NULL;
HungarianNotation.CString.CharPointer

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 sz。

HungarianNotation.CString.CharArray

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 sz。

HungarianNotation.CString.WideCharPointer

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 wsz。

HungarianNotation.CString.WideCharArray

当定义时，检查将确保变量名将添加以给定字符串为前缀。默认前缀为 wsz。

之前

// CharPointer
const char *NamePtr = "Name";

// CharArray
const char NameArray[] = "Name";

// WideCharPointer
const wchar_t *WideNamePtr = L"Name";

// WideCharArray
const wchar_t WideNameArray[] = L"Name";

之后

// CharPointer
const char *szNamePtr = "Name";

// CharArray
const char szNameArray[] = "Name";

// WideCharPointer
const wchar_t *wszWideNamePtr = L"Name";

// WideCharArray
const wchar_t wszWideNameArray[] = L"Name";
HungarianNotation.PrimitiveType.*

当定义时，检查将确保涉及基本类型的变量名将添加以给定字符串为前缀。默认前缀定义在默认映射表中。

HungarianNotation.UserDefinedType.*

当定义时，检查将确保涉及基本类型的变量名将添加以给定字符串为前缀。默认前缀定义在默认映射表中。

之前

int8_t   ValueI8      = 0;
int16_t  ValueI16     = 0;
int32_t  ValueI32     = 0;
int64_t  ValueI64     = 0;
uint8_t  ValueU8      = 0;
uint16_t ValueU16     = 0;
uint32_t ValueU32     = 0;
uint64_t ValueU64     = 0;
float    ValueFloat   = 0.0;
double   ValueDouble  = 0.0;
ULONG    ValueUlong   = 0;
DWORD    ValueDword   = 0;

之后

int8_t   i8ValueI8    = 0;
int16_t  i16ValueI16  = 0;
int32_t  i32ValueI32  = 0;
int64_t  i64ValueI64  = 0;
uint8_t  u8ValueU8    = 0;
uint16_t u16ValueU16  = 0;
uint32_t u32ValueU32  = 0;
uint64_t u64ValueU64  = 0;
float    fValueFloat  = 0.0;
double   dValueDouble = 0.0;
ULONG    ulValueUlong = 0;
DWORD    dwValueDword = 0;