C++Talk.NET

Guest

Hi everyone,

I've been trying to find elegant ways to use local classes as functors
and pass them to the STL algorithms. Here is my first solution. I would
appreciate any critique or thoughts on weaknesses on my approach:

------------------------------------------------
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

template<class T>
class Functor {
public:
virtual bool operator()(T t1, T t2){return true;};
};

int main() {
vector<int> iv;
iv.push_back(1); iv.push_back(2); iv.push_back(3); iv.push_back(4);

struct Local_functor : public Functor<int> {
bool operator()(int i1, int i2) {return i1 > i2;}
} f;

sort(iv.begin(), iv.end(), dynamic_cast<Functor<int> &>(f));
copy(iv.begin(), iv.end(), ostream_iterator<int>(cout, "\n"));

return 0;
}
------------------------------------------------

/Ali

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Maxim Yegorushkin · Guest

ali_tof...@hotmail.com wrote:

Pete Becker · Guest

ali_tofigh (AT) hotmail (DOT) com wrote:

Franz · Guest

ALiX · Guest

Michael Tiomkin · Guest

ali_tofigh (AT) hotmail (DOT) com wrote:

Carl Barron · Guest

In article <1139501386.428996.301460 (AT) o13g2000cwo (DOT) googlegroups.com>,
Maxim Yegorushkin <maxim.yegorushkin (AT) gmail (DOT) com> wrote:

Carl Barron · Guest

In article <1139522355.433610.12060 (AT) f14g2000cwb (DOT) googlegroups.com>,
Michael Tiomkin <tmk (AT) netvision (DOT) net.il> wrote:

Maxim Yegorushkin · Guest

Carl Barron wrote:

[]

Maxim Yegorushkin · Guest

ALiX wrote:

ALiX · Guest

The code below is _not_ elegant. This is just to understand how things
work technically. Would you say that the code below would work
according to the standard?

Thanks for all the input!
/ALiX

------------------------------------------------------------
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

template<class T>
class Functor {
public:
Functor &func;
Functor(Functor &f) : func(f) {}
virtual bool operator()(T t1, T t2) {func(t1, t2);}
};

int main() {
vector<int> iv;
iv.push_back(1); iv.push_back(2); iv.push_back(3); iv.push_back(4);

struct Local_functor : public Functor<int> {
Local_functor() : Functor<int>(*this) {}
bool operator()(int i1, int i2) {return i1 > i2;}
} f;
Functor<int> g(f);

sort(iv.begin(), iv.end(), g);
copy(iv.begin(), iv.end(), ostream_iterator<int>(cout, "\n"));

return 0;
}
------------------------------------------------------------

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Ed · Guest

Hi ALIX, interesting bit of code. The thing I noticed is that the
Functor copy constructor is initialising the Func reference with the
argument instead of the arguments func reference. i.e.

Functor(Functor &f) : func(f.func ) {}

It seems that without doing this you will end up with all these
temporaries forming a chain which call each other all the way back to
the original one on the stack. Interesting but definatly bad.

Instead of having the g temporary why not pass the reference?

sort(iv.begin(), iv.end(), f.func);

Generally though it seems a lot simpler than the earlier version, I
dont know how boost::Ref works but I guess the application operator is
still virtual which means vptrs flying everywhere.

Maybe there is a way to remove the virtual(ness) of the operator() by
passing a member function pointer for the base class to call in its
operator() on the func reference which at that point could be cast to
the desired deriving type?

I would like to know why we cant just define functions within functions
and why dont the standerd algorithms have policies for functor copying
behaiviour?

ALiX wrote:

ALiX · Guest

Ed wrote: