Différences

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

--- prog:clang-tidy [2024/12/05 08:18] – [readability-identifier-naming] : fin de l'algo root
+++ prog: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.
-<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=====