8

How can I move the contents of std::vector into an array safely without copying or iterating over all elements?

void someFunc(float* arr, std::size_t& size)
{
   std::vector<float> vec(5, 1.5f);
   // do something with the data

   size = vec.size();
   arr = vec.data(); // this doesn't work, as at the end of the function the data in std::vector will be deallocated

}

main()
{
   float* arr;
   std::size_t size{0};

   someFunc(arr, size);

   // do something with the data
   delete [] arr;
}

How can I assign my array with the data in std::vector and making sure that deallocation will not be called on std::vector? Or maybe any other ideas to go around this?

Bobo Feugo
  • 162
  • 1
  • 10
  • 4
    What is your goal? Why not keep the vector and use its `.data()`? – mkrieger1 Oct 02 '19 at 15:37
  • You can use a `vector` on legacy functions that take a `T*`. As stated, just use the `data()` member. There is no need to shuffle between vector and a regular array, if this is what you were intending to do. – PaulMcKenzie Oct 02 '19 at 15:44
  • Well, I actually can stick with std::vector, but still need to use some old code that consider the data to be in raw array. And I really don't want to edit or rewrite the old code – Bobo Feugo Oct 02 '19 at 15:45
  • 2
    @BoboFeugo -- But all you need is to pass `data()` to the top-level "old code" function, and the rest is all an array, the old code has no idea the data was being managed by a vector. Have you ever used `data()`? – PaulMcKenzie Oct 02 '19 at 15:46
  • @PaulMcKenzie That only works if the "old code" doesn't want to assume ownership. – Max Langhof Oct 02 '19 at 15:47
  • As I know `data()` will return a pointer to const data, but I need to modify the data – Bobo Feugo Oct 02 '19 at 15:48
  • 1
    @BoboFeugo [only from a `const vector`](https://en.cppreference.com/w/cpp/container/vector/data). From a mutable vector you get a pointer-to-mutable – Caleth Oct 02 '19 at 15:49
  • @MaxLanghof The only thing I can think of that the old code would have done with ownership that would totally mess this up is to call `delete[]` on the pointer (which is a bad design to being with). – PaulMcKenzie Oct 02 '19 at 15:50
  • 1
    @PaulMcKenzie or `free()`, or `delete`, or `lib_MyBadOlLib_Free()` – Caleth Oct 02 '19 at 15:51
  • 1
    @BoboFeugo You are thinking of `std::string::c_str()`, where the return value is `const`. Not so for a non-const vector. – PaulMcKenzie Oct 02 '19 at 15:51
  • 1
    I want to do exactly this because I am using a library (lodepng) that reads a file into a vector. I want to return a unique_ptr that wraps the vector's data, which could be very large (or I want to repeat the operation many times; either way I don't want to allocate, read, then copy, nor do I want to return the vector itself, though this is likely what I'll settle on). – taranaki Jul 29 '20 at 04:18

2 Answers2

7

You can't.

A vector owns its buffer. You cannot steal it.

You will have to copy/move the elements individually, optionally using a helper algorithm that does the iteration for you (std::copy/std::move).

(Also note that, since your element type is just float, a move here is a copy.)

(Also note that this std::move, the algorithm, is not the same as std::move, the rvalue cast.)

Consider whether you really need to do this. You can treat the vector's data as an array using vec.data() whenever you need to, as long as you keep the vector alive. Surely that's better than sacrificing RAII?

Lightness Races in Orbit
  • 378,754
  • 76
  • 643
  • 1,055
  • So how do you use std::move for this purpose? – Bobo Feugo Oct 02 '19 at 15:38
  • 3
    https://en.cppreference.com/w/cpp/algorithm/move Though, since you only have floats, "move" will really just be a copy. – Lightness Races in Orbit Oct 02 '19 at 15:38
  • actually the `move` I asked for is not the one from the standard algorithm, instead i wanted something like `move-semantics` or a shallow copy. But as the most comments stated that it's not possible, i may have to change my implementation! – Bobo Feugo Oct 03 '19 at 12:37
  • @Bobo Indeed, you're asking how to move (or "steal") the vector's internal buffer - you can't do that. Well, you can steal it into another vector, but that doesn't help you ;) The `std::move` I'm talking about is for the "individual" elements. – Lightness Races in Orbit Oct 03 '19 at 12:53
  • @LightnessRacesinOrbit why not the other way around, where you have the vector steal from a pre-existing allocation? This answer is pretty defeatist –  Jun 29 '20 at 11:20
0

This would have been handy for me for stealing a "typed" vector contents into an "untyped" vector.

This is what I want to do:

std::vector<uint8_t>­one;
std::vector<V> other = std::move(one);

When I know that the contents are exactly what I expect (there is a runtime type info field)

I would use this to do 'move semantics' between an untyped and a typed class where part of the underlying representation is in a vector - just in the typed case it is vector of Vs.

Think of it as a different "view" of the data. In general cases the data is untyped as there are special edge-cases, but after handling them via branching it would be handy to handle the "normal" cases type safe ways..

I see I can implement this behaviour if I throw out std::vector and do my implementation using direct pointer arithmetic as then I can access that in move construction, but I would love to not give up on vectors...

Just wanted to add this to show what kind of rationale might be behind these kind of questions and I think sometimes it is valid

prenex
  • 24
  • 3