Re: Declarators

On Sep 22, 7:29 pm, rkld...@gmail.com wrote:


Matthias Berndt already pointed out (no pun intended) that it is:
"p is function taking int that returns pointer to function that takes
two char * and returns int"

My method for deciphering such declarations is to personify the
elements:

int (*foo) (float, double);

"When I derference foo, I get a function taking float, double and
returning int."

The key is "When I dereference...". It is important to start at the
proper place(s) in the declaration to let it unravel without too much
mental effort. It is also important, IMHO, to have the proper mindset
about the notion of * dererfencing. Yes, we all know what * does, and
how to use it, but the "mood" that some programmers experience when
seeing * is different than that of others. Let me explain what I mean
by mood:

char *p;

Some programmers will see this and think

"char star p";

Other programmers will think,

"deferencing p yields type char."

Of course, these two statements are equivalent, but there is a subtle
difference in mindest, and the latter will carry the programmer much
farther than the former. Mental parsing as "char star p" should only
be used after programmer has already developed the "when I dereference
p" habit, and is comfortable taking the short cut, knowing that a
short cut is being taken.

You can catch programmers guilty of the "char star p" mentality by
watching how they declare references:

void foo(int& i) {i += 10;} // Note the lack of space betweenn "int"
and "&".

Placing the "&" right up against the "int" indicates that the
programmer wants to aggregate quickly the notion of "int reference" as
an atomic unit so that the conjecture becomes:

"int reference i".

Now watch what happens when one tries this with simple variable
declarations:

const int& a=0, &b=0, &c=0, &d=0;

The "int&" that caused the programmer to think "int reference" works
well for "a" , but cannot be used for "&b", "&c", and "&d" because the
ampersands for those variables are in inconsistent and "weird"
locations.

It would have been more appropriate, IMHO, to have written:

const int &a=0, &b=0, &c=0, &d=0;

Now there is consistency. By examing the variables first, in
conjunction with their preceeding ampersands the mind concludes:

"a refers to const int, b referes to const int,..." etc.

This subtle, seeminlgy insignificant change in mindset becomes more
profound and almost essential for human parsing of super-complex
declarations.

-Le Chaud Lapin-

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]