LG

Outils pour utilisateurs

Outils du site

Piste :
prog:clang-tidy

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
prog:clang-tidy [2024/12/05 08:18] – [readability-identifier-naming] : fin de l'algo rootprog:clang-tidy [2024/12/23 09:44] (Version actuelle) – [readability-identifier-naming] : précision sur GlobalFunction root
Ligne 85: Ligne 85:
 Ci-dessous, ''defined(Xxxx)'' signifie que ''XxxxCase'', ''XxxxPrefix'', ''XxxxSuffix'', ''XxxxIgnoredRegex'' ou ''XxxxHungarianPrefix'' est dans les règles. Ci-dessous, ''defined(Xxxx)'' signifie que ''XxxxCase'', ''XxxxPrefix'', ''XxxxSuffix'', ''XxxxIgnoredRegex'' ou ''XxxxHungarianPrefix'' est dans les règles.
  
-<code> +| Algo | Exemple | 
-si (variable Objective-C && defined(ObjcIvar)) +|<code> 
-  => ObjcIvar+variable objective-C: 
 +  si SK_ObjcIvar: 
 +    SK_ObjcIvar 
 +  sinon 
 +    fin 
 +</code>|<code cpp> 
 +</code>| 
 +|<code> 
 +typedef: 
 +  si SK_Typedef: 
 +    SK_Typedef 
 +  sinon 
 +    fin 
 +</code>|<code cpp> 
 +typedef int INTeGER; 
 +</code>| 
 +|<code> 
 +using: 
 +  si SK_TypeAlias: 
 +    SK_TypeAlias 
 +  sinon 
 +    fin 
 +</code>|<code cpp> 
 +using DOUbLE = double; 
 +</code>| 
 +|<code> 
 +namespace: 
 +  si inline namespace && SK_InlineNamespace: 
 +    SK_InlineNamespace 
 +  si SK_Namespace 
 +    SK_Namespace 
 +  fin 
 +</code>|<code cpp> 
 +inline namespace NAMEsPACE {}
  
-si (typedef && defined(Typedef)) +namespace nAMEPACE {} 
-  => Typedef+</code>| 
 +|<code> 
 +enum: 
 +  si enum && SK_Enum: 
 +    SK_Enum 
 +  fin
  
-si (using && defined(TypeAlias)) +field in enum: 
-  => TypeAlias+  si enum class && SK_ScopedEnumConstant: 
 +    SK_ScopedEnumConstant 
 +  si SK_EnumConstant: 
 +    SK_EnumConstant 
 +  si SK_Constant: 
 +    SK_Constant 
 +  fin</code>|<code cpp> 
 +enum eNUM { EnuM_CONST };
  
-si (namespace) +enum class eNUM { ENUM_Const }; 
-  si (namespace est inline) && defined(InlineNamespace) +</code>| 
-    =>InlineNamespace+|<code> 
 +union ou struct ou class: 
 +  si abstract (une méthode virtuelle pure) && SK_AbstractClass: 
 +    SK_AbstractClass 
 +  si struct && SK_Struct: 
 +    SK_Struct 
 +  si struct && SK_Class: 
 +    SK_Class 
 +  si class && SK_Class: 
 +    SK_Class 
 +  si class && SK_Struct: 
 +    SK_Struct 
 +  si union && SK_Union: 
 +    SK_Union 
 +  si enum && SK_Enum: 
 +    SK_Enum 
 +  fin 
 +</code>|<code cpp> 
 +class ABStract { 
 +  virtual fOo() = 0; 
 +};
  
-  si defined(Namespace) +struct STRuct {};
-    =>Namespace+
  
-si (enum && defined(Enum)) +class ClAsS {};
-  => Enum+
  
-si (valeur d'un enum) +union UnIon {};
-  si (enum class && defined(ScopedEnumConstant)) +
-    => ScopedEnumConstant +
-  si (defined(EnumConstant)) +
-    => EnumConstant +
-  si (defined(Constant)) +
-    => Constant +
-  => Ignore+
  
-si (union ou struct ou class) +enum class eNUM {}; 
-  si (abstract (au moins une méthode virtuelle pure) && defined(AbstractClass)) +</code>| 
-    => AbstractClass +|<code> 
-  si (struct && defined(Struct)) +membre d'une classe: 
-    => Struct +  si CheckAnonFieldInParent && struct/union parent est anonyme: 
-  si (struct && defined(Class)) +    Appliquer les règles ci-dessous en 
-    => Class +      considérant le private/protected/public du parent. 
-  si (class && defined(Class)) +  si const: 
-    => Class +    si SK_ConstantMember: 
-  si (class && defined(Struct)) +      SK_ConstantMember 
-    => Struct +    si SK_Constant: 
-  si (union && defined(Union)) +      SK_Constant 
-    => Union +  si private && SK_PrivateMember: 
-  si (enum && defined(Enum)) +    SK_PrivateMember 
-    => Enum +  si protected && SK_ProtectedMember: 
-  => Ignore+    SK_ProtectedMember 
 +  si public && SK_PublicMember: 
 +    SK_PublicMember 
 +  si SK_Member: 
 +    SK_Member 
 +  fin 
 +</code>|<code cpp> 
 +class { 
 +  const int InT;
  
-si (membre d'une classe) +private: 
-  si (option CheckAnonFieldInParent && struct/union parent est anonyme) +  short ShorT;
-    Appliquer les règles ci-dessous en considérant le private/protected/public du parent. +
-  si (const) +
-    si (defined(ConstantMember)) +
-      => ConstantMember +
-    si (defined(Constant)) +
-      => Constant +
-  si (private && defined(PrivateMember)) +
-    => PrivateMember +
-  si (protected && defined(ProtectedMember)) +
-    => ProtectedMember +
-  si (public && defined(PublicMember)) +
-    => PublicMember +
-  si (defined(Member)) +
-    => Member +
-  => Ignore+
  
-si (paramètre d'une fonction) +protected: 
-  si (constexpr && defined(ConstexprVariable)) // C'est possible ? +  double DoublE;
-    => ConstexprVariable +
-  si (const) +
-    si (pointer && defined(ConstantPointerParameter)) +
-      => ConstantPointerParameter +
-    si (defined(ConstantParameter)) +
-      => ConstantParameter +
-    si (defined(Constant)) +
-      => Constant +
-  si (variadic && defined(ParameterPack)) +
-    => ParameterPack +
-  si (pointer && defined(PointerParameter)) +
-    => PointerParameter +
-  si (defined(Parameter)) +
-    => Parameter +
-  => Ignore+
  
-si (variable) +public: 
-  si (constexpr && defined(ConstexprVariable)) +  float FloaT; 
-    => ConstexprVariable +}</code>| 
-  si (const) +|<code> 
-    si (static && defined(ClassConstant)) +paramètre: 
-      => ClassConstant +  // Possible en C++ ?!? 
-    si (global && pointer && defined(GlobalConstantPointer)) +  si constexpr && SK_ConstexprVariable: 
-      => GlobalConstantPointer +    SK_ConstexprVariable 
-    si (global && defined(GlobalConstant)) +  si const: 
-      => GlobalConstant +    si pointeur && SK_ConstantPointerParameter: 
-    si (local && static && defined(StaticConstant)) +      SK_ConstantPointerParameter 
-      => StaticConstant +    si SK_ConstantParameter: 
-    si (local && pointer && defined(LocalConstantPointer)) +      SK_ConstantParameter 
-      => LocalConstantPointer +    si SK_Constant: 
-    si (local && defined(LocalConstant)) +      SK_Constant 
-      => LocalConstant +  si variadic && SK_ParameterPack: 
-    si (defined(Constant)) +    SK_ParameterPack 
-      => Constant +  si pointeur && SK_PointerParameter: 
-     +    SK_PointerParameter 
-  si (static && defined(ClassMember)) +  si SK_Parameter: 
-    => ClassMember +    SK_Parameter 
-  si (global && pointer && defined(GlobalPointer)) +  fin 
-    => GlobalPointer +</code>|<code cpp> 
-  si (global && defined(GlobalVariable)) +template <class... Types> 
-    => GlobalVariable +void fOo(const int *IiI, const short &ShorT, 
-  si (local && static && defined(StaticVariable)) +         int *JjJ, short SsS, Types... arGs); 
-    => StaticVariable +</code>| 
-  si (local && pointer && defined(LocalPointer)) +|<code> 
-    => LocalPointer +variable: 
-  si (local && defined(LocalVariable)) +  si constexpr && SK_ConstexprVariable: 
-    => LocalVariable +    SK_ConstexprVariable 
-  si (defined(Variable)) +  si const: 
-    => Variable +    si static && membre && SK_ClassConstant: 
-  => Ignore+      SK_ClassConstant 
 +    si global && pointeur && SK_GlobalConstantPointer: 
 +      SK_GlobalConstantPointer 
 +    si global && SK_GlobalConstant: 
 +      SK_GlobalConstant 
 +    si local && static && SK_StaticConstant: 
 +      SK_StaticConstant 
 +    si local && pointeur && SK_LocalConstantPointer: 
 +      SK_LocalConstantPointer 
 +    si local && SK_LocalConstant: 
 +      SK_LocalConstant 
 +    // Plus restrictif que la condition précédente ?!? 
 +    si local && dans le bloc principal 
 +      de la fonction/méthode && SK_LocalConstant: 
 +        SK_LocalConstant 
 +    si SK_Constant: 
 +      SK_Constant 
 +  fin 
 +  si static && membre && SK_ClassMember: 
 +    SK_ClassMember 
 +  si global && pointeur && SK_GlobalPointer: 
 +    SK_GlobalPointer 
 +  si global && SK_GlobalVariable: 
 +    SK_GlobalVariable 
 +  si local && static && SK_StaticVariable: 
 +    SK_StaticVariable 
 +  si local && pointeur && SK_LocalPointer: 
 +    SK_LocalPointer 
 +  si local && SK_LocalVariable: 
 +    SK_LocalVariable 
 +  // Plus restrictif que la condition précédente ?!? 
 +  si local && dans le bloc principal 
 +    de la fonction/méthode && SK_LocalVariable: 
 +      SK_LocalVariable 
 +  si SK_Variable: 
 +    SK_Variable 
 +  fin 
 +</code>|<code cpp> 
 +constexpr int eE = 150;
  
-si (methode) +class Cc { 
-  si (override) +  static const int Ee = 150; 
-    => Ignore +};
-  si (constexpr && defined(ConstexprMethod)) +
-    => ConstexprMethod +
-  si (constexpr && defined(ConstexprFunction)) +
-    => ConstexprFunction +
-  si (static && defined(ClassMethod)) +
-    => ClassMethod +
-  si (virtual && defined(VirtualMethod)) +
-    => VirtualMethod +
-  si (private && defined(PrivateMethod)) +
-    => PrivateMethod +
-  si (protected && defined(ProtectedMethod)) +
-    => ProtectedMethod +
-  si (public && defined(PublicMethod)) +
-    => PublicMethod +
-  si (defined(Method)) +
-    => Method +
-  si (defined(Function)) +
-    => Function +
-  => Ignore+
  
-si (fonction) +const int *Jj = nullptr; 
-  si (constexpr && defined(ConstexprFunction)) +const int jJ = 0;
-    => ConstexprFunction +
-  si (global && defined(GlobalFunction)) +
-    => GlobalFunction +
-  si (defined(Function)) +
-    => Function+
  
-si (typename in template) +void fOo() { 
-  si (defined(TypeTemplateParameter)) +  static const int zZZz = 150; 
-    => TypeTemplateParameter +  const int *ZzzZ = nullptr; 
-  si (defined(TemplateParameter)) +  { 
-    => TemplateParameter +    const int ZZzz = 150; 
-  => Ignore+  } 
 +  const int ZZzZ = 150; 
 +};
  
-si (value in template) +class Cc2 { 
-  si (defined(ValueTemplateParameter)) +  static int Ee2 = 150; 
-    => ValueTemplateParameter +};
-  si (defined(TemplateParameter)) +
-    => TemplateParameter +
-  => Ignore+
  
-si (template <typename> class / typename) +int *Jj2 = nullptr; 
-  si (defined(TemplateTemplateParameter)) +int jJ2 = 0;
-    => TemplateTemplateParameter +
-  si (defined(TemplateParameter)) +
-    => TemplateParameter +
-  => Ignore+
  
-si (concept && defined(Concept)) +void fOo2() { 
-  => Concept+  static int zZZz2 = 150; 
 +  int *ZzzZ2 = nullptr; 
 +  { 
 +    int ZZzz2 = 150; 
 +  } 
 +  int ZZzZ2 = 150; 
 +}; 
 +</code>| 
 +|<code> 
 +méthode: 
 +  si override: 
 +    ignore 
 +  si constexpr && SK_ConstexprMethod: 
 +    SK_ConstexprMethod 
 +  si constexpr && SK_ConstexprFunction: 
 +    SK_ConstexprFunction 
 +  si static && SK_ClassMethod: 
 +    SK_ClassMethod 
 +  si virtual && SK_VirtualMethod: 
 +    SK_VirtualMethod 
 +  si private && SK_PrivateMethod: 
 +    SK_PrivateMethod 
 +  si protected && SK_ProtectedMethod: 
 +    SK_ProtectedMethod 
 +  si public && SK_PublicMethod: 
 +    SK_PublicMethod 
 +  si SK_Method: 
 +    SK_Method 
 +  si SK_Function: 
 +    SK_Function 
 +  ignore 
 +</code>|<code cpp> 
 +class A{ 
 +    public: 
 +    virtual void fOo()= 0; 
 +};
  
-=> Ignore +class B:public A{ 
-</code>+    public: 
 +    void fOo() override; 
 + 
 +    constexpr int fOo2(); 
 +    static void fOo3(); 
 + 
 +    virtual void fOo4(); 
 + 
 +    private: 
 +     void fOo5(); 
 +    protected: 
 +     void fOo6(); 
 +    public: 
 +     void fOo7(); 
 +}; 
 +</code>| 
 +|<code> 
 +fonction: 
 +  si constexpr && SK_ConstexprFunction: 
 +    SK_ConstexprFunction 
 +  // C'est quoi une fonction non globale ? 
 +  si global && SK_GlobalFunction: 
 +    SK_GlobalFunction 
 +  si SK_Function: 
 +    SK_Function 
 +  ignore 
 +</code>|<code cpp> 
 +constexpr void b1r(); 
 +void bAr(); 
 +</code>| 
 +|<code> 
 +typename dans template: 
 +  si SK_TypeTemplateParameter: 
 +    SK_TypeTemplateParameter 
 +  si SK_TemplateParameter: 
 +    SK_TemplateParameter 
 +  ignore 
 + 
 +value in template: 
 +  si SK_ValueTemplateParameter: 
 +    SK_ValueTemplateParameter 
 +  si SK_TemplateParameter: 
 +    SK_TemplateParameter 
 +  ignore 
 + 
 +template <typename> class / typename: 
 +  si SK_TemplateTemplateParameter: 
 +    SK_TemplateTemplateParameter 
 +  si SK_TemplateParameter: 
 +    SK_TemplateParameter 
 +  ignore 
 +</code>|<code cpp> 
 +template<typename TypeName, int VaLuE, 
 +  template<typename> typename TypeTypeName> 
 +void FoBa(); 
 +</code>| 
 +|<code> 
 +concept && SK_Concept: 
 +  SK_Concept</code>|<code cpp> 
 +template<class T, class U> 
 +concept ConCepT = std::is_base_of<U, T>::value; 
 +</code>| 
 +|<code> 
 +define && SK_MacroDefinition: 
 +  SK_MacroDefinition</code>|<code cpp> 
 +#define MaCrO 
 +</code>|
  
 =====Extensions===== =====Extensions=====
prog/clang-tidy.1733383120.txt.gz · Dernière modification : de root