Shulou(Shulou.com)06/02 Report--

This article mainly introduces the example analysis of enumerations and unions in C language, which has a certain reference value. Interested friends can refer to it. I hope you can learn a lot after reading this article.

Enumerate

What is enumeration?

As the name implies, it is to enumerate one by one, enumerate all the cases, all the values one by one.

There are many things that can be listed in our lives.

For example, there are seven days in a week, twelve months in a year, male and female in gender, excellent, good, passing and failing in evaluation, and so on.

We can use enumerated types when the values of some data have only a fixed number of possible values.

Definition of enumerated types

Enum enumeration type name {enumeration value 1, enumeration value 2,... , enumerated value n}

The definition of an enumerated type is similar to a structure, using the keyword enum, followed by the name of the enumerated type, the enumerated value in parentheses, and finally, don't forget the semicolon.

Also, you don't need a comma after the last enumeration value!

The general methods to define enumerated types are as follows:

Note: this defines enumerated types, not enumerated variables!

For example, the following:

Enum Day// week {Mon, Tues, Wed, Thur, Fri, Sat, Sun}; enum Sex// gender {MALE, FEMALE, SECRET}; enum Color// color {RED, GREEN, BLUE}

In addition, there are other methods of definition.

Advantages of enumerated types

So let's think about the question, why do we need enumerations?

We can actually define constants in the way # define, so do we still need to define enumerations?

Actually, it is necessary.

In some cases, enumerations can make our code clearer.

For example, when we need to print a menu, we need to have different options, so each option corresponds to a value, then we can use enumeration to match the value with the corresponding meaning, so that we can know the specific meaning of this case situation when we implement each specific detail.

Besides, there are other advantages:

Prevent naming contamination (encapsulation)

Easy to debug

Easy to use and can define multiple constants at a time

Use of enumerated types

By enumerating types, we can define enumerated variables

Enum Color// colors {RED, GREEN, BLUE}; / / use methods and other types all the time, just like int a; enum Color clr;// uses enumerated values to assign values to enumerated types clr = RED;// Note: generally, when we assign values to enumerations, we use enumerated values instead of other values, otherwise it doesn't make any sense

We usually use structures like the chestnuts above.

First create a template for enumerations and burn this template to create variables.

In addition, there are other ways:

Define enumerated variables while creating a template

Enum Color// color {RED, GREEN, BLUE} clr1,clr2;// in the end, we define two enumerated variables

Omit enumerated type names and create enumerated variables anonymously

Enum {RED, GREEN, BLUE} clr1,clr2;// two enumerated variables are defined here

The above two variables can still be used, but we can only define variables in this way without writing the name of the enumerated type. We can no longer use this template to create variables.

Use typedef to rename enumerated types

Typedef enum Color// color {RED, GREEN, BLUE} cr;// Note: cr here is a new enumeration type name, not a defined enumeration variable / / you can also anonymously rename points in the typedef enum {RED, GREEN, BLUE} cr; enumeration that need to be noted.

Enumerated values can only be integer data, such as characters, integers, etc., and cannot be floating point

When enumerating type variables are assigned, enumerated values are generally used to assign values, but other values are not suitable for assignment.

The enumeration value itself is a constant. We can modify the value of the enumeration variable, but not the enumeration value.

When enumerated values are processed, they are treated as integer values, so enumerated variables can be arithmetic, relational, and so on.

The definition of the type of association

Union consortium type name {data type member name 1, data type member name 2,... , data type member name n;}

A federation is also called a common body, and this is also a special data type.

Variables defined by this type also contain a series of members, characterized by the fact that these members share the same space.

The chestnuts are as follows:

Characteristics of union Un {char c; int i;}; consortium

Members of federated variables use a common piece of space.

The size of the consortium is at least the size of the largest member of the member.

(at least we'll talk about it later.)

Is the output of # includeunion Un {int i; char c;}; union Un un;int main () {/ / the same? Printf ("% p\ n", & un); printf ("% p\ n", & (un.i)); printf ("% p\ n", & (un.c)); return 0;}

Run the above code and we will find that all three addresses are the same

The member variable I is the first member, and the address is the same as the address of the consortium. We can understand that c, as the second member variable, its address is also the same as the address of the first member variable, so this means that they do use the same space.

The use of consortia

There are many ways to define variables by union types, similar to structures and enumerations.

Create a template first, and then define the variable

Union Un {int i; char c;}; union Un un

Define variables while creating a template

Union Un {int i; char c;} un;// where un is a union variable

Anonymously define union variables

Union {int i; char c;} un;// where un is a union variable

Similarly, because of the omission of the union type name, we can only define variables in this way, and we can no longer use this template to define variables

Typedef rename consortium type name

Memory alignment exists in typedef union Un {int i; char c;} un;typedef union {int i; char c;} un; consortium

As mentioned above, the size of the union is at least the size of the largest member variable. Why at least?

Let's first take a look at the following chestnuts:

Is the output of union Un {char arr [6]; short s;}; union Un uttingint main () {/ / the same? Printf ("u", sizeof (union Un)); return 0;}

The output of the above code is 6

If we change the size of the character array to 5, we will find that the size is still 6.

This is because there is also alignment in the consortium.

In the chestnut above, it would be considered that the default alignment of the character array is 1, while short defaults to its digit 2, but the size of the member variable is calculated based on the size of the array, not on the element type of the array. If you are a character array with 6 elements, then the size is 6, the number of elements is 5, the size is 5, and int, short and other data types are calculated according to the default size.

First of all, the size of the union needs to be at least the size of the largest member variable.

Then the size should be a multiple of the maximum alignment of each member variable, if not a multiple, then align to an integer multiple.

This explains why when the above code changes the size of the character array to five elements, the size of the union is still 6. 5.

Thank you for reading this article carefully. I hope the article "enumeration in C language and sample Analysis of consortia" shared by the editor will be helpful to everyone. At the same time, I also hope that you will support and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.