One of the fundamental distinctions in Swift, lies in how it handles data: through classes and structs. These two constructs are at the core of Swift's type system and dictate how data is stored, passed around, and manipulated. The key difference between classes and structs boils down to reference types and value types. In this article, we'll explore these concepts in depth to help you understand when to use classes or structs in your Swift code.

Reference Types: Classes

Classes in Swift are reference types. This means that when you create an instance of a class and assign it to a variable or pass it as an argument to a function, you're not working with the actual object; instead, you're dealing with a reference to that object in memory.

Here's a practical example to illustrate reference types, including a method:

class Dog {
    var name: String
    init(name: String) {
        self.name = name
    }
    func bark() {
        print("\(name) is barking!")
    }
}
let dog1 = Dog(name: "Fido")
let dog2 = dog1 // Assigns a reference, not a copy
dog2.name = "Buddy"
print(dog1.name) // Prints "Buddy"
dog1.bark() // Prints "Buddy is barking!"
dog2.bark() // Prints "Buddy is barking!"

In the code above, dog1 and dog2 both reference the same instance of the Dog class. When we modify dog2.name ,it affects dog1.name as well. This behavior stems from the fact that classes use reference semantics, and changes to one reference propagate to all references to the same object.

The Dog class includes a bark method. This method allows instances of the class to perform an action, which is to print a message indicating that the dog is barking. Both dog1 and dog2 can call the bark method, and when they do, the method refers to the same instance's name property. This behavior illustrates how methods in classes work with reference types, allowing shared behavior among different references to the same object.

Value Types: Structs

In contrast to classes, structs in Swift are value types. When you create an instance of a struct and assign it to a variable or pass it as an argument, you're working with a copy of the actual data, not a reference to it.

Let's see how value types work with a simple example that includes a method:

struct Point {
    var x: Double
    var y: Double
    mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}
var point1 = Point(x: 1.0, y: 2.0)
var point2 = point1 // Creates a copy of point1
point2.x = 3.0
print(point1.x) // Prints "1.0"
point2.moveBy(x: 2.0, y: 3.0)
print(point1.x) // Prints "1.0"
print(point2.x) // Prints "3.0"

In this case, point1 and point2 are entirely independent of each other. Changing the value of point2.x does not affect point1.x .This behavior is a result of struct instances having value semantics, meaning that changes to one instance don't impact other instances.

The Point struct includes a moveBy method. This method allows instances of the struct to modify their own properties. When we call moveBy on point1 ,it modifies the x and y properties of point1 ,resulting in point1 moving to a new position. However, notice that point2 remains unchanged because structs have value semantics. The moveBy method works on a copy of the struct, ensuring that the original instance remains unaltered. This behavior showcases how methods in structs interact with value types, preserving the independence of instances.

When to Use Reference Types (Classes)

Classes are the preferred choice when you need:

1. Shared Mutability: If multiple parts of your codebase need to share and modify the same data, classes are the way to go. Because they use reference semantics, changes are visible to all references.
2. Inheritance: When you require inheritance and polymorphism for building complex object hierarchies or sharing behavior across objects, classes are your best bet.
3. Heavyweight Objects: For objects with a large number of properties and methods, classes are more suitable as they offer flexibility and extensibility.
4. Automatic Memory Management: Swift's Automatic Reference Counting (ARC) efficiently manages memory for class instances by handling reference counting.

When to Use Value Types (Structs)

Structs are the ideal choice when you need:

1. Immutable Data: If your data should not change after creation, struct instances provide a safe way to ensure immutability, which is crucial for thread safety.
2. Predictable Behavior: When you want to pass data between functions or threads without worrying about unexpected side effects, struct's value semantics provide a clear and predictable solution.
3. Small, Self-Contained Data: For small, self-contained pieces of data like coordinates, sizes, or simple models, structs are more efficient and straightforward.
4. Copy Efficiency: If you're concerned about memory efficiency and want to minimize unnecessary copying of data, structs with copy-on-write (COW) behavior can be advantageous.

In summary, understanding the distinction between reference types (classes) and value types (structs) is crucial for writing robust Swift code. Including methods in your classes and structs can provide behavior and functionality tailored to the specific needs of each type. By considering the implications of reference and value semantics, you can make informed decisions and build more reliable and maintainable software with Swift.