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:

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

​

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.

1var person1 = Person(name: "Alice", age: 30)
2var person2 = person1
3person2.age = 25
4
5print(person1.age) // Outputs: 30
6print(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.

1struct Car {
2    var model: String = "Sedan"
3    var year: Int = 2022
4}
5
6let car1 = Car() // Uses default values: model = "Sedan", year = 2022
7let 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.

1struct Person {
2    var name: String
3    var age: Int
4
5    func greeting() -> String {
6        return "Hello, my name is \(name) and I am \(age) years old."
7    }
8}
9
10let person = Person(name: "John", age: 28)
11print(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:

1struct Person {
2    var name: String
3    var age: Int
4
5    func getInfo() -> String {
6        return "\(name) is \(age) years old."
7    }
8}
9
10let personA = Person(name: "Emma", age: 22)
11let personB = Person(name: "Noah", age: 29)
12
13print(personA.getInfo()) // Outputs: Emma is 22 years old.
14print(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.

1struct Counter {
2    var count: Int = 0
3
4    mutating func increment() {
5        count += 1
6    }
7}
8
9var counter = Counter()
10counter.increment()
11print(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.

Short on time? Speed things up with DhiWise!

Tired of manually designing screens, coding on weekends, and technical debt? Let DhiWise handle it for you!

You can build an e-commerce store, healthcare app, portfolio, blogging website, social media or admin panel right away. Use our library of 40+ pre-built free templates to create your first application using DhiWise.