许多后端检索server启动时候需要从文件加载到内存中构建索引，这个过程往往会消耗比较多的时间，这样会造成sever启动消耗比较多的时间，在存在多台服务器的时候会更加明显。
我们可以将够构建索引的过程独立成一个单独的进程，此进程实现的功能是根据原始文件构建索引结构，并将索引结构序列化到本地二进制文件，Server在启动的时候只需要读取二进制文件就可以构造出索引结构，可以大大提高启动速度。

io.hpp ,对std::ifstream 以及std::ofstream 的封装，提供从vector序列化到二进制文件和从二进制文件反序列化到vector等接口

#ifndef IO_HPP
#define IO_HPP
#include <string>
#include <vector>
#include <fstream>
class FileReader
public:
    FileReader(const std::string& filename)
        : input_stream(filename,std::ios::binary)
    /* Read count objects of type T into pointer dest */
    template <typename T> void ReadInto(T *dest, const std::size_t count)
        static_assert(std::is_trivially_copyable<T>::value,
                      "bytewise reading requires trivially copyable type");
        if (count == 0)
            return;
        const auto &result = input_stream.read(reinterpret_cast<char *>(dest), count * sizeof(T));
        const std::size_t bytes_read = input_stream.gcount();
        if (bytes_read != count * sizeof(T) && !result)
            return;
    template <typename T> void ReadInto(std::vector<T> &target)
        ReadInto(target.data(), target.size());
    template <typename T> void ReadInto(T &target) 
         ReadInto(&target, 1); 
    template <typename T> T ReadOne()
        T tmp;
        ReadInto(tmp);
        return tmp;
    std::uint32_t ReadElementCount32() 
        return ReadOne<std::uint32_t>(); 
    std::uint64_t ReadElementCount64() 
        return ReadOne<std::uint64_t>(); 
    template <typename T> void DeserializeVector(std::vector<T> &data)
        const auto count = ReadElementCount64();
        data.resize(count);
        ReadInto(data.data(), count);
private:
    std::ifstream input_stream;
class FileWriter
public:
    FileWriter(const std::string& filename)
        : output_stream(filename,std::ios::binary)
    /* Write count objects of type T from pointer src to output stream */
    template <typename T> void WriteFrom(const T *src, const std::size_t count)
        static_assert(std::is_trivially_copyable<T>::value,
                      "bytewise writing requires trivially copyable type");
        if (count == 0)
            return;
        const auto &result =
            output_stream.write(reinterpret_cast<const char *>(src), count * sizeof(T));
    template <typename T> void WriteFrom(const T &target) 
        WriteFrom(&target, 1); 
    template <typename T> void WriteOne(const T tmp) 
        WriteFrom(tmp); 
    void WriteElementCount32(const std::uint32_t count) 
        WriteOne<std::uint32_t>(count); 
    void WriteElementCount64(const std::uint64_t count) 
        WriteOne<std::uint64_t>(count); 
    template <typename T> void SerializeVector(const std::vector<T> &data)
        const auto count = data.size();
        WriteElementCount64(count);
        return WriteFrom(data.data(), count);
private:
    std::ofstream output_stream;
#endif

binary_io.cpp

#include "io.hpp"
#include <iostream>
struct Data
    int a;
    double b;
    friend std::ostream& operator<<(std::ostream& out,const Data& data)
        out << data.a << "," << data.b;
        return out;
template<typename T>
void printData(const std::vector<T>& data_vec)
    for (const auto data : data_vec)
        std::cout << "{" << data << "} ";
    std::cout << std::endl;
template<typename T>
void serializeVector(const std::string& filename,const std::vector<T>& data_vec)
    FileWriter file_writer(filename);
    file_writer.SerializeVector<T>(data_vec);
template<typename T>
void deserializeVector(const std::string& filename,std::vector<T>& data_vec)
    FileReader file_reader(filename);
    file_reader.DeserializeVector<T>(data_vec);
int main()
    std::vector<Data> vec1 = {{1,1.1},{2,2.2},{3,3.3},{4,4.4}};
    std::cout << "before write to binary file.\n";
    printData(vec1);
    const std::string filename = "vector_data";
    std::cout << "serialize vector to binary file.\n";
    serializeVector<Data>(filename,vec1);
    std::vector<Data> vec2;
    deserializeVector<Data>(filename,vec2);
    std::cout << "vector read from binary file.\n";
    printData(vec2);
    return 0;
g++ -std=c++11 binary_io.cpp -o binary_io
 
./binary_io
 
执行结果 
  
 程序将内存中vector 数据写入二进制文件，并从二进制文件中反序列化到一个新的vector。可以看到序列化前和序列化后的结果一致。
 
序列化到文件的数据结构需要满足 is_trivially_copyable。std::is_trivially_copyable 在c++11 引入，TriviallyCopyable类型对象有以下性质
 
每个拷贝构造函数是trivial 或者是deleted
每个移动构造函数是trivial 或者是deleted
每个拷贝赋值运算符是trivial 或者是deleted
每个移动赋值运算符是trivial 或者是deleted
以上至少有一个是non-deleted
析构函数是trivial 并且non-deleted
对于is_trivially_copyable 类型对象的性质，解释如下
 
 
Objects of trivially-copyable types are the only C++ objects that may be safely copied with std::memcpy or serialized to/from binary files with std::ofstream::write()/std::ifstream::read(). In general, a trivially copyable type is any type for which the underlying bytes can be copied to an array of char or unsigned char and into a new object of the same type, and the resulting object would have the same value as the original
 
只有满足trivially-copyable的对象才可以保证序列化到二进制文件后， 从二进制文件反序列化到内存后的值保持不变。
                    许多后端检索server启动时候需要从文件加载到内存中构建索引，这个过程往往会消耗比较多的时间，通过提前将数据结构序列化为二进制文件，server 反序列化二进制文件的方式可以有效提升启动速度。
很多人都知道rapidjson这个json库，大家也都知道他的高效，可是你一定也对他的使用方法，函数API接口感受到非常不适应，你一定非常怀念使用java和C#对一个实体类的那么轻松加简单的直接json序列化，本篇博客使用一个RapidJsonHelper类，将帮你实现对一个C++实体类的的序列化和反序列化。rapidjson的版本是1.1。
				
Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何




    

				
众所周知，虽然c++在一定程度上是c的超集，但c++和c有很大的不同，其中之一，就是c++的类和c的结构体有很大的区别。在c++中，如果一个类和c中的结构体相同，这样的类被称作pod（plain old data），可以通过std::is_pod检查一个类是否是pod类。下文会介绍pod的相关要求：
pod的组成
在c++，对于一个pod的类要满足那几条要求做了一个详细的概括，具体来说，is_pod可以拆分为is_trivial和is_standard_layout，is_trivial又可以拆分成is_t
#include <fstream> //文件操作需要引拥的头文件
ofstream     //文件写操作 内存写入存储设备
ifstream     //文件读操作，存储设备读区到内存中
fstream     //读写操作，对打开的文件可进行读写操作
1.打开文件（ifstream）
在fstr...
        public:
            CDummy(const char * szName):m_pName(szName){}
            std::string GetName(){return m_pName;}
        private:
            const char * m_pName;
该文目的为C++批量处理xml文件部分数据，转txt（yolov5格式数据)。
第一步：读取xml文件名
第二步：创建同名txt文件（为将txt文件对应xml文件以跟图片对应）
第三步：获取xml相关数据并进行归一化
第四步：将数据存入txt文件
实现效果为：获取图片宽高和object下的armor类中的armor_class,armor_color,bndbox中的四个数等内容，整合为yolo要求的txt格式中的五个数据：
1.类别；2.归一化的图片中
JSON 是纯文本，容易阅读，方便编辑，适用性最广；
MessagePack 是二进制，小巧高效，在开源界接受程度比较高；
ProtoBuffer 是工业级的数据格式，注重安全和性能，多用在大公司的商业产品里。
序列化和反序列化
序列化，就是把内存里“活的对象”转换成静止的字节序列，便于存储和网络传输；
而反序列化则是反向操作，从静止的字节序列重新构建出内存里可用的对象。
接下来，我就和你介绍三种既简单又高效的数据
// 将结构体序列化为字节数组
void serialize(Student* student, char* buffer, int size) {
    if (size < sizeof(Student)) {
        printf("buffer size is too small\n");
        return;
    memcpy(buffer, student, sizeof(Student));
// 将字节数组反序列化为结构体
void deserialize(Student* student, char* buffer, int size) {
    if (size < sizeof(Student)) {
        printf("buffer size is too small\n");
        return;
    memcpy(student, buffer, sizeof(Student));
int main() {
    // 创建一个结构体实例
    Student stu = {"Tom", 20, 90.5};
    // 将结构体序列化为字节数组
    char buffer[sizeof(Student)];
    serialize(&stu, buffer, sizeof(buffer));
    // 将字节数组反序列化为结构体
    Student newStu;
    deserialize(&newStu, buffer, sizeof(buffer));
    // 输出反序列化后的结构体
    printf("name: %s, age: %d, score: %lf\n", newStu.name, newStu.age, newStu.score);
    return 0;
在上面的示例中，我们定义了一个名为 `Student` 的结构体，并且实现了 `serialize` 和 `deserialize` 函数。`serialize` 函数将 `Student` 结构体转换为字节数组，`deserialize` 函数将字节数组转换为 `Student` 结构体。
在 `main` 函数中，我们创建了一个 `Student` 实例，并且将其序列化为字节数组。然后，我们将字节数组反序列化为一个新的 `Student` 结构体，并输出其成员变量的值。
需要注意的是，序列化和反序列化的过程中，需要保证字节数组的大小足够存储结构体的数据。否则，可能会出现内存访问错误。
两者都会调用移动构造
push 2我的理解就是有一个拷贝构造呀，然后使用placement new来进行移动构造
另外push也是能实现移动语义的吧，也有const左值引用和右值版本
                c++11 右值引用,移动构造函数,emplace_back 解析
                    20要继续努力哦!: 
                    那是不是这个意思？
push_back和emplace_back在接受右值时，没啥区别，都是调用拷贝构造（c++11后 重载push_back 可接受右值 实现就是调用emplace_back）
但是我有个问题 push_back(2) 这个2是字面值吧？那就是有值？之前我一直以为是隐式的拷贝构造 现在有点疑惑？希望知道的大佬帮忙解决一下
对于左值的话，push_back只能调用拷贝构造，而emplace_back可以调用std::move函数实现移动语义
emmm 为啥push-back不行？
希望大佬们帮忙解决一下！
                c++11 右值引用,移动构造函数,emplace_back 解析
                    Nnboylhj: 
                    这里有答案：c++中为什么push_back({1,2})可以，emplace_back({1,2})会报错? - 知乎
https://www.zhihu.com/question/438004429
                linux shell 确保脚本只有一个运行实例
                    yong1585855343: 
                    万一程序突发终止，由于 /tmp/lock.file 还在，下一次就没法启动了