Containers vs Smart pointers in C++

Question

How can I decide when choosing between std::containers (std::vector or std::array) and smart pointers pointing to arrays

I know containers are objects for memory managment. They are exception safe and there will not be any memory leak and they also provide veriuty of functions for memory managment(push.back etc) and smart pointers are pointer that also do not leak memory because they delete themsefs when they are not needed anymore(like unique_ptr when geting out of scope). Propably in containers there is an overhead every time they are created.

My question is how can i decide which method to use and why.

std::vector <unsigned char>myArray(3 * outputImageHight * outputImageWidth);

std::unique_ptr<unsigned char[]>myArray(new unsigned char[3 * outputImageHight * outputImageWidth]);

Always default to a container, in 99.99% of all cases it will be correct. — Some programmer dude, Feb 15 '19 at 11:23
Except if you measure a drop in performance because you have something that would not be there in the raw `unique_ptr`. That would be the 0.01%. — Matthieu Brucher, Feb 15 '19 at 11:25
@MatthieuBrucher And that performance-drop is a measured top-three bottleneck of the program. — Some programmer dude, Feb 15 '19 at 11:29
So smart pointers for arrays exists only for 0.01% of the cases — Aris, Feb 15 '19 at 11:30
Just small note, use `make_unique` instead of `new`+ctor. [reasons](https://stackoverflow.com/questions/37514509/advantages-of-using-stdmake-unique-over-new-operator) — Quimby, Feb 15 '19 at 11:40
Next time you ask a question, please don't post pictures of code instead of code as text. — Jabberwocky, Feb 15 '19 at 12:39
i post picture because i was not able to post the code correctly. The post got eddited from some other user. — Aris, Feb 15 '19 at 12:46

Karl Nicoll · Accepted Answer · 2019-02-15T11:52:22.103

I would use the vector. Your pointer version offers basically no improvements over the vector, and you lose a lot of useful functionality. You're most likely going to need to measure the size and iterate your array at some point, with a vector you get this for free, whereas you'd need to implement it yourself for your pointer version; at which point you may as well have just used the vector to begin with.

There may be a performance cost instantiating the vector, but I doubt that it would be a bottleneck for most applications. If you're creating so many vectors that instantiating them is costing you time, you can probably be smarter about managing them (pooling your memory, custom vector allocators, etc). If in doubt, measure.

One example where you might need to use the unique_ptr<> version might be if you're working with a library written in C where you lose ownership of the array. For example:

std::unique_ptr<unsigned char[]>myArray(
    new unsigned char[3 * outputImageHight * outputImageWidth]);

my_c_lib_data_t cLibData;
int result = my_c_lib_set_image(cLibData, myArray);

if (MYLIB_SUCCESS == result)
    // mylib successfully took ownership of the char array, so release the pointer.
    myArray.release();

If you have the choice though, prefer to use C++ style containers where you can.

Actually i do need to iterate at the array and i actually do need to measure the size and actually implement it myself. And i also thought about this but my question is that if there is never a reason to use smart pointers for arrays why they even add them? — Aris, Feb 15 '19 at 11:43
@Aris - Good question! I added an extra paragraph to my answer that covers an example where the `unique_ptr` version might be useful. — Karl Nicoll, Feb 15 '19 at 11:52

peterchen · Answer 2 · 2019-02-15T13:23:42.277

4

std::vector, primarily because it better represents the "sequence of items in contiguous memory", it is the default representation for that, and enables a wide range of common operations.

vector has move semantics, so the benefit of std::unique_ptr is limited.

~~If you are lucky, your STL implementation `provides small vector optimization, skipping the memory allocation for small sizes.~~
^{-- edit: I wasn't aware SBO is apparently prohibited by the standard - sorry for getting your hopes up, thanks @KarlNicholl}

If pointer semantics are required, a unique_ptr<vector<T>> or shared_ptr<vector<T>> is a valid choice with little overhead.

boost did introduce shared_array etc., that represent your second option better, but I haven't seen them get much traction.

edited Feb 15 '19 at 13:23

answered Feb 15 '19 at 11:43

peterchen

40,917
20
104
186

2

Is small vector optimization supported in `std::vector` nowadays? Last I knew it was not permitted because `swap()` would potentially invalidate iterators with an SBO vector implementation, which is not allowed (see here https://stackoverflow.com/a/8191356/52724). That said, [`boost::container::small_vector`](https://www.boost.org/doc/libs/1_69_0/doc/html/boost/container/small_vector.html) exists and is useful for small-buffer optimization. – Karl Nicoll Feb 15 '19 at 12:00

score 0 · Answer 3 · answered Feb 15 '19 at 11:34

0

Always use STL containers except in situation where you have good reason to use pointers. Reasons are reliability and readability, IMO.

answered Feb 15 '19 at 11:34

risbo

188
7

Containers vs Smart pointers in C++

3 Answers3