[A89] Re: Pointers and Matricies


[A89] Re: Pointers and Matricies

On Fri, Feb 23, 2001, Sebastian Reichelt wrote:
> | What makes Pascal more logical then C?
> The syntax.
> | And logical in what way?
> For example, I completely hate the keyword 'void', because it can have many
> meanings and looks just like a normal type.

The keyword 'var' (in Pascal) also has "many" meanings.

'void' looks just like a normal type -- because it IS a normal type.
A `short' usually occupies 2 bytes, a `char' usually occupies 1 byte and
a `void' occupies 0 bytes.  The other meaning of `void' is the empty
argument list.

> Next, I think the way functions
> are declared is pretty strange: They start out like a variable, and then
> they just take parameters.

Yes!  Everything is declared the same way and declarations are consistent
with each other!  A declaration with a type "X" and a declaration with a
type that is derived from "X" (eg. "pointer to X") look very similar -- and
why not, they both contain mostly "X"!!!  This "derived type is similar"
rule applies to ALL types "X", including function declarations.

Also, a type declaration in C follows the actual usage of the variable/
function.  The type declaration `int <something>;' declares <something> to
be an `int'.  By applying this rule blindly, `int *a;' tells us that `*a' is
an `int' -- which is absolutely correct!  This "inverse" interpretation
works with every data type (oh consistency!), including function
declarations.  `int foo(void) { ... }' declares a function, but also, just
like above, correctly tells us that the type of `foo()' is `int'.

> Function types are the worst; what's up with
> "void(*)(void)" (as opposed to a simple "procedure")?

Huh?  "void (*)(void)" is a "pointer to a function" type, not a "function"

Anyway, the reason to use `void foo(void)' instead of `Procedure foo'
follows directly from both the "derived type is similar" "rule" and the
"inverse" interpretation as described above.  When we dereference a "pointer
to function" we must get a "function".  So if we want `*foo' (the de-
referenced pointer `foo') to be of the type "function taking no args
returning int" and we know that the declaration `int <something>(void);'
results in <something> having this type, we know that we can write
`int (*foo)(void);' to get exactly what we want.

> And matrices are
> pretty bad as well:  First there is the type, then the variable name, then
> the dimensions, which belong to the type from my point of view.

Once again I refer to the "inverse" interpretation of declarations.  If
`foo[i]' is an `int' (and it's certain that `foo' is not a pointer etc),
then the declaration of `foo' must be, eg., `int foo[5];'.

> In using
> pointers, I find that the location of the asterisks is 'switched around';
> this also makes more parentheses necessary.

True.  The language is not perfect, but IMHO it's far better than,
say, Pascal.  See also  http://www.lysator.liu.se/c/bwk-on-pascal.html

Johan Eilert