How to interpret complex C/C + + statements

How to interpret complex C/C + + statements

Article catalog

I think many people have encountered declarations like int * (* fp1) (int) [10], or similar things you can't understand? This article will teach you to explain such complex C/C + + declarations, including the use of typing, const and function fingers.

order

Have you ever encountered something like this. int * (* (*fp1) (int) ) [10]; And can't understand? This article will teach you to explain the C/C + + declaration from easy to difficult, from simple c language declaration, const modifier, typedef modifier, function pointer, and finally to the "left and right rule". The purpose of this article is to help understand the declaration of c language. It is not recommended to follow the c programming specification like the code in this article.

1. Foundation

Let me start with a very simple example. Consider the statement:

int n;

Declare n as an int type

int *p;

Declare p as a pointer of type int, which the author suggests in the original text

int *p

instead of

int* p

This individual thinks that unification is good.

You can also declare pointers to pointers

char **argv;

In principle, there are no restrictions on the usage, which means that you can have a finger pointing to finger to finger, but usually the secondary pointer is difficult to understand.

Consider the following statement:

int RollNum[30][4];
int (*p)[4]=RollNum;
int *q[5];

p is declared as a pointer that points to an array of type int, the size of which is 4. If p + + is executed; Increase the value of p by 4*sizeof(int) q is declared as an array. The contents of the array store pointers. What pointers? All pointers point to data of type int.

2. const modifier

When you want to prevent modifying a variable (which seems contradictory), you can use the const keyword. When declaring a const variable in c language, you need to initialize the variable, otherwise it cannot be assigned elsewhere.

const int n=5;
int const m=10;

Two variables are of the same type - constant integer. This is because the C + + standard specifies that keywords can be placed before types or variable names. Personally, I prefer the former style because it makes the modifier clearer.

But const and pointers are relatively difficult to understand.

const int *p;
int const *q;

Which of them points to one and which points to one? In fact, they all point to int types. Both p and q point to const int, which means that the value pointing to the variable cannot be changed.

int * const r= &n; // n has been declared as an int

Here r is a const pointer, which points to n during initialization, so the following statement is illegal.

r=&m;

however

*r=4;

Yes. However, if the following statement is declared:

const int * const p=&n; // n has been declared as const int

English: declare a const pointer to a const int, the pointer is const, and the variable is const, which cannot be changed during operation. Only initialization can be assigned.

Some statements are listed below for reference:

char ** p1;                    //        pointer to       pointer to       char
const char **p2;               //        pointer to       pointer to const char
char * const * p3;             //        pointer to const pointer to       char
const char * const * p4;       //        pointer to const pointer to const char
char ** const p5;              //  const pointer to       pointer to       char
const char ** const p6;        //  const pointer to       pointer to const char
char * const * const p7;       //  const pointer to const pointer to       char
const char * const * const p8; //  const pointer to const pointer to const char

3. Subtleties of typedef

Look directly at the code:

typedef char * PCHAR;
PCHAR p,q;

Both p and q are defined as char * types.

Here are some usage methods and explanations of typedef:

typedef char * a;  // a is a pointer to a char

typedef a b();     // b is a function that returns
                   // a pointer to a char

typedef b *c;      // c is a pointer to a function
                   // that returns a pointer to a char

typedef c d();     // d is a function returning
                   // a pointer to a function
                   // that returns a pointer to a char

typedef d *e;      // e is a pointer to a function 
                   // returning  a pointer to a 
                   // function that returns a 
                   // pointer to a char

e var[10];         // var is an array of 10 pointers to 
                   // functions returning pointers to 
                   // functions returning pointers to chars.

typedef is also common in structure type definitions

typedef struct tagPOINT
{
    int x;
    int y;
}POINT;

POINT p; /*Valid C code */

4. Function pointer

Function pointers are relatively difficult to understand. In dos in primitive times, win32 in modern times and x-windows, it is often used in callback functions. Virtual function table in c + +, STL template, and Win NT/2K/XP system services, etc. A simple example of a function finger:

int (*p)(char);
void * (*a[5])(char * const, char * const);

Declare p as a pointer to a function whose parameter is char and return value is int

Declare a as an array of function pointers, and each element in the array points to a

Contains two char*const Pointer, return value is void*Function of

Function pointer to

5 left right rule

This is a simple rule that allows interpretation of any declaration. The specific explanations are as follows:

Read the statement from the innermost parentheses, go right, then left. When parentheses are encountered, the direction should be opposite. Once everything in parentheses has been parsed, it jumps out. Then continue until the entire declaration is resolved.

A note about the rules: the first time you start reading a declaration, you must start with the identifier, not the innermost parentheses.

give an example:

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

Click the following steps to start the process:

Start with identifier -------------------fp1
 On the right is ) ´╝îLook left and right, I found it*---fp1 Is a pointer
 Jump out()I met him later(int) ------------The pointer points to a function, one of which int parameter
 Look left, I found it * ---------------This function returns a pointer
 Jump out(), Look right, I found it [10] ----The returned pointer points to an array of 10 elements
 Look left, I found it * ---------------Array elements are pointers
 Look to the left, find int -------------Each array element points to int type

The anatomy is complete Complete explanation in English:

Start from the variable name -------------------------- fp1
Nothing to right but ) so go left to find * -------------- is a pointer
Jump out of parentheses and encounter (int) --------- to a function that takes an int as argument
Go left, find * ---------------------------------------- and returns a pointer
Jump put of parentheses, go right and hit [10] -------- to an array of 10
Go left find * ----------------------------------------- pointers to
Go left again, find int -------------------------------- ints.

declare fp1 as pointer to function (int) returning pointer to array 10 of pointer to int

Another exercise:

int *( *( *arr[5])())();
Start with identifier -----------------arr
 right,find[5] -----------------arr Is an array of 5 elements
 Look left, find * ---------------Each element is a pointer
 Jump out(), Look right, I found it() ------Each pointer points to a function, that is, the array element is a function pointer
 Look left, find * --------------- The function pointed to returns a pointer
 Jump out(), Look right, I found it() -------The return value points to the function
 Look left, find *  ---------------Function return pointer
 Keep looking left, find int ----------Pointer pointing int Type data.

The anatomy is complete Complete explanation in English:

Start from the variable name --------------------- arr
Go right, find array subscript --------------------- is an array of 5
Go left, find * ----------------------------------- pointers
Jump out of parentheses, go right to find () ------ to functions
Go left, encounter * ----------------------------- that return pointers
Jump out, go right, find () ----------------------- to functions
Go left, find * ----------------------------------- that return pointers
Continue left, find int ----------------------------- to ints.

declare arr as array 5 of pointer to function returning pointer to function returning pointer to int

List some complex c statements and explanations for learning:

float ( * ( *b()) [] )();              // b is a function that returns a 
                                       // pointer to an array of pointers
                                       // to functions returning floats.

void * ( *c) ( char, int (*)());       // c is a pointer to a function that takes
                                       // two parameters:
                                       //     a char and a pointer to a
                                       //     function that takes no
                                       //     parameters and returns
                                       //     an int
                                       // and returns a pointer to void.

void ** (*d) (int &, char **(*)(char *, char **));   // d is a pointer to a function that takes
                                       // two parameters:
                                       //     a reference to an int and a pointer
                                       //     to a function that takes two parameters:
                                       //        a pointer to a char and a pointer
                                       //        to a pointer to a char
                                       //     and returns a pointer to a pointer 
                                       //     to a char
                                       // and returns a pointer to a pointer to void

float ( * ( * e[10]) (int &) ) [5];    // e is an array of 10 pointers to 
                                       // functions that take a single
                                       // reference to an int as an argument 
                                       // and return pointers to
                                       // an array of 5 floats.

Original link: How to interpret complex C/C++ declarations

Added by quickstopman on Mon, 03 Jan 2022 02:20:52 +0200