Build 10x products in minutes by chatting with AI - beyond just a prototype.
Does Swift have structs?
What is the difference between a struct and a data class in Swift?
Is string a struct or class in Swift?
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
