Using STL containers with a class containing its own key - c++

Question

I have an object, which can be identified by its name, and I want to place it in one of the STL containers.
class MyClass {
public:
//getters and setters, other functions
private:
std::string name;
//other member variables
};
So at first I thought that the usage of map-like structures is irrelevant in my case, because in those structures the identifier (the key) is separated from the class itself. Using a map I must return the name variable and copy it "outside" the class (waste of memory and illogical, breaking OOP rules).
My next shot was the usage of set-like structures. In this case I only have the key field, where I load my whole object. Using this method I must overload my <, > and == operators in order to use an object as key. I can even make a functor for hashing if I use unordered_set, it works just fine. The problem here is that I cannot use the container functions as I would with a map. This is valid mapInstance.find("example"), and this is not setInstance.find("example"). I must create an object with the member variable name set to "example" and pass it to the find() function. The problem with this solution is that the other member variables in my class are duplicated and not used. I even tried overloading the <, > and == operators for std::string and MyClass classes, which works fine if I use them like this stringInstance < MyClassInstance, but the container functions are unusable (I even tried to overload the functor to work with a string with no success).
Can you suggest me a simple way (or a way), how to solve this problem with std::set or std::map(maybe others)?
In std::map the key cannot be a reference (as I know), and I don't know how to resolve it with std::set.
Note: The problem with storing a pointer in a map's key field is that if we change our mind and use unordered_map instead of map, the hash will be calculated based on the pointer, not based on the string (the hash function can be overridden, but it seems very complicated for a simple task).
Thanks for your help!

Answer 1

You should ask yourself what your requirements for your container are.
Things to consider are:
How many objects will usually be in the container
What are the memory constraints
How often will objects be searched for and which complexity is acceptable?
A std::map has some requirements which might conflict with your class. E.g. the key is not allowed to be changed once an element is added to the map. However, your class might change the name at every time. From this consideration it should become clear that a std::map cannot work with a reference to a string as the key.
In the simplest case, you might consider using a std::list and std::find_if with a predicate to check for a special name. This would have O(n) complexity.

Answer 2

Sometimes you have to build upon what's given to get the desired results. I'd suggest that what you're looking for is a specialized adapter for your use case.
Here's a very basic implementation that you can build upon. In many cases, the cache locality you get from using std::vector will give better performance than using a standard container that provides a similar feature set.
Given a simple type and some helper operators:
struct Obj
{
int key;
std::string name;
};
bool operator<(const Obj& lhs, const Obj& rhs)
{
return lhs.key < rhs.key;
}
bool operator==(const Obj& lhs, int rhs)
{
return lhs.key == rhs;
}
bool operator<(const Obj& lhs, int rhs)
{
return lhs.key < rhs;
}
We can devise a simple flat_map class that provides the basic complexity guarantees of a map, but will meet your requirement of finding objects by key without constructing a value type (like you need to with a set). Insertion gives more complexity, but lookups are of similar complexity. If lookups occur much more frequently then insertions (which is the case most of the time) this can work well.
class flat_map
{
public:
using container_type = std::vector<Obj>;
// insert object into the set
// complexity varies based on length of container
void insert(Obj&& obj)
{
container_.emplace_back(std::move(obj));
std::sort(container_.begin(), container_.end());
}
// find with O(log N) complexity
container_type::iterator find(int key)
{
auto it = std::lower_bound(container_.begin(), container_.end(), key);
if(it != container_.end() && *it == key)
return it;
return container_.end();
}
private:
container_type container_;
};
Example usage:
int main()
{
flat_map obj;
obj.insert({1, "one"});
obj.insert({2, "two"});
obj.insert({3, "three"});
auto it = obj.find(2);
std::cout << it->key << ' ' << it->name << '\n';
}
You can extend the flat_map adapter in any way you see fit. Adding the required overloads to meet your requirements, templatizing the parameters (allocator, comparisons, storage types, etc.).