Choosing function parameter types - pointers or objects?

[ballpointpenthief]

At the moment, I only write functions which accept pointers as
arguments in order to change a value, but I've realised it would often
be a lot more effiecient to pass a pointer rather than an actual
object.
I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

I'm also interested in any grey areas, or even off-topic functions that
have been written like in the win32 API for instance, but I doubt
anyone else is.

Cheers, Matt

[Richard Heathfield]

ballpointpenthi ef said:

I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

If it's a native type (int, short, long, double, that sort of thing), pass
it in raw unless you need to hack its value. Anything else - structs and
stuff - pass a pointer.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[Frederick Gotham]

ballpointpenthi ef posted:

I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

You'd have the measure the efficiency of:

(1) Passing the object by value (thus copying it in the process).

and

(2) Passing its address, and dereferencing the address.
For the intrinsic types, (1) is faster.

For a huge type, an object of which is perhaps a kilobyte, (2) would be
faster.
I'm sure the others can give you a more detailed reply.

--

Frederick Gotham

[Keith Thompson]

Richard Heathfield <in*****@invali d.invalid> writes:

ballpointpenthi ef said:

I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

If it's a native type (int, short, long, double, that sort of thing), pass
it in raw unless you need to hack its value. Anything else - structs and
stuff - pass a pointer.

I wouldn't hesitate to pass a *small* structure directly.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Richard Heathfield]

Keith Thompson said:

Richard Heathfield <in*****@invali d.invalid> writes:

ballpointpenthi ef said:

I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

If it's a native type (int, short, long, double, that sort of thing),
pass it in raw unless you need to hack its value. Anything else - structs
and stuff - pass a pointer.

I wouldn't hesitate to pass a *small* structure directly.

I would. Small structures have a habit of growing larger. :-)

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[goose]

Frederick Gotham wrote:

<snipped>

You'd have the measure the efficiency of:

(1) Passing the object by value (thus copying it in the process).

and

All function arguments are passed by value in C.
(2) Passing its address, and dereferencing the address.
For the intrinsic types, (1) is faster.

For a huge type, an object of which is perhaps a kilobyte, (2) would be
faster.

Although the OP never mentioned efficiency[1], I think a good strategy
to pass as little as possible would be to pass a pointer whenever
sizeof (datatype) > sizeof (void *).

Efficiency on such a microscopic scale is a silly goal anyway, the
savings are not going to offset the disadvantages. The general rule
I use is to use opaque data types whenever I can which solves the
whole problem quite neatly. In the rare occasion that I cannot use
an opaque type, I'd still use pointers for any data that contains more
than one primitive type (structs, arrays) and only pass the value
itself when it is a primitive type.

goose,
hand

[1] I got the impression the question was more one of style than
of efficiency, but thats just me :-).

[Stephen Sprunk]

"ballpointpenth ief" <Ma************ *@gmail.com> wrote in message
news:11******** **************@ 75g2000cwc.goog legroups.com...

At the moment, I only write functions which accept pointers as
arguments in order to change a value, but I've realised it would often
be a lot more effiecient to pass a pointer rather than an actual
object.
I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

It is common practice to pass read-only parameters of primitive types by
value, and everything else by pointer.

S

--
Stephen Sprunk "Stupid people surround themselves with smart
CCIE #3723 people. Smart people surround themselves with
K5SSS smart people who disagree with them." --Aaron Sorkin
--
Posted via a free Usenet account from http://www.teranews.com

[Frederick Gotham]

goose posted:

Although the OP never mentioned efficiency[1], I think a good strategy
to pass as little as possible would be to pass a pointer whenever
sizeof (datatype) > sizeof (void *).

Then there's no discussion, because both methods solve the problem.

One of them is more efficient in certain cases, yes, but both get the job
done.

If the OP doesn't care about efficiency, the just flip a coin.

--

Frederick Gotham

[Ian Collins]

goose wrote:

Frederick Gotham wrote:

<snipped>

You'd have the measure the efficiency of:

(1) Passing the object by value (thus copying it in the process).

and

All function arguments are passed by value in C.

(2) Passing its address, and dereferencing the address.
For the intrinsic types, (1) is faster.

For a huge type, an object of which is perhaps a kilobyte, (2) would be
faster.

Although the OP never mentioned efficiency[1], I think a good strategy
to pass as little as possible would be to pass a pointer whenever
sizeof (datatype) > sizeof (void *).

Unfortunately this is platform specific.

The cut-off point between pass by value and by pointer varies form
system to system. sizeof(void*) is a reasonable general case.

--
Ian Collins.

[Joe Wright]

Keith Thompson wrote:

Richard Heathfield <in*****@invali d.invalid> writes:

ballpointpenthi ef said:

I know this question is a bit vague, but I was wondering about any
rules / guidelines / style issues, for when to use pointers, and when
not to, in your function parameters?

If it's a native type (int, short, long, double, that sort of thing), pass
it in raw unless you need to hack its value. Anything else - structs and
stuff - pass a pointer.

I wouldn't hesitate to pass a *small* structure directly.

Why pass a struct rather than a pointer to it? You can examine the
struct either way but if you would modify any member of it, and pass the
struct by value, the function must 'return' the value and you must
assign it to the original struct. If you pass a pointer to it, you can
modify the member of the original struct (in)directly.

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---