Jiancong Li's Blog

printf("%d", i);

printf("Integers\n");
printf("Decimal:\t%i %d %.6i %i %.0i %+i %i\n", 1, 2, 3, 0, 0, 4, -4);
printf("Hexadecimal:\t%x %x %X %#x\n", 5, 10, 10, 6);
printf("Octal:\t%o %#o %#o\n", 10, 10, 4);

printf("Floating point\n");
printf("Rounding:\t%f %.0f %.32f\n", 1.5, 1.5, 1.3);
printf("Padding:\t%05.2f %.2f %5.2f\n", 1.5, 1.5, 1.5);
printf("Scientific:\t%E %e\n", 1.5, 1.5);
printf("Hexadecimal:\t%a %A\n", 1.5, 1.5);

std::string to_string(int i);
std::string to_string(unsigned i);
std::string to_string(unsigned long i);
std::string to_string(unsigned long long x);
std::string to_string(long i);
std::string to_string(long long x);
std::string to_string(short x);
std::string to_string(unsigned short x);

/// 保留两位小数: 输出类似 1.12
std::string to_string(double d);
/// 返回字符串: "true" 或 "false"
std::string to_string(bool x);
/// 重载指针, 输出类似 0x123
template <typename T>
inline std::string to_string(T* const x);

char ac[1024] = {0};
strcat(ac, "Hello");
strcat(ac, "World");
strcat(ac, gos::to_string(123).c_str());

std::string str;
str = "123" + "456";

std::string str;
std::string strTemp("456");
str = "123" + strTemp;

std::string operator+(const std::string& strLeft, const std::string& strRight);

str = "123" + strTemp;
<=>
str = operator+("123", strTemp);
<=>
str = operator+(std::string("123"), strTemp);

std::string str;
std::string strTemp("World");
str = "Hello" + strTemp + gos::to_string(i);
<=>
str = ("Hello" + strTemp) + gos::to_string(123);

gos::string_stream stream;
stream << "Hello" << "World" << 123;

class string_stream
{
public:
    string_stream& operator<<(int i)
    {
        m_str += i;
        return *this;
    }

    ...
private:
    std::string m_str;
};

gos::string_stream stream;
stream << "Hello";
<=>
stream.operator<<("Hello");

/// 打印 socket 地址
string_stream& operator<<(const SOCKADDR_IN& addr_in);
/// 打印 PID_T
string_stream& operator<<(const PID_T& stPID);
/// 打印 vector
template <typename T>
string_stream& operator<<(const std::vector<T>& vec);
/// 打印 二进制数据
string_stream& operator<<(const std::vector<unsigned char>& vec);
/// 打印 map
template <typename Key, typename Value>
string_stream& operator<<(const std::map<Key, Value>& map);

class string_stream
{
public:
    std::string str()
    {
        return m_str;
    }
};

struct STRUCT_T
{
public:
    int i;
    double d;
};

STRUCT_T st;
printf("%d, %f", st.i, st.d);

gos::string_stream& operator<<(gos::string_stream& out, const STRUCT_T& st)
{
    out << st.i << st.d;
    return out;
}

gos::string_stream stream;
stream << st;

struct STRUCT_T
{
private:
    int i;
    double d;
};

/// 该函数是否可行?
gos::string_stream& operator<<(gos::string_stream& out, const STRUCT_T& st)
{
    out << st.i << st.d;
    return out;
}

struct STRUCT_T
{
private:
    int i;
    double d;

    friend gos::string_stream& operator<<(gos::string_stream& out, const STRUCT_T& st)
    {
        out << st.i << st.d;
        return out;
    }
};

template <typename T>
std::string format_dbg_string(const T& x, const std::string& strName)
{
    gos::string_stream stream;
    stream << strName << "(" << x << ")";
    return stream.str();
}

const char* szMsgName = "MsgName";
GosLog(LOG_INFO, "szMsgName: %s", gos::format_dbg_string(szMsgName, "szMsgName").c_str());

#define DBG(x) gos::format_dbg_string(x, std::string(#x)).c_str()

GosLog(LOG_INFO, "szMsgName: %s", gos::format_dbg_string(szMsgName, "szMsgName").c_str());
<=>
GosLog(LOG_INFO, "%s", DBG(szMsgName));

GosLog(LOG_ERROR, "CRC error! %s, %s, %s, %s ", DBG(ucLocalCRC16_H), DBG(ucLocalCRC16_L), DBG(ucCRC16_H), DBG(ucCRC16_L);

class STRUCT_T
{
public:
    int i;
    double d;
    friend gos::string_stream& operator<<(gos::string_stream& out, const STRUCT_T& st)
    {
        out << "STRUCT_T: " << DBG(&st);
    	out << DBG(st.i);
        out << DBG(st.d);
        return out;
    }
};

GosLog(LOG_ERROR,"%s", DBG(st));
/// 输出
2022-10-16 08:08:43.908 [ERROR] [dis] :STRUCT_T: 0x2389472 i(123)d(1.12)

class log_stream
{
public:
    template <typename T>
    log_stream& operator<<(const T& data)
    {
        m_stream << data;
        return *this;
    }

    ~log_stream()
    {
        GosLog(LOG_INFO, "%s", m_stream.str().c_str());
    }

private:
    gos::string_stream m_stream;
};

/// 定义辅助宏
#define LOG gos::log_stream() stream

LOG << "Hello" << "World";

class log_sync : public GThread
{
public:
    void log(const int& level, const std::string& strLog)
    {
        queue.push(level, strLog);
    }

    virtual GOS_THREAD_RET ThreadEntry(void* pPara)
    {
        while (true)
        {
            std::string strLog = queue.pop();
            /// 写入文件
            log_to_file("%s", strLog.c_str());
        }
    }
};

#define LOGD gos::log_stream(LOG_DETAIL)
#define LOGI gos::log_stream(LOG_INFO)
#define LOGW gos::log_stream(LOG_WARN)
#define LOGE gos::log_stream(LOG_ERROR)

#define LOG_IF(condition) ((condition) ? (LOG << #condition << ", ") : DoNothing()))

LOG_IF(vec.size() > 100) << "vec is too large!";
<=>
if(vec.size() > 100)
{
    LOG << "vec.size() > 100" << "vec is too large!";
}

#define LOGD_IF
#define LOGI_IF
#define LOGW_IF
#define LOGE_IF

/// 每 60 次打印一次
LOG_EVERY_N(60) << "Receive ATS Info!";

/// 打印前五条日志
LOG_FIRST_N(5) << "Hello World!";

While(true)
{
    /// 该日志只打印一次
    LOG_ONCE << "Thread is start!";
}

class tick_count
{
public:
    void start();
    void finish();
    std::string get_time_string();
};

class stop_watch
{
public:
    void tick(const std::string& strInfo)
    {
        /// 在消息容器中，记录信息和时间间隔
    }

    ~stop_watch()
    {
        tick.finish("finish");
        /// 遍历消息容器，并打印其间隔时间和百分比
    }
};

void f()
{
    gos::stop_watch sw;

    st.tick("1");
    ...
    st.tick("2");
    ...
    st.tick("3");
    ...
}

class interval_time_factory
{
public:
    void start(const std::string& strKey)
    {
        m_interval_time.insert(gos::to_string(p), gos_get_uptime_1us());
    }

    void finish(const std::string& strKey)
    {
        GosLog("%s interval time is %d", strKey.c_str(), m_interval_time[strKey]);
    }

private:
    /// key: 唯一主键, value: 间隔时间记录对象
    std::map<std::string, interval_time> m_interval_time;
};

int* f1()
{
    int *p = new int;
    interval_time_factory::GetInstance().start(gos::to_string(p));
}

void f2(int* p)
{
    delete p;
    interval_time_factory::GetInstance().finish(gos::to_string(p));
}

f1();
...
f2();

class object : public gos::object_counter
{
};

object obj0;

std::cout << obj0.get_count();  ///< 1
{
    object obj1;
    std::cout << obj1.get_count();  ///< 2
}

std::cout << obj0.get_count();  ///< 1

class object : public gos::object_live_time
{
};

{
    object obj;
    ...
} /// obj 在此处调用析构函数

void f()
{
    INT64 iStart = gos_get_uptime_1us();
    ...
    INT64 iFinish = gos_get_uptime_1us();

    GosLog(LOG_DETAIL, "f is spend time: %lld", iFinish - iStart);
}

class profiler
{
public:
    profiler()
    {
        INT64 iStart = gos_get_uptime_1us();
    }

    ~profiler()
    {
        INT64 iFinish = gos_get_uptime_1us();

        GosLog(LOG_DETAIL, "f is spend time: %lld", iFinish - iStart);
    }

private:
    INT64 iStart;
};

/// 定义辅助宏
#define PROFILER() profiler(__FILE__, __FUNCTION__, __LINE__)

void f()
{
    PROFILER();
    ...
}

void f()
{
    PROFILER();
    PROFILER(); ///< 编译错误, 重定义
}

const int& clamp(const int& value, const int& low, const int& height)
{
    if(value < low)
    {
        /// 数值小于下界， 返回下界值
        return low;
    }
    else if(height < value)
    {
        /// 数值大于上界， 返回上界值
        return height;
    }
    else
    {
        /// 返回原始值
        return value;
    }
}

Conf.GetValue("max_timeout", iMaxTimeout);

/// 判断配置项是否配置超出范围
LOG_IF(iMaxTimeout != gos::clamp(iMaxTimeout, 0, 3600) << "config is out of range!";

/// 或者自动限制范围
iMaxTimeout = gos::clamp(iMaxTimeout, 0, 3600);

class heartbeat
{
public:
    heartbeat(int max_time_ms);
    void live();
    void is_live();
};

/// 最大超时时间为 3s
heartbeat obj(3000);

/// app 心跳消息来了
obj.live();

/// app 心跳消息来了
obj.live();

/// 在定时器中定期轮询
while(timer())
{
    if(obj.is_live())
    {
        ...
    }
    else
    {
        ...
    }
}

class timeout
{
public:
    timeout(int max_time_ms) : m_heartbeat(max_time_ms)
    {
        m_heartbeat.live();
    }

    bool is_timeout()
    {
        return !m_heartbeat.is_live();
    }

private:
    gos::heartbeat m_heartbeat;
};

/// 请呼业务呼入时, 定义 60s 超时的对象
timeout obj(60 * 1000);

/// 定时器轮询
if(obj.is_timeout())
{
    ...
}
else
{
    ...
}

class approx
{
public:
    approx(const int64_t& anchor, const int64_t& diff) : m_anchor(anchor), m_diff(diff) {}

    /// 判断数值是否与本对象定义的数值相近, 数值在 [m_anchor - m_diff, m_anchor + m_diff] 返回真
    bool equal(const int64_t& number)
    {
        return std::abs(number - m_anchor) <= m_diff;
    }

private:
    int64_t m_anchor;  ///< 用于比较的锚点值
    int64_t m_diff;    ///< 浮动的数值
};

gos::tick_count timer;
timer.start();  ///< 计时开始
gos_sleep_ms(20);
timer.finish(); ///< 计时结束
int time = timer.get_ms();
/// 判断时间间隔是否在 20 正负 1 的范围
if(gos::approx(20, 1).equal(time))
{
    ...
}

class lock_guard
{
public:
    lock_guard(gos::mutex& mutex) : m_mutex(mutex)
    {
        m_mutex.lock();
    }

    ~lock_guard()
    {
        m_mutex.unlock();
    }

private:
    gos::mutex& m_mutex;
};

gos::mutex mutex;

void f()
{
    std::lock_guard<gos::mutex> guard(mutex);

    if(condition)
    {
        return;
    }
    else if(condition)
    {
        return;
    }
    else if(condition)
    {
        return;
    }

    return;
}

int f2()
{
    std::lock_guard<gos::mutex> guard(mutex);
    return data;
}

void f3()
{
    std::lock_guard<gos::mutex> guard(mutex);

    throw std::exception("抛出异常");

    double d = 1 / 0;

    if(queue.empty())
    {
        queue.front();
    }

    ...

    return;
}

gos::mutex mutex1;
gos::mutex mutex2;

void f()
{
   std::lock_guard<gos::mutex> guard1(mutex1);

   if(condition)
   {
   		return;
   }

   std::lock_guard<gos::mutex> guard2(mutex2);

   return;
}

/**
 * @brief           获取新旧两个 vector, 需要添加的元素，需要删除的元素，和重复的元素
 * @param           vecOld    [in]  旧数据
 * @param           vecNew    [in]  新数据
 * @param           vecAdd    [out] 需要添加的元素
 * @param           vecDel    [out] 需要删除的元素
 * @param           vecUnion  [out] 需要更新的元素
 * @return          true
 * @return          false
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @date            2022-06-02 13:50:34
 * @note
 */
template <typename T>
inline bool GetDifferenceBetweenVector(const std::vector<T>& vecOld, const std::vector<T>& vecNew,
                                       std::vector<T>& vecAdd, std::vector<T>& vecDel, std::vector<T>& vecUnion);

GetDifferenceBetweenVector(vecOldATS, vecNewATS, vecAdd, vecDel, vecUnion);

for(unsigned i = 0; i < vecAdd.size(); ++i)
{
    /// 创建列车图标
}

for(unsigned i = 0; i < vecDel.size(); ++i)
{
    /// 删除列车图标
}

for(unsigned i = 0; i < vecUnion.size(); ++i)
{
    /// 更新列车图标位置
}

/// 特殊字符转码
gos::EncodeEscapeChar();

/// 特殊字符解码
gos::DecodeEscapeChar();

bool IsValid(char* sz)
{
    if(!sz)
    {
        return false;
    }

    while(sz != '\0')
    {
        if(*sz < 0 || *sz > 9)
        {
            return false;
        }
    }
    return true;
}

bool IsValid(char* sz)
{
    if(!sz)
    {
        return false;
    }

    while(sz != '\0')
    {
        if(!isalnum(*sz))
        {
            return false;
        }
    }
    return true;
}

bool IsValid(char* sz)
{
    if (!sz)
    {
        return false;
    }

    while (sz != '\0')
    {
        if (*sz != ':' && *sz != '-' && *sz != ' ' && !(*sz >= 'a' && *sz <= 'f') && !(*sz >= 'A' && *sz <= 'F') &&
            !(*sz >= '0' && *sz <= '9'))
        {
            return false;
        }
    }
    return true;
}

bool IsValid(char* sz)
{
    if (!sz)
    {
        return false;
    }

    if ((遍历一遍，查看是否拥有至少一个数字字符)
        && (遍历一遍, 查看是否拥有至少一个大写字母)
        && (遍历一遍, 查看是否拥有至少一个小写字母)
        && (遍历一遍, 查看是否有至少一个数字字符))
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool IsValid(const std::string& str)
{
    /// 假如每个字符都符合特定规则(字符为数字)
    return all_of(str, IsNumber);
}

bool IsNumber(const char c)
{
    return c >= '0' && c <= '9';
}

typedef bool (*FUNC)(const char);

bool all_of(const std::string& str, FUNC pF)
{
    for(unsigned i = 0; i < str.size(); ++i)
    {
        char c = str.at(i);
        if(!pF(c))
        {
            return false;
        }
    }
    return true;
}

bool IsValid(const std::string& str)
{
    return all_of(str, IsNumber);
}

bool IsUpcaseLetter(const char c)
{
    return c >= 'A' && c <= 'Z';
}

bool any_of(const std::string& str, FUNC pF)
{
    ...
}

bool IsValid(const std::string& str)
{
    /// 这个字符串有任一大写字母 且 有任一数字
    return any_of(str, IsUpcaseLetter) && any_of(str, IsNumber);
}

bool IsValid(const std::string& str)
{
    gos::input_check filter;
    filter.AddRules(any_of, IsNumber).AddRules(any_of, IsUpcastLetter);
    return filter.IsValid(str);
}

class json_parser
{
public:
    /// 虚析构函数, 防止内存泄漏
    virtual ~json_parser() {}

    /// 结构体转 Json 字符串
    virtual bool StructToJson(std::string &str) const = 0;

    /// Json 字符串转结构体
    virtual bool JsonToStruct(const std::string &str) = 0;
};

class object : public json_parser
{
public:
    int i;
    std::string str;

    /// 结构体转 Json 字符串
    virtual bool StructToJson(std::string &str) const
    {
        GJsonParam Param;

        Param.Add("int", i);
        Param.Add("string", str);

        strJson = Param.GetString();
        return true;
    }

    virtual bool JsonToStruct(const std::string &str)
    {
        GJson Json;
        return Json.Parse(str) && Json.GetValue("int", i) && Json.GetValue("string", str);
    }
};

object obj;

std::string strJson;
/// 获取 json 字符串
obj.StructToJson(strJson);
/// 发送消息
SendMsg(strJson);

template <typename T>
class json_parser
{
public:
    /// 结构体转 Json 字符串
    virtual bool StructToJson(std::string &str) const = 0;

    /// Json 字符串转结构体
    virtual bool JsonToStruct(const std::string &str) = 0;

    /// 转化结构体数组到 Json 字符串
    bool VectorToJson(const std::vector<T> &vec, std::string &str) const;

    /// 转换 Json 字符串到结构体数组
    bool JsonToVector(const std::string &strFormatString, std::vector<T> &vec) const;
};

class object : public json_parser<object>
{
public:
    virtual bool StructToJson(std::string &str) const
    {
        ...
    }

    virtual bool JsonToStruct(const std::string &str)
    {
        ...
    }
};

std::vector<object> vecObj;

object ObjTemp;
std::string strJson;
/// 数组 转换 json
ObjTemp.VectorToJson(vecObj, strJson);

/// json 转换 数组
ObjTemp.JsonToStruct(strJson, vecObj);

class shared_ptr
{
public:
    shared_ptr(T* p) : pCount(new int), p(pData)
    {
        *pCount = 1;
    }

    shared_ptr(const shared_ptr& stOther)
    {
        pCount = stOther.pCount;
        pData = stOther.pData;

        ++(*pCount);
    }

    ~shared_ptr()
    {
        --(*pCount);
        if(*pCount == 0)
        {
            delete pCount;
            delete pData;
        }
    }

private:
    int* pCount;
    T* pData;
};

void f()
{
    shared_ptr obj0; ///< pCount == 1
    {
        shared_ptr obj1 = stOther; ///< pCount == 2
    } ///< obj1 析构, pCount == 1

} ///<  obj0 析构, pCount 自减为 0, 执行 delete 操作

#include <iostream>   // std::cout, std::endl
#include <cassert>    // assert()
#include <ctime>      // clock()
#include <vector>     // std::vector

#include "MemoryPool.hpp"  // MemoryPool<T>
#include "StackAlloc.hpp"  // StackAlloc<T, Alloc>

// 插入元素个数
#define ELEMS 10000000
// 重复次数
#define REPS 100

int main()
{
    clock_t start;

    // 使用 STL 默认分配器
    StackAlloc<int, std::allocator<int> > stackDefault;
    start = clock();
    for (int j = 0; j < REPS; j++) {
        assert(stackDefault.empty());
        for (int i = 0; i < ELEMS; i++)
          stackDefault.push(i);
        for (int i = 0; i < ELEMS; i++)
          stackDefault.pop();
    }
    std::cout << "Default Allocator Time: ";
    std::cout << (((double)clock() - start) / CLOCKS_PER_SEC) << "\n\n";

    // 使用内存池
    StackAlloc<int, MemoryPool<int> > stackPool;
    start = clock();
    for (int j = 0; j < REPS; j++) {
        assert(stackPool.empty());
        for (int i = 0; i < ELEMS; i++)
          stackPool.push(i);
        for (int i = 0; i < ELEMS; i++)
          stackPool.pop();
    }
    std::cout << "MemoryPool Allocator Time: ";
    std::cout << (((double)clock() - start) / CLOCKS_PER_SEC) << "\n\n";

    return 0;
}

#include <memory>

template <typename T>
struct StackNode_
{
  T data;
  StackNode_* prev;
};

// T 为存储的对象类型, Alloc 为使用的分配器, 并默认使用 std::allocator 作为对象的分配器
template <typename T, typename Alloc = std::allocator<T> >
class StackAlloc
{
  public:
    // 使用 typedef 简化类型名
    typedef StackNode_<T> Node;
    typedef typename Alloc::template rebind<Node>::other allocator;

    // 默认构造
    StackAlloc() { head_ = 0; }
    // 默认析构
    ~StackAlloc() { clear(); }

    // 当栈中元素为空时返回 true
    bool empty() {return (head_ == 0);}

    // 释放栈中元素的所有内存
    void clear();

    // 压栈
    void push(T element);

    // 出栈
    T pop();

    // 返回栈顶元素
    T top() { return (head_->data); }

  private:
    //
    allocator allocator_;
    // 栈顶
    Node* head_;
};

// 释放栈中元素的所有内存
void clear() {
  Node* curr = head_;
  // 依次出栈
  while (curr != 0)
  {
    Node* tmp = curr->prev;
    // 先析构, 再回收内存
    allocator_.destroy(curr);
    allocator_.deallocate(curr, 1);
    curr = tmp;
  }
  head_ = 0;
}
// 入栈
void push(T element) {
  // 为一个节点分配内存
  Node* newNode = allocator_.allocate(1);
  // 调用节点的构造函数
  allocator_.construct(newNode, Node());

  // 入栈操作
  newNode->data = element;
  newNode->prev = head_;
  head_ = newNode;
}

// 出栈
T pop() {
  // 出栈操作 返回出栈元素
  T result = head_->data;
  Node* tmp = head_->prev;
  allocator_.destroy(head_);
  allocator_.deallocate(head_, 1);
  head_ = tmp;
  return result;
}

// StackAlloc.hpp

#ifndef STACK_ALLOC_H
#define STACK_ALLOC_H

#include <memory>

template <typename T>
struct StackNode_
{
  T data;
  StackNode_* prev;
};

// T 为存储的对象类型, Alloc 为使用的分配器,
// 并默认使用 std::allocator 作为对象的分配器
template <class T, class Alloc = std::allocator<T> >
class StackAlloc
{
  public:
    // 使用 typedef 简化类型名
    typedef StackNode_<T> Node;
    typedef typename Alloc::template rebind<Node>::other allocator;

    // 默认构造
    StackAlloc() { head_ = 0; }
    // 默认析构
    ~StackAlloc() { clear(); }

    // 当栈中元素为空时返回 true
    bool empty() {return (head_ == 0);}

    // 释放栈中元素的所有内存
    void clear() {
      Node* curr = head_;
      while (curr != 0)
      {
        Node* tmp = curr->prev;
        allocator_.destroy(curr);
        allocator_.deallocate(curr, 1);
        curr = tmp;
      }
      head_ = 0;
    }

    // 入栈
    void push(T element) {
      // 为一个节点分配内存
      Node* newNode = allocator_.allocate(1);
      // 调用节点的构造函数
      allocator_.construct(newNode, Node());

      // 入栈操作
      newNode->data = element;
      newNode->prev = head_;
      head_ = newNode;
    }

    // 出栈
    T pop() {
      // 出栈操作 返回出栈结果
      T result = head_->data;
      Node* tmp = head_->prev;
      allocator_.destroy(head_);
      allocator_.deallocate(head_, 1);
      head_ = tmp;
      return result;
    }

    // 返回栈顶元素
    T top() { return (head_->data); }

  private:
    allocator allocator_;
    Node* head_;
};

#endif // STACK_ALLOC_H

// main.cpp

#include <iostream>
#include <cassert>
#include <ctime>
#include <vector>

// #include "MemoryPool.hpp"
#include "StackAlloc.hpp"

// 根据电脑性能调整这些值
// 插入元素个数
#define ELEMS 25000000
// 重复次数
#define REPS 50

int main()
{
    clock_t start;

    // 使用默认分配器
    StackAlloc<int, std::allocator<int> > stackDefault;
    start = clock();
    for (int j = 0; j < REPS; j++) {
        assert(stackDefault.empty());
        for (int i = 0; i < ELEMS; i++)
          stackDefault.push(i);
        for (int i = 0; i < ELEMS; i++)
          stackDefault.pop();
    }
    std::cout << "Default Allocator Time: ";
    std::cout << (((double)clock() - start) / CLOCKS_PER_SEC) << "\n\n";

    // 使用内存池
    // StackAlloc<int, MemoryPool<int> > stackPool;
    // start = clock();
    // for (int j = 0; j < REPS; j++) {
    //     assert(stackPool.empty());
    //     for (int i = 0; i < ELEMS; i++)
    //       stackPool.push(i);
    //     for (int i = 0; i < ELEMS; i++)
    //       stackPool.pop();
    // }
    // std::cout << "MemoryPool Allocator Time: ";
    // std::cout << (((double)clock() - start) / CLOCKS_PER_SEC) << "\n\n";

    return 0;
}

#ifndef MEMORY_POOL_HPP
#define MEMORY_POOL_HPP

#include <climits>
#include <cstddef>

template <typename T, size_t BlockSize = 4096>
class MemoryPool
{
  public:
    // 使用 typedef 简化类型书写
    typedef T*              pointer;

    // 定义 rebind<U>::other 接口
    template <typename U> struct rebind {
      typedef MemoryPool<U> other;
    };

    // 默认构造, 初始化所有的槽指针
    // C++11 使用了 noexcept 来显式的声明此函数不会抛出异常
    MemoryPool() noexcept {
      currentBlock_ = nullptr;
      currentSlot_ = nullptr;
      lastSlot_ = nullptr;
      freeSlots_ = nullptr;
    }

    // 销毁一个现有的内存池
    ~MemoryPool() noexcept;

    // 同一时间只能分配一个对象, n 和 hint 会被忽略
    pointer allocate(size_t n = 1, const T* hint = 0);

    // 销毁指针 p 指向的内存区块
    void deallocate(pointer p, size_t n = 1);

    // 调用构造函数
    template <typename U, typename... Args>
    void construct(U* p, Args&&... args);

    // 销毁内存池中的对象, 即调用对象的析构函数
    template <typename U>
    void destroy(U* p) {
      p->~U();
    }

  private:
    // 用于存储内存池中的对象槽,
    // 要么被实例化为一个存放对象的槽,
    // 要么被实例化为一个指向存放对象槽的槽指针
    union Slot_ {
      T element;
      Slot_* next;
    };

    // 数据指针
    typedef char* data_pointer_;
    // 对象槽
    typedef Slot_ slot_type_;
    // 对象槽指针
    typedef Slot_* slot_pointer_;

    // 指向当前内存区块
    slot_pointer_ currentBlock_;
    // 指向当前内存区块的一个对象槽
    slot_pointer_ currentSlot_;
    // 指向当前内存区块的最后一个对象槽
    slot_pointer_ lastSlot_;
    // 指向当前内存区块中的空闲对象槽
    slot_pointer_ freeSlots_;

    // 检查定义的内存池大小是否过小
    static_assert(BlockSize >= 2 * sizeof(slot_type_), "BlockSize too small.");
};

#endif // MEMORY_POOL_HPP

// 调用构造函数, 使用 std::forward 转发变参模板
template <typename U, typename... Args>
void construct(U* p, Args&&... args) {
    new (p) U (std::forward<Args>(args)...);
}

// 销毁指针 p 指向的内存区块
void deallocate(pointer p, size_t n = 1) {
  if (p != nullptr) {
    // reinterpret_cast 是强制类型转换符
    // 要访问 next 必须强制将 p 转成 slot_pointer_
    reinterpret_cast<slot_pointer_>(p)->next = freeSlots_;
    freeSlots_ = reinterpret_cast<slot_pointer_>(p);
  }
}

// 销毁一个现有的内存池
~MemoryPool() noexcept {
  // 循环销毁内存池中分配的内存区块
  slot_pointer_ curr = currentBlock_;
  while (curr != nullptr) {
    slot_pointer_ prev = curr->next;
    operator delete(reinterpret_cast<void*>(curr));
    curr = prev;
  }
}

// 同一时间只能分配一个对象, n 和 hint 会被忽略
pointer allocate(size_t n = 1, const T* hint = 0) {
  // 如果有空闲的对象槽，那么直接将空闲区域交付出去
  if (freeSlots_ != nullptr) {
    pointer result = reinterpret_cast<pointer>(freeSlots_);
    freeSlots_ = freeSlots_->next;
    return result;
  } else {
    // 如果对象槽不够用了，则分配一个新的内存区块
    if (currentSlot_ >= lastSlot_) {
      // 分配一个新的内存区块，并指向前一个内存区块
      data_pointer_ newBlock = reinterpret_cast<data_pointer_>(operator new(BlockSize));
      reinterpret_cast<slot_pointer_>(newBlock)->next = currentBlock_;
      currentBlock_ = reinterpret_cast<slot_pointer_>(newBlock);
      // 填补整个区块来满足元素内存区域的对齐要求
      data_pointer_ body = newBlock + sizeof(slot_pointer_);
      uintptr_t result = reinterpret_cast<uintptr_t>(body);
      size_t bodyPadding = (alignof(slot_type_) - result) % alignof(slot_type_);
      currentSlot_ = reinterpret_cast<slot_pointer_>(body + bodyPadding);
      lastSlot_ = reinterpret_cast<slot_pointer_>(newBlock + BlockSize - sizeof(slot_type_) + 1);
    }
    return reinterpret_cast<pointer>(currentSlot_++);
  }
}

// 比较内存池和 std::vector 之间的性能
    std::vector<int> stackVector;
    start = clock();
    for (int j = 0; j < REPS; j++) {
        assert(stackVector.empty());
        for (int i = 0; i < ELEMS; i++)
          stackVector.push_back(i);
        for (int i = 0; i < ELEMS; i++)
          stackVector.pop_back();
    }
    std::cout << "Vector Time: ";
    std::cout << (((double)clock() - start) / CLOCKS_PER_SEC) << "\n\n";

#include <iostream>
#include <gtest/gtest.h>

int f(int i)
{
    retrun i;
}

TEST(f,simple_test)
{
    ASSERT_TRUE(f(1) == 1);
    ASSERT_EQ(f(1), 1);
}

// 主函数
int main(int argc, char** argv)
{
    // 初始化 Google Test 框架
    ::testing::InitGoogleTest(&argc, argv);
    // 运行所有测试用例
    return RUN_ALL_TESTS();
}