say in C I have a function with a pointer argument
foo( const sometype_t * p )
I have asked about this D nightmare before. Using the same
pattern in D or the in argument qualifier as far as I can see the
value of the pointer is then itself effectively locked made
constant. Without dangerous and ugly casts you are stuck.
q1. If you want a pointer to memory that is not to be modified
then you can't walk the pointer through that memory. So what are
my options? I need a pointer that I can increment. (I could avoid
the whole issue by using an index instead, but that seems to be
giving in to madness.)
It seems to me that this is the worst thing I have seen about D.
Perhaps trying to make pointers unusable is a surreptious
strategt]y for encouraging designers to phase them out. Making
code unsafe just to get out of this nightmare (by casting or
giving up and dropping important const protection) is not the way.
q2. If you want a pointer to modifiable memory but wish to ensure
that the value of that address stays fixed, stays where it's put,
then what on earth do you do. What are my options?
Is there any way at all to campaign for a change to this
craziness? I doubt this is a democracy. It's also rather more
than a bit late.
q3. The in keyword seems to be mixed up concerning the
distinction between modifiable arguments and modifiable memory.
Is there any way of making in usable for the purposes of
documenting the calling convention, showin which arguments are
inputs only, which are outputs and which are modified -
read-modified-returned?
Apologies for my lack for my lack of familiarity with the
possible ways out of this.
q4. If my understanding is correct, it seems difficult to create
a non const copy of (an address that is fixed) either; that is,
making a modifiable copy of an address, one which can be
incremented, moved upwards starting from a locked base address.
It seems that declaring a pointer argument with const or even
using the keyword in triggers this problem, the latter being
particularly nightmarish because I would want in to mean that
that argument (the address, which is what I am declaring) is
merely an input-only parameter to the routine, or alternatively a
locked /fixed address value which stay s put, and nothing.
I'm interested in the cleanest safest techniques for digging
myself out of this while always preserving const correctness,
preventing possibility of writing to memory and preventing evil
type changes where pointers end up pointing to some different
kind of objects because if evil casting. I really don't want to
use casts that have to much power, where they could allow
overrides to any kind of bugs in or even create a new bug,
including cases when things break because of duplication of types
so later changes of types cause a bug because kludge contain
duplicate type specifiers that do not get updated.
There probably is a tool somewhere to safely create a modifiable
object based on a const object but I'm not sure where to look.
Any wise guidance appreciated mucky.
