Reading C and C++ Const Pointers the Spiral way. – Ease Out Life.

The Clockwise/Spiral Rule

There is a technique known as the “Clockwise/Spiral Rule” which enables any C programmer to parse in their head any C declaration!

There are three simple steps to follow:

  1. Starting with the unknown element, move in a spiral/clockwise direction; when ecountering the following elements replace them with the corresponding english statements:
    [X] or []
    => Array X size of… or Array undefined size of…
    (type1, type2)
    => function passing type1 and type2 returning…
    *
    => pointer(s) to…
  2. Keep doing this in a spiral/clockwise direction until all tokens have been covered.
  3. Always resolve anything in parenthesis first!

Example #1: Simple declaration

                     +-------+
                     | +-+   |
                     | ^ |   |
                char *str[10];
                 ^   ^   |   |
                 |   +---+   |
                 +-----------+

Question we ask ourselves: What is str?

“str is an…

  • We move in a spiral clockwise direction starting with `str’ and the first character we see is a `[‘ so, that means we have an array, so…

    “str is an array 10 of…

  • Continue in a spiral clockwise direction, and the next thing we encounter is the `*’ so, that means we have pointers, so…

    “str is an array 10 of pointers to…

  • Continue in a spiral direction and we see the end of the line (the `;’), so keep going and we get to the type `char’, so…

    “str is an array 10 of pointers to char”

  • We have now “visited” every token; therefore we are done!

Example #2: Pointer to Function declaration

                     +--------------------+
                     | +---+              |
                     | |+-+|              |
                     | |^ ||              |
                char *(*fp)( int, float *);
                 ^   ^ ^  ||              |
                 |   | +--+|              |
                 |   +-----+              |
                 +------------------------+

Question we ask ourselves: What is fp?

“fp is a…

  • Moving in a spiral clockwise direction, the first thing we see is a `)’; therefore, fp is inside parenthesis, so we continue the spiral inside the parenthesis and the next character seen is the `*’, so…

    “fp is a pointer to…

  • We are now out of the parenthesis and continuing in a spiral clockwise direction, we see the `(‘; therefore, we have a function, so…

    “fp is a pointer to a function passing an int and a pointer to float returning…

  • Continuing in a spiral fashion, we then see the `*’ character, so…

    “fp is a pointer to a function passing an int and a pointer to float returning a pointer to…

  • Continuing in a spiral fashion we see the `;’, but we haven’t visited all tokens, so we continue and finally get to the type `char’, so…

    “fp is a pointer to a function passing an int and a pointer to float returning a pointer to a char”

Example #3: The “Ultimate”

                      +-----------------------------+
                      |                  +---+      |
                      |  +---+           |+-+|      |
                      |  ^   |           |^ ||      |
                void (*signal(int, void (*fp)(int)))(int);
                 ^    ^      |      ^    ^  ||      |
                 |    +------+      |    +--+|      |
                 |                  +--------+      |
                 +----------------------------------+

Question we ask ourselves: What is `signal’?

Notice that signal is inside parenthesis, so we must resolve this first!

  • Moving in a clockwise direction we see `(‘ so we have…

    “signal is a function passing an int and a…

  • Hmmm, we can use this same rule on `fp’, so… What is fp? fp is also inside parenthesis so continuing we see an `*’, so…

    fp is a pointer to…

  • Continue in a spiral clockwise direction and we get to `(‘, so…

    “fp is a pointer to a function passing int returning…”

  • Now we continue out of the function parenthesis and we see void, so…

    “fp is a pointer to a function passing int returning nothing (void)”

  • We have finished with fp so let’s catch up with `signal’, we now have…

    “signal is a function passing an int and a pointer to a function passing an int returning nothing (void) returning…

  • We are still inside parenthesis so the next character seen is a `*’, so…

    “signal is a function passing an int and a pointer to a function passing an int returning nothing (void) returning a pointer to…

  • We have now resolved the items within parenthesis, so continuing clockwise, we then see another `(‘, so…

    “signal is a function passing an int and a pointer to a function passing an int returning nothing (void) returning a pointer to a function passing an int returning…

  • Finally we continue and the only thing left is the word `void’, so the final complete definition for signal is:

    “signal is a function passing an int and a pointer to a function passing an int returning nothing (void) returning a pointer to a function passing an int returning nothing (void)”

The same rule is applied for const and volatile. For Example:

	const char *chptr;
  • Now, what is chptr??

    “chptr is a pointer to a char constant”

How about this one:

	char * const chptr;
  • Now, what is chptr??

    “chptr is a constant pointer to char”

Finally:

	volatile char * const chptr;
  • Now, what is chptr??

    “chptr is a constant pointer to a char volatile.”

—-
The original post was written by :

David Anderson

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s