IT博客-魔のkyo的工作室-随笔分类-C++

C++ std::chrono中时钟的用法以及和time_t的转换和格式化

魔のkyo — Tue, 07 Jan 2020 04:20:00 GMT

#include
#include
#include

using namespace std;

constexpr int64_t SEC = 1000000;
constexpr int64_t MIN = SEC * 60;
constexpr int64_t HOUR = MIN * 60;
constexpr int64_t DAY = HOUR * 24;

// 返回当前时间作为格林威治(GMT)时间距离 GMT时间 1970-1-1 00:00:00 的微秒数
int64_t get_time_us()
{
    chrono::system_clock clock;
    return chrono::duration_cast(
        clock.now().time_since_epoch()).count();
}

// 返回当前时间作为本地（北京）时间距离 GMT时间 1970-1-1 00:00:00 的微秒数，等于get_gmtime_us加8小时
int64_t get_localtime_us()
{
    return get_time_us() + HOUR * 8;
}

// 格林威治时间的微秒数格式化成本地时间字符串
string gmtime2localstr(int64_t time_us, const string& fmt="%Y-%m-%d %H:%M:%S")
{
    stringstream ss;
    time_t t = time_us / SEC;
    auto tm = std::localtime(&t);
    ss << std::put_time(tm, fmt.c_str());
    return ss.str();
}

// 本地时间字符串解析成格林威治时间的微秒数
int64_t localstr2gmtime(const std::string& s, const std::string& fmt="%Y-%m-%d %H:%M:%S")
{
    stringstream ss;
    ss << s;
    struct tm tm;
    ss >> std::get_time(&tm, fmt.c_str());
    return (int64_t)mktime(&tm) * SEC;
}

// 字符串转微秒数，不考虑时区
std::string time2str(int64_t time_us, const std::string& fmt="%Y-%m-%d %H:%M:%S")
{
    stringstream ss;
    time_t t = time_us / SEC;
    auto tm = std::gmtime(&t);
    ss << std::put_time(tm, fmt.c_str());
    return ss.str();
}

// 微秒数转字符串，不考虑时区
int64_t str2time(const std::string& s, const std::string& fmt="%Y-%m-%d %H:%M:%S")
{
    stringstream ss;
    ss << s;
    struct tm tm;
    ss >> std::get_time(&tm, fmt.c_str());
    return (int64_t)mktime(&tm) * SEC + HOUR * 8; // 这里 + 8 HOURs是因为mktime内部考虑了时区，我期望有一个gmmktime函数，但是标准库似乎并没有
}

其实对于time_t或者说从格林尼治1970年1月1日0时的毫秒数来说，并不需要区分时区，全球都是同一个毫秒数只是在对应到有时间表示时才需要区分时区，
这里之所有引入get_localtime_us是为了方便时间计算，例如计算当前时间的下一个8点40的微秒数，如果任意天00:00对齐到 % DAY == 0这样会比较好算。

auto _08_40 = (HOUR * 8 + MIN * 40);

auto next_08_40 = ((time_us - _08_40) / DAY + 1) * DAY + _08_40;

魔のkyo 2020-01-07 12:20 发表评论

用iconv在Linux上进行字符编码转换

魔のkyo — Wed, 27 Nov 2019 10:36:00 GMT

Windows上参考
http://www.cnitblog.com/luckydmz/archive/2010/03/03/64458.html

#include
#include
#include <string>
#include

class EncodingConvertor
{
public:
    // "UTF-8", "GBK"
    EncodingConvertor(const char* toEncoding, const char* fromEncoding)
    {
        _iconv = iconv_open(toEncoding, fromEncoding);
    }

    std::string convert(const char* in)
    {
        constexpr size_t BLOCK_SIZE = 1024; // iconv可以分块转换，对于特别长的字符串（特别大的文件）
        size_t inlen = strlen(in);
        size_t outbuflen = std::max(inlen * 2, BLOCK_SIZE);
        const char* pin = in;
        char* outbuf = (char*)malloc(outbuflen);
        char* pout = outbuf;

        size_t ret = 0;
        do {
            size_t perlen = BLOCK_SIZE;
            if(pout + perlen > outbuf + outbuflen - 1)
            { // 如果outbuf后面剩余空间不足一个转换块大小，就重新分配空间
                int pout_offset = pout - outbuf;
                outbuflen = std::max(outbuflen * 2, BLOCK_SIZE);
                outbuf = (char*)realloc(outbuf, outbuflen);
                pout = outbuf + pout_offset; // outbuf可能指向新地址，所以要把pout偏移过去
            }
            ret = iconv(_iconv, (char**)&pin, &inlen, &pout, &perlen);
            if(perlen == BLOCK_SIZE)
            { // 转移前后perlen没有变化应该是出错了
                outbuf[0] = 0;
                break;
            }
        } while(ret == -1);
        *pout = 0;

        std::string r(outbuf);
        free(outbuf);
        return r;
    }

    ~EncodingConvertor()
    {
        iconv_close(_iconv);
    }

private:
    iconv_t _iconv;
};

int main()
{
    EncodingConvertor convertor("UTF-8", "GBK");
    std::string s = convertor.convert("GBK string");
    std::cout << s << std::endl;
    return 0;
}

魔のkyo 2019-11-27 18:36 发表评论

Python使用msgpack对任意单层POD类型class编解码

魔のkyo — Tue, 19 Nov 2019 16:00:00 GMT

import msgpack

def obj_dict_serializer(obj):
    return msgpack.dumps(vars(obj))

def obj_dict_deserializer(T):
    def deserializer(buf):
        obj = T()
        dic = msgpack.unpackb(buf)
        for k,v in dic.items():
            k = k.decode()
            if type(v)==bytes:
                v = v.decode()
            setattr(obj, k, v)
        return obj
    return deserializer

def obj_list_serializer(obj):
    return msgpack.dumps(list(vars(obj).values()))

def obj_list_deserializer(T):
    def deserializer(buf):
        obj = T()
        for k, v in zip(vars(obj).keys(), msgpack.unpackb(buf)):
            if type(v)==bytes:
                v = v.decode()
            setattr(obj, k, v)
        return obj
    return deserializer

if __name__ == '__main__':
    from dataclasses import dataclass
    @dataclass
    class Stu:
        id : int = 0
        name: str = ""
        stuno: str = ""

    stu1 = Stu(1, "张三", "190003160")
    stu2 = Stu(2, "李四", "190003161")

    buf1 = obj_dict_serializer(stu1)
    stu1_ = obj_dict_deserializer(Stu)(buf1)
    print(stu1, stu1_)
    print(stu1 == stu1_)

    buf2 = obj_dict_serializer(stu2)
    stu2_ = obj_dict_deserializer(Stu)(buf2)
    print(stu2, stu2_)
    print(stu2 == stu2_)

配合在C++上使用msgpack.hpp 像class、struct中添加 MSGPACK_DEFINE 或 MSGPACK_DEFINE_MAP，可以实现python和C++之间的数据互传后的编解码

魔のkyo 2019-11-20 00:00 发表评论

可变模版参数(variadic templates)

魔のkyo — Sat, 09 Nov 2019 05:23:00 GMT

C++11引入了一个很强大的模板功能，即可变模板参数(variadic templates)，

它允许定义出可变参数个数，同时可变参数类型的模板，看一个简单的例子

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 template <typename Args> // 通过typename声明的Args称为模板参数包，注意是写在typename后面的
 6 void func(const Args& args) // 这里的const Args&称为函数参数类型包，而声明出的args称为函数参数包
 7 {
 8     printf(args); // 这里的args称为对函数参数包的展开
 9 }
10 
11 int main(void)
12 {
13     func("%s %d", "Hello world", 123);
14 }
15 

输出为

Hello world 123

上面的展示很简单明确，现在我们基本知道可变模板参数是个什么东西了。那么它有什么用呢，下面我们来做一些稍微复杂一点的事，如果我们不用printf这样的接受可变长参数列表的函数作为输出，而使用cout该怎么修改上面的代码呢？下面我们稍作修改，通过递归调用把参数一个一个拆出来。

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 // 递归终止
 6 void func()
 7 {
 8 
 9 }
10 
11 template <typename T, typename Args>
12 void func(const T& obj, const Args& args)
13 {
14     cout << obj << " ";
15     func(args); // 递归调用
16 }
17 
18 int main(void)
19 {
20     func("Hello world", 123); //因为改成通过cin，前面的格式化字符串删掉了
21 }

通过增加在模板参数包前面增加一个参数T接受一个参数，再把后面的所有参数递归调用，就实现了一个一个拆出来，最后的调用中args...是可以为0个参数的，这时候调用到了上面的重载函数func()什么都不做。我们可能会想，能不能不写一个空的func()直接在模板函数里面判断args携带的参数个数来终止递归呢，答案是：可以的，但没那么简单。取得可变模板参数的个数可以使用sizeof...()或tuple_size<>::value，下面实现一下

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 template <typename T, typename Args>
 6 void func(const T& obj, const Args& args)
 7 {
 8     cout << obj << " ";
 9     if (sizeof(Args) > 0) {
10         func(args); // 递归调用
11     }
12 }
13 
14 int main(void)
15 {
16     func("Hello world", 123); //因为改成通过cin，前面的格式化字符串删掉了
17 }
18 

上面的代码试图通过判断sizeof...(Args)是否大于0决定是否继续递归，但是上面的代码会编译错误，因为if的判断是在运行期才做的，对func(args...)的调用在编译时就要有匹配的函数存在，而当args一个参数都没有时，编译器找不到匹配的函数进行调用（func至少接受一个参数T）。

所以问题的关键点是if分支是运行期的分支，如果我们做一个编译期的分支不就可以解决了么。

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 template <typename T, typename Args>
 6 void func(const T& obj, const Args& args);
 7 
 8 // 声明一个带有一个bool参数的模板struct
 9 template<bool Flag>
10 struct If_Func;
11 
12 // 下面对bool参数分别进行true/false两种特化实现，以此实现编译期的分支
13 template<>
14 struct If_Func<true>
15 {
16     template<typename Args>
17     static void call (const Args& args) {
18         func(args);
19     }
20 };
21 
22 template<>
23 struct If_Func<false>
24 {
25     template<typename Args>
26     static void call(const Args& args) {
27         
28     }
29 };
30 
31 template <typename T, typename Args>
32 void func(const T& obj, const Args& args)
33 {
34     cout << obj << " ";
35     constexpr bool flag = sizeof(Args) > 0;
36     If_Func<flag>::call(args);
37 }
38 
39 int main(void)
40 {
41     func("Hello world", 123); //因为改成通过cin，前面的格式化字符串删掉了
42 }

上面引入了一个If_Func，这个东西从语法层面来说就是类模板和模板特化，不是新东西，但是这种用法一般被称为模板元编程，C++1x里有一个头文件<type_traits>里面提供了很多模板可以帮助我们进行各种判断，比如判断一个类型是否指针，是否POD，一个类是否是另一个类的子类，等等，可以辅助我们进行模板元编程，有兴趣的自行搜索了解。

下面我们讲另一个东西，元组(tuple)，它可以看成是对std::pair的n个元素扩充

#include <iostream>
#include <tuple>
using namespace std;

int main(void)
{
    tuple<int, double, string> t = make_tuple(1, 3.14, "Hello world");
    cout << typeid(t).name() << endl;
    cout << std::tuple_size<decltype(t)>::value << endl; // 输出tuple的元素个数
    cout << std::get<0>(t) << endl; // 输出tuple的第0个元素
    cout << std::get<1>(t) << endl; // 输出tuple的第1个元素
    cout << std::get<2>(t) << endl; // 输出tuple的第2个元素
}

这里不展开讲tuple的用法，我们注意，tuple的模板参数其实类型和数量都是可变的，事实上它就是利用了可变模板参数来实现的。怎么实现呢，大概是这样

template<typename Args>
class my_tuple;

template<>
class my_tuple<>
{

};

template<typename T, typename Args>
class my_tuple<T, Args> : public my_tuple<Args>
{
public:

protected:
    T _obj;
};

通过递归继承的方式，每次把一个参数拆出来作为成员变量，其余的参数丢给基类，直到参数为空。

标准库并没有实现tuple的输出，现在产生一个问题，我们自己能否实现一个tuple的输出函数呢。

要实现的就是如果我们使用

cout << make_tuple(123, 3.14, "Hello") << endl;

可以像python里面

print( (123, 3.14, "Hello") )

输出元组一样，打印出类似 (123, 3.14, 'Hello')

我们要实现的函数原型是这样

template 

ostream& operator << (ostream& out, const tuple t);

直接给出代码，里面再次用到了所谓的模板元编程技巧。

#include <iostream>
#include <string>
#include <tuple>
#include <sstream>
using namespace std;

template <size_t N>
struct PrintHelper;

template <>
struct PrintHelper<1>
{
    template<typename Args>
    static void recursive_print(ostream& out, const tuple<Args> t)
    {
        out << "(" << std::get<0>(t) << ", ";
    }
};

template <size_t N>
struct PrintHelper
{
    template<typename Args>
    static void recursive_print(ostream& out, const tuple<Args> t)
    {
        PrintHelper<N - 1>::recursive_print(out, t);
        out << std::get<N - 1>(t) << ", ";
    }

    template<typename Args>
    static void print(ostream& out, const tuple<Args> t)
    {
        PrintHelper<N - 1>::recursive_print(out, t);
        out << std::get<N - 1>(t) << ")";
    }
};


template <typename Args>
ostream& operator << (ostream& out, const tuple<Args> t)
{
    PrintHelper<tuple_size<decltype(t)>::value >::print(out, t);
    // PrintHelper::print(out, t); // 和上面等价
    return out;
}

int main(void)
{
    cout << std::make_tuple(123, 3.14, "Hello") << endl;
}

事实上这里会输出

(123, 3.14, Hello)

Hello的两端并没有引号，如果想加上引号，可以再次利用模板元编程技巧通过编译时的分支把string类型的输出方法特化，此处不再给出具体代码，留给读者自行探索。

魔のkyo 2019-11-09 13:23 发表评论

Boost和C++1x最值得学习的库概览

魔のkyo — Fri, 08 Nov 2019 10:05:00 GMT

Boost库分两种

header-only的 和 header + lib的

大多数都是header-only的，直接包含头文件就可以用。header + lib由一组头文件和一个库文件构成，可以自己用下载下来的代码编译出库文件或者直接在网上下载对应版本编译好的库。

需要连接lib的有以下库：

    Boost.Chrono	已经标准化 std::chrono C++11

    Boost.Context	C++的协程支持（Coroutine）

    Boost.Filesystem	已经标准化 std::filesystem C++17 处理文件和路径的

    Boost.GraphParallel	是Boost.Graph库的扩展，为了支持并行和分布式计算，包含一些图算法

    Boost.IOStreams	IO流，我觉得最大的特点是可以通过filter进行zlib, gzip 和 bzip2的压缩和解压

    Boost.Locale	本地化库，最主要是解决字符编码转换的问题，还有些日期货币格式转换

    Boost.Log		日志库

    Boost.MPI		用于分布式计算中的消息传递

    Boost.ProgramOptions	读取 命令行参数 或 配置文件

    Boost.Python	和pyhon的交互框架

    Boost.Regex	已经标准化std::regex C++11

    Boost.Serialization	序列化

    Boost.Signals	信号槽模式的一个实现

    Boost.Thread	已经标准化std::thread C++11

    Boost.Timer		计时器，可以用std::chrono::high_resolution_clock自己实现，所以没必要

    Boost.Wave		C++预处理器，似乎是为了方便编写一些对C++代码进行预处理的代码

以上被标记为红色的我觉得比较有用，可以学习一下，此外包括header-only的一些库，很多都已经被标准化，这些被标准化的往往是比较有用的，我找了了一下大概有下面这些：

 std::bind / std::function / std::ref / std::cref

 std::is_pod / std::is_base_of / std::enable_if / std::result_of / auto / decltype

数组封装 std::array 和vector比固定大小，和原生[]数组比不会退化为指针，有迭代器

任意类型 std::any

可选类型 std::optional / std::nullopt

正则表达式 std::regex

编译时分数 std::ratio

指针增强 std::shared_ptr  / std::weak_ptr / std::unique_ptr

n元组 std::tuple / std::make_tuple / std::get

多线程和锁 std::thread / std::mutex / std::lock_guard / std::unique_lock / std::atomic

时钟 std::chrono::high_resolution_clock / std::chrono::system_clock / std::chrono::steady

HASH表 std::unordered_map / std::unordered_set / std::hash

静态断言 static_assert

我把相关联的东西合并在了一行，这些可以说是C++1x新标准最值得学习的内容。

魔のkyo 2019-11-08 18:05 发表评论

通过_CRTDBG_MAP_ALLOC宏在VC上启用内存泄漏检测

魔のkyo — Mon, 04 Nov 2019 16:34:00 GMT

#include <iostream>
using namespace std;

#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

// 按理说通过定义上面的宏再引入头文件，new就会被重新定义成记录文件和行号的
// 但是实际测试下来没有，不知道为什么，而手动定义是起作用的，Microsoft Visual C++ 2019 16.3.2
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)

int main(void)
{
    /* 还有其他选项，可以跳转到定义处查看
#define _CRTDBG_ALLOC_MEM_DF        0x01  // Turn on debug allocation
#define _CRTDBG_LEAK_CHECK_DF       0x20  // Leak check at program exit
    */
    // 当没有定义_DEBUG宏时，下面的调用会被替换成一个哑的宏，什么都不做
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    int* p = new int();
}

程序结束有会在输出栏输出如下信息，可以直接双击就会跳转到产生泄漏的文件和行号

Detected memory leaks!

Dumping objects ->

D:\development\cpp_test\Project1\main.cpp(21) : {82} normal block at 0x00000218B2905FC0, 4 bytes long.

Data : < > 00 00 00 00

Object dump complete.

魔のkyo 2019-11-05 00:34 发表评论