XQA
Back to C Programming
2025-12-089 min read

Member access operator

Learn Member access operator step by step with clear examples and exercises.

Why This Matters

In this extensive guide on member access operators in C programming, we aim to help you master the art of navigating complex data types like structures, unions, and arrays using the dot (.) and arrow (->) operators. Understanding these operators is crucial for writing efficient code, improving readability, and solving real-world coding problems.

Why This Matters

Member access operators play a significant role in C programming by providing an efficient and concise way to interact with members of structures, unions, and arrays. Mastering these operators will not only make your code more readable but also help you excel in competitive programming interviews and real-world coding scenarios.

Prerequisites

To fully grasp the concepts covered in this lesson, it is recommended that you have a good understanding of:

  1. Basic C syntax and variables
  2. Control structures (if-else, loops)
  3. Functions in C
  4. Pointers in C
  5. Structures and unions in C
  6. Arrays in C
  7. File I/O (optional but helpful for reading and writing structures)

If you're new to these concepts, consider checking our previous lessons on basic C syntax, control structures, functions, pointers, structures, unions, arrays, and file I/O before diving into this guide.

Core Concept

In C programming, member access operators (dot . and arrow ->) are used to access the members of structures, unions, and arrays. The dot operator is used with structures and unions, while the arrow operator is used with pointers pointing to structures or unions.

Structures and Unions

To illustrate the usage of member access operators with structures and unions, let's create a simple structure called Person:

struct Person {
int age;
char name[50];
};

Now, we can create an instance of this structure and use the dot operator to access its members:

struct Person person;
person.age = 25;
strcpy(person.name, "John Doe");

Similarly, with unions, we can define a union Details:

union Details {
int id;
char name[50];
};

And access its members using the dot operator:

union Details details;
details.name = "John Doe";

Structures with Arrays as Members

You can also define a structure member as an array by specifying the size within the brackets (e.g., int arr[10]; inside a structure). However, keep in mind that each instance of the structure will have its own copy of the array:

struct ArrayStruct {
int arr[5];
};

struct ArrayStruct myArray;
myArray.arr[0] = 1;
myArray.arr[1] = 2;
// ... and so on for the rest of the array members

Arrays

To use member access operators with arrays, we first need to create an array of structures or unions. For instance, let's create an array people of type struct Person:

struct Person people[3];

Now, we can access the members of each structure in the array using the dot operator:

people[0].age = 25;
strcpy(people[0].name, "John Doe");
people[1].age = 30;
strcpy(people[1].name, "Jane Smith");

Accessing Array Members with Pointers

You can also access array members using pointers. First, create a pointer to the first element of the array:

struct Person *personPtr = people;

Now, you can use the arrow operator to access the members:

personPtr->age = 25;
strcpy(personPtr->name, "John Doe");
personPtr++; // Move to the next element in the array

Pointers to Structures and Unions

To use the arrow operator with structures or unions, we first need to create a pointer to the structure or union and allocate memory for it:

struct Person *personPtr = (struct Person *)malloc(sizeof(struct Person));
union Details *detailsPtr = (union Details *)malloc(sizeof(union Details));

Now, you can access its members using the arrow operator:

personPtr->age = 25;
strcpy(personPtr->name, "John Doe");
detailsPtr->name = "John Doe";

Worked Example

Let's create a program that demonstrates the usage of member access operators with structures and arrays:

#include <stdio.h>
#include <string.h>
#include <stdlib.h> // for malloc()

struct Person {
int age;
char name[50];
};

void printPerson(struct Person person) {
printf("Age: %d, Name: %s\n", person.age, person.name);
}

int main() {
struct Person person;
struct Person *personPtr = (struct Person *)malloc(sizeof(struct Person));
struct Person people[3];

person.age = 25;
strcpy(person.name, "John Doe");
printPerson(person);

personPtr->age = 30;
strcpy(personPtr->name, "Jane Smith");
printPerson(*personPtr);

people[0].age = 25;
strcpy(people[0].name, "John Doe");
people[1].age = 30;
strcpy(people[1].name, "Jane Smith");

printf("First person in the array:\n");
printPerson(people[0]);
printf("Second person in the array:\n");
printPerson(people[1]);

free(personPtr); // don't forget to free memory allocated with malloc()

return 0;
}

When you run this program, it will output:

Age: 25, Name: John Doe
Age: 30, Name: Jane Smith
First person in the array:
Age: 25, Name: John Doe
Second person in the array:
Age: 30, Name: Jane Smith

Common Mistakes

  1. Forgetting to include the header file: Make sure you always include the necessary header files, such as `, `, or others depending on your code requirements.
  2. Incorrect structure member access: Ensure that you're using the correct member name and that it matches the structure definition.
  3. Array index out of bounds: Be careful not to access array elements outside their defined range, as this can lead to unexpected behavior or program crashes.
  4. Mismatched data types: Make sure that the data type you're using for a member in your structure matches the actual data being stored.
  5. Not initializing structures or arrays: Always initialize your structures and arrays before attempting to access their members to avoid undefined behavior.
  6. Leaking memory: When using dynamic memory allocation with malloc(), don't forget to free the allocated memory when it is no longer needed, as shown in our worked example.
  7. Using the arrow operator with structures or unions directly: The arrow operator should be used with pointers pointing to structures or unions, not with the structures or unions themselves.
  8. Confusing structure and union members: Be aware that each instance of a structure has its own copy of array members, while a union shares its memory among all instances.
  9. Not checking for null pointer: When using pointers, always check if they are not null before dereferencing them to avoid segmentation faults.
  10. Not handling errors gracefully: Always handle potential errors in your code, such as file I/O errors or memory allocation failures, to ensure robustness and prevent unexpected behavior.

Practice Questions

  1. Write a program that defines a union Details containing an integer and a character array, then creates an instance of the union and stores some data in it using member access operators.
  2. Create a structure called Student with members for name, roll number, and subject. Define an array of 5 students and store their details using member access operators. Print out the details of the first three students.
  3. Modify the previous exercise to include a function that calculates the average roll number of the first three students in the Student array.
  4. Write a program that creates a structure called Employee with members for name, age, and salary. Define an array of 10 employees and use member access operators to read their details from a file named "employees.txt". The file should contain one employee per line in the following format: "Name Age Salary".
  5. Write a program that creates a union called Date containing members for day, month, and year. Define an instance of the union and use member access operators to read a date from a user using scanf() function. Convert the entered date into a Julian date (the number of days elapsed since January 1, 4713 BC) and print it out.
  6. Write a program that creates a structure called Book with members for title, author, and publication year. Define an array of 10 books and use member access operators to read their details from a file named "books.txt". The file should contain one book per line in the following format: "Title Author Year".
  7. Write a program that creates a structure called Car with members for make, model, year, and mileage. Define an array of 5 cars and use member access operators to read their details from a file named "cars.txt". The file should contain one car per line in the following format: "Make Model Year Mileage".
  8. Write a program that creates a structure called Point with members for x-coordinate and y-coordinate. Define an array of 10 points and use member access operators to read their details from a file named "points.txt". The file should contain one point per line in the following format: "X Y".
  9. Write a program that creates a union called Color containing members for red, green, and blue components. Define an instance of the union and use member access operators to read RGB values from a user using scanf() function. Convert the entered RGB values into a single integer representing the color in RGB format (e.g., 0xFF00FF for magenta) and print it out.
  10. Write a program that creates a structure called Rectangle with members for width, height, x-coordinate, and y-coordinate. Define an array of 5 rectangles and use member access operators to read their details from a file named "rectangles.txt". The file should contain one rectangle per line in the following format: "Width Height X Y". Calculate the area of each rectangle and store it in another array. Then, sort the rectangles based on their areas and print out the details of the top 3 rectangles with the largest areas.

FAQ

  1. Can I use the dot operator with arrays? No, the dot operator is used for structures and unions, not arrays. To access elements in an array, you should use indexing (e.g., arr[i]).
  2. What happens if I try to access a non-existent member in a structure or union using the dot operator? Accessing a non-existent member will result in undefined behavior, which can lead to program crashes or unexpected results.
  3. Can I use the arrow operator with structures and unions directly? No, the arrow operator is used with pointers pointing to structures or unions. You first need to create a pointer to a structure or union and then use the arrow operator to access its members.
  4. Is it possible to have a structure member that is an array? Yes, you can define a structure member as an array by specifying the size within the brackets (e.g., int arr[10]; inside a structure). However, keep in mind that each instance of the structure will have its own copy of the array.
  5. Can I use both the dot and arrow operators with the same structure or union? Yes, you can use both operators with the same structure or union, but they are used differently: the dot operator is used with structures or unions directly, while the arrow operator is used with pointers pointing to structures or unions.
  6. Is it possible to define a pointer to an array of structures? Yes, you can define a pointer to an array of structures by using two indirection operators (*) and specifying the structure type followed by the array size in square brackets (e.g., struct Person (*people)[3]).
  7. What is the difference between a structure with an array member and an array of structures? A structure with an array member contains a single array that belongs to each instance of the structure, while an array of structures contains multiple instances of the structure, each with its own members.
  8. Can I use a pointer to access elements in an array of structures? Yes, you