Is there an alternative to the term "calling object"?

Question

Let's suppose you've got a class defined (in pseudocode):

class Puppy {
    // ...
    string sound = "Rawr!";

    void bark() {
        print(sound);
    }
}

And say, given a Puppy instance, you call it's bark() method:

int main() {
    Puppy p;
    p.bark();
}

Notice how bark() uses the member variable sound. In many contexts, I've seen folks describe sound as the member variable of the "calling object."

My question is, what's a better term to use than "calling object"?

To me, the object is not doing any calling. We know that member functions are in a way just functions with an implicit this or self parameter.

I've come up with "receiving object" or "message recipient" which makes sense if you're down with the "messaging" paradigm.

Do any of you happy hackers have a term that you like to use?

I feel it should mean "the object upon which a method is called" and TOUWAMIC just doesn't cut it.

As for who the "caller" is, I would say that main instantiates a Puppy object and calls its bark() method.

score 8 · Answer 1 · answered Nov 15 '11 at 19:20

Using the word object in the reference is redundant.

Perhaps caller and callee is simplistic enough. Referring to the actual object as an instance of type is also another approach as noted by Wyatt; instance of Puppy or if being succinct is the goal...instance.

score 3 · Answer 2 · answered Nov 15 '11 at 19:45

p is the receiver, recipient, target, callee, "the puppy," or just "p".

The object sending the message/calling the method is the sender or caller. Caller can also mean the function or method calling p.bark().

Sometimes the relationship between the objects is used instead because that's an easier way to identify the two, so one might be the parent and the other the child, or one might be the delegate and the other the delegator.

score 1 · Answer 3 · answered Nov 15 '11 at 19:27

Based on your comment in Wyatt's post:

Rather, how to describe p in the context of method calls.

I'd have to go with describing p in the context of method calls as being the "method's instance".

In object-oriented programming, a method is a subroutine (or procedure or function) associated with a class. [Wikipedia]

As such, when describing the inverse relationship, I would believe that "method's instance" would be correct your described context (but exchanging class for instance as we're describing the relationship to the instance, not the class definition itself).

score 1 · Answer 4 · answered Nov 15 '11 at 19:33

1

I'd go with any of:

call target
method owner (although this doesn't really make sense if p is null, because then it hardly owns anything)
callee

Although in that very context, I'd go with p ;)

answered Nov 15 '11 at 19:33

back2dos

30,140

score 0 · Answer 5 · answered Nov 15 '11 at 19:14

0

I'd generally call p an instance of Puppy, not the calling object

answered Nov 15 '11 at 19:14

Wyatt Barnett

20,787

score 0 · Answer 6 · answered Nov 15 '11 at 21:39

The "Calling Object" is roughly equivalent to a dispatcher, so I guess you could use that term to describe it.

Methods are bound to a class, so "Calling Object" is redundant as Aaron points out.

Usually I think of "the Caller" as some code or object outside of the bound method.

Say I have a form called form1 and I create a instance of Puppy. From form1 I called p.bark(). I would see the Calling object is form1.

I don't think there is a 100% correct answer here.

Is there an alternative to the term "calling object"?

6 Answers6