Re: Function arguments: References vs pointers

From:

Otis Bricker <obricker@my-dejanews.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Tue, 26 Jun 2007 01:34:01 CST

Message-ID:

<Xns995ABD7094962obrickermydejanewsco@216.196.97.136>

{ Edits: quoted signature and quoted mod comment removed. Please quote
only relevant material. See link in banner below. -mod }

Rune Allnor <allnor@tele.ntnu.no> wrote in news:1181987595.302139.50940
@o61g2000hsh.googlegroups.com:

Hi all.

Consider the two functions

void f(int& i)
{
i = 1;
}

void g(int* j)
{
*j = 2;
}

Both are fed an argument which specify an integer in the
calling program, they set the value of that integer to 1
and 2 respectively.

What are the practical differences - if any - between the
two versions of the function call?

One obvious difference is the calling syntax:

int k;

f(k);
g(&k);

The call to f() is "clean" from the programmer's point of view, it is
also transparent with respect to whether the function actually
uses call by reference or call by value. The call to g() is more
cumbersome; it may be very cumbersome if the argument is
not an individually declared variable but a member of some
struct or array.

Except for the source code being easier to read by the human
when using references, are there more differences between the
two forms?

My personal and unexamined choice is to try to maintain the illusion of
call-by-value. So unless there is an overwelming need, I only use const-
reference parameters. If the object might be modified, I use a pointer. I
picked this up years ago somewhere and it has seemed like a good idea all
along.

As with all rules, it can be broken when you need to. But I find that,
done consistently, it helps to be able to assume that f(k) will not be
modifying k.

Otis B

--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]