Associativity of function call operator in C

Question

I was going through the topic of associativity of C operators.

There I came across this fact that the function call operator () has a left to right associativity. But associativity only comes to play when multiple operators of the same precedence occur in an expression. But I couldn't find any example involving function call operator where associativity plays a crucial role.

For example in the statement a = f(x) + g(x);, the result depends on the evaluation order and not on the associativity of the two function calls. Similarly the call f(g(x)) will evaluate function g() first and then the function f(). Here we have a nested function call and again associativity doesn't play any role.

The other C operators in this priority group are array subscript [], postfix ++ and postfix --. But I couldn't find any examples involving a combination of these operators with () where associativity plays a part in expression evaluation.

So my question is does the associativity of function call being defined as left to right affect any expression in C? Can anyone provide an example where the associativity of function call operator () does matter in expression evaluation?

Answer 1

Here is an example, where left-right associativity of function call operator matters:

#include <stdio.h>

void foo(void)
{
    puts("foo");
}

void (*bar(void))(void) // bar is a function that returns a pointer to a function
{
    puts("bar");
    return foo;
}

int main(void)
{
    bar()();

    return 0;
}

The function call:

bar()();

is equivalent to:

(bar())();

Answer 2

In addition to @GrzegorzSzpetkowski's answer, you can also have the following:

void foo(void) { }

int main(void) {
    void (*p[1])(void);
    p[0] = foo;
    p[0]();
    return 0;
}

This creates an array of function pointers, so you can use the array subscript operator with the function call operator.

Answer 3

The statement that function application associates to the left is entirely redundant in the C language definition. This "associativity" is implied by the fact that a function argument list appears right of the function expression itself and must be enclosed in parentheses. This means that for a given function expression, there can never be any doubt about the extent of its argument list: it extends from the obligatory opening parenthesis after the function expression to the matching closing parenthesis.

The function expression (which often is just an identifier, but may be more complicated) might itself be a (bare) function call, as in f(n)(1,0). (Of course this requires the value returned by f(n) to be something that can then be called with argument list (1,0), for which C has some possibilities and C++ a lot more, but these are semantic considerations that only come to play after parsing, so they should be ignored for the associativity discussion.) This means the syntax rule for function calls is left-recursive (the function part can itself be a function call); this may be formulated by saying "function calls associate to the left", but the fact is obvious. By contrast the right part (argument list) cannot be a (bare) function call because of the required parentheses, so there cannot be right recursion.

For instance consider (a)(b)(c) (where I put in redundant parenthesis in order to suggest symmetry and possible ambiguity). Here in itself (b)(c) might be taken to be the call of b (redundantly parenthesised) with argument c; however such a call cannot be construed to be the argument of a, since that would require additional parentheses as in (a)((b)(c)). So without any mention of associativity, it is clear that (a)(b)(c) can only mean that a is called with argument b, and the resulting value is called with argument c.