Question

I was searching about this topic and I found many ways to convert an array[] to an std::vector, like using:

assign(a, a + n)

or, direct in the constructor:

std::vector<unsigned char> v ( a, a + n );

Those solve my problem, but I am wondering if it is possible (and correct) to do:

myvet.resize( 10 );
memcpy( &myvet[0], buffer, 10 );

I am wondering this because I have the following code:

IDiskAccess::ERetRead nsDisks::DiskAccess::Read( std::vector< uint8_t >& bufferRead, int32_t totalToRead )
{
    uint8_t* data = new uint8_t[totalToRead];
    DWORD totalRead;
    ReadFile( mhFile, data, totalToRead, &totalRead, NULL );
    bufferRead.resize( totalRead );
    bufferRead.assign( data, data + totalRead );
    delete[] data;

    return IDiskAccess::READ_OK;
}

And I would like to do:

IDiskAccess::ERetRead nsDisks::DiskAccess::Read( std::vector< uint8_t >& bufferRead, int32_t totalToRead )
{
    bufferRead.resize( totalToRead );
    DWORD totalRead;
    ReadFile( mhFile, &bufferRead[0], totalToRead, &totalRead, NULL );
    bufferRead.resize( totalRead );

    return IDiskAccess::READ_OK;
}

(I have removed the error treatment of the ReadFile function to simplify the post).

It is working, but I am affraid that it is not safe. I believe it is ok, as the memory used by the vector is continuous, but I’ve never seen someone using vectors this way.

Is it correct to use vectors like this? Is there any other better option?

Answer 1

Yes it is safe with std::vector C++ standard guarantees that the elements will be stored at contiguous memory locations.

C++11 Standard:

23.3.6.1 Class templatevector overview [vector.overview]

A vector is a sequence container that supports random access iterators. In addition,itsupports(amortized) constant time insert and erase operations at the end; insert and erase in the middle take linear time. Storage management is handled automatically, though hints can be given to improve efficiency. The elements of a vector are stored contiguously, meaning that ifv is avector whereT is some type other than bool, then it obeys the identity&v[n] == &v[0] + n for all0 <= n < v.size().