用于MongoDB的CRUD操作认证(CRUD operation authentication for mongodb)

 不在remove_if的情况下，因为语义不同。 std::remove_if实际上并没有从容器中清除任何东西，而list::remove_if却是这样，所以你肯定不希望前者调用后者。 
 
 无论是你还是实现都可以从字面上专门化容器的通用算法，因为算法是采用迭代器的函数模板，而容器本身就是类模板，其迭代器类型取决于模板参数。 所以为了使std::remove_if专门用于list<T>::iterator你需要remove_if的部分特化，并且不存在函数模板的部分特化。 
 
 我不记得是否允许实现为特定的迭代器类型重载算法，但即使不是“官方”算法可以调用可能被重载的函数，也可以使用可能部分专用的类。 不幸的是，如果您编写了自己的容器并且已经发现了一种使标准算法对其效率更高的方法，那么这些技术都不会帮助您。 
 
 例如，假设你有一个带有随机访问迭代器的容器，但是你可以使用一种特别有效的排序技术来处理标准排序：可能是一种桶排序。 然后，你可能会考虑在类中使用一个自由函数template <typename T> void sort(MyContainer<T>::iterator first, MyContainer<T>::iterator last) ，并允许用户调用它using std::sort; sort(it1, it2); using std::sort; sort(it1, it2); 而不是std::sort(it1, it2); 。 问题是，如果他们在泛型代码中这样做，他们冒着别人写一些其他容器类型的函数会有一个名为sort的函数，甚至不会对范围进行排序（英文单词“sort”具有多个含义，之后所有）。 所以基本上你不能以一种能够提高用户定义容器效率的方式对一个迭代器范围进行一般排序。 
 
 当代码中的差异仅取决于迭代器的类别时（例如std::distance对于随机访问迭代器来说是快速的，否则就会变慢），这是通过使用称为“迭代器标签调度”的东西来完成的，这是最常见的在不同容器之间存在明显效率差异的情况下。 
 
 如果存在任何适用于标准容器的剩余情况（折扣结果不同或者效率只需要特定迭代器类别的情况），让我们拥有它们。 

Not in the case of remove_if, since the semantics are different. std::remove_if doesn't actually erase anything from the container, whereas list::remove_if does, so you definitely don't want the former calling the latter.
 
Neither you nor the implementation can literally specialize the generic algorithms for containers because the algorithms are function templates that take iterators, and the containers are themselves class templates, whose iterator type depends on the template parameter. So in order to specialize std::remove_if generically for list<T>::iterator you would need a partial specialization of remove_if, and there ain't no such thing as a partial specialization of a function template.
 
I can't remember whether implementations are allowed to overload algorithms for particular iterator types, but even if not the "official" algorithm can call a function that could be overloaded, or it can use a class that could be partially specialized. Unfortunately none of these techniques help you if you've written your own container, and have spotted a way to make a standard algorithm especially efficient for it.
 
Suppose for example you have a container with a random-access iterator, but where you have an especially efficient sort technique that works with the standard ordering: a bucket sort, perhaps. Then you might think of putting a free function template <typename T> void sort(MyContainer<T>::iterator first, MyContainer<T>::iterator last) in the same namespace as the class, and allow people to call it with using std::sort; sort(it1, it2); instead std::sort(it1, it2);. The problem is that if they do that in generic code, they risk that someone else writing some other container type will have a function named sort that doesn't even sort the range (the English word "sort" has more than one meaning, after all). So basically you cannot generically sort an iterator range in a way that picks up on efficiencies for user-defined containers.
 
When the difference in the code depends only on the category of the iterator (for example std::distance which is fast for random access iterators and slow otherwise), this is done using something called "iterator tag dispatch", and that's the most common case where there's a clear efficiency difference between different containers.
 
If there are any remaining cases that apply to standard containers (discounting ones where the result is different or where the efficiency only requires a particular iterator category), let's have them.