The structure in C is a user-defined data type that can be used to group items of possibly different types into a single type. The struct keyword is used to define the structure in the C programming language. The items in the structure are called its member and they can be of any valid data type. Additionally, the values of a structure are stored in contiguous memory locations.
We have to declare structure in C before using it in our program. In structure declaration, we specify its member variables along with their datatype. We can use the struct keyword to declare the structure in C using the following syntax:
struct structure_name
data_type member_name1;
data_type member_name1;
.
.
>;
The above syntax is also called a structure template or structure prototype and no memory is allocated to the structure in the declaration.
To use structure in our program, we have to define its instance. We can do that by creating variables of the structure type. We can define structure variables using two methods:
struct structure_name
data_type member_name1;
data_type member_name1;
.
.
>variable1, varaible2, . ;
// structure declared beforehand
struct structure_name variable1, variable2, . ;
We can access structure members by using the ( . ) dot operator.
structure_name.member1;
strcuture_name.member2;
In the case where we have a pointer to the structure, we can also use the arrow operator to access the members.
Structure members cannot be initialized with the declaration. For example, the following C program fails in the compilation.
struct Point
int x = 0; // COMPILER ERROR: cannot initialize members here
int y = 0; // COMPILER ERROR: cannot initialize members here
>;
The reason for the above error is simple. When a datatype is declared, no memory is allocated for it. Memory is allocated only when variables are created.
By default, structure members are not automatically initialized to 0 or NULL. Uninitialized structure members will contain garbage values. However, when a structure variable is declared with an initializer, all members not explicitly initialized are zero-initialized.
struct Point
int x;
int y;
>;
struct Point p = ; // Both x and y are initialized to 0
We can initialize structure members in 3 ways which are as follows:
struct structure_name str;
str.member1 = value1;
str.member2 = value2;
str.member3 = value3;
.
.
.
struct structure_name str = < value1, value2, value3 >;
In this type of initialization, the values are assigned in sequential order as they are declared in the structure template.
Designated Initialization allows structure members to be initialized in any order. This feature has been added in the C99 standard .
struct structure_name str = < .member1 = value1, .member2 = value2, .member3 = value3 >;
The Designated Initialization is only supported in C but not in C++.
The following C program shows how to use structures
Struct 1: i = 1, c = A, f = 1.000000, s = GeeksforGeeks Struct 2: i = 1, c = A, f = 1.000000, s = GeeksforGeeks Struct 3 i = 5, c = a, f = 5.000000
The typedef keyword is used to define an alias for the already existing datatype. In structures, we have to use the struct keyword along with the structure name to define the variables. Sometimes, this increases the length and complexity of the code. We can use the typedef to define some new shorter name for the structure.
var1.a = 20 var2.x = 314
C language allows us to insert one structure into another as a member. This process is called nesting and such structures are called nested structures . There are two ways in which we can nest one structure into another:
In this method, the structure being nested is also declared inside the parent structure.
Example
struct parent
int member1;
struct member_str member2
int member_str1;
char member_str2;
.
>
.
>
In this method, two structures are declared separately and then the member structure is nested inside the parent structure.
Example
struct member_str
int member_str1;
char member_str2;
.
>
struct parent
int member1;
struct member_str member2;
.
>
One thing to note here is that the declaration of the structure should always be present before its definition as a structure member. For example, the declaration below is invalid as the struct mem is not defined when it is declared inside the parent structure.
struct parent
struct mem a;
>;
struct mem
int var;
>;
We can access nested Members by using the same ( . ) dot operator two times as shown:
str_parent.str_child.member;
var1.a = 25 var1.b.x = 195 var1.b.c = A
We can define a pointer that points to the structure like any other variable. Such pointers are generally called Structure Pointers . We can access the members of the structure pointed by the structure pointer using the ( -> ) arrow operator.
The self-referential structures in C are those structures that contain references to the same type as themselves i.e. they contain a member of the type pointer pointing to the same structure type.
struct structure_name
data_type member1;
data_type member2;
struct structure_name* str;
>
var2.mem1: 10 var2.mem2: 20
Such kinds of structures are used in different data structures such as to define the nodes of linked lists, trees, etc.
Technically, the size of the structure in C should be the sum of the sizes of its members. But it may not be true for most cases. The reason for this is Structure Padding.
Structure padding is the concept of adding multiple empty bytes in the structure to naturally align the data members in the memory. It is done to minimize the CPU read cycles to retrieve different data members in the structure.
There are some situations where we need to pack the structure tightly by removing the empty bytes. In such cases, we use Structure Packing. C language provides two ways for structure packing:
Size of str1: 8 Size of str2: 5
As we can see, the size of the structure is varied when structure packing is performed.
To know more about structure padding and packing, refer to this article – Structure Member Alignment, Padding and Data Packing .
Bit Fields are used to specify the length of the structure members in bits. When we know the maximum length of the member, we can use bit fields to specify the size and reduce memory consumption.
struct structure_name
data_type member_name: width_of_bit-field;
>;
Size of Str1: 8 Size of Str2: 4
As we can see, the size of the structure is reduced when using the bit field to define the max size of the member ‘a’.
C structures are used for the following:
In C language, structures provide a method for packing together data of different types. A Structure is a helpful tool to handle a group of logically related data items. However, C structures also have some limitations.
