struct with assignment

• The general arrow operator syntax. The left-hand operand is a pointer to a structure object, and the right-hand operator is the name of one of the object's fields.
• Examples illustrate the arrow operator based on the student examples in Figure 3(b).

Choosing the correct selection operator

• Choose the arrow operator if the left-hand operand is a pointer.
• Otherwise, choose the dot operator.

Moving Structures Within A Program

A basket is a convenient way to carry and move many items by holding its handle. Similarly, a structure object is convenient for a program to "hold" and move many data items with a single (variable) name. Specifically, a program can assign one structure to another (as long as they are instances of the same structure specification), pass them as arguments to functions, and return them from functions as the function's return value.

Assignment is a fundamental operation regardless of the kind of data involved. The C++ code to assign one structure to another is simple and should look familiar:

• C++ code defining a new structure object and copying an existing object to it by assignment.
• An abstract representation of a new, empty structure.
• An abstract representation of how a program copies the contents of an existing structure to another structure.

Function Argument

Once the program creates a structure object, passing it to a function looks and behaves like passing a fundamental-type variable. If we view the function argument as a new, empty structure object, we see that argument passing copies one structure object to another, behaving like an assignment operation.

• The first part of the C++ code fragment defines a function (similar to a Java method). The argument is a student structure. The last statement (highlighted) passes a previously created and initialized structure as a function argument.
• In this abstract representation, a program copies the data stored in s2 to the function argument temp . The braces forming the body of the print function create a new scope distinct from the calling scope where the program defines s2 . The italicized variable names label and distinguish the illustrated objects.

Function Return Value

Just as a program can pass a structure into a function as an argument, so it can return a structure as the function's return value, as demonstrated by the following example:

• C++ code defining a function named read that returns a structure. The program defines and initializes the structure object, temp , in local or function scope with a series of console read operations and returns it as the function return value. The assignment operator saves the returned structure in s3 .
• A graphical representation of the return process. Returning an object with the return operator copies the local object, temp , to the calling scope, where the program saves it in s1 .

• C Programming Tutorial
• Basics of C
• C - Overview
• C - Features
• C - History
• C - Environment Setup
• C - Program Structure
• C - Hello World
• C - Compilation Process
• C - Comments
• C - Keywords
• C - Identifiers
• C - User Input
• C - Basic Syntax
• C - Data Types
• C - Variables
• C - Integer Promotions
• C - Type Conversion
• C - Type Casting
• C - Booleans
• Constants and Literals in C
• C - Constants
• C - Literals
• C - Escape sequences
• C - Format Specifiers
• Operators in C
• C - Operators
• C - Arithmetic Operators
• C - Relational Operators
• C - Logical Operators
• C - Bitwise Operators
• C - Assignment Operators
• C - Unary Operators
• C - Increment and Decrement Operators
• C - Ternary Operator
• C - sizeof Operator
• C - Operator Precedence
• C - Misc Operators
• Decision Making in C
• C - Decision Making
• C - if statement
• C - if...else statement
• C - nested if statements
• C - switch statement
• C - nested switch statements
• C - While loop
• C - For loop
• C - Do...while loop
• C - Nested loop
• C - Infinite loop
• C - Break Statement
• C - Continue Statement
• C - goto Statement
• Functions in C
• C - Functions
• C - Main Function
• C - Function call by Value
• C - Function call by reference
• C - Nested Functions
• C - Variadic Functions
• C - User-Defined Functions
• C - Callback Function
• C - Return Statement
• C - Recursion
• Scope Rules in C
• C - Scope Rules
• C - Static Variables
• C - Global Variables
• Arrays in C
• C - Properties of Array
• C - Multi-Dimensional Arrays
• C - Passing Arrays to Function
• C - Return Array from Function
• C - Variable Length Arrays
• Pointers in C
• C - Pointers
• C - Pointers and Arrays
• C - Applications of Pointers
• C - Pointer Arithmetics
• C - Array of Pointers
• C - Pointer to Pointer
• C - Passing Pointers to Functions
• C - Return Pointer from Functions
• C - Function Pointers
• C - Pointer to an Array
• C - Pointers to Structures
• C - Chain of Pointers
• C - Pointer vs Array
• C - Character Pointers and Functions
• C - NULL Pointer
• C - void Pointer
• C - Dangling Pointers
• C - Dereference Pointer
• C - Near, Far and Huge Pointers
• C - Initialization of Pointer Arrays
• C - Pointers vs. Multi-dimensional Arrays
• Strings in C
• C - Strings
• C - Array of Strings
• C - Special Characters
• C Structures and Unions
• C - Structures
• C - Structures and Functions
• C - Arrays of Structures
• C - Self-Referential Structures
• C - Lookup Tables
• C - Dot (.) Operator
• C - Enumeration (or enum)
• C - Structure Padding and Packing
• C - Nested Structures
• C - Anonymous Structure and Union
• C - Bit Fields
• C - Typedef
• File Handling in C
• C - Input & Output
• C - File I/O (File Handling)
• C Preprocessors
• C - Preprocessors
• C - Pragmas
• C - Preprocessor Operators
• C - Header Files
• Memory Management in C
• C - Memory Management
• C - Memory Address
• C - Storage Classes
• Miscellaneous Topics
• C - Error Handling
• C - Variable Arguments
• C - Command Execution
• C - Math Functions
• C - Static Keyword
• C - Random Number Generation
• C - Command Line Arguments
• C Programming Resources
• C - Questions & Answers
• C - Quick Guide
• C - Cheat Sheet
• C - Useful Resources
• C - Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Structures in C

A structure in C is a derived or user-defined data type. We use the keyword struct to define a custom data type that groups together the elements of different types. The difference between an array and a structure is that an array is a homogenous collection of similar types, whereas a structure can have elements of different types stored adjacently and identified by a name.

We are often required to work with values of different data types having certain relationships among them. For example, a book is described by its title (string), author (string), price (double), number of pages (integer), etc. Instead of using four different variables, these values can be stored in a single struct variable.

Declare (Create) a Structure

You can create (declare) a structure by using the "struct" keyword followed by the structure_tag (structure name) and declare all of the members of the structure inside the curly braces along with their data types.

To define a structure, you must use the struct statement. The struct statement defines a new data type, with more than one member.

Syntax of Structure Declaration

The format (syntax) to declare a structure is as follows −

The structure tag is optional and each member definition is a normal variable definition, such as "int i;" or "float f;" or any other valid variable definition.

At the end of the structure's definition, before the final semicolon, you can specify one or more structure variables but it is optional .

In the following example we are declaring a structure for Book to store the details of a Book −

Here, we declared the structure variable book1 at the end of the structure definition. However, you can do it separately in a different statement.

Structure Variable Declaration

To access and manipulate the members of the structure, you need to declare its variable first. To declare a structure variable, write the structure name along with the "struct" keyword followed by the name of the structure variable. This structure variable will be used to access and manipulate the structure members.

The following statement demonstrates how to declare (create) a structure variable  

Usually, a structure is declared before the first function is defined in the program, after the include statements. That way, the derived type can be used for declaring its variable inside any function.

Structure Initialization

The initialization of a struct variable is done by placing the value of each element inside curly brackets.

The following statement demonstrates the initialization of structure  

Accessing the Structure Members

To access the members of a structure, first, you need to declare a structure variable and then use the dot (.) operator along with the structure variable.

The four elements of the struct variable book1 are accessed with the dot (.) operator . Hence, "book1.title" refers to the title element, "book1.author" is the author name, "book1.price" is the price, "book1.pages" is the fourth element (number of pages).

Take a look at the following example −

Run the code and check its output −

In the above program, we will make a small modification. Here, we will put the type definition and the variable declaration together, like this −

Note that if you a declare a struct variable in this way, then you cannot initialize it with curly brackets. Instead, the elements need to be assigned individually.

When you execute this code, it will produce the following output −

Copying Structures

The assignment (=) operator can be used to copy a structure directly. You can also use the assignment operator (=) to assign the value of the member of one structure to another.

Let's have two struct book variables, book1 and book2 . The variable book1 is initialized with declaration, and we wish to assign the same values of its elements to that of book2 .

We can assign individual elements as follows −

Note the use of strcpy() function to assign the value to a string variable instead of using the "= operator".

You can also assign book1 to book2 so that all the elements of book1 are respectively assigned to the elements of book2. Take a look at the following program code −

Structures as Function Arguments

You can pass a structure as a function argument in the same way as you pass any other variable or pointer.

Take a look at the following program code. It demonstrates how you can pass a structure as a function argument −

When the above code is compiled and executed, it produces the following result −

Pointers to Structures

You can define pointers to structures in the same way as you define pointers to any other variable.

Declaration of Pointer to a Structure

You can declare a pointer to a structure (or structure pointer) as follows −

Initialization of Pointer to a Structure

You can store the address of a structure variable in the above pointer variable struct_pointer . To find the address of a structure variable, place the '&' operator before the structure's name as follows −

Let's store the address of a struct variable in a struct pointer variable.

Accessing Members Using Pointer to a Structure

To access the members of a structure using a pointer to that structure, you must use the → operator as follows −

C defines the → symbol to be used with struct pointer as the indirection operator (also called struct dereference operator ). It helps to access the elements of the struct variable to which the pointer reference to.

In this example, strptr is a pointer to struct book book1 variable. Hence, strrptr→title returns the title, just like book1.title does.

When you run this code, it will produce the following output −

Note: The dot (.) operator is used to access the struct elements via the struct variable. To access the elements via its pointer, we must use the indirection (->) operator

A struct variable is like a normal variable of primary type, in the sense that you can have an array of struct, you can pass the struct variable to a function, as well as return a struct from a function.

You may have noted that you need to prefix "struct type" to the name of the variable or pointer at the time of declaration. This can be avoided by creating a shorthand notation with the help of typedef keyword, which we will explain in a subsequent chapter.

Structures are used in different applications such as databases, file management applications, and for handling complex data structures such as tree and linked lists.

Bit Fields allow the packing of data in a structure. This is especially useful when memory or data storage is at a premium. Typical examples include −

• Packing several objects into a machine word, for example, 1-bit flags can be compacted.
• Reading external file formats − non-standard file formats could be read in, for example, 9-bit integers.

Declaration

C allows us to do this in a structure definition by putting :bit length after the variable. For example −

Here, the packed_struct contains 6 members: Four 1 bit flags f1..f3, a 4-bit type and a 9-bit my_int.

C automatically packs the above bit fields as compactly as possible, provided that the maximum length of the field is less than or equal to the integer word length of the computer. If this is not the case, then some compilers may allow memory overlap for the fields while others would store the next field in the next word.

• C Data Types
• C Operators
• C Input and Output
• C Control Flow
• C Functions
• C Preprocessors
• C File Handling
• C Cheatsheet
• C Interview Questions

C Structures

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.

C Structure Declaration

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:

The above syntax is also called a structure template or structure prototype and no memory is allocated to the structure in the declaration.

C Structure Definition

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:

1. Structure Variable Declaration with Structure Template

2. structure variable declaration after structure template, access structure members.

We can access structure members by using the ( . ) dot operator.

In the case where we have a pointer to the structure, we can also use the arrow operator to access the members.

Initialize Structure Members

Structure members cannot be initialized with the declaration. For example, the following C program fails in the compilation.

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.

Default Initialization

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.

We can initialize structure members in 3 ways which are as follows:

• Using Assignment Operator.
• Using Initializer List.
• Using Designated Initializer List.

1. Initialization using Assignment Operator

2. initialization using initializer list.

In this type of initialization, the values are assigned in sequential order as they are declared in the structure template.

3. Initialization using Designated Initializer List

Designated Initialization allows structure members to be initialized in any order. This feature has been added in the C99 standard .

The Designated Initialization is only supported in C but not in C++.

Example of Structure in C

The following C program shows how to use structures

typedef for Structures

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.

Nested Structures

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:

1. Embedded Structure Nesting

In this method, the structure being nested is also declared inside the parent structure.

2. Separate Structure Nesting

In this method, two structures are declared separately and then the member structure is nested inside the parent structure.

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.

Accessing Nested Members

We can access nested Members by using the same ( . ) dot operator two times as shown:

Example of Structure Nesting

Structure pointer in c.

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.

Example of Structure Pointer

Self-referential structures.

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.

Example of Self-Referential Structures

Such kinds of structures are used in different data structures such as to define the nodes of linked lists, trees, etc.

C Structure Padding and Packing

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:

• Using #pragma pack(1)
• Using __attribute((packed))__

Example of Structure Padding and Packing

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.

Syntax of Bit Fields

 example of bit fields.

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’.

Uses of Structure in C

C structures are used for the following:

• The structure can be used to define the custom data types that can be used to create some complex data types such as dates, time, complex numbers, etc. which are not present in the language.
• It can also be used in data organization where a large amount of data can be stored in different fields.
• Structures are used to create data structures such as trees, linked lists, etc.
• They can also be used for returning multiple values from a function.

Limitations of C Structures

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.

• Higher Memory Consumption: It is due to structure padding.
• No Data Hiding: C Structures do not permit data hiding. Structure members can be accessed by any function, anywhere in the scope of the structure.
• Functions inside Structure: C structures do not permit functions inside the structure so we cannot provide the associated functions.
• Static Members: C Structure cannot have static members inside its body.
• Construction creation in Structure: Structures in C cannot have a constructor inside Structures.

Related Articles

• C Structures vs C++ Structure

Please Login to comment...

Similar reads.

• C-Structure & Union

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Intro to C for CS31 Students

Part 2: structs & pointers.

• Pointers and Functions C style "pass by referece"
• Dynamic Memory Allocation (malloc and free)
• Pointers to Structs

Defining a struct type

Declaring variables of struct types, accessing field values, passing structs to functions, rules for using pointer variables.

• Next, initialize the pointer variable (make it point to something). Pointer variables store addresses . Initialize a pointer to the address of a storage location of the type to which it points. One way to do this is to use the ampersand operator on regular variable to get its address value: int x; char ch; ptr = &x; // ptr get the address of x, pointer "points to" x ------------ ------ ptr | addr of x|--------->| ?? | x ------------ ------ cptr = &ch; // ptr get the address of ch, pointer "points to" ch cptr = &x; // ERROR! cptr can hold a char address only (it's NOT a pointer to an int) All pointer variable can be set to a special value NULL . NULL is not a valid address but it is useful for testing a pointer variable to see if it points to a valid memory address before we access what it points to: ptr = NULL; ------ ------ cptr = NULL; ptr | NULL |-----| cptr | NULL |----| ------ ------
• Use *var_name to dereference the pointer to access the value in the location that it points to. Some examples: int *ptr1, *ptr2, x, y; x = 8; ptr1 = NULL; ptr2 = &x; ------------ ------ ptr2 | addr of x|--------->| 8 | x ------------ ------ *ptr2 = 10; // dereference ptr2: "what ptr2 points to gets 10" ------------ ----- ptr2 | addr of x|--------->| 10 | x ------------ ----- y = *ptr2 + 3; // dereference ptr2: "y gets what ptr2 points to plus 3" ----- ----- ptr1 = ptr2; // ptr1 gets address value stored in ptr2 ------------ ----- ptr2 | addr of x |--------->| 10 | x ------------ ----- /\ ------------ | ptr1 | addr of x |-------------- ------------ // TODO: finish tracing through this code and show what is printed *ptr1 = 100; ptr1 = &y; *ptr1 = 80; printf("x = %d y = %d\n", x, y); printf("x = %d y = %d\n", *ptr2, *ptr1);
• and what does this mean with respect to the value of each argument after the call?
• Implement a program with a swap function that swaps the values stored in its two arguments. Make some calls to it in main to test it out.

malloc and free

Pointers, the heap, and functions, linked lists in c.

cppreference.com

Struct and union initialization.

When initializing an object of struct or union type, the initializer must be a non-empty, (until C23) brace-enclosed, comma-separated list of initializers for the members:

where the designator is a sequence (whitespace-separated or adjacent) of individual member designators of the form . member and array designators of the form [ index ] .

All members that are not initialized explicitly are empty-initialized .

[ edit ] Explanation

When initializing a union , the initializer list must have only one member, which initializes the first member of the union unless a designated initializer is used (since C99) .

When initializing a struct , the first initializer in the list initializes the first declared member (unless a designator is specified) (since C99) , and all subsequent initializers without designators (since C99) initialize the struct members declared after the one initialized by the previous expression.

It's an error to provide more initializers than members.

[ edit ] Nested initialization

If the members of the struct or union are arrays, structs, or unions, the corresponding initializers in the brace-enclosed list of initializers are any initializers that are valid for those members, except that their braces may be omitted as follows:

If the nested initializer begins with an opening brace, the entire nested initializer up to its closing brace initializes the corresponding member object. Each left opening brace establishes a new current object . The members of the current object are initialized in their natural order , unless designators are used (since C99) : array elements in subscript order, struct members in declaration order, only the first declared member of any union. The subobjects within the current object that are not explicitly initialized by the closing brace are empty-initialized .

If the nested initializer does not begin with an opening brace, only enough initializers from the list are taken to account for the elements or members of the member array, struct or union; any remaining initializers are left to initialize the next struct member:

[ edit ] Notes

The initializer list may have a trailing comma, which is ignored.

[ edit ] Example