Specify the concept of initializer

C90 The standard requires that the elements in the initialization program appear in a fixed order , In the same order as the elements in the array or structure to be initialized . But in the new standard C99 in , Added a new feature ： Specify initializer . Using this feature, you can initialize the specified array or structure element .

The specified initializer of the array

The specified initializer of a one-dimensional array

Use the properties of the specified initializer , We can define and initialize an array like this ：

1. int a[6] = {[4] = 10,[2] = 25};

The above initialization is equivalent to the following way ：

1. int a[6] = {0,0,25,0,10,0};

You can see that in this way, you can not follow the order , And specify specific elements for initialization . In addition to the above usage , We can also initialize a range of elements in the array （ Notice this is GCC Extended syntax for , instead of C99 Standards for ）, Such as this ：

1. int a[5] = {[4] = 10,[0 ... 3] = 23};

The initialization of the above program is equivalent to the following initialization ：

1. int a[5] = {23,23,23,23,10};

If there are specified elements in array initialization and unspecified elements in array initialization, how to analyze them ？ Such as this ：

1. int a[5] = {11,[3] = 44,55,[1] = 22,33};

Then it is equivalent to the following code ：

1. int a[5] = {11,22,33,44,55};

If the size of the array is not specified when defining the array , What is the actual size of the array ？ Such as this ：

1. int main(void)

2. {

3. int number[] = {[20] = 1,[10] = 8,9};

4. int n = sizeof(number)/sizeof(number[0]);

5. printf("The Value of n is:%d\n",n);

6. }

The output is like this ：

1. The Value of n is:21

in other words , If the size of the array is not given , The maximum initialization position determines the size of the array

The specified initializer of a two-dimensional array

Two dimensional arrays can also use the method of specifying initializers , The following is the initialization of a two-dimensional array ：

1. int array[2][2] =

2. {

3. [0] = {[0] = 11},

4. [1] = {[1] = 22},

5. };

Such initialization is equivalent to the following code ：

1. int array1[2][2] =

2. {

3. {11,00},

4. {00,22}

5. };

By the above code , We can also know , In the method of specifying initializer of two-dimensional array , first [] The number in represents the number of rows of the initialized two-dimensional array , And in the {} The inside initializes the elements of the current line , Actually, that is to say {} The initialization method in is the same as that of one-dimensional array , A feasible way of one-dimensional array , Two dimensional arrays are also feasible .

application

After describing the basic concept of array specifying initializer , Let's take a concrete example , The following example is based on the programming method of state machine ATM machine , First ATM It has the following states ;

We can use the idea of state machine to write this program , First, use enumeration to define each state and corresponding operation ：

1. typedef enum

2. {

3. Idle_State,

4. Card_Inserted_State,

5. Pin_Entered_State,

6. Option_Selected_State,

7. Amount_Entered_State,

8. last_State

9. }eSysyemState;

11. typedef enum

12. {

13. Card_Insert_Event,

14. Pin_Enter_Event,

15. Option_Selection_Event,

16. Amount_Enter_Event,

17. Amount_Dispatch_Event,

18. last_Event

19. }eSystemEvent;

Then there is the specific implementation of the corresponding operation ：

1. eSysyemState AmountDispatchHandler(void)

2. {

3. return Idle_State;

4. }

6. eSysyemState EnterAmountHandler(void)

7. {

8. return Amount_Entered_State;

9. }

11. eSysyemState OptionSelectionHandler(void)

12. {

13. return Option_Selected_State;

14. }

16. eSysyemState InsertCardHandle(void)

17. {

18. return Card_Inserted_State;

19. }

21. eSysyemState EnterPinHandler(void)

22. {

23. return Pin_Entered_State;

24. }

To make the implementation of the state machine look less verbose , We use the way of looking up tables here , First redefine a function pointer two-dimensional array type ：

1. typedef eSysyemState (* const afEventHandler[last_State][last_Event])(void);

Simply put, this is a two-dimensional array , The function pointer is stored in the two-dimensional array , This function pointer points to the return value of eSysyemState, The formal parameter is void Function of . After redefining the type , We can use it to define new variables , before this , Add a little bit of array related content , For example, there is the following code ：

1. typedef int array[3];

2. array data;

Then the above code is equivalent to the following code ：

1. int data[3];

With the above code , We can implement our lookup table , The specific code is as follows ：

1. static afEventHandler StateMachine =

2. {

3. [Idle_State] = {[Card_Insert_Event] = InsertCardHandle},

4. [Card_Inserted_State] = {[Pin_Enter_Event] = EnterPinHandler },

5. [Pin_Entered_State] = {[Option_Selection_Event] = OptionSelectionHandler},

6. [Option_Selected_State] = {[Amount_Entered_Event] = EnterAmountHandler},

7. [Amount_Entered_State] = {[Amount_Dispatch_Event] = AmountDispatchHandler},

8. };

Now let's look at the initialization method, which is more clear , This is actually a method of parsing a two-dimensional array using the specified initializer , Last , That is, our state machine running code ：

1. #include <stdio.h>

3. int main(void)

4. {

5. eSysyemState eNextState = Idle_State;

6. eSystemEvent eNewEvent;

7. while(1)

8. {

9. eNewEvent = ReadEvent();

10. /* Omit relevant judgment */

11. eNextState = (*StateMachine[eNextState][eNewEvent])();

12. }

13. return 0;

14. }

The specified initializer of the structure

The following structures are defined ：

1. struct point

2. {

3. int x,y;

4. }

Then the initialization of structure variables can be done in the following ways ：

1. struct point p =

2. {

3. .y = 2,

4. .x = 3

5. };

The above code is equivalent to the following code ：

1. struct point p = {3,2};

What's the use of such initialization ？ Here is linux A piece of kernel code ：

1. const struct file_operations eeprom_fops =

2. {

3. .llseek = eeprom_lseek,

4. .read = eeprom_read,

5. .write = eeprom_write,

6. .open = eeprom_open,

7. .release = eeprom_close

8. };

The above is to initialize by specifying the initializer , among file_operations There are many members in this structure , The above initialized members are only part of them ,

1. struct file_operations {

2. struct module *owner;

3. loff_t (*llseek) (struct file *, loff_t, int);

4. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

5. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

6. int (*open) (struct inode *, struct file *);

7. int (*flush) (struct file *, fl_owner_t id);

8. int (*release) (struct inode *, struct file *);

9. /* There are still a lot of it , Omit */

10. }

Using this method of specifying initializers , Flexible use , And the code is easy to maintain . Because if you assign values in a fixed order , When our file_operations When the structure type changes , For example, add members 、 Reduction of membership 、 Adjust membership order , Then use this structure type to define a large number of variables C Files need to be re initialized , That will lead to substantial changes in the program .

The specified initializer of the structure array

After describing the above specified initializers for structures and arrays , We can also initialize the structure array in this way , Such as this ：

1. #include <stdio.h>

2. int main(void)

3. {

4. struct point {int x,y;};

5. struct point pts[5] =

6. {

7. [2].y = 5,

8. [2].x = 6,

9. [0].x = 2

10. };

11. int i;

12. for(i = 0;i < 5;i++)

13. printf("%d %d\n",pts[i].x,pts[i].y);

14. }

The output is as follows ：

1. 2 0

2. 0 0

3. 6 5

4. 0 0

5. 0 0

summary

The above is the general content of the specified initializer , This is also the blind spot of my previous knowledge , Through this summary, learn , Can also be a good grasp of , Short step , A thousand miles ～

Reference material ：

[1] https://blog.51cto.com/zhaixue/2346825

[2] https://www.geeksforgeeks.org/designated-initializers-c/

[3] https://aticleworld.com/state-machine-using-c/

Your reading is my greatest encouragement , Your suggestion is the biggest promotion for me