C++ jak twierdzić, że wszystko std :: shared_ptr w wektorze odnosimy się do czegoś

Question

Kiedy mam funkcję odbiera (Smart) wskaźnik, który ma odnosić się coś, zawsze zaczynają się następująco:

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

Teraz szukam podobnego warunku asertywnego dla wektora (lub innego pojemnika) wskaźników (inteligentnych). Najlepsze co mogę wymyślić to:

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; })); 
    // ... 
} 

Zastanawiam się, czy można to poprawić. Czy można uniknąć lambda? (Próbowałem użyć metody get() shared_ptr, ale odliczanie szablonów nie powiedzie się). Czy istnieje inny sposób potwierdzenia całego kontenera?

Answer 1

jeszcze jeden wariant, aby to zrobić:

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

Answer 2

Można użyć zaimplementować własną orzecznik użytkowy:

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{}); 
    // ... 
} 

---

i/lub własne „zakres twierdzenie”:

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; }); 
    // ... 
} 

Answer 3

Innym nieco pokrętnym sposobem wyrażania go ze standardową funkcjonalnością tylko:

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

Od C++ 14 roku, można użyć rodzajowego specjalizację std::logical_not:

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