c++ how to assert that all std::shared_ptr in a vector are referring to something

Question

When I have a function receiving a (smart) pointer that is supposed to refer something, I always start as follows:

class Foo;
void doSomething(const std::shared_ptr<Foo>& pFoo)
{
    assert(pFoo);
    // ...
}

Now I am looking for a similar assert condition for a vector (or other container) of (smart) pointers. The best I could come up with is:

void doSomething(const std::vector<std::shared_ptr<Foo> >& pFoos)
{
    assert(std::all_of(pFoos.begin(), pFoos.end(), [](const std::shared_ptr<Foo>& pFoo) { return pFoo; }));
    // ...
}

I wonder whether this could be improved.. can the lambda be avoided? (I tried to use the get() method of shared_ptr but template deduction fails then) Or is there another way to assert for a whole container?

Is there any reason why you wouldn't change your function's syntax to receive a `Foo&` instead? After all, that _guarantees_ there is an object and no assert is required. Similarly with the vector, which could contain `std::reference_wrapper`. — paddy, Dec 08 '16 at 10:55
@PiotrSkotnicki That visits all the elements, whereas we can break out when the first one that doesn't satisfy a condition is found. — juanchopanza, Dec 08 '16 at 11:19
@juanchopanza The program terminates due to assertion failure, if there is an element that does not satisfy conditions, and visits all elements in every other case. Is there really a need to make that one final check to run faster? — VLL, Dec 08 '16 at 11:56

Sandro · Accepted Answer · 2019-01-24T11:26:13.503

11

one more way to do it:

assert(std::find(pFoos.begin(), pFoos.end(), nullptr) == pFoos.end());

edited Jan 24 '19 at 11:26

answered Dec 08 '16 at 11:49

Sandro

2,707
2
20
30

Quentin · Answer 2 · 2016-12-08T12:20:58.650

9

Another slightly convoluted way to express it with standard functionality only:

assert(std::none_of(pFoos.begin(), pFoos.end(), std::logical_not<std::shared_ptr<Foo>>{}));

From C++14 onwards, you can use the generic specialization of std::logical_not:

assert(std::none_of(pFoos.begin(), pFoos.end(), std::logical_not<>{}));

edited Dec 08 '16 at 12:20

answered Dec 08 '16 at 11:12

Quentin

62,093
7
131
191

this solution works only for c++14 and it does not work for c++11 – Sandro Dec 08 '16 at 12:18

score 1 · Answer 3 · answered Dec 08 '16 at 10:57

You could use implement your own utility predicate:

struct is_nullptr
{
    template <typename T>
    bool operator()(T&& x) const noexcept { return x == nullptr; }
};

void doSomething(const std::vector<std::shared_ptr<Foo> >& pFoos)
{
    assert(!std::any_of(pFoos.begin(), pFoos.end(), is_nullptr{});
    // ...
}

And/or your own "range assertion":

template <typename TContainer, typename TPredicate>
void range_assert(TContainer&& container, TPredicate&& p)
{
    for(auto&& x : container)
    {
        assert(p(x));
    }
}

void doSomething(const std::vector<std::shared_ptr<Foo> >& pFoos)
{
    range_assert(pFoos, [](const std::shared_ptr<Foo>& x) { return x; });
    // ...
}

c++ how to assert that all std::shared_ptr in a vector are referring to something

3 Answers3

Linked