std :: vector <char> 进入std :: vector <T> 转换c ++

Question

I want to create a std::vector<T> of length len from serialized data contained in a std::vector<char> of length len * (sizeof T) , without copying data when not necessary (it may not be possible for, eg, align requirements of T ). In other words I look for an optimization of the following code, operating on the same guarantees:

template<typename T>
auto copyStuff(std::vector<char>&&input) {
    std::vector<T> result;
    result.resize(input.size()/(sizeof T));
    for (int i=0; i < result.size(); i++) {
        memcpy(&result[i], &input[i * (sizeof T)], sizeof T);
    }
    return result;
}

which

• avoids copying at all when possible
• otherwise copies all bytes in a single memcpy call if possible
• or falls back to the above implementation or equivalent when neither is possible.

Is there a standard way, or a portable library, to achieve this (or a "good enough" approximation)?

Clarifications:

• I need to be able to only assume that T is trivially copiable, and the layout of the input std::vector<char> is simply the concatenation of the memory representation of the item which I want to construct.
• I am looking for a way to be certain that I'm not going into undefined or implementation defined behaviour when doing optimizations
• I am willing to consider non-standard container libraries (instead of vector s) if they offer this low overhead type punning.

Answer 1

It is not possible to get vector of one type from another type without copying.

You can avoid one set of copies by constructing the vector of T (of sufficient size) initially, and then writing the serialized data directly onto that vector without the use of an intermediate vector of chars.

A few caveats:

• Copying the data directly will mean that the data is not portable to CPU's with different endianness or otherwise different representation of numbers, so this form of serialisation is not appropriate for communication across systems (such as networking, shared files).
• T must be trivially copyable type.