1. 断言assert和堆栈调用情况打印

来自**util.h**、**util.cpp**文件
目的：系统自带assert触发后报错信息过于简单，希望将报错内容和位置细化一些，实现一个简单的异常跟踪与堆栈情况打印，方便调试。

头文件：<assert.h> 、<execinfo.h>

  • 堆栈打印封装如下： ```cpp //获取函数堆栈 void BackTrace(std::vector& bt, int size, int skip) { void arr = (void)malloc(sizeof(void ) size);

    //返回当前堆栈使用的真实层数 size是期望层数上限 size_t true_size = backtrace(arr, size);

    //这里面有malloc的过程 strings是一块动态分配内存 char **strings = backtrace_symbols(arr, true_size); if(strings == nullptr) {

    1.   KIT_LOG_ERROR(g_logger) << "BackTrace: backtrace_symbols error";
    2.   return;

    }

    for(size_t i = skip;i < true_size;++i) {

    1.   bt.push_back(strings[i]);

    }

    free(strings); free(arr); }

//打印函数堆栈 std::string BackTraceToString(int size, const std::string &prefix, int skip) { std::vector bt; BackTrace(bt, size, skip);

  1. //借助流 输出
  2. std::stringstream ss;
  3. for(size_t i = 0;i < bt.size();++i)
  4. {
  5.     ss << prefix << bt[i] << std::endl;
  6. }
  8. return ss.str();

}

  2. - **宏函数封装如下：**
  4. **来自**`**marco.h**`**文件**
  5. ```clojure
  6. #define KIT_ASSERT(x) do{\
  7.     if(!(x)){\
  8.         KIT_LOG_ERROR(KIT_LOG_ROOT()) << "\nASSERTION: " #x   \
  9.                                       <<  "\nbacktrace: \n" \
  10.                                       << kit_server::BackTraceToString(100, "    ");\
  11.         assert(x);\
  12.     }\
  13. }\
  14. while(0)
  16. //第二个参数可做一些补充说明
  17. #define KIT_ASSERT2(x, w)do{\
  18.     if(!(x)){\
  19.         KIT_LOG_ERROR(KIT_LOG_ROOT()) << "\nASSERTION: " #x   \
  20.                                       << "\n" << #w \
  21.                                       <<  "\nbacktrace: \n" \
  22.                                       << kit_server::BackTraceToString(100, "    ");\
  23.         assert(x);\
  24.     }\
  25. }\
  26. while(0)

2. 获取当前系统时间

来自**util.h**、**util.cpp**文件

使用getofday()函数能够获取到us级别的系统时间，较为精确，也方便向其他精度的时间单位上去转化

  1. //获取ms级时间
  2. uint64_t GetCurrentMs()
  3. {
  4.     struct timeval tv;
  5.     gettimeofday(&tv, nullptr);
  6.     return tv.tv_sec * 1000ul + tv.tv_usec / 1000;
  7. }
  9. //获取us级时间
  10. uint64_t GetCurrentUs()
  11. {
  12.     struct timeval tv;
  13.     gettimeofday(&tv, nullptr);
  14.     return tv.tv_sec * 1000 * 1000ul + tv.tv_usec;
  15. }

3. 获取线程、协程信息

来自**util.h**、**util.cpp**文件

3.1 获取线程ID和线程名称

  1. pid_t GetThreadId()
  2. {
  3.     //返回内核中tid  不使用pthread_self()是因为其返回的不是真正线程ID
  4.     return syscall(SYS_gettid);
  5. }
  7. const std::string& GetThreadName()
  8. {
  9.     //返回内核中tid  不使用pthread_self()是因为其返回的不是真正线程ID
  10.     return Thread::_getName();
  11. }

3.2 获取协程ID

  1. uint64_t GetCoroutineId()
  2. {
  3.     return Coroutine::GetCoroutineId();
  4. }

4. if-else条件判断编译优化

来自**marco.h**文件

  1. //编译器优化
  2. #if  defined __GNUC__ || defined __llvm__
  3. #   define KIT_LIKELY(x)   __builtin_expect(!!(x), 1)
  4. #   define KIT_UNLIKELY(x)   __builtin_expect(!!(x), 0)
  5. #else
  6. #   define KIT_LIKELY(x)    (x)
  7. #   define KIT_UNLIKELY(x)  (x)
  8. #endif

5. 文件通用操作类封装

来自**util.h**、**util.cpp**文件

  1. /**
  2.  * @brief 文件通用操作类
  3.  */
  4. class FSUtil
  5. {
  6. public:
  7.     /**
  8.      * @brief 获取当前文件夹路径下所有的文件
  9.      * @param[out] files 输出当前路径下所有文件的名称
  10.      * @param[in] path 当前要操作的文件夹的路径
  11.      * @param[in] subfix 指定的后缀名
  12.      */
  13.     static void ListAllFile(std::vector<std::string>& files, 
  14.         const std::string& path, const std::string& subfix);
  17.     /**
  18.      * @brief 创建一个目录
  19.      * @param[in] dirname 目录名称
  20.      * @return 返回是否成功创建了目录
  21.      */
  22.     static bool Mkdir(const std::string& dirname);
  24. };

5.1 获取某一个文件夹路径下所有的指定目标文件

  1. /**
  2.  * @brief 获取当前文件夹路径下所有的文件
  3.  * @param[out] files 输出当前路径下所有文件的名称
  4.  * @param[in] path 当前要操作的文件夹的路径
  5.  * @param[in] subfix 指定的后缀名
  6.  */
  7. void FSUtil::ListAllFile(std::vector<std::string>& files, 
  8.     const std::string& path, const std::string& subfix)
  9. {
  10.     //探测目录是否存在
  11.     if(access(path.c_str(), F_OK) < 0)
  12.     {
  13.         KIT_LOG_ERROR(g_logger) << "file path don't exist access error, errno=" 
  14.             << errno << ", is:" << strerror(errno);
  15.         return;
  16.     }
  18.     //打开目录流
  19.     DIR* dir = opendir(path.c_str());
  20.     if(!dir)
  21.     {
  22.         KIT_LOG_ERROR(g_logger) << "open dir error, errno=" << errno
  23.             << ",is:" << strerror(errno);
  24.         return;
  25.     }
  27.     //从目录流中读取文件信息
  28.     struct dirent* dp = nullptr;
  29.     errno = 0;
  30.     while((dp = readdir(dir)) != nullptr)
  31.     {
  32.         //如果是一个文件夹类型 需要继续读取 进行递归
  33.         if(dp->d_type == DT_DIR)
  34.         {
  35.             //把当前目录路径和父目录路径过滤
  36.             if(strcmp(dp->d_name, ".") == 0 ||
  37.                 strcmp(dp->d_name, "..") == 0)
  38.                     continue;
  40.             ListAllFile(files, path + "/" + dp->d_name, subfix);
  41.         }
  42.         else if(dp->d_type == DT_REG)   //如果是一个普通文件
  43.         {
  44.             std::string file_name = dp->d_name;
  45.             //如果 传入后缀为空 默认收集所有文件
  46.             if(!subfix.size())
  47.             {
  48.                 files.push_back(path + "/" + file_name);
  49.             }
  50.             else
  51.             {
  52.                 //文件名比传入后缀还要短 就不是我们要找的文件
  53.                 if(file_name.size() < subfix.size())
  54.                     continue;
  56.                 //截取出后缀 如果为目标文件要收集起来
  57.                 if(file_name.substr(file_name.length() - subfix.size()) == subfix)
  58.                 {
  59.                     files.push_back(path + "/" + file_name);
  60.                 }
  62.             }
  64.         }
  65.     }
  67.     //关闭目录流
  68.     closedir(dir);
  70.     //判断readir()函数是否出错
  71.     if(errno != 0)
  72.     {
  73.         KIT_LOG_ERROR(g_logger) << "readdir error, errnn=" << errno 
  74.             << ",is:" << strerror(errno);
  75.         return;
  76.     }
  78. }

5.2 创建目录

  1. /**
  2.  * @brief 辅助函数 主要用于探测一下文件是否存在
  3.  * @param[in] file 文件名称
  4.  * @param[out] st 更新当前文件信息
  5.  * @return 返回执行结果
  6.  */
  7. static int __lstst(const char *file, struct stat *st = nullptr)
  8. {
  9.     struct stat new_st;
  10.     int ret = lstat(file, &new_st);
  11.     if(st)
  12.         *st = new_st;
  14.     return ret;
  15. }
  17. /**
  18.  * @brief 创建目录的辅助函数
  19.  * @param[in] dirname 目录名称
  20.  * @return 返回创建目录的结果
  21.  */
  22. static int __mkdir(const char* dirname)
  23. {
  24.     //该目录已经存在 不需要再创建
  25.     if(access(dirname, F_OK) == 0)
  26.         return 0;
  28.     return mkdir(dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
  29. }
  31. /**
  32.  * @brief 创建一个目录
  33.  * @param[in] dirname 目录名称
  34.  * @return 返回是否成功创建了目录
  35.  */
  36. bool FSUtil::Mkdir(const std::string& dirname)
  37. {
  38.     //目录已经存在
  39.     if(__lstst(dirname.c_str()) == 0)
  40.         return true;
  42.     //给目录名称进行深拷贝
  43.     char *path = strdup(dirname.c_str());
  44.     if(!path)
  45.     {
  46.         KIT_LOG_ERROR(g_logger) << "strdup mem is not enough! errno=" << errno << ", is:" << strerror(errno);
  47.         return false;
  48.     }
  50.     char *ptr = strchr(path + 1, '/');
  51.     if(!ptr)
  52.     {
  53.         KIT_LOG_ERROR(g_logger) << "strchr: no find '/' invalid dirname!";
  54.         return false;
  55.     }
  57.     //如果存在多级目录 逐级检查是否存在 不存在就会创建
  58.     for(;ptr; *ptr = '/', ptr = strchr(ptr + 1, '/'))
  59.     {
  60.         //截断到当前层的目录路径
  61.         *ptr = '\0';
  62.         //检查是否存在 不存在就创建 创建失败就退出
  63.         if(__mkdir(path) != 0)
  64.             break;
  65.     }
  67.     //找完了最后的'/' 尝试最后一层目录是否存在
  68.     if(ptr == nullptr)
  69.     {
  70.         if(__mkdir(path) == 0)
  71.         {
  72.             free(path);
  73.             return true;
  74.         }
  75.     }
  77.     free(path);
  78.     return false;
  80. }

6. 单例模板封装

来自**single.h**文件
目的：将我们指定的类封装为一个单例对象来使用。

  1. template<class T, class X = void, int N = 0>
  2. class Single
  3. {
  4. public:
  5.     static T* GetInstance()
  6.     {
  7.         static T v;//C++11 魔力static 保证线程安全
  8.         return &v;
  9.     }
  10. };
  13. template<class T, class X = void, int N = 0>
  14. class SinglePtr
  15. {
  16. public:
  17.     static std::shared_ptr<T> GetInstance()
  18.     {
  19.         static std::shared_ptr<T> v(new T);
  20.         return v;
  21.     }
  22. };