• Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 300
  • Last Modified:

function chaining

I have a inline function that is to allow for function chaining. using an add function that is  already written.
this is what I have so far.
fraction & inc(){*this=add(*this,*this);return *this;}
the function inc() is supposed to add 1 to the instance.
Thank you for any help.
0
strmtrpr
Asked:
strmtrpr
1 Solution
 
NorbertCommented:
Your problem is not clear for me
0
 
alexoCommented:
Hmmm...  Details missing.

First I assume you have a way of converting a constant number to a 'fraction' object.  E.g., via a constructor.

There are two possible cases:

(1) Let's assume add() is written like this:

    fraction add(const fraction& a, const fraction& b)
    {
        fraction result;
        // Do something...
        return result;
    }

Note that add returns BY VALUE and not BY REFERENCE.  That is because it creates a new object instead of modifying an existing one.  Therefore, inc() should not be implemented in terms of add().

Now, consider the other case:

(2) Let's assume add() is written like this:

    fraction& add(fraction& obj, const fraction& x)
    {
        // Do something...
        return obj;
    }

In this case, I assume modifies the first argument (and also returns the result BY REFERENCE, since no new object is created).  If that is the case, inc() could be written like this:

    fraction& inc(const fraction& obj)
    {
        return add(obj, 1);
    }

However, if inc() and add() modify the object, it will be much better to implement them as member functions:

    fraction& fraction::add(const fraction& x)
    {
        // Do something to add x to *this...
        return *this;
    }

    fraction& fraction::inc()
    {
        return add(1);
    }

But if that's the case, why not use operators?

    fraction& fraction::operator+=(const fraction& x)
    {
        // Do something to add x to *this...
        return *this;
    }

    fraction& fraction::operator++(int) // postfix increment
    {
        return operator+=(1);
    }

Now you can write:

    fraction x, y;
    // ...
    x += y;
    ++x;

Hope it helps.
0

Featured Post

Industry Leaders: We Want Your Opinion!

We value your feedback.

Take our survey and automatically be enter to win anyone of the following:
Yeti Cooler, Amazon eGift Card, and Movie eGift Card!

Tackle projects and never again get stuck behind a technical roadblock.
Join Now