Как написать функтор, принимающий в качестве аргумента пару std::pair и возвращающий результат сравнения на равенство второго элемента этой пары со значением хранимым в функторе? (Это значение должно передаваться конструктору функтора.)

Чтобы можно было использовать так:

map<int, int> m;
// ...
count_if(m.begin(), m.end(), second_is(0));

multimap<string, string> mm;
// ...
count_if(mm.begin(), mm.end(), second_is(string("abcd")));

Или вот полный пример:

#include "second_is.hpp"

#include <algorithm>
#include <iostream>
#include <map>
#include <string>

using namespace std;

int main()
{
    map<int, int> m;
    m[6] = 3;
    m[7] = 3;
    m[9] = 0;

    cout << count_if(m.begin(), m.end(), second_is(0)) << '\n'; // 1
    cout << count_if(m.begin(), m.end(), second_is(3)) << '\n'; // 2
    cout << count_if(m.begin(), m.end(), second_is(9)) << '\n'; // 0

    multimap<string, string> mm;
    mm.insert(make_pair(string("foo"), string("abcd")));
    mm.insert(make_pair(string("bar"), string("efgh")));
    mm.insert(make_pair(string("baz"), string("abcd")));

    cout << count_if(mm.begin(), mm.end(), second_is(string("abcd"))) << '\n'; // 2
    cout << count_if(mm.begin(), mm.end(), second_is(string("efgh"))) << '\n'; // 1
    cout << count_if(mm.begin(), mm.end(), second_is(string("ijkl"))) << '\n'; // 0

    return 0;
}

Здравствуйте, igna, Вы писали:

I>Как написать функтор, принимающий в качестве аргумента пару std::pair и возвращающий результат сравнения на равенство второго элемента этой пары со значением хранимым в функторе? (Это значение должно передаваться конструктору функтора.)

template<typename type>
struct second_is_t
{
  type value;
  second_is_t(type const& value) : value(value) {}
  template<typename first_t>
  bool operator () (std::pair<first_t, type> const& p) const
  {
    return value == p.second;
  }
};

template<typename type>
second_is_t<type> second_is(type const& value)
{
  return second_is_t<type>(value);
}

Здравствуйте, igna, Вы писали:

I>Как написать функтор, принимающий в качестве аргумента пару std::pair и возвращающий результат сравнения на равенство второго элемента этой пары со значением хранимым в функторе? (Это значение должно передаваться конструктору функтора.)

I>Чтобы можно было использовать так:

...

template <class V>
class second_is_impl
{
   V v_;
public:
   second_is_impl(const V& v) : v_(v) {}

   template <class K>
   bool operator() (const pair<K, V>& p) const
   {
      return p.second == v_; 
   }
};

template<class V>
inline second_is_impl<V> second_is(const V& v)
{
   return second_is_impl<V>(v);
}

ЗЫ
Судя по всему, с тобой сыграл злую шутку тот факт, что value_type того же map<int, int> это не pair<int, int>, а pair<const int, int>.

Здравствуйте, Bell, Вы писали:

У тебя v_ в private секции, зато я был первым

Здравствуйте, remark, Вы писали:

R>У тебя v_ в private секции, зато я был первым
Ну, пока писал public: — опоздал

Здравствуйте, Bell, Вы писали:

B>Здравствуйте, remark, Вы писали:

R>>У тебя v_ в private секции, зато я был первым
B>Ну, пока писал public: — опоздал
ага, значит, скорость печати у тебя — примерно 2 символа в секунду

You will always get what you always got
  If you always do  what you always did

Здравствуйте, Bell, Вы писали:

B>

B>template <class V>
B>class second_is_impl
B>{
B>   V v_;
B>public:
B>   second_is_impl(const V& v) : v_(v) {}

B>   template <class K>
B>   bool operator() (const pair<K, V>& p) const
B>   {
B>      return p.second == v_; 
B>   }
B>};

B>template<class V>
B>inline second_is_impl<V> second_is(const V& v)
B>{
B>   return second_is_impl<V>(v);
B>}
B>

О великие гуру, поясните пока менее опытному товарищу, почему для передачи функтора в алгоритм используется функция его создающая?
Почему б не передавать функтор напрямую?

А>О великие гуру, поясните пока менее опытному товарищу, почему для передачи функтора в алгоритм используется функция его создающая?
А>Почему б не передавать функтор напрямую?
Я конечно не гуру, но попробую ответить:
Чтобы не специфицировать его тип явно. Для шаблонной функции тип будет выведен автоматически. А потом оптимизатор лишние вызовы повыбрасывает, зато писанины меньше

Здравствуйте, Аноним, Вы писали:

А>О великие гуру, поясните пока менее опытному товарищу, почему для передачи функтора в алгоритм используется функция его создающая?
А>Почему б не передавать функтор напрямую?

Надо будет явно указывать шаблонный параметр, а так он выводится. Т,е. second_is(1) вместо second_is<int>(1).

Здравствуйте, remark, Вы писали:

R>Надо будет явно указывать шаблонный параметр, а так он выводится. Т,е. second_is(1) вместо second_is<int>(1).

Точно! О выводимости параметра(ов) я чето не подумал

Большое спасибо Вам и товарищу Left2.

Здравствуйте, remark, Вы писали:

Спасибо. А можно так?:

template<typename type>
struct second_is_t
{
  type value;
  second_is_t(type const& value) : value(value) {}
  template<typename pair_t>
  bool operator () (pair_t const& p) const
  {
    return value == p.second;
  }
};

template<typename type>
second_is_t<type> second_is(type const& value)
{
  return second_is_t<type>(value);
}

Тогда value и p.second не обязательно должны иметь один и тот же тип.

Здравствуйте, Bell, Вы писали:

Спасибо, а можно так? (тот же вопрос, что здесь

Автор: igna
Дата: 27.09.07

):

template <class V>
class second_is_impl
{
   V v_;
public:
   second_is_impl(const V& v) : v_(v) {}

   template <class P>
   bool operator() (const P& p) const
   {
      return p.second == v_; 
   }
};

template<class V>
inline second_is_impl<V> second_is(const V& v)
{
   return second_is_impl<V>(v);
}

Тогда value и p.second не обязательно должны иметь один и тот же тип.

Здравствуйте, igna, Вы писали:

I>Тогда value и p.second не обязательно должны иметь один и тот же тип.

Можно. Но тогда и тип аргумента не обязательно будет std::pair<...>.

Здравствуйте, remark, Вы писали:

R>Можно. Но тогда и тип аргумента не обязательно будет std::pair<...>.

Верно. Тогда так:

template<typename type>
struct second_is_t
{
  type value;
  second_is_t(type const& value) : value(value) {}
  template<typename first_t, typename second_t>
  bool operator () (std::pair<first_t, second_t> const& p) const
  {
    return value == p.second;
  }
};

template<typename type>
second_is_t<type> second_is(type const& value)
{
  return second_is_t<type>(value);
}

Здравствуйте, jazzer, Вы писали:

J>Здравствуйте, Bell, Вы писали:

B>>Здравствуйте, remark, Вы писали:

R>>>У тебя v_ в private секции, зато я был первым
B>>Ну, пока писал public: — опоздал
J>ага, значит, скорость печати у тебя — примерно 2 символа в секунду
Нас сосчитали

Здравствуйте, igna, Вы писали:

I>Здравствуйте, Bell, Вы писали:

I>Спасибо, а можно так? (тот же вопрос, что здесь

Автор: igna
Дата: 27.09.07

):

Тот же ответ, что здесь

Автор: igna
Дата: 27.09.07

Здравствуйте, igna, Вы писали:

I>Здравствуйте, remark, Вы писали:

R>>Можно. Но тогда и тип аргумента не обязательно будет std::pair<...>.


I>Верно. Тогда так:

В шаблонах вообще так:

если компилируется — значит можно!

Здравствуйте, remark, Вы писали:

R>В шаблонах вообще так:

если компилируется — значит можно!

Это только если у тебя фул стандард компатибле комилятор
А таких, как известно, в природе не существует. Бывают только в разной степени хорошие приближения

про версии стандарта я вообще молчу

А можно boost::bind использовать...

Здравствуйте, Аноним, Вы писали:

А>А можно boost::bind использовать...

Покажи как, пожалуйста.