如何将void *返回std :: vector <float>

Question

I can construct data on Line 19 from vvp.at(0) if I know the size of vf .

#include <iostream>
#include <vector>

typedef void* VoidPointer;
typedef std::vector< float > VF;
typedef std::vector< VoidPointer > VVP;

int main(int argc, char** argv)
{
    VF vf;
    vf.push_back(13.0f);
    vf.push_back(14.0f);
    vf.push_back(15.0f);
    vf.push_back(16.0f);

    VVP vvp;
    vvp.push_back( (VoidPointer)const_cast<float *>( &(vf.front()) ) );

    VF data ( static_cast< float* >( vvp.at(0) ),
              static_cast< float* >( vvp.at(0) ) + vf.size() );

    std::cout << "data.size() is " << data.size() << std::endl;

    for(VF::const_iterator i = data.begin(); i != data.end(); ++i)
    {
        std::cout << "data contains " << *i << std::endl;
    }

    return 0;
}

Leaving aside whether this is sensible (the example is contrived) I'd like to know how to cast vvp.at(0) to a std::vector<float> if I didn't know the size of vf . I'm thinking along the lines of something like:

std::vector<float> data( *static_cast< std::vector<float>* >( vvp.at(0) ) );

But that causes the program to termintate with std::bad_alloc, I don't mind copying if need be.

Answer 1

That is not a cast from vvp.at(0) to a vector, it's a copy of an array of floats into a new vector. And you can't copy it without knowing the length. You only saved a pointer to the first element, so the information was lost.

You could make std::vector<std::pair<VoidPointer, size_t> > VVP and save both &vf.front() and vf.size() (or start and end pointers, if you prefer).

You could make std::vector<VF *> and store pointers to vectors (ie vvp.push_back(&vf) ) and now there's no casting at all.

Edit: In case you didn't realize: The pointer &vf is unrelated to &vf.front() . vf is a structure which contains the pointer &vf.front() (or a way to get it). There's no information in just the address &vf.front() to let you find &vf .

Answer 2

The only thing I can think of is extremely non-portable (and equally crazy). Each vector allocates a contiguous array of memory. Any allocation function has to keep track of how many bytes have been allocated, so that it can de-allocate them given only the beginning of the allocation's address.

AFAIK, the C++ standard does not specify how this book keeping is done and therefore, this up to each compiler. One method is to write a count before the actual allocation address - I believe this is what the Visual C++ compiler does. (Eg. if allocating at 0x104, a 32-bit count could be stored at 0x100). Again, you will have to know how your specific compiler does this book keeping.

Anyway, the point is, once you do, a little pointer arithmetic and de-referencing could theoretically look up the allocated size (I'm of course assuming you're still using a vector with a default allocator here), and figure out how many floats were actually allocated using only a void pointer.

Here's an example that works in Visual Studio in 32-bit debug mode:

#include <iostream>
#include <vector>

size_t bytes_allocated( void* p )
{
#ifndef _DEBUG
#error Doesn't work
#endif // _DEBUG
    size_t const offset = 12;
    size_t const counter_size = 4;
    size_t const total_offset = offset + counter_size;
    void* counter_address = ((char*)p)-total_offset;
    size_t* count = reinterpret_cast<size_t*>(counter_address);
    return *count;
}

int main(int argc, char* argv[])
{
    typedef float test_type;
    std::vector<test_type> v;
    v.push_back(23);
    v.push_back(23);
    v.push_back(23);
    size_t count = bytes_allocated(&v[0]);
    std::cout<<count<<" bytes allocated\n";
    std::cout<<count/sizeof(test_type)<<" items allocated\n";
    return 0;
}

The output is:

12 bytes allocated
3 items allocated