Предикаты в STL

bool isOdd(int i) {
return i&1;
}
 
std::list<int> l;
l.remove_if(isOdd);

template <typename T>
struct is_power_of_two : public std::unary_function <T, bool> {
   bool operator()(const T & value) const {
      return !(value & (value - 1));
   }
};
 
.......
 
list.remove_if(is_power_of_two <int>());

#include <vector>
#include <algorithm>
using namespace std;
 
bool p1(int a)
{
    return true;
}
 
struct p2
{
    bool operator()(int a)
    {
        return true;
    }
};
 
int main()
{
    vector<int> v;
    remove_if(v.begin(),v.end(),p1);
    p2 obj;
    remove_if(v.begin(),v.end(),obj);
    return 0;
}

#include <iostream>
#include <functional>
#include <iterator>
#include <string>
#include <list>
 
// функтор проверяющий наличие подстроки в строке
class contains : public std::unary_function<std::string, bool>
{
    private:
        std::string substr_;
    
    public:
        contains(const std::string& substr)
            : substr_(substr)
        {
            
        }
 
        // благодоря перегрузке этого оператора объект класса может "прикидываться" функцией
        bool operator () (const std::string& s) const
        {
            return s.find(substr_) != std::string::npos;
        }
};
 
int main()
{
    typedef std::ostream_iterator<std::string> string_ostream_iter_t;
    typedef std::list<std::string> string_list_t;
    //-----------------------
 
    string_list_t lst;
 
    // заполняем список
    lst.push_back("one");
    lst.push_back("two");
    lst.push_back("three");
    lst.push_back("four");
    lst.push_back("five");
 
    // удаляем строки содержащие букву "о"  
    lst.remove_if(contains("o"));
    
    // а так можно удалить строки НЕ содержащие букву "o"
    // в частности для того чтобы это работало contains и был унаследован от std::unary_function
    // lst.remove_if(std::not1(contains("o")));
    
    // выводим оставшиеся элементы списка на экран
    std::copy(lst.begin(), lst.end(), 
              string_ostream_iter_t(std::cout, "\n"));
}

#include <iostream>
#include <list>
#include <algorithm>
#include <iterator>
 
int main()
{
   std::list<int> lst = {1,2,3,4,5};
   lst.erase(std::remove_if(lst.begin(), lst.end(), [](const int c) { return c % 2 == 0; }), lst.end());
   std::copy(lst.begin(), lst.end(), std::ostream_iterator<int>(std::cout, " "));
}

#include <iostream>
#include <algorithm>
#include <list>
#include <functional>
using namespace std;
 
void main(){
    list<int> l1, l2(3,1);
    short i;
    list<int>::iterator start=l1.begin();
    for(i=0; i<10; i++, start++){
        l1.push_back(rand()%100);
        cout << *start << "  ";
    }//for
    cout<<endl;
 
    start=l1.begin();
    advance(start,3);
    cout << "start=" << *start <<endl;
 
    l2.remove_if(equal_to(4));  //error
 
}//main

l2.remove_if(equal_to<int>(4));

std::bind2nd(std::equal_to<int>(), 4);

template<typename A0, typename A1 >
struct is_bool{
    bool operator()(const A0 & val0, const A1 & val1 ) const {
        return (val0 & val1);
    }
};

class compare_class {
    public:
    bool operator()(int A, int B) {
        return (A < B);
    }
};
 
int main(void){
    
lcd.begin(20, 4);
lcd.setCursor(0, 0);
 
compare_class cc;
 
bool b = cc(15,9);
 
(void)(b);
 
lcd.print(b);
 
    while (1) {  }
}

lcd.print(сс(15,9));
// или
lcd.print(compare_class()(15,9));

enum com{ com0, com1, com2, com3, com4 };
 
template <com c, int n>
class compare_class {
    public:
    bool operator()() { return (c < n); }
};
 
int main(void){
    
lcd.begin(20, 4);
lcd.setCursor(0, 0);
 
compare_class<com0,5> cc;
 
bool b = cc();
 
lcd.print(b);
 
    while (1) {  }
}