Using std::vector::push_back with std::mem_fun and std::bind1st
I'm trying to use std::vector with std::mem_fun and std::binder1st, but it doesnt seem to be feasible, can this be done?
I've tried to exemplify with the code below.
#include <vector>
#include <functional>
#include <iostream>
using namespace std;
struct A {
int _Foo;
virtual int AFoo() { return _Foo; };
};
struct B: public A {
int BFoo(int bar) { return _Foo+bar ; };
};
struct C: public A {
int CFoo() { return --_Foo; };
};
class MyContainer
{
static const int MyArraySize = 100;
A* MyArray[MyArraySize];
public:
MyContainer() {
int half = MyArraySize / 2;
for( int i=0; i< half; ++i )
MyArray[i] = new B;
for( int i=half; i < MyArraySize; ++i )
MyArray[i] = new C;
}
template<class T, class Fn1>
int Execute( Fn1 func )
{
int count = 0;
for( int i=0; i< MyArraySize; ++i ){
T* t = dynamic_cast<T*>(MyArray[i]);
if( t )
{
func(t);
++count;
}
}
return count;
}
template<class T, class Res, class Arg>
int Execute( mem_fun1_t<Res, T, Arg> func, Arg argument )
{
return Execute<T>( binder2nd< mem_fun1_t<Res,T,Arg> >( func, argument ) );
}
template<class T>
vector<T*> GetItems() // <-- This is the problem function
{
vector<T*> ret;
Execute<T>( bind1st( mem_fun(&vector<T*>::push_back), ret ) );
return ret;
}
};
int main( int argc, char* argv[] )
{
MyContainer cont;
cont.Execute<B>( mem_fun(&B::BFoo), 10 );
cont.Execute<C>( mem_fun(&C::CFoo) );
vector<B*> v = cont.GetItems<A>(); // <-- the problem function is called here.
cout << "v.size = " << v.size() << endl;
}
My goal is to have a container class to which I can tell it to execute a function receiving the selected items ('A' objects or 'A' derivate objects) as parameters. But I didn't manage to use std::vector::push_pack with it.
2 ответа
Проблема в том, что binder1st определяет operator () как:
operator() (const typename Operation::second_argument_type& x) const
, а mem_fun1_t определяет operator () как:
S operator() (T* p, A x) const
Проблема в том, что push_back определяется как:
void vector<T>::push_back(const T &x)
В итоге мы получаем следующее:
void mem_fun1_t::operator()(vector<T *> *p, const T *&x)
И:
void binder1st::operator()(const T *&&x)
Другими словами, ссылка на ссылку на указатель. Ссылка на ссылку не существует в C ++. Единственный достойный способ исправить это - вместо этого использовать boost :: bind:
vector<T*> ret;
Execute<T>( boost::bind( mem_fun(&vector<T*>::push_back), &ret, _1) );
return ret;
Также обратите внимание, что у вас была ошибка, и вам нужно передать bind & ret вместо просто ret (поскольку mem_fun ожидает указатель, mem_fun_ref будет работать тем не мение).
Самый простой способ вызвать функции-члены для всего набора элементов в контейнере - использовать for_each:
using namespace std;
using namespace std::tr1;
vector<T> cont;
// ...
for_each( cont.begin(), cont.end(),
bind( &T::foo, 42 ) );
// assume void T::foo(int); exists
Если у вас нет tr1, вы можете использовать:
for_each( cont.begin(), cont.end(),
bind2nd( mem_fun( &s::foo ), 42 ) // first parameter is the object itself
);
Однако я не уверен, чего вы пытаетесь достичь. У вас есть и полиморфизм во время компиляции (ака шаблоны), и полиморфизм во время выполнения (ака виртуальные функции-члены). Такая конструкция кажется слишком сложной. На самом деле достаточно следующего определения:
int Execute()
{
int count = 0;
for( int i=0; i< MyArraySize; ++i ){
MyArray[ i ]->Foo(); // assume virtual int A::Foo(); exists
++count;
}
return count;
}
Однако, как вы, возможно, узнали, виртуальные члены должны иметь ту же сигнатуру, чтобы быть переопределенными в подклассах (иначе вы перегружаете функцию).
Обратите внимание, что пример GetItems не вызывает функцию-член содержащихся объектов, он вызывает член, а именно push_back на объекте-контейнере vector.
Если все, что вы хотите сделать, это скопировать указатели из массива vanilla в vector, вы можете использовать специализированный ctor vector, который принимает два итератора:
template<class T>
vector<T*> GetItems() // <-- This is the problem function
{
return vector<T*>( &MyArray[ 0 ], &MyArray[ 0 ] + MyArraySize );
}