Re: 'academic' problem ( speed/memory efficiency vs. human readability and easy de
burningsunorama@gmail.com () wrote (abridged):
Recently we've had at work a little talk about the way of providing
const modifier for function parameters. From my point of view are, of
course, design requirements always more important and thus one should
always use const keyword with parameters whose values shouldn't get
changed inside a function ( lets call these ,In' parameters ).
Are you talking about the declaration or the definition?
void func( int x );
void func( const int y ) {
const int z = 0;
// Use y and z.
}
I think if you use const for z then you can defend using it for y in the
definition. However, I regard this:
void func( const int x );
as a mistake because the const adds nothing. The declaration already says
that x is passed by value and so the caller's variable can't be changed.
It hints that the implementation of func does not modify y, which is an
implementation detail that should not leak into the declaration.
Personally I write:
void func( int y ) {
int z = 0;
// Use y and z.
}
unless I have a special reason to stress that y and z don't change.
Generally my functions are so short that the reader, and the compiler, can
figure it out for themselves anyway, so const doesn't add much to clarity
or efficiency. Nor has this been a source of bugs for me.
The opposite opinion was based on fact, that when you need to
use/declare a local variable inside the function, the code is less
efficient (because you lose speed and memory usage is higher), since
you could you use a stack variable provided as a parameter ( and since
is it YOU who writes the body of a function YOU take care of proper
content of the variable ).
I think now you are talking about the difference between:
void func( const int y ) {
int y2 = y;
++y2;
}
versus:
void func( int y ) {
++y;
}
I'd never write the former. It seems crazy to me - I see no virtue in it.
Have I misunderstood you?
I do sometimes use local variables rather than change arguments, but
that's because I sometimes find it clearer, and can be convenient to have
the original value around when debugging. I'm more likely to write:
for (iterator i = first; i != last; ++i)
// Use i.
than:
for (; first != last; ++first)
// Use first.
But not because I have declared first const.
-- Dave Harris, Nottingham, UK.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]