从指针有条件地初始化 std::vector

Question

I am interfacing with some C++ code that has a method providing a pointer and object size (some proprietary library that I can't change). The interface looks something like this:

float *arrayPtr();
int arraySize();

I have a class that needs to copy this to a vector (in order to extend its lifetime). In the scenario where this pointer is not a nullptr, the constructor is fairly simple (I need to copy the data to extend its lifetime):

struct A {
    std::vector<float> vec;
    A(float *ptr, int size) : vec( ptr, std::next(ptr, size) ) {}
}

I am, however, a little unsure of how best to handle the initialization when ptr is a nullptr . I could default initialize, and then move everything to the constructor body, but that feels quite inefficient:

A(float *ptr, int size) {
    if (ptr) {
        vec = std::vector<float>( ptr, std::next(ptr, size));
    }
}

Are there any other alternatives?

When ptr is a nullptr , I would like the vector to just be default initialized to an empty vector.

EDIT:

It just occurred to me that I should probably be doing this:

A(float *ptr, int size) : vec( ptr ? std::vector<float>(ptr, std::next(ptr, size)) : std::vector<float>() ) {}

But perhaps there is a better form??

Answer 1

This is not necessarily "better" (actually I think your original code is fine, since there is not really any cost to default initialization of a vector), but when you need to perform some logic for an initializer you can use a helper function:

struct A {
    std::vector<float> vec;
    A(float *ptr, int size) : vec( make_A_vector(ptr, size) ) {}

private:  
    static std::vector<float> make_A_vector(float const *begin, int size)
    {
        if ( size < 0 || (size > 0 && !begin) )
             throw std::runtime_error("invalid array length for A");

        if ( size == 0 )
             return {};

        return std::vector<float>(begin, begin + size);
   }
};

---

Another common design is to keep your class simple and have construction logic entirely in a free function:

struct A
{
    std::vector<float> vec;
};

inline A make_A(float const *ptr, int size)
{
     // sanity check omitted for brevity
     if ( size == 0 )
         return A{};

     return A{ std::vector<float>(ptr, ptr + size) };
}

It's an experience-based judgement call as to what would be overkill and what would be aesthetic:)

Answer 2

Researching what std::next and the ctor of std::vector is doing. your first try works just fine. ONLY and ONLY if your size is reliably 0 , when your pointer is a nullptr .

std::next(it, n)

it - Iterator to base position. ForwardIterator shall be at least a forward iterator.

n - Number of element positions offset (1 by default). This shall only be negative for random-access and bidirectional iterators. difference_type is the numerical type that represents distances between iterators of the ForwardIterator type.

If you are assured, your given size is 0 , when you get a nullptr , std::next returns the same position as your pointer points to.

std::vector

You use this ctor:

Constructs the container with the contents of the range [first, last).

If your first and last are the same, you get an empty std::vector . So the nullptr is never a problem.

---

Regardless this findings. you should ALWAYS check for nullptr 's. For the sake of defensive programming - ALL INPUT IS EVIL!

---

You mentioned, the library you get is known for being error prone. Please save yourself much troubles and check every parameter you get out of it of integrity.

---

One comment on your worries that your implementation would perform any worse then an other. Check those implementations in an loop with thousands or millions of iterations. Then you can make an prediction if it effects you.