Structures in C++

Data is the lifeblood of our applications in programming and structures in C++ emerge as the sculptors of organization and clarity. But what exactly are these structures, and why are they so valuable in the C++ toolkit?

In this tutorial, I will discuss the mechanics of creating, using, and manipulating structures in C++. We will also cover advanced concepts like nested structures, bit fields, and unions that will help you harness the full potential of structures in your C++ programs.

What Are Structures in C++?

Let us consider a situation where we need to represent a student in our program. This student has a name, an age, a grade point average, and a major. Instead of declaring separate variables for each of these attributes, we can group them together into a single, cohesive unit called a structure.

Data structures in C and C++ are user-defined data types that act as a blueprint for creating complex data objects. These data structures in C++ allow us to bundle together variables of different types under a single, meaningful name. This not only makes our code more organized but also enhances its readability by clearly defining the relationships between data elements.

Why Use Structures in C++?

Structures in C++ offer numerous advantages in programming:

• Organization: Structures in C++ group related data items together, making our code more structured and easier to manage. Instead of scattered variables, we have a single entity representing a concept like a "student," "employee," or "product."
• Readability: By using C++ data structures, we create a self-documenting code that clearly expresses the relationships between data elements. This makes our code easier to understand for both yourself and other developers.
• Data modeling: Structures provide a natural way to model real-world entities and concepts within our code. We can create structures to represent people, places, objects, or even abstract ideas.
• Efficiency: Passing structures in C++ to functions can be more efficient than passing multiple individual variables, as it reduces the overhead of passing arguments.

The Role of Structures in C++

Structures play a vital role in the C++ type system. They are similar to classes in many ways, but with a few key differences. By default, all members of a structure are public, meaning they can be accessed and modified directly from outside the structure. This makes structures ideal for simple data containers where encapsulation is not a primary concern.

Structures in C++ serve as the foundation for more complex data structures and algorithms. We can use structures to build arrays, linked lists, trees, and other data structures, creating a rich and flexible framework for managing your data.

Declaring and Defining Structures in C++

Now that we have grasped the essence of structures, let us explore how to create them in C++. Think of this process as drafting blueprints for our data, meticulously defining the shapes and sizes of the individual components that will ultimately come together to form a cohesive whole.

Syntax of Structures in C++

The declaration and definition of a structure follow a straightforward syntax:

struct StructureName {
dataType member1;
dataType member2;
// ... more members
};

Let's break down this basic structure of C++ syntax:

1. struct keyword: The struct keyword signals to the compiler that we are defining a structure.
2. StructureName: This is our chosen name for the structure. By convention, CPP struct names in C++ usually start with a capital letter and use PascalCase (e.g., Student, ProductInfo, BankAccount).
3. Curly braces {}: The curly braces enclose the list of member variables that make up the structure.
4. Member variables: Each line within the curly braces declares a member variable, specifying its data type and name.

Member Variables

Member variables are the individual components of our structure. They represent the various attributes or pieces of information we want to store together. C++ offers tremendous flexibility in choosing member variable types:

• Built-in types: int, float, double, char, bool, etc.
• Arrays: int grades[5];
• Pointers: int* ptr;
• Other structures: We can even nest structures within structures to create hierarchical data organizations.

Naming Conventions for Structures in C++

While C++ does not enforce strict naming conventions for structures, following established guidelines can significantly improve code readability and maintainability.

• Structure names: Use PascalCase (e.g., BankAccount, CustomerRecord). This distinguishes structure names from variable names.
• Member names: Use descriptive names that accurately reflect the purpose of each member (e.g., firstName, lastName, accountBalance). Consider using camelCase (e.g., dateOfBirth) or snake_case (e.g., date_of_birth).

(Example) Defining a Student structure:

struct Student {
std::string name;
int age;
double gpa;
std::string major;
};

In this C++ struct example, we define a Student structure with members for name, age, GPA, and major. Now that we have laid the groundwork, we can move on to creating instances of this structure and accessing its members, which we will explore in the next section.

If you wish to learn how to code in C++ and other concepts such as C++ control structures, you can check out upGrad’s software engineering courses.

Accessing and Modifying Structure Members

Once we have meticulously crafted our structure blueprints, it is time to breathe life into them by creating instances (variables) of our structures and accessing the valuable data they hold. C++ offers a variety of techniques for accessing, modifying, and initializing the members within these structures.

The Dot (.) Operator

The simplest way to access a member of a structure variable is through the dot operator (.). This operator acts as a bridge, connecting the structure variable to its individual components.

Example:

Student student1; // Declare a variable of type Student
student1.name = "Alice"; // Assign a value to the name member
student1.age = 20; // Assign a value to the age member
std::cout << student1.gpa; // Access the gpa member

In this example, student1 is an instance of the Student structure. We use the dot operator to set the name and age members and to retrieve the value of the gpa member.

Structure Pointers and the Arrow (->) Operator

When dealing with pointers to structures, the arrow operator (->) becomes our trusty companion. It is a shorthand for dereferencing the pointer and then accessing the member using the dot operator.

Example:

Student student2;
Student* ptr = &student2; // Create a pointer to student2
ptr->name = "Bob"; // Equivalent to (*ptr).name = "Bob";
ptr->age = 22; // Equivalent to (*ptr).age = 22;
std::cout << ptr->gpa; // Equivalent to (*ptr).gpa;

Initialization of Structures in C++

C++ provides multiple ways to initialize structure variables:

1. Direct initialization: Assign values to members directly within curly braces during declaration.

Example:

Student student3 = {"Carol", 21, 3.8, "Computer Science"};

2. Member-by-member initialization: Assign values to each member individually after declaration.

Example:

Student student4;
student4.name = "David";
student4.age = 19;
// ... and so on

3. Aggregate initialization: A more concise syntax that allows you to initialize members without specifying their names.

Example:

Student student5{"Emily", 20, 3.5, "Engineering"};

Nested Structures

Sometimes, the data we need to model has a hierarchical structure. Nested structures allow us to represent these relationships within our code.

Example:

struct Address {
std::string street;
std::string city;
std::string state;
};
struct Student {
std::string name;
int age;
double gpa;
std::string major;
Address address; // Nested structure
};
Student student6;
student6.address.street = "123 Main St";

Structures in C++ and Functions

Structures in C++ become even more powerful when combined with functions. This dynamic duo allows us to encapsulate data and the operations that act upon it, leading to modular and well-organized code. Let us explore how structures and functions interact in C++.

Passing Structures in C++ to Functions

We can pass structures as arguments to functions, just like we would with any other data type. There are two primary ways to do this:

1. Passing by value: A copy of the entire structure is made and passed to the function. Any modifications made to the structure within the function will not affect the original structure.

Example:

void printStudent(Student s) { // Pass by value
std::cout << s.name << ", " << s.age << std::endl;
}

2. Passing by reference: A reference to the original structure is passed to the function. Any modifications made to the structure within the function will directly affect the original structure.

Example:

void updateGPA(Student& s, double newGPA) { // Pass by reference
s.gpa = newGPA;
}

Use pass by value when you want to protect the original structure from changes. Use pass by reference when you want the function to modify the original structure.

Returning Structures in C++ from Functions

Functions can also return structures in C++ as their output. Again, we have two choices:

1. Returning by value: A copy of the structure is created and returned from the function. This is suitable for small structures where the overhead of copying is negligible.

Example:

Student createStudent(std::string name, int age, double gpa, std::string major) {
Student s {name, age, gpa, major};
return s; // Return by value (copy created)
}

2. Returning by reference: A reference to the original structure is returned. This is more efficient for large structures, as it avoids the overhead of copying.

Example:

Student& getTopStudent(std::vector<Student>& students) {
// ... logic to find the top student ...
return students[0]; // Return by reference
}

We should be cautious when returning by reference, as it exposes the internal state of the structure to potential modification outside the function.

Structure Arrays

Often, we will need to work with multiple instances of a structure. Structure arrays provide a convenient way to store and manage collections of structured data.

Example:

Student students[3]; // Array of 3 Student structures
students[0] = {"Alice", 20, 3.8, "Computer Science"};
students[1] = {"Bob", 22, 3.5, "Engineering"};
students[2] = {"Carol", 19, 3.9, "Mathematics"};
for (const Student& s : students) {
printStudent(s);
}

In this CPP struct example, we create an array of three Student structures and then iterate through the array to print the details of each student.

Note: We can also use the list data structure C++ to work with a list of students.

Structure of C++ With Example Program

#include <iostream>
#include <string>
struct Student { // Structure declaration
std::string name;
int age;
double gpa;
};
// Function to print student information
void printStudent(const Student &s) {
std::cout << "Name: " << s.name << std::endl;
std::cout << "Age: " << s.age << std::endl;
std::cout << "GPA: " << s.gpa << std::endl;
}
int main() {
Student student1; // Declare a Student structure variable
student1.name = "Alice"; // Initialize its members
student1.age = 20;
student1.gpa = 3.8;
printStudent(student1); // Call the function to print details
return 0;
}

In the above C++ program structure, the Student structure is defined to hold information about a student. The printStudent function takes a Student object as a parameter (by reference to avoid copying) and prints its details.

Final Tips

Structures in C++ are powerful tools for organizing and representing complex information in our C++ programs if we know how to use them properly. By understanding the access and initialization techniques discussed in this guide, you can effectively manipulate the data within your structures.

If you wish to learn programming languages such as C++, you can check out upGrad’s computer science programs such as the Master’s in Computer Science Program.

Frequently Asked Questions

What is a structure in C++?

A structure is a user-defined data type that groups together related variables (members) of potentially different types under a single name.

How do you declare a structure in C++?

You declare a structure using the struct keyword, followed by the structure name, and then enclose the member declarations within curly braces.

Can you have functions inside a C++ structure?

Yes, C++ structures can contain both member variables (data) and member functions (methods).

How do you access members of a structure in C++?

You can access members using the dot (.) operator for objects or the arrow (->) operator for pointers to objects.

What is the difference between a structure and a class in C++?

The main difference is the default access specifier. Members of a structure are public by default, while members of a class are private by default.

How do you initialize a structure in C++?

You can initialize a structure in several ways, including direct initialization, member-by-member initialization, and aggregate initialization (available in C++11 and later).

What is the size of a structure in C++?

The size of a structure is the sum of the sizes of its members, potentially with padding added for alignment purposes.

Can structures contain other structures in C++?

Yes, you can nest structures within other structures to create hierarchical data organizations.