Comment by colanderman

9 years ago

Way simpler: from inside out, read any subpart of the type as an expression. (Arrays have precedence over pointers, as usual.) The type that remains is that expression's type. So e.g. given the type:

    const char *foo[][50]

the following expressions have the following types:

     foo       -> const char *[][50]
     foo[0]    -> const char *  [50]
     foo[0][0] -> const char *
    *foo[0][0] -> const char

Another example:

    int (*const bar)[restrict]
    
      bar     -> int (*const)[restrict]
     *bar     -> int         [restrict]
    (*bar)[0] -> int

One more:

    int (*(*f)(int))(void)
    
        f        -> int (*(*)(int))(void)
      (*f)       -> int (*   (int))(void)
      (*f)(0)    -> int (*        )(void)
     *(*f)(0)    -> int            (void)
    (*(*f)(0))() -> int

(In this case, the last expression is more readily written as f(0)(), since pointers to functions and functions are called using the same syntax.)

What happened to the const in the second example?

  • The pointer itself is const; not what it points to.

        bar  -> const pointer to mutable array of ints
        *bar -> mutable array of ints
    

    And const pointers are dereferenced with * , not (* const), so the rule needs an exception for const pointers (as well as volatile pointers).

  • That const applies only to the bar symbol itself, not to anything it points to. So once bar is dereferenced, the const doesn't matter. The beauty of this method is that it predicts that correctly without having to think about it.

  • Yeah, I think they confused

      const *
    

    with

      * const

    • Nope, * const means that the identifier (i.e. thing to the right of the star) is const. That is, in this example, the symbol "bar" is const, not anything that it points to. So once you dereference it, the const no longer matters.

      3 replies →