Complicated Declarations in C | Understanding Complex Syntax

In C programming, complicated declarations can often be difficult to read, especially when involving pointers, arrays, and function pointers. However, by breaking them down systematically, they become easier to understand. Let’s go through some key concepts and examples.

1. Understanding Declaration Rules in C

C declarations follow the right-left rule:

1. Start with the identifier (variable name).
2. Look right first, then look left.
3. Apply precedence rules:
   • Parentheses () take the highest precedence.
   • Arrays [] come next.
   • Function () declarations follow.
   • Pointer * has the lowest precedence.

2. Examples of Complicated Declarations

Let’s analyze some complex C declarations:

a) Pointer to an integer

cCopyEditint *ptr;

• ptr is a pointer (*).
• It points to an integer (int).

b) Pointer to a pointer to an integer

cCopyEditint **ptr;

• ptr is a pointer to another pointer (*).
• The second pointer points to an integer (int).

c) Array of pointers to integers

cCopyEditint *arr[10];

• arr is an array of 10 elements ([10]).
• Each element is a pointer (*).
• The pointer points to an integer (int).

d) Pointer to an array of integers

cCopyEditint (*ptr)[10];

• ptr is a pointer (*).
• It points to an array of 10 integers ([10]).

e) Function returning a pointer to an integer

cCopyEditint *func();

• func is a function (()).
• It returns a pointer (*).
• The pointer points to an integer (int).

f) Pointer to a function returning an integer

cCopyEditint (*funcPtr)();

• funcPtr is a pointer (*).
• It points to a function (()).
• The function returns an integer (int).

Example Usage:

int myFunction() {
    return 42;
}

int main() {
    int (*funcPtr)();  // Pointer to function
    funcPtr = myFunction;  // Assign function address
    printf("%d", funcPtr());  // Call function via pointer
    return 0;
}

g) Array of pointers to functions returning integers

int (*funcArray[5])();

• funcArray is an array of 5 elements ([5]).
• Each element is a pointer (*).
• The pointer points to a function (()).
• The function returns an integer (int).

Example Usage:

cCopyEdit#include <stdio.h>

int add() { return 10; }
int subtract() { return 5; }

int main() {
    int (*funcArray[2])();  // Array of function pointers
    funcArray[0] = add;
    funcArray[1] = subtract;
    
    printf("%d\n", funcArray[0]());  // Output: 10
    printf("%d\n", funcArray[1]());  // Output: 5
    return 0;
}

h) Pointer to a function returning a pointer to an integer

int *(*funcPtr)();

• funcPtr is a pointer (*).
• It points to a function (()).
• The function returns a pointer (*).
• The pointer points to an integer (int).

Example Usage:

int value = 100;

int *getPointer() {
    return &value;
}

int main() {
    int *(*funcPtr)();  // Pointer to function returning int pointer
    funcPtr = getPointer;
    printf("%d", *funcPtr());  // Output: 100
    return 0;
}

3. How to Decode Complicated Declarations Easily

To break down a complex declaration:

1. Identify the variable name.
2. Apply precedence: () > [] > *.
3. Use the right-left rule:
   • Start from the variable name.
   • Read right first, then left.

For example:

int (*(*fp)())[10];

• fp is a pointer (*).
• It points to a function (()).
• The function returns a pointer (*).
• The pointer points to an array of 10 integers ([10]).

4. Using cdecl to Simplify Declarations

Instead of manually parsing complex declarations, you can use the cdecl tool:

Command-line Usage:

Then type:

explain int (*(*fp)())[10];

Output:

declare fp as pointer to function returning pointer to array[10] of int

Alternatively, to create declarations:

cdecl> declare ptr as pointer to function returning pointer to int

Output:

int *(*ptr)();

Conclusion

Complicated declarations in C can be intimidating, but by following precedence rules and breaking them down systematically, they become much easier to understand. Using tools like cdecl can also simplify the process.