Check if container of shared_ptr contains a pointer? - c++

Question

Using Observer pattern. I have a class, called Monitor for example, that is monitoring a collection of objects. The class is an Observer and each object in it's collection is a Subject. Currently the collection is implemented as a std::list of shared_ptr. In the Update method of the Monitor class I want to check if the update is coming from one of the objects in it's collection.
std::list<SomeSharedPointer> items_;
...
void Monitor::Update(Subject *subject)
{
if(subject == something_)
{
DoSomething();
}
else if
??
// if subject is one of the objects in our collection then do something..
}
Subject here is a raw pointer and my collection is a list of shared_ptr. How can I effectively check if the subject coming in is any one of the objects in my collection?
(Note my compiler, msvc, supports lambdas if there is an algorithmic solution requiring one)
UPDATE
I should add that I realize I can use a for loop over the container, but I'm wondering if there's a snazzier way.
UPDATE 2
SomeSharedPointer is a typedef for std::shared_ptr<SomeType> where SomeType derives from abstract class Subject (standard Observer pattern implementation). SomeType will at some point call Notify() which will call the Update() method for each observer.

Answer 1

auto i = std::find_if(items_.begin(), items_.end(),
[=](const SomeSharedPointer& x) { return x.get() == subject; });
if (i != c.end())
{
// Object found, and i is an iterator pointing to it
}
A little helper method can make this more readable:
typedef std::list<SomeSharedPtr> ObserverCollection;
// You can also add a const version if needed
ObserverCollection::iterator find_observer(Subject* s)
{
return std::find_if(items_.begin(), items_.end(),
[=](const SomeSharedPointer& x) { return x.get() == s; });
}
Then, you use it like this if you need the iterator
auto i = find_observer(subject);
if (i != items_.end())
{
// Object found
}
or simply like this if you don't:
if (find_observer(subject) != items_.end())
{
...
}

Answer 2

If you don't have C++11 support for auto, declare the iterator the old fashioned way
for (auto iter = items_.begin(); iter != items_.end(); ++iter)
{
if (subject == iter->get())
{
.. do stuff ..
}
}
Shared pointer has a .get() function that returns the pointer.

Answer 3

Since you said that the observer needs to make a decision based on a state of items it is monitoring, then you should add a method to the base class (Subject in your question) which returns an enum defining the item's state. Then based on the state, add a switch in the update method:
enum State{ STATE_1, STATE_2 };
void Monitor::Update(Subject *subject)
{
switch( subject->getState() )
{
case STATE_1:
// do something 1
break;
case STATE_2:
// do something 2
break;
default:
//error
}
}

Answer 4

If possible, you could consider changing your container to something that gives you better search behavior. For instance, you could use a std::set. It costs more per insertion, but faster per lookup. Or, std::unordered_set. Both insertion and lookup are fast, but iteration is likely slower. To achieve proper comparison, you can create a helper class to enable converting your raw pointer into a shared pointer that has an no-op deleter.
template <typename T>
struct unshared_ptr {
std::shared_ptr<T> p_;
unshared_ptr (T *p) : p_(p, [](...){}) {}
operator const std::shared_ptr<T> & () const { return p_; }
operator T * () const { return p_.get(); }
};
If your container supported the find method, then:
typedef unshared_ptr<SomeType> unshared_some;
if (items_.end() != items_.find(unshared_some(subject))) {
DoSomething();
}
Try it online!
If you are sticking with std::list, you can abuse the remove_if method by passing in a predicate that always returns false, but performs your matching test.
bool matched = false;
auto pred = [subject, &matched](SomeSharedPtr &v) -> bool {
if (!matched && v.get() == subject) {
matched = true;
}
return false;
};
items_.remove_if(pred);
if (matched) {
DoSomething();
} //...