How and when to properly use *this pointer and argument matching?

Question

When I go thru the code written by collegue, in certain place, they use:

this->doSomething(); //-->case A
doSomething(); //-->case B

In fact I'm not sure about the great usage of *this pointer...:(

Another question with argument matching:

obj.doOperation();  //-->case C
(&obj)->doOperation(); //-->case D

In fact both cases are performing the desired operation, is it simply a way to make the code look more complex?

What is your recommendation on the above two question? When is the appropriate time to use them and why?

Why this is tagged with C? What has the term "argument matching" to do here? — Jens Gustedt, Sep 29 '10 at 15:52
Of course you should always use the most complicated looking method :) — codymanix, Sep 29 '10 at 16:40
I like the remark: **simply** a way to make the code look more **complex** (bolds mine), or paraphrasing, "a simple way to write complex code." Wow! — Arun, Sep 30 '10 at 04:57

score 5 · Accepted Answer · answered Sep 29 '10 at 15:41

5

This is not an answer to your question, but a note that both fragments may do different things:

namespace B { void doSomething() {} }

struct A {    
    void f()
    {
        using B::doSomething;
        this->doSomething(); // call A::doSomething
        doSomething(); // calls B::doSomething
    }

    int a;
    void g(int a)
    {
        this->a = a; // assigns argument to member
    }

    A* operator & () { return this; }
    void doOperation() {}
    void doSomething() {}
};

void g(A &obj)
{
    obj.doOperation();  // calls A::doOperation directly
    (&obj)->doOperation(); // calls A::operator & first
}

answered Sep 29 '10 at 15:41

Yakov Galka

70,775
16
139
220

And if you'd overloaded `operator->`, it would also call that in the second example! – Oliver Charlesworth Sep 29 '10 at 15:45
The former is a possible argument against using `using`! – Oliver Charlesworth Sep 29 '10 at 15:46
2

@Oli: "if you'd overloaded ..." no. It would be called if I'd write `obj->doOperation()`. "The former is a..." it's a very weak argument. – Yakov Galka Sep 29 '10 at 15:48
Good point on `operator->`. Regarding `using`, I'd say it's a fairly canonical argument; cluttering up the local namespace which then leads to confusion, rather than explicit disambiguation (i.e. `B::doSomething()`). – Oliver Charlesworth Sep 29 '10 at 15:53
@Oli: Agree in this situation, but not against using `using` in general. – Yakov Galka Sep 29 '10 at 15:55

score 3 · Answer 2 · answered Sep 29 '10 at 15:47

Cases B and C are always the appropriate way. Cases A and D are equivalent and do nothing different.

A few exceptions to that:

If the class has an overloaded operator& that does surprising things, then case D could do something different that C. Actually having classes which do this is not recommended, since it would be confusing.
If there is a local variable doSomething (or something else of that name in the local scope), then A would refer to a different doSomething than B. Again it isn't recommended to get yourself into such a situation, better give different names to different things.

score 1 · Answer 3 · answered Sep 29 '10 at 15:59

1

C and D are different. If doOperation is virtual, case D will perform the virtual call, case C will perform a non-virtual call if obj is not a reference. This assumes however that operator& and operator-> have not been overloaded.

I tend to use A over B since there may be a local doSomething identifier. Inside template code, things may get worse (although I can't come with a precise example right now). It is a good habit to take.

answered Sep 29 '10 at 15:59

Alexandre C.

55,948
11
128
197

"non-virtual call if obj is not a reference" — Hmmm.... Can there be a difference between virtual and non-virtual call if obj is not a reference? Isn't it get resolved to the same function? – Yakov Galka Sep 29 '10 at 16:02
@ybungalobill: nope. if `obj` is a variable of class `C`, `obj.doSomething()` will always resolve to `obj.C::doSomething()`. If `obj` is a reference, it will perform the virtual dispatch. – Alexandre C. Sep 29 '10 at 16:03
If obj is a variable, virtual call `(&obj)->doSomething()` will get resolved to the same function as the non-virtual call `obj.doSomething()`, but one call is virtual and the other is non-virtual I guess :) – Maciej Hehl Sep 29 '10 at 16:24

How and when to properly use *this pointer and argument matching?

3 Answers3