«

Hi,

I wanted to use the most efficient argument passing method. I was
always taught that its best to pass (const SomeObject& obj) if possible
.... but in this case, I can't pass a const param since I will be
modifying the parameter in the function.


Eg: 1

void foo(SomeObject& obj)
{
obj.doSomething();
}


or Eg: 2

void foo(SomeObject* obj)
{
obj->doSomething();
}


Aside from the NULL PTR safety of the reference version, is there a
performance advantage in the way the function and parameters are
placed/copied onto the stack for either version?

Thanks,

-Luther

* LuB:
>
> I wanted to use the most efficient argument passing method.

Premature optimization is the root of all evil. And anyway, what you ask for
here is a bit advanced. If you absolutely want to do it, refer to 'Modern C++
Design' for a discussion of how to partially automate the selection of how to
do argument passing, based on size and in/out/in-out requirements.


> I was
> always taught that its best to pass (const SomeObject& obj) if possible

No.


> ... but in this case, I can't pass a const param since I will be
> modifying the parameter in the function.
>
>
> Eg: 1
>
> void foo(SomeObject& obj)
> {
> obj.doSomething();
> }
>
>
> or Eg: 2
>
> void foo(SomeObject* obj)
> {
> obj->doSomething();
> }
>
>
> Aside from the NULL PTR safety of the reference version, is there a
> performance advantage in the way the function and parameters are
> placed/copied onto the stack for either version?

No, but I can imagine the reference version to be easier to optimize (because
no analysis is needed to check what the reference refers to in each
statement), so it might be that it's better optimized with some compilers.

However, the NULL pointer safety is important, and there are other
non-efficiency related issues.

One particularly important such issue is that the reference cannot be
re-seated within the function. Another is that arithmetic cannot be performed
on the reference, only on the object it refers to (think of e.g. a std::string
argument). A third is that the reference signature clearly indicates a single
object, whereas the pointer signature matches object or array or null.


--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

Thanks Alf!

-LuB

> I wanted to use the most efficient argument passing method. I was
> always taught that its best to pass (const SomeObject& obj) if possible
> ... but in this case, I can't pass a const param since I will be
> modifying the parameter in the function.
>
>
> Eg: 1
>
> void foo(SomeObject& obj)
> {
> obj.doSomething();
> }
>
>
> or Eg: 2
>
> void foo(SomeObject* obj)
> {
> obj->doSomething();
> }
>
>
> Aside from the NULL PTR safety of the reference version, is there a
> performance advantage in the way the function and parameters are
> placed/copied onto the stack for either version?
>
> Thanks,
>
> -Luther
>

If the object is small enough it is actually (most of the time) more
efficient to pass it by value, but that will have a different semantics.

I personally prefer pointer over reference.

Ben

Nicely stated. I prefer reference over pointer. Not relevant to this
thread other than to say the compiler supports both use models and
performance is not a factor in deciding which you use.

As far as the compiler: surely it's true that almost every compiler
will generate the same code whether you pass by reference or pass by
pointer (assuming the C++ code is equivalent). Yes?

Stuart

Stuart MacMartin wrote:

> Nicely stated.


What is?



Brian
--
Please quote enough of the previous message for context. To do so from
Google, click "show options" and use the Reply shown in the expanded
header.

"Default User" <> wrote in message
news:...
> Stuart MacMartin wrote:
>
>> Nicely stated.
>
>
> What is?

What's on second.

-Mike