Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   C++ (http://www.velocityreviews.com/forums/f39-c.html)
-   -   external functionality with a functor object? (http://www.velocityreviews.com/forums/t457099-external-functionality-with-a-functor-object.html)

aaragon 09-22-2006 05:54 PM

external functionality with a functor object?
 
Hi everyone,

I'm trying to provide some external functionality to a class through a
functor object defined by the user. The concept is as follows:

template <class Functor>
class ClassA
{
...
double evaluate(){
Functor functor_;
return functor_();
}
...
};

// defined by the uesr
struct Functor
{
double operator() (){
return 2+2;
}
};

int main(int argc, char *argv[])
{
ClassA<Functor> a;
a.evaluate();
}

The problem that I have is that the functor needs to know what the
ClassA is to work. So I thought that maybe using a templatized functor
may work:
template <class T>
struct Functor
{
double operator() (T t_){
return t_.x() + t_.y();
}
};
This was a good idea except for the fact that now I have no idea of how
the user is going to delacre an object of classA =/
Any ideas????


Victor Bazarov 09-22-2006 06:12 PM

Re: external functionality with a functor object?
 
aaragon wrote:
> I'm trying to provide some external functionality to a class through a
> functor object defined by the user. The concept is as follows:
>
> template <class Functor>
> class ClassA
> {
> ...
> double evaluate(){
> Functor functor_;
> return functor_();


Or, in one line instead of two:

return Functor()();

:-)

> }
> ...
> };
>
> // defined by the uesr
> struct Functor
> {
> double operator() (){
> return 2+2;
> }
> };
>
> int main(int argc, char *argv[])
> {
> ClassA<Functor> a;
> a.evaluate();
> }
>
> The problem that I have is that the functor needs to know what the
> ClassA is to work. So I thought that maybe using a templatized
> functor may work:
> template <class T>
> struct Functor
> {
> double operator() (T t_){
> return t_.x() + t_.y();
> }


How about making your 'operator()' a template?

struct Functor
{
template<class T> double operator()(T t_) {
return t_.x() + t_.y();
}
};

> };
> This was a good idea except for the fact that now I have no idea of
> how the user is going to delacre an object of classA =/
> Any ideas????


See above.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask



amparikh@gmail.com 09-22-2006 06:16 PM

Re: external functionality with a functor object?
 

aaragon wrote:
> Hi everyone,
>
> I'm trying to provide some external functionality to a class through a
> functor object defined by the user. The concept is as follows:
>
> template <class Functor>
> class ClassA
> {
> ...
> double evaluate(){
> Functor functor_;
> return functor_();
> }
> ...
> };
>
> // defined by the uesr
> struct Functor
> {
> double operator() (){
> return 2+2;
> }
> };
>
> int main(int argc, char *argv[])
> {
> ClassA<Functor> a;
> a.evaluate();
> }
>
> The problem that I have is that the functor needs to know what the
> ClassA is to work. So I thought that maybe using a templatized functor
> may work:
> template <class T>
> struct Functor
> {
> double operator() (T t_){
> return t_.x() + t_.y();
> }
> };
> This was a good idea except for the fact that now I have no idea of how
> the user is going to delacre an object of classA =/
> Any ideas????


Not sure what you are trying to do by that Template Functor but this
should work.

struct eval
{
int x(){
return 1;
}
int y(){
return 2;
}

};

template <class Functor>
class ClassA
{
public:
eval tmp;
double evaluate(){
Functor functor_;
return functor_(tmp);
}
};


template <class T>
struct Functor
{
double operator() (T t_){
return t_.x() + t_.y();
}

};

int main(int argc, char* argv[])
{

ClassA<Functor<eval> > a;
a.evaluate();
}


aaragon 09-22-2006 08:08 PM

Re: external functionality with a functor object?
 

Victor Bazarov wrote:
> aaragon wrote:
> > I'm trying to provide some external functionality to a class through a
> > functor object defined by the user. The concept is as follows:
> >
> > template <class Functor>
> > class ClassA
> > {
> > ...
> > double evaluate(){
> > Functor functor_;
> > return functor_();

>
> Or, in one line instead of two:
>
> return Functor()();
>
> :-)
>
> > }
> > ...
> > };
> >
> > // defined by the uesr
> > struct Functor
> > {
> > double operator() (){
> > return 2+2;
> > }
> > };
> >
> > int main(int argc, char *argv[])
> > {
> > ClassA<Functor> a;
> > a.evaluate();
> > }
> >
> > The problem that I have is that the functor needs to know what the
> > ClassA is to work. So I thought that maybe using a templatized
> > functor may work:
> > template <class T>
> > struct Functor
> > {
> > double operator() (T t_){
> > return t_.x() + t_.y();
> > }

>
> How about making your 'operator()' a template?
>
> struct Functor
> {
> template<class T> double operator()(T t_) {
> return t_.x() + t_.y();
> }
> };
>


Yes! This works fine! =)

> > };
> > This was a good idea except for the fact that now I have no idea of
> > how the user is going to delacre an object of classA =/
> > Any ideas????

>
> See above.
>
> V
> --
> Please remove capital 'A's when replying by e-mail
> I do not respond to top-posted replies, please don't ask


However, I still have one problem. The user needs to implement the
entire functor and I don't think that is nice. Maybe if I write a
hidden implementation of the functor and the let the user only to
override the function ()(), perhaps???


Victor Bazarov 09-22-2006 09:02 PM

Re: external functionality with a functor object?
 
aaragon wrote:
> [..]
> However, I still have one problem. The user needs to implement the
> entire functor and I don't think that is nice. Maybe if I write a
> hidden implementation of the functor and the let the user only to
> override the function ()(), perhaps???


I don't understand the problem. Can you elaborate?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask



aaragon 09-22-2006 09:22 PM

Re: external functionality with a functor object?
 

Victor Bazarov wrote:
> aaragon wrote:
> > [..]
> > However, I still have one problem. The user needs to implement the
> > entire functor and I don't think that is nice. Maybe if I write a
> > hidden implementation of the functor and the let the user only to
> > override the function ()(), perhaps???

>
> I don't understand the problem. Can you elaborate?
>
> V
> --
> Please remove capital 'A's when replying by e-mail
> I do not respond to top-posted replies, please don't ask


Sure. Well, the way you mentioned works just fine. But the idea is to
hide the implementation details for the user. Let's say, the user has
to write:

struct Functor
{
template<class T>
double operator()(T t_) {
return t_.x() + t_.y();
}
};

int main(int argc, char *argv[])
{
ClassA<Functor> a;
a.evaluate();
....
}

and for someone who does not have idea about C++, the functor struct is
just hard! So, I was thinking that it may be a good idea to do
something easier, like overriding the function because the user does
not have to deal with implementation details. If the user does not put
template<class T> the functor will not work. Any ideas to accomplish
this?


=?ISO-8859-15?Q?Juli=E1n?= Albo 09-22-2006 09:44 PM

Re: external functionality with a functor object?
 
aaragon wrote:

> I'm trying to provide some external functionality to a class through a
> functor object defined by the user. The concept is as follows:
>
> template <class Functor>
> class ClassA
> {
> ...
> double evaluate(){
> Functor functor_;
> return functor_();
> }
> ...
> };
>
> // defined by the uesr
> struct Functor
> {
> double operator() (){
> return 2+2;
> }
> };
>
> int main(int argc, char *argv[])
> {
> ClassA<Functor> a;
> a.evaluate();
> }


Did you need all this templates? A simpler way can be:

class ClassA {
public:
// ...
virtual double operator () ()= 0;
//...
double evaluate ()
{
return operator () ();
}
};


class UserClassA : public ClassA {
double operator () ()
{
return 2 + 2;
}
};

int main ()
{
UserClassA a;
a.evaluate ();
}

--
Salu2

Victor Bazarov 09-23-2006 01:38 AM

Re: external functionality with a functor object?
 
aaragon wrote:
> Victor Bazarov wrote:
>> aaragon wrote:
>>> [..]
>>> However, I still have one problem. The user needs to implement the
>>> entire functor and I don't think that is nice. Maybe if I write a
>>> hidden implementation of the functor and the let the user only to
>>> override the function ()(), perhaps???

>>
>> I don't understand the problem. Can you elaborate?
>>
>> V
>> --
>> Please remove capital 'A's when replying by e-mail
>> I do not respond to top-posted replies, please don't ask

>
> Sure. Well, the way you mentioned works just fine. But the idea is
> to hide the implementation details for the user. Let's say, the user
> has to write:
>
> struct Functor
> {
> template<class T>
> double operator()(T t_) {
> return t_.x() + t_.y();
> }
> };
>
> int main(int argc, char *argv[])
> {
> ClassA<Functor> a;
> a.evaluate();
> ...
> }
>
> and for someone who does not have idea about C++, the functor struct
> is just hard! So, I was thinking that it may be a good idea to do
> something easier, like overriding the function because the user does
> not have to deal with implementation details. If the user does not
> put template<class T> the functor will not work. Any ideas to
> accomplish this?


So, what is the user supposed to write to accomplish what they need?
If the 'Functor' above is hard (and yes, member templates are not the
simplest thing to understand, I give you that), what would be "easy"
for somebody "who does not have idea about C++"? If they don't have
a clue, why would they be writing those functors?

Let's suppose you want to make their life easier. You write some kind
of base class

class BaseFunctor { /* not sure what goes here yet */ };

, right? OK, how the user will make use of it? They would have to
know to derive from it, correct? So

class UserFunctor : public Functor { /* something */ };

and then to achieve the goal they would need to know how to override
a virtual function and not to change the signature... It seems that
they still would need to know a lot.

Of course, another approach is to hide the scary template stuff into
a macro, like this:

#define FUNCTOR_METHOD(type, arg) \
template<class T> double operator()(T arg)

and then ask your user to do

struct Functor {
FUNCTOR_METHOD(double, t_) {
return t_.x() + t_.y();
}
};

Is that better?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask



aaragon 09-23-2006 04:17 AM

Re: external functionality with a functor object?
 

Victor Bazarov wrote:
> aaragon wrote:
> > Victor Bazarov wrote:
> >> aaragon wrote:
> >>> [..]
> >>> However, I still have one problem. The user needs to implement the
> >>> entire functor and I don't think that is nice. Maybe if I write a
> >>> hidden implementation of the functor and the let the user only to
> >>> override the function ()(), perhaps???
> >>
> >> I don't understand the problem. Can you elaborate?
> >>
> >> V
> >> --
> >> Please remove capital 'A's when replying by e-mail
> >> I do not respond to top-posted replies, please don't ask

> >
> > Sure. Well, the way you mentioned works just fine. But the idea is
> > to hide the implementation details for the user. Let's say, the user
> > has to write:
> >
> > struct Functor
> > {
> > template<class T>
> > double operator()(T t_) {
> > return t_.x() + t_.y();
> > }
> > };
> >
> > int main(int argc, char *argv[])
> > {
> > ClassA<Functor> a;
> > a.evaluate();
> > ...
> > }
> >
> > and for someone who does not have idea about C++, the functor struct
> > is just hard! So, I was thinking that it may be a good idea to do
> > something easier, like overriding the function because the user does
> > not have to deal with implementation details. If the user does not
> > put template<class T> the functor will not work. Any ideas to
> > accomplish this?

>
> So, what is the user supposed to write to accomplish what they need?
> If the 'Functor' above is hard (and yes, member templates are not the
> simplest thing to understand, I give you that), what would be "easy"
> for somebody "who does not have idea about C++"? If they don't have
> a clue, why would they be writing those functors?
>
> Let's suppose you want to make their life easier. You write some kind
> of base class
>
> class BaseFunctor { /* not sure what goes here yet */ };
>
> , right? OK, how the user will make use of it? They would have to
> know to derive from it, correct? So
>
> class UserFunctor : public Functor { /* something */ };
>
> and then to achieve the goal they would need to know how to override
> a virtual function and not to change the signature... It seems that
> they still would need to know a lot.
>
> Of course, another approach is to hide the scary template stuff into
> a macro, like this:
>
> #define FUNCTOR_METHOD(type, arg) \
> template<class T> double operator()(T arg)
>
> and then ask your user to do
>
> struct Functor {
> FUNCTOR_METHOD(double, t_) {
> return t_.x() + t_.y();
> }
> };
>
> Is that better?
>
> V
> --
> Please remove capital 'A's when replying by e-mail
> I do not respond to top-posted replies, please don't ask


=) That's a good idea! (altough I don't like to deal with macros for
some reason). Another would be to pass just a function instead of an
object, right? Maybe that's also an easy way to implement this. What
do you think?


Victor Bazarov 09-24-2006 04:42 PM

Re: external functionality with a functor object?
 
aaragon wrote:
> Victor Bazarov wrote:
>> [..]
>> Of course, another approach is to hide the scary template stuff into
>> a macro, like this:
>>
>> #define FUNCTOR_METHOD(type, arg) \
>> template<class T> double operator()(T arg)
>>
>> and then ask your user to do
>>
>> struct Functor {
>> FUNCTOR_METHOD(double, t_) {
>> return t_.x() + t_.y();
>> }
>> };
>>
>> Is that better?
>>
>> V
>> --
>> Please remove capital 'A's when replying by e-mail
>> I do not respond to top-posted replies, please don't ask

>
> =) That's a good idea! (altough I don't like to deal with macros for
> some reason). Another would be to pass just a function instead of an
> object, right? Maybe that's also an easy way to implement this. What
> do you think?


Yes, functions are essentially functors (in C++ terms) since when named
by their name they can be called using the function call operator.

You still haven't explained how your users that aren't very sophisticated
(by your own opinion) will deal with those things. What do you expect
them to be able to do? What level do you think they need to be at to be
able to use your library? I am not saying you should require them to
implement type traits with a bunch of typedefs and static members to
successfully utilize your library, but FCOL, if they don't know C++ (or
most of it), maybe you should concentrate on Visual Basic mechanism for
them to use?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask




All times are GMT. The time now is 10:57 PM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.