Chapter 17 - Structs

Structs, short for "structures," are a foundational programming concept used in many programming languages. They allow developers to create complex data types that group related data under one entity. Unlike simple variables that store only one type of data (like an integer or a string), structs are composite types that can hold multiple data fields, potentially of varying types. Structs are particularly useful for organizing data logically and are a precursor to more advanced concepts like classes in object-oriented programming.

What are Structs?

At their core, structs are custom data types that group together variables (also called fields or members). These fields can represent different attributes of an entity or object. For instance, if you are creating a program to manage employee records, a struct could encapsulate related attributes like the employee's name, ID, age, and position.

Structs differ from classes in that they are typically value types rather than reference types, meaning they are usually stored directly in memory rather than as pointers to heap-allocated memory. This distinction makes structs more efficient for small, simple data groupings.

Structs can vary significantly across programming languages, but they all serve the purpose of logically grouping related data. Let’s examine how structs work in several programming languages.

How to Define and Use Structs

Structs are defined by specifying their name and the fields they contain. Each field has a name and a type. Here's a detailed look at how to define and use structs in different languages.

Python: Using NamedTuples and DataClasses

Python does not have a traditional struct, but it provides alternatives like collections.namedtuple and dataclasses to achieve similar functionality.

from collections import namedtuple

# Using namedtuple
Employee = namedtuple('Employee', ['name', 'id', 'age', 'position'])

employee1 = Employee(name='Alice', id=101, age=30, position='Engineer')
print(employee1.name)  # Output: Alice

# Using dataclass
from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    id: int
    age: int
    position: str

employee2 = Employee(name='Bob', id=102, age=35, position='Manager')
print(employee2.position)  # Output: Manager

PHP: Structs via Classes

PHP lacks a native struct but uses classes to achieve similar results.

<?php
class Employee {
    public string $name;
    public int $id;
    public int $age;
    public string $position;

    public function __construct(string $name, int $id, int $age, string $position) {
        $this->name = $name;
        $this->id = $id;
        $this->age = $age;
        $this->position = $position;
    }
}

$employee = new Employee('Alice', 101, 30, 'Engineer');
echo $employee->name; // Output: Alice

Go: Structs are First-Class Citizens

Go provides first-class support for structs and uses them extensively for creating data models.

package main

import "fmt"

type Employee struct {
    Name     string
    ID       int
    Age      int
    Position string
}

func main() {
    employee := Employee{Name: "Alice", ID: 101, Age: 30, Position: "Engineer"}
    fmt.Println(employee.Name) // Output: Alice
}

C++: Traditional Structs

In C++, structs are a cornerstone of data modeling. They are similar to classes but default to public access for members.

#include <iostream>
using namespace std;

struct Employee {
    string name;
    int id;
    int age;
    string position;
};

int main() {
    Employee employee = {"Alice", 101, 30, "Engineer"};
    cout << employee.name << endl; // Output: Alice
    return 0;
}

Zig: Simplicity in Structs

Zig, a modern low-level programming language, also provides robust struct support.

const std = @import("std");

const Employee = struct {
    name: []const u8,
    id: u32,
    age: u32,
    position: []const u8,
};

pub fn main() void {
    const employee = Employee{
        .name = "Alice",
        .id = 101,
        .age = 30,
        .position = "Engineer",
    };
    std.debug.print("{s}\n", .{employee.name}); // Output: Alice
}

Benefits of Structs in Programming

Structs bring several advantages to software development:

Organization: Structs group related data logically, making code more readable and maintainable.
Type Safety: Fields within a struct have defined types, reducing the risk of runtime errors.
Efficiency: Structs are value types in many languages, which can make them faster to use for small, fixed-size data structures.
Flexibility: They can be nested, allowing for complex data models.

When to Use Structs

Structs are ideal for situations where you need to encapsulate a fixed set of related attributes. Examples include:

Representing entities like employees, products, or vehicles.
Creating simple data-transfer objects.
Modeling geometric shapes or points.
Implementing lightweight data structures in performance-critical applications.

Advanced Usage of Structs

Nested Structs

Structs can contain other structs as fields, enabling more complex models.

Go Example:

package main

import "fmt"

type Address struct {
    City    string
    ZipCode int
}

type Employee struct {
    Name    string
    ID      int
    Age     int
    Address Address
}

func main() {
    employee := Employee{
        Name: "Alice",
        ID: 101,
        Age: 30,
        Address: Address{City: "New York", ZipCode: 10001},
    }
    fmt.Println(employee.Address.City) // Output: New York
}

Struct Methods

Many languages allow attaching methods to structs for additional functionality.

C++ Example:

#include <iostream>
using namespace std;

struct Employee {
    string name;
    int id;
    int age;
    string position;

    void display() {
        cout << "Name: " << name << ", Position: " << position << endl;
    }
};

int main() {
    Employee employee = {"Alice", 101, 30, "Engineer"};
    employee.display(); // Output: Name: Alice, Position: Engineer
    return 0;
}

Conclusion

Structs are a versatile and essential feature in many programming languages. By allowing developers to logically group related data, structs improve code organization, type safety, and efficiency. Whether you're working with lightweight data models or building the foundation for complex systems, understanding structs is a valuable skill that will serve you well across programming domains.

Last modified: 26 January 2025