[重构]: 改进代码规范、修复命名并增强测试

- **代码检查配置**: 调整.clang-tidy配置，禁用llvm-header-guard检查项，优化GitHub Actions的clang-tidy忽略路径
- **命名规范化**: 统一算法模块参数命名（v→vec）、线程池变量命名（n→availableCores）、服务器函数参数命名（fd→fileDescriptor）
- **设计模式改进**:
  - Factory模式添加构造日志，改用pragma once，增强拷贝控制
  - Singleton模式重构为单元测试驱动，移除main.cpp实现，增加多线程安全测试用例
- **代码现代化改造**:
  - 线程池任务调度改用lambda表达式替代std::bind
  - 自旋锁明确禁用移动语义(DISABLE_MOVE)
  - 头文件保护全面转为#pragma once
- **工具类增强**: 扩展utils/object.hpp拷贝控制宏，新增DEFAULT_COPY/MOVE系列宏
- **测试覆盖**: 为Singleton模式添加gtest单元测试，验证单例唯一性及多线程安全性
- **文档更新**: 同步修订README项目结构说明，保持与代码结构一致

Author: RealChuan

.clang-tidy

@@ -1,5 +1,5 @@
 ---
-Checks:          'clang-analyzer-*,readability-*,performance-*,modernize-*,bugprone-*,cert-*,portability-*,llvm-*,google-*'
+Checks:          'clang-analyzer-*,readability-*,performance-*,modernize-*,bugprone-*,cert-*,portability-*,llvm-*,-llvm-header-guard,google-*'
 WarningsAsErrors: ''
 HeaderFilterRegex: '.'
 AnalyzeTemporaryDtors: false

.github/workflows/cpp_linter.yml

@@ -48,7 +48,7 @@ jobs:
           step-summary: true
           database: build
           ignore: .github | build
-          ignore-tidy: .github | MonitorDir/monitordir_win.cc | MonitorDir/monitordir_mac.cc
+          ignore-tidy: .github | Client | Icmp| Server | MonitorDir/monitordir_win.cc | MonitorDir/monitordir_mac.cc
 
       - name: Fail fast?!
         if: steps.linter.outputs.clang-tidy-checks-failed > 0

Algorithm/Search/search.hpp

@@ -8,10 +8,10 @@
 
 // 顺序查找
 template<typename T>
-auto sequential_search(const std::vector<T> &v, const T &value) -> int
+auto sequential_search(const std::vector<T> &vec, const T &value) -> int
 {
-    for (int i = 0; i < v.size(); ++i) { // 从头到尾遍历
-        if (v[i] == value) {             // 如果找到了，就返回下标
+    for (int i = 0; i < vec.size(); ++i) { // 从头到尾遍历
+        if (vec[i] == value) {             // 如果找到了，就返回下标
             return i;
         }
     }
@@ -20,15 +20,15 @@ auto sequential_search(const std::vector<T> &v, const T &value) -> int
 
 // 二分查找
 template<typename T>
-auto binary_search(const std::vector<T> &v, const T &value) -> int
+auto binary_search(const std::vector<T> &vec, const T &value) -> int
 {
     int low = 0;                    // 最小下标
-    int high = v.size() - 1;        // 最大下标
+    int high = vec.size() - 1;      // 最大下标
     while (low <= high) {           // 当最小下标小于等于最大下标时
         int mid = (low + high) / 2; // 取中间下标
-        if (v[mid] == value) {      // 如果中间元素等于要查找的元素，就返回下标
+        if (vec[mid] == value) {    // 如果中间元素等于要查找的元素，就返回下标
             return mid;
-        } else if (v[mid] < value) { // 如果中间元素小于要查找的元素，就在右半部分查找
+        } else if (vec[mid] < value) { // 如果中间元素小于要查找的元素，就在右半部分查找
             low = mid + 1;
         } else { // 如果中间元素大于要查找的元素，就在左半部分查找
             high = mid - 1;
@@ -39,23 +39,23 @@ auto binary_search(const std::vector<T> &v, const T &value) -> int
 
 // 斐波那契查找
 template<typename T>
-auto fibonacci_search(const std::vector<T> &v, const T &value) -> int
+auto fibonacci_search(const std::vector<T> &vec, const T &value) -> int
 {
-    std::vector<int> fibonacci{1, 1};     // 斐波那契数列
-    while (fibonacci.back() < v.size()) { // 生成斐波那契数列
+    std::vector<int> fibonacci{1, 1};       // 斐波那契数列
+    while (fibonacci.back() < vec.size()) { // 生成斐波那契数列
         fibonacci.push_back(fibonacci[fibonacci.size() - 1] + fibonacci[fibonacci.size() - 2]);
     }
     int low = 0;                              // 最小下标
-    int high = v.size() - 1;                  // 最大下标
+    int high = vec.size() - 1;                // 最大下标
     int k = fibonacci.size() - 1;             // 斐波那契数列的下标
     while (low <= high) {                     // 当最小下标小于等于最大下标时
         int mid = low + fibonacci[k - 1] - 1; // 取黄金分割点
-        if (mid >= v.size()) {                // 如果黄金分割点大于等于数组长度
-            mid = v.size() - 1;               // 就将黄金分割点设置为数组最后一个元素的下标
+        if (mid >= vec.size()) {              // 如果黄金分割点大于等于数组长度
+            mid = vec.size() - 1;             // 就将黄金分割点设置为数组最后一个元素的下标
         }
-        if (v[mid] == value) { // 如果中间元素等于要查找的元素，就返回下标
+        if (vec[mid] == value) { // 如果中间元素等于要查找的元素，就返回下标
             return mid;
-        } else if (v[mid] < value) { // 如果中间元素小于要查找的元素，就在右半部分查找
+        } else if (vec[mid] < value) { // 如果中间元素小于要查找的元素，就在右半部分查找
             low = mid + 1;
             k -= 2;
         } else {            // 如果中间元素大于要查找的元素，就在左半部分查找
@@ -68,13 +68,13 @@ auto fibonacci_search(const std::vector<T> &v, const T &value) -> int
 
 // 线性索引查找
 template<typename T>
-auto linear_index_search(const std::vector<T> &v, const T &value) -> int
+auto linear_index_search(const std::vector<T> &vec, const T &value) -> int
 {
-    std::vector<T> index;                // 索引
-    index.push_back(v[0]);               // 第一个索引为第一个元素
-    for (int i = 1; i < v.size(); ++i) { // 生成索引
-        if (v[i] > index.back()) {       // 如果当前元素大于索引的最后一个元素
-            index.push_back(v[i]);
+    std::vector<T> index;                  // 索引
+    index.push_back(vec[0]);               // 第一个索引为第一个元素
+    for (int i = 1; i < vec.size(); ++i) { // 生成索引
+        if (vec[i] > index.back()) {       // 如果当前元素大于索引的最后一个元素
+            index.push_back(vec[i]);
         }
     }
     int low = 0;                    // 最小下标
@@ -94,7 +94,7 @@ auto linear_index_search(const std::vector<T> &v, const T &value) -> int
 
 // KMP查找
 template<typename T>
-auto kmp_search(const std::vector<T> &v, const std::vector<T> &pattern) -> int
+auto kmp_search(const std::vector<T> &vec, const std::vector<T> &pattern) -> int
 {
     std::vector<int> next(pattern.size());               // next数组
     next[0] = -1;                                        // next数组的第一个元素为-1
@@ -109,11 +109,11 @@ auto kmp_search(const std::vector<T> &v, const std::vector<T> &pattern) -> int
         next[i] = k; // 将k赋值给next数组的当前元素
     }
     k = -1; // next数组的下标
-    for (int i = 0; i < v.size(); ++i) {
-        while (k > -1 && pattern[k + 1] != v[i]) { // 如果k大于-1且下一个元素不等于当前元素
+    for (int i = 0; i < vec.size(); ++i) {
+        while (k > -1 && pattern[k + 1] != vec[i]) { // 如果k大于-1且下一个元素不等于当前元素
             k = next[k];
         }
-        if (pattern[k + 1] == v[i]) { // 如果下一个元素等于当前元素
+        if (pattern[k + 1] == vec[i]) { // 如果下一个元素等于当前元素
             ++k;
         }
         if (k == pattern.size() - 1) { // 如果k等于模式串的最后一个元素的下标
@@ -139,7 +139,7 @@ auto move_by_suffix(int j, const std::vector<int> &suffix, const std::vector<boo
 }
 // BM查找
 template<typename T>
-auto bm_search(const std::vector<T> &v, const std::vector<T> &pattern) -> int
+auto bm_search(const std::vector<T> &vec, const std::vector<T> &pattern) -> int
 {
     std::vector<int> bc(256, -1);              // 坏字符哈希表
     for (int i = 0; i < pattern.size(); ++i) { // 生成坏字符哈希表
@@ -161,71 +161,71 @@ auto bm_search(const std::vector<T> &v, const std::vector<T> &pattern) -> int
         }
     }
     int i = 0;
-    while (i <= v.size() - pattern.size()) { // 从头到尾遍历
+    while (i <= vec.size() - pattern.size()) { // 从头到尾遍历
         int j = pattern.size() - 1;
-        while (j >= 0 && v[i + j] == pattern[j]) { // 从后往前比较
+        while (j >= 0 && vec[i + j] == pattern[j]) { // 从后往前比较
             --j;
         }
         if (j == -1) { // 如果模式串的所有元素都匹配了
             return i;
         }
-        i += std::max(move_by_suffix(j, suffix, prefix), j - bc[v[i + j]]); // 将模式串向后移动
+        i += std::max(move_by_suffix(j, suffix, prefix), j - bc[vec[i + j]]); // 将模式串向后移动
     }
     return -1; // not found
 }
 
 // Sunday查找
 template<typename T>
-auto sunday_search(const std::vector<T> &v, const std::vector<T> &pattern) -> int
+auto sunday_search(const std::vector<T> &vec, const std::vector<T> &pattern) -> int
 {
     std::vector<int> bc(256, -1);              // 坏字符哈希表
     for (int i = 0; i < pattern.size(); ++i) { // 生成坏字符哈希表
         bc[pattern[i]] = i;
     }
     int i = 0;
-    while (i <= v.size() - pattern.size()) { // 从头到尾遍历
+    while (i <= vec.size() - pattern.size()) { // 从头到尾遍历
         int j = 0;
-        while (j < pattern.size() && v[i + j] == pattern[j]) { // 从前往后比较
+        while (j < pattern.size() && vec[i + j] == pattern[j]) { // 从前往后比较
             ++j;
         }
         if (j == pattern.size()) { // 如果模式串的所有元素都匹配了
             return i;
         }
-        if (i + pattern.size() == v.size()) { // 如果模式串的最后一个元素在主串中不存在
-            return -1;                        // not found
+        if (i + pattern.size() == vec.size()) { // 如果模式串的最后一个元素在主串中不存在
+            return -1;                          // not found
         }
-        i += pattern.size() - bc[v[i + pattern.size()]]; // 将模式串向后移动
+        i += pattern.size() - bc[vec[i + pattern.size()]]; // 将模式串向后移动
     }
     return -1; // not found
 }
 
 // Rabin-Karp查找
 template<typename T>
-auto rabin_karp_search(const std::vector<T> &v, const std::vector<T> &pattern) -> int
+auto rabin_karp_search(const std::vector<T> &vec, const std::vector<T> &pattern) -> int
 {
     int pattern_hash = 0; // 模式串的哈希值
     for (int i = 0; i < pattern.size(); ++i) {
         pattern_hash += pattern[i];
     }
     int v_hash = 0; // 主串的哈希值
     for (int i = 0; i < pattern.size(); ++i) {
-        v_hash += v[i];
+        v_hash += vec[i];
     }
     int i = 0;
-    while (i <= v.size() - pattern.size()) { // 从头到尾遍历
-        if (v_hash == pattern_hash) {        // 如果模式串的哈希值等于主串的哈希值
+    while (i <= vec.size() - pattern.size()) { // 从头到尾遍历
+        if (v_hash == pattern_hash) {          // 如果模式串的哈希值等于主串的哈希值
             int j = 0;
-            while (j < pattern.size() && v[i + j] == pattern[j]) { // 从前往后比较
+            while (j < pattern.size() && vec[i + j] == pattern[j]) { // 从前往后比较
                 ++j;
             }
             if (j == pattern.size()) { // 如果模式串的所有元素都匹配了
                 return i;
             }
         }
-        if (i + pattern.size() == v.size()) { // 如果模式串的最后一个元素在主串中不存在
-            return -1;                        // not found
+        if (i + pattern.size() == vec.size()) { // 如果模式串的最后一个元素在主串中不存在
+            return -1;                          // not found
         }
-        v_hash += v[i + pattern.size()] - v[i]; // 将模式串向后移动
+        v_hash += vec[i + pattern.size()] - vec[i]; // 将模式串向后移动
         ++i;
     }
     return -1; // not found

DesignPattern/Factory/factory.cc

@@ -2,7 +2,10 @@
 
 #include <iostream>
 
-Factory::Factory() {}
+Factory::Factory()
+{
+    std::cout << "Factory" << std::endl;
+}
 
 Factory::~Factory()
 {
@@ -19,7 +22,9 @@ class ComputerFactory : public Factory
 public:
     ComputerFactory()
         : Factory()
-    {}
+    {
+        std::cout << "ComputerFactory" << std::endl;
+    }
     virtual ~ComputerFactory() { std::cout << "~ComputerFactory" << std::endl; }
 
     virtual void name() { std::cout << "ComputerFactory" << std::endl; }
@@ -30,7 +35,9 @@ class PhoneFactory : public Factory
 public:
     PhoneFactory()
         : Factory()
-    {}
+    {
+        std::cout << "PhoneFactory" << std::endl;
+    }
     virtual ~PhoneFactory() { std::cout << "~PhoneFactory" << std::endl; }
 
     virtual void name() { std::cout << "PhoneFactory" << std::endl; }

DesignPattern/Factory/factory.hpp

@@ -1,7 +1,8 @@
-#ifndef FACTORY_HPP
-#define FACTORY_HPP
+#pragma once
 
-class Factory
+#include <utils/object.hpp>
+
+class Factory : noncopyable
 {
 public:
     Factory();
@@ -15,8 +16,6 @@ class Factory
     virtual void name();
 };
 
-enum FactoryType { Computer, Phone };
-
-auto createFactory(FactoryType type) -> Factory *;
+enum FactoryType : int { Computer, Phone };
 
-#endif // FACTORY_HPP
+auto createFactory(FactoryType type) -> Factory *;

DesignPattern/Factory/main.cpp

@@ -7,9 +7,9 @@ auto main(int argc, char *argv[]) -> int
     (void) argc;
     (void) argv;
 
-    std::unique_ptr<Factory> f(createFactory(FactoryType::Computer));
-    std::unique_ptr<Factory> f1(createFactory(FactoryType::Phone));
-    //std::unique_ptr<Factory> f2(createFactory(FactoryType(-1)));
+    std::unique_ptr<Factory> computerFactoryPtr(createFactory(FactoryType::Computer));
+    std::unique_ptr<Factory> phoneFactoryPtr(createFactory(FactoryType::Phone));
+    // std::unique_ptr<Factory> invalidFactoryPtr(createFactory(FactoryType(-1)));
 
     return 0;
 }

DesignPattern/Observer/observer.hpp

@@ -1,5 +1,4 @@
-#ifndef OBSERVER_HPP
-#define OBSERVER_HPP
+#pragma once
 
 #include <iostream>
 #include <list>
@@ -64,5 +63,3 @@ class ConcreteSubject : public Subject
     std::list<std::weak_ptr<Observer>> m_Observers;
     int m_state = 0;
 };
-
-#endif // OBSERVER_HPP

DesignPattern/Singleton/CMakeLists.txt

@@ -1,2 +1,5 @@
-add_executable(Singleton main.cpp singleton.cc singleton.hpp
-                         singletonmanager.hpp)
+add_executable(singleton_unittest singleton_unittest.cc singleton.cc
+                                  singleton.hpp)
+target_link_libraries(singleton_unittest PRIVATE GTest::gtest GTest::gtest_main
+                                                 GTest::gmock GTest::gmock_main)
+add_test(NAME singleton_unittest COMMAND singleton_unittest)

DesignPattern/Singleton/main.cpp

@@ -4,7 +4,7 @@ namespace Hungry {
 
 // ② This the second way to implement Singleton
 // std::unique_ptr<Singleton> Singleton::s_singleton_ptr(new Singleton);
-std::unique_ptr<Singleton> Singleton::s_singleton_ptr;
-std::mutex Singleton::s_mutex;
+std::unique_ptr<Singleton> Singleton::singletonPtr;
+std::mutex Singleton::mutex;
 
 } // namespace Hungry