Return pointer or variable by ref.?

[Nafai]

Hello I would like you guys to give me the best solution for this problem:
class bigInteger {
private:
vector<char> digits;
public:
...

bigInteger& operator+=(const bigInteger& x)
{ ... } // Already implemented.
// WHICH WAY DO I CHOOSE?

// Option 1
bigInteger operator+(const bigInteger& x) const
{
bigInteger y = *this; // ONE COPY
y += x;
return y; // TWO COPIES (?)
}

// Option 2
bigInteger* operator+(const bigInteger& x) const
{
bigInteger y = new bigInteger(*this);
*y += x;
return y;
} // ONLY ONE COPY, but I wouldn't like to avoid pointers, and I am
using references, pointers, and static variables mixed up everywhere.

// Option 3
bigInteger& operator+(const bigInteger& x) const
{
bigInteger y = new bigInteger(*this);
*y += x;
return *y;
} // It isn't OK. Now I miss garbage collector!

// Option 4
void add(const bigInteger& op, bigInteger& out)
{
out = *this;
out += op;
} // OK, but can't use operator+ and build arithmetic expressions

};
If you have any better solution, tell me!

Thanks.

[Nafai]

} // ONLY ONE COPY, but I wouldn't like to avoid pointers, and I am
using references, pointers, and static variables mixed up everywhere.

I meant: ... but I _would_ like to avoid pointers ...

[Karl Heinz Buchegger]

Nafai wrote:

If you have any better solution, tell me!

Let the optimizer do its work

bigInteger& operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

--
Karl Heinz Buchegger
kb******@gascad.at

[Nafai]

Karl Heinz Buchegger escribió:

Nafai wrote:

If you have any better solution, tell me!

Let the optimizer do its work

bigInteger& operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

But is it OK to return a local variable?

[Nafai]

If you have any better solution, tell me!

Let the optimizer do its work

bigInteger& operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

But is it OK to return a local variable?

But is it OK to return a local variable _by reference_?

[Karl Heinz Buchegger]

Nafai wrote:

Karl Heinz Buchegger escribió:

Nafai wrote:

If you have any better solution, tell me!

Let the optimizer do its work

bigInteger& operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

But is it OK to return a local variable?

Ooops. Sorry. I didn't want to write that. It happend
during Cut&Paste. You are right of course. The return
type is object, not reference to object.

bigInteger operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

--
Karl Heinz Buchegger
kb******@gascad.at

[Nafai]

Karl Heinz Buchegger escribió:

Nafai wrote:

Karl Heinz Buchegger escribió:

Nafai wrote:
If you have any better solution, tell me!
Let the optimizer do its work

bigInteger& operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

But is it OK to return a local variable?

Ooops. Sorry. I didn't want to write that. It happend
during Cut&Paste. You are right of course. The return
type is object, not reference to object.

bigInteger operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

So I may suppose that there will be only one copy thanks to the
optimizer. Am I right?

[Karl Heinz Buchegger]

Nafai wrote:

Karl Heinz Buchegger escribió:

Nafai wrote:

bigInteger operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

So I may suppose that there will be only one copy thanks to the
optimizer. Am I right?

The language standard has nothing to say about that. But in
practice, yes, the optimizer will do a good job and optimize
away the local variable. In fact, if the above function gets inlined,
and there is no reason that it won't, it is one of the simpler
tasks of the optimizer to get rid of it.

--
Karl Heinz Buchegger
kb******@gascad.at

[Nafai]

Karl Heinz Buchegger escribió:

Nafai wrote:

Karl Heinz Buchegger escribió:

Nafai wrote:

bigInteger operator+(const bigInteger& x) const
{
bigInteger y( *this );
y += x;
return y;
}

So I may suppose that there will be only one copy thanks to the
optimizer. Am I right?

The language standard has nothing to say about that. But in
practice, yes, the optimizer will do a good job and optimize
away the local variable. In fact, if the above function gets inlined,
and there is no reason that it won't, it is one of the simpler
tasks of the optimizer to get rid of it.

OK, thank-you.