Re: references and pointers
On Nov 8, 6:24 pm, Paavo Helde <nob...@ebi.ee> wrote:
Kira Yamato <kira...@earthlink.net> wrote innews:2007110402083216807-kira=
kun@earthlinknet:
[...]
References are usually implemented by pointers anyway, so there is no
efficiency gain (except that you don't (shouldn't) need to check for
NULL-ness, but that's more a design issue and costs next to nothing
anyway on current hardware).
It depends. A reference cannot be reseated. The compiler knows
this. That may open up some additional optimization
possibilities, or make them simpler.
Pointers are not good for out parameters IMHO, because
pointers can be NULL.
C++ doesn't allow out parameters, at least not for class types,
so the question is moot:-).
For inout parameters (or parameters which are conceptually out,
even if you can't call the function without actually having
given them a value), it's a question of convention---I prefer
references, too, but I'll adapt to the local convention.
Pointers are required, on the other hand, if the out parameter
is optional---things like the second parameter to functions in
the strtoxxx family (strtod, etc.).
If I call some function for retrieving some data and passing NULL
pointer, what I'm saying?
That you're not interested in the data, only in the side effects
of looking for it.
Out parameters are not all that frequent. Except in some very
rare cases of optimization, they only occur when a function has
more than one value to return. In that case, it's a fairly
common idiom to pass the address of the second return value as a
pointer, with the convention that a null pointer means that
you're only interested in the primary return value. There are a
number of examples of this in the C standard, for example.
Do I want to get this data after all or not? If
not, why I call this function?
Because if it has an out parameter, it also has a return value,
and you're only interested in the return value.
I should call another function or overload instead if I don't
want to get any data back.
That's another alternative---provide two functions. But what is
the real difference between:
Type1 function( Type2* out = NULL ) ;
and
Type1 function() ;
Type1 function( Type2& out ) ;
(The only real difference I can see is that some older compilers
might still accept a temporary as argument in the second case.
Which is an argument for using the first alternative---and for
using pointers in general for out parameters. But you should
probably update such compilers, rather than adapting your coding
standards to them.)
In case of references I am obliged to provide the space for
data and the meaning of the operation is much clearer.
You are right that raw pointers should generally not be used
in C++ code. If pointer semantics are required, for example
for storing in STL containers, some kind of smart pointers
should be used instead.
This is simply false. There are times when smart pointers are
appropriate, but most use of pointers is for navigation, and raw
pointers are still the best solution for that.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34