Yes this seems like a good option to me!

Thanks for the nice comment!
For the map on shared_ptr, how about using the erase_if function in the article, with a predicate checking if the value.use_count() == 1?

You’re right. I try to reference posts in the Posts page, but they are references by category, in chronological order inside of the categories, but there is no global chronological order. I’m trying to think about a way to better organize the contents of the website. I’m open to any suggestion!

Fixed, thanks!

+1

Please add links to the previous (and future) articles in the series. It would be great if you could also add an arvhive of posts in chronological order – I find it incredibly difficult to locate old posts on this blog. Thanks!

Now, it’s time for an extra question :

I have a map (a kind of factory of object/ cache ), where the value is share_ptr and i like to sometimes “purge” my factory, ie i’d like to erase_if the map-value is the last owner of the shared pointer…How can i do this in a clean way ?

This could be coded fluently as a 1 liner

for (auto it = begin(container); it != end(container); it = shouldRemove(*it) ? container.erase(it) : next(it));

If a lot of erase-by-values are required for an associate container, then one way is to also have an inverse container. ie a multi-container that has a key of the value stored in the primary container and a value as an iterator to the entry in the primary container. This, obviously, uses a lot more memory and you have to be careful with operations on the primary container that may invalidate iterators (as the iterator value stored in the inverse container would then be invalid). .equal_range() can be used to obtain the range of iterators of the associate container corresponding to a specific key (ie value in the primary container) – and the values for these used to directly erase the elements in the primary – and then erased from the associate conatiner.

This way can add some code complexity, but where many erase-by-values are performed on large associate containers, it has definite performance advantages and should be considered.

 
template <class AssociativeContainer, class Predicate>
static void remove_if(AssociativeContainer& c, Predicate pred) {
	using Iterator = typename AssociativeContainer::iterator;
	Iterator cur = std::begin(c);
	const Iterator last = std::end(c);
	while ((cur = std::find_if(cur, last, pred)) != last) {
		Iterator tmp = cur++;
		c.erase(tmp);
	}
}