A Comprehensive Guide to Swift Structs: Everything You Need to Know

Swift is a powerful and intuitive programming language that allows developers to write clean and efficient code. One of the key features of Swift is its support for structs, which provide a lightweight way to define custom data types.

In this blog, you'll dive deep into Swift structs, their syntax, use cases, and how they differ from classes. By the end of this article, you'll have a strong understanding of how to use structs effectively in your Swift projects.

What Are Swift Structs?

In Swift, a struct is a value type that allows you to define a blueprint for a custom data type. Unlike classes, which are reference types, Swift structs store copies of values rather than references. This means that when you create an instance of a struct and pass it around, a copy is made each time. This behavior makes structs ideal for scenarios where you want to ensure values remain unchanged and independent.

Structure Definition in Swift

To define a structure in Swift, you use the struct keyword. Here’s a simple example:

Copy
1
2
3
4
struct Person {
    var name: String
    var age: Int
}

In this structure definition, the Person struct has two properties: name of type String and age of type Int. This struct allows you to create custom data models representing a person.

Value Types vs. Reference Types

A fundamental distinction in Swift is between value types and reference types. A struct is a value type, meaning every time a new instance is assigned to a variable or constant, a copy is made. Classes, on the other hand, are reference types, meaning they reference the same memory location when assigned to a variable or constant.

Copy
1
2
3
4
5
6
var person1 = Person(name: "Alice", age: 30)
var person2 = person1
person2.age = 25

print(person1.age) // Outputs: 30
print(person2.age) // Outputs: 25

In this example, modifying person2 does not change person1 because structs are value types. Each instance has its own copy of the data. This is different from class instances, where changes to one instance would reflect in others pointing to the same memory.

Using Stored Properties in Swift Structs

Stored properties are constants or variables stored as part of an instance. When you define properties inside a struct, they hold data directly. For example, in the struct Person above, name and age are stored properties.

Default Values and Memberwise Initializers

Swift structs come with a default initializer that allows you to create an instance without specifying any initial values. Additionally, Swift automatically provides a memberwise initializer for structs with stored properties.

Copy
1
2
3
4
5
6
7
struct Car {
    var model: String = "Sedan"
    var year: Int = 2022
}

let car1 = Car() // Uses default values: model = "Sedan", year = 2022
let car2 = Car(model: "Coupe", year: 2021) // Uses memberwise initializer

In this example, the struct Car has default values for model and year, allowing you to create instances with minimal code. The memberwise initializer allows you to specify values directly when creating a new instance.

Functions Inside Structs

Swift structs can contain functions (methods) that operate on their properties. This makes them very versatile for encapsulating behavior alongside data.

Copy
1
2
3
4
5
6
7
8
9
10
11
struct Person {
    var name: String
    var age: Int

    func greeting() -> String {
        return "Hello, my name is \(name) and I am \(age) years old."
    }
}

let person = Person(name: "John", age: 28)
print(person.greeting()) // Outputs: Hello, my name is John and I am 28 years old.

In the above example, the greeting function uses the func keyword to define a function inside the struct that accesses the name and age properties using dot notation.

Comparing Structs and Classes in Swift

Memory Management and Reference Counting

One of the major differences between structs and classes is how they manage memory. Classes use reference counting to keep track of how many instances reference a particular object in memory. Structs, being value types, do not require reference counting since each instance holds its own copy of the data.

When to Use Structs Over Classes

1. Immutability: If you want instances to remain unaltered after being assigned, use structs. For example, when working with geometric shapes or fixed data like coordinates, structs are ideal.

2. Thread Safety: Since structs do not share instances, they are inherently safer when working in a multi-threaded environment, reducing the risk of race conditions.

3. Performance: Swift structs are often more memory efficient than classes due to their value type nature, making them a good choice for simple data models.

Working with Structs in Swift: Examples

Example: Struct Person

Let's look at another example of the struct Person that includes two variables and a method to access the properties:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Person {
    var name: String
    var age: Int

    func getInfo() -> String {
        return "\(name) is \(age) years old."
    }
}

let personA = Person(name: "Emma", age: 22)
let personB = Person(name: "Noah", age: 29)

print(personA.getInfo()) // Outputs: Emma is 22 years old.
print(personB.getInfo()) // Outputs: Noah is 29 years old.

In this example, the getInfo string func returns a string with details of the Person struct. Each instance of Person holds data independently, making it easy to create two instances with different values.

Advanced Struct Concepts: Mutating Methods

By default, functions within a struct cannot modify its properties because structs are value types. To modify properties within a method, you must declare the method as mutating.

Copy
1
2
3
4
5
6
7
8
9
10
11
struct Counter {
    var count: Int = 0

    mutating func increment() {
        count += 1
    }
}

var counter = Counter()
counter.increment()
print(counter.count) // Outputs: 1

In this example, the increment function is declared as mutating because it changes the count property of the struct.

The Bottom Line!

Swift structs are a powerful tool for creating custom types that emphasize value semantics, immutability, and simplicity. They differ from classes in how they handle memory and data, making them ideal for many scenarios where value types are preferred. Using structs ensures that instances remain independent, making your Swift code more predictable and less prone to errors.