C++ std::string vector serializer

serializer.cpp

// 32 bit int handling functions
void appendU32ToString(std::string &str, uint32_t value) {
    char intchar[4];
    std::memcpy(&intchar, &value, 4);

    for (size_t i = 0; i < 4; i++) { // Please tell me there is a less stupid way of doing this
        str.push_back(intchar[i]);
    }
}

uint32_t decodeU32FromString(std::string &str, int pos) {
    uint32_t output;
    char intchar[4];

    std::strncpy(intchar, str.substr(pos, 4).c_str(), 4);
    std::memcpy(&output, intchar, 4);
    return output;
}

// 16 bit int handling functions
void appendU16ToString(std::string &str, uint16_t value) {
    char intchar[2];
    std::memcpy(&intchar, &value, 2);

    for (size_t i = 0; i < 2; i++) { // Please tell me there is a less stupid way of doing this
        str.push_back(intchar[i]);
    }
}

uint16_t decodeU16FromString(std::string &str, int pos) {
    uint32_t output;
    char intchar[2];

    std::strncpy(intchar, str.substr(pos, 2).c_str(), 2);
    std::memcpy(&output, intchar, 2);
    return output;
}

std::string serialize(std::vector<std::string> inputvec) {
    int headersize;
    headersize = (inputvec.size() * sizeof(uint32_t)); // Set header size in bytes
    std::string out; // Output string
    std::string header; // Header string (not including the header length)

    int offsetcounter = 0;
    for (size_t i = 0; i < (headersize / 4); i += 1) { // Offset is from beginning of file, not data chunk
        appendU32ToString(header, (offsetcounter + headersize + 2));
        offsetcounter += inputvec[i].size();
    }

    appendU16ToString(out, header.size());
    out += header;

    for (size_t i = 0; i < inputvec.size(); i++) {
        out += inputvec[i];
    }

    return out;
}

std::vector<std::string> deserialize(std::string in) {
    std::vector<std::string> out;
    std::string header;
    int b_headersize = decodeU16FromString(in, 0);
    int headersize = (b_headersize / 4);

    header = in.substr(2, b_headersize);
    std::vector<int> offsets;

    for (size_t i = 0; i < b_headersize; i += 4) {
        offsets.push_back(decodeU32FromString(header, i));
    }
    
    for (size_t i = 0; i < offsets.size(); i++) {
        out.push_back(in.substr(offsets[i], offsets[i+1] - offsets[i]));
    }

    return out;
}