Set of shared_ptr and set function count - c++

Question

I have a set of shared pointers.
I want to make a function that checks if a shared pointer exists in it.
I assumed I need to use set.count to get it.
But I get 0 all the time... even though the shared pointer exists in there.
So my question is: how does count compare shared pointers?
Please bare in mind I am new to C++, I can provide with code, but there's a lot of it.
EDIT 2:
The function that checks the building and adds a car.
void Garage::addCar(Car& n, Building& m){
shared_ptr<Building> mm(new Building(m));
if (this->Buildings.count(mm) == 0){
cout << m.name << " doesn't exist in " << this->name << "." << endl;
return;
}
shared_ptr<Car> s(new Car(n));
m.addCar(s);
Cars.insert(s);
}
Function that creates Buildings
Building Garage::create Building(string name){
shared_ptr< Building> f_ptr(new Building(name));
Buildings.insert(f_ptr);
return (*f_ptr);
}
Class garage
class Garage {
public:
Garage(string name);
~Garage();
void admitCar(Car& n, Building& m);
void dismissCar(Car& n, Building& m);
void employEmployee(Employee& n, Building& m);
void dismissEmployee(Employee& n, Building& m);
Building createBuilding(string name);
void deleteBuilding(Building&);
private:
int nextIndex;
string name;
set<shared_ptr<Building> > Buildings;
set<shared_ptr<Employee> > Employees;
set<shared_ptr<Car> > Car;
}
Whenever I want to add a car to a building, it says that that building doesnt exist in that garage...
SOLUTION(my own):
bool Garage::hasBuilding(shared_ptr<Building> f){
return (this->Buildings.count(f) != 0);
}
This is the function I created. It works.
I tried Jonathan Wakely and LiKao ways but they were a bit too complicated for me and I had problems which again I couldn't myself solve.
Thank You for the help :)

Answer 1

The pointers you are comparing are different, because they are pointing to different objects. Whenever you say new Building a new building will be created, although it my have the same name as an older building. Hence any pointer to that new Building will be different to any pointer to the old Building from which the new one was created. Hence the comparison is correct, the new Building is not present in the set (you just created it by copying so it cannot be present).
You want a set, which can be compared based on a property of the object the pointer points to. For this you need to add a different comparison function which looks into the pointer to the object. Something like this should work:
struct less_building : std::binary_function<std::shared_ptr<Building>,std::shared_ptr<Building>,bool> {
bool operator()( const std::shared_ptr<Building> & b1, const std::shared_ptr<Building> & b2 ) {
return std::less( b1->name, b2->name );
}
};
This may need some friends declaration depending on your definition of Building, but in general something like this will do the trick.
NOTE1:
Be sure to understand the implications of this, before you use this trick. Using this comparator will mean, that no two Buildings in your set can have the same name, irregardless of any other attribute they may have. Each pair of Buildings which have the same name will afterwards be considered the same Building. Depending on your modelling domain, this may or may not be what you want.
In case you want to also compare other attributes in case the names are the same, then you have to add this to your comparison functor. However then that means that there can be no two Buildings which have the same set of attributes. Again, this may or may not be what you want, depending on the problem.
NOTE2:
Usually it is very inconvenient, to mix std::shared_ptr and references to the same types of objects, which also leads to the problem you are experiences. If you are using std::shared_ptr for a type at any place, you should try to be consistent and only pass these std::shared_ptr around. The reason is, that converting from a std::shared_ptr to a reference (for example using operator*()) is much like a one-way function. I.e. you can get the reference from a std::shared_ptr but it is very hard to get back the std::shared_ptr from the reference. I can think of two ways to get back the std::shared_ptr once you decayed it to a reference, but one requires you to change the object (deriving from std::enable_shared_from_this<Building>) and the other just smells very badly of unclean code (creating a new std::shared_ptr with a no-op deleter to the address of the reference). So I would not recommend either ways.
Instead either choose a design which fits your problem domain, as shown above. Or keep the std::shared_ptr from decaying. If you pass them around as (const)-references to the std::shared_ptr this will not actually cost much more than just passing around the pointer itself.

Answer 2

Based on your "edit 2", I think I see your misunderstanding. These are two completely unrelated shared pointers:
Building m;
shared_ptr<Building> a(new Building(m));
shared_ptr<Building> b(new Building(m));
They will not match inside a std::set.
However, these are related pointers:
Building m;
shared_ptr<Building> a(new Building(m));
shared_ptr<Building> b = a;
So they will match inside a std::set.
Essentially, the comparisons are performed on the pointers, not on the underlying objects.

Answer 3

To answer your question
how does count compare shared pointers?
The comparison is done using the std::shared_ptr's get() method, meaning the managed pointers are compared. Conserning std::set<std::shared_ptr<T>>, the relevant comparison is bool operator<.
See here for more information.

Answer 4

I want to make a function that checks if a shared pointer exists in it.
I don't think you do.
shared_ptr<Building> mm(new Building(m));
if (this->Buildings.count(mm) == 0){
How can the shared pointer mm exist in the set when you've just created it there, and it points to a brand new object you've just created? How could they have got in the set between you creating them and looking for them in the set?
I think you want to check if a Building exists in it, by comparing the building's values, you don't care if a specific object or a specific shared pointer is in the set.
You could either search the set, comparing m to the building pointed to by every element:
void Garage::addCar(Car& n, Building& m){
bool found = false;
for (auto& shptr : Buildings)
{
if (*sp == m) // dereference shared_ptr to compare the Building
{
found = true;
break;
}
}
or use a custom comparison in the set, as in this answer.