Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Explicit function vs. overloaded operator?

Reply
Thread Tools

Explicit function vs. overloaded operator?

 
 
BCC
Guest
Posts: n/a
 
      05-26-2004
In looking through some code I have inherited, I notice a lot of places
where the programmer used operator() as a function call:
void operator() (int x, int y);

Rather than an explicit function name:
void MyFunction(int x, int y);

Then when he instantiates a class he calls it:
MyClass myclass;
myclass (x, y);

vs.

MyClass myclass;
myclass.MyFunction(x, y);


Is there any advantage to this or is it just a style?

Thanks,
B


 
Reply With Quote
 
 
 
 
Victor Bazarov
Guest
Posts: n/a
 
      05-26-2004
BCC wrote:
> In looking through some code I have inherited, I notice a lot of places
> where the programmer used operator() as a function call:
> void operator() (int x, int y);
>
> Rather than an explicit function name:
> void MyFunction(int x, int y);
>
> Then when he instantiates a class he calls it:
> MyClass myclass;
> myclass (x, y);
>
> vs.
>
> MyClass myclass;
> myclass.MyFunction(x, y);
>
>
> Is there any advantage to this or is it just a style?


If your object/type is used as an argument for a template that
expects a functor (a function or a type with operator() defined)
then you need operator().

Otherwise, no.

In general if you think you might need both, just implement it in
the function and then define the operator() so that it simply calls
the member function.

Victor
 
Reply With Quote
 
 
 
 
Jeff Schwab
Guest
Posts: n/a
 
      05-26-2004
BCC wrote:
> In looking through some code I have inherited, I notice a lot of places
> where the programmer used operator() as a function call:
> void operator() (int x, int y);
>
> Rather than an explicit function name:
> void MyFunction(int x, int y);
>
> Then when he instantiates a class he calls it:
> MyClass myclass;
> myclass (x, y);
>
> vs.
>
> MyClass myclass;
> myclass.MyFunction(x, y);
>
>
> Is there any advantage to this or is it just a style?


The advantage is that the user of the functor (object with overloaded
operator()) doesn't need to know whether an object of some class is
being used, instead of an ordinary function. Functors are especially
useful for encapsulating policies in generic code.
 
Reply With Quote
 
David Harmon
Guest
Posts: n/a
 
      05-27-2004
On Wed, 26 May 2004 18:53:48 -0400 in comp.lang.c++, Jeff Schwab
<(E-Mail Removed)> wrote,
>
>The advantage is that the user of the functor (object with overloaded
>operator()) doesn't need to know whether an object of some class is
>being used, instead of an ordinary function. Functors are especially
>useful for encapsulating policies in generic code.


Except that the user actually does depend on the type of function
or functor class being used. Only if the caller is a template
instantiated on that type do you get anywhere close to not needing to
know, and that only when the type is in fact known by the compiler.

 
Reply With Quote
 
Siemel Naran
Guest
Posts: n/a
 
      05-27-2004
"BCC" <(E-Mail Removed)> wrote in message news:t59tc.73289

> In looking through some code I have inherited, I notice a lot of places
> where the programmer used operator() as a function call:
> void operator() (int x, int y);
>
> Rather than an explicit function name:
> void MyFunction(int x, int y);


Does he pass MyFunction objects to a template? Something like this:

template <class Iter1, class Iter2, class Action>
void for_each(Iter1 begin1, const Iter1 end1, Iter2 begin1, Action action) {
for ( ; begin1!=end1; ++begin1, ++begin2) action(*begin1, *begin2);
}

If yes, then it makes sense to write an operator(), as the template for_each
requires it. But then again we could have written for_each to call
action.MyFunction(*begin1, *begin2).

The technical advantage of operator() is that Action can be either a class
object with an operator() or a simple function. If a function, then the
type of Action is something like void (*)(int, int).

The conceptual advantage is that if class MyClass does just one thing, then
operator() reflects this one thing, and thus the essence of the class. But
I think this is a matter of style. Having an explicit function name might
make the code easier to read. For example, style.Combine(1, 2) is usually
easier to read and understand in code reviews than style(1, 2).

> Then when he instantiates a class he calls it:
> MyClass myclass;
> myclass (x, y);


Please note you can say MyClass()(x, y), though not sure if this notation is
in popular usage.

> vs.
>
> MyClass myclass;
> myclass.MyFunction(x, y);
>
>
> Is there any advantage to this or is it just a style?


My guess it's a matter of style.


 
Reply With Quote
 
Jeff Schwab
Guest
Posts: n/a
 
      05-27-2004
Siemel Naran wrote:
> "BCC" <(E-Mail Removed)> wrote in message news:t59tc.73289
>
>
>>In looking through some code I have inherited, I notice a lot of places
>>where the programmer used operator() as a function call:
>>void operator() (int x, int y);
>>
>>Rather than an explicit function name:
>>void MyFunction(int x, int y);

>
>
> Does he pass MyFunction objects to a template? Something like this:
>
> template <class Iter1, class Iter2, class Action>
> void for_each(Iter1 begin1, const Iter1 end1, Iter2 begin1, Action action) {
> for ( ; begin1!=end1; ++begin1, ++begin2) action(*begin1, *begin2);
> }
>
> If yes, then it makes sense to write an operator(), as the template for_each
> requires it. But then again we could have written for_each to call
> action.MyFunction(*begin1, *begin2).
>
> The technical advantage of operator() is that Action can be either a class
> object with an operator() or a simple function. If a function, then the
> type of Action is something like void (*)(int, int).
>
> The conceptual advantage is that if class MyClass does just one thing, then
> operator() reflects this one thing, and thus the essence of the class. But
> I think this is a matter of style. Having an explicit function name might
> make the code easier to read. For example, style.Combine(1, 2) is usually
> easier to read and understand in code reviews than style(1, 2).




If the whole purpose of the "style" object is to combine things, perhaps
the name of the object should be a verb, though the object's class name
still should be a noun:

Combiner combine;
combine( 1, 2 );

I find myself using the style quite a bit, but only in programs I plan
to enhance quite a bit, particularly those that need to do a lot of
different things for a lot of different people. The advantage is that
it pretty much forces me to create a new type for each new concept,
rather than just adding a method to an existing object that happens to
be in the right places at the right times.


>>Then when he instantiates a class he calls it:
>>MyClass myclass;
>>myclass (x, y);

>
>
> Please note you can say MyClass()(x, y), though not sure if this notation is
> in popular usage.



I've used it, but I usually feel guilty about it and end up elongating
it. There are a few classes for which I have actually found this
style preferable, and for those, I document the style explicitly near
the class definition. For example, rather than having a global Log
object, I create them wherever I need them. In many places, e.g. catch
blocks, I only need to write one thing to the Log before the block ends.
In the Log case, I've overloaded operator<< instead of operator(), so
the code looks like this:

Log( ) << "message";

It looks less weird when a different constructor is used:

catch( ... )
{
Log( Log::high_priority ) << "An unknown exception occurred.";
}

>
>
>>vs.
>>
>>MyClass myclass;
>>myclass.MyFunction(x, y);
>>
>>
>>Is there any advantage to this or is it just a style?

>
>
> My guess it's a matter of style.


Mine too.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Explicit instantiation of STL vector demands explicit instantiation of all the templates it using internally. krunalbauskar@gmail.com C++ 1 12-25-2006 03:51 PM
What's the difference betwwen explicit instantiaion and explicit specialization? Andy C++ 5 01-30-2005 11:46 PM
Is explicit template qualification required for explicit delete? J.T. Conklin C++ 1 08-11-2004 02:06 AM
operator= - code in overloaded function doesn't get called Tobias Langner C++ 2 07-31-2003 09:22 AM
Why can't '='(Assignment) operator be overloaded as friend function ? Nitin Bhardwaj C++ 8 07-14-2003 03:50 PM



Advertisments