Structures and Classes

In Swift, both classes and structures are complex data types that allow you to define properties to store values and methods to provide functionality. However, there are key differences between them.

Syntax

The basic syntax for defining a structure is:

struct StructName {
   // property and method definitions
}

For defining a class:

class ClassName {
   // property and method definitions
}

Initialization

Both classes and structs can have initializers:

struct Point {
   var x: Double
   var y: Double
}
let origin = Point(x: 0.0, y: 0.0)
class Circle {
   var radius: Double
   init(radius: Double) {
       self.radius = radius
   }
}
let circle = Circle(radius: 5.0)

Properties and Methods

Both classes and structs can have properties and methods:

struct Rectangle {
   var width = 0.0
   var height = 0.0
   
   func area() -> Double {
       return width * height
   }
}
class Square {
   var sideLength = 0.0
   func area() -> Double {
       return sideLength * sideLength
   }
}

Value Types vs. Reference Types

The primary difference between classes and structs is that structs are value types and classes are reference types.

// Using structs
var point1 = Point(x: 0, y: 0)
var point2 = point1  // point2 is a copy of point1
point2.x = 5
print(point1.x)  // Output: 0
print(point2.x)  // Output: 5
// Using classes
var circle1 = Circle(radius: 1)
var circle2 = circle1  // circle2 and circle1 refer to the same object
circle2.radius = 5
print(circle1.radius)  // Output: 5
print(circle2.radius)  // Output: 5

Inheritance and Type Casting

Classes support inheritance, which means a class can inherit properties and methods from another class. Structures do not support inheritance.

class Shape {
   var sides = 0
}
class Triangle: Shape {
   // Inherits `sides` property from Shape
   var base = 0.0
   var height = 0.0
}

Memberwise Initializers for Structure Types

Structures automatically receive a memberwise initializer if they do not define any of their own initializers.

let rectangle = Rectangle(width: 5, height: 10)

Classes do not receive a default memberwise initializer.

Mutability

In Swift, structures are generally preferred for data that does not need to be modified after it is created. By making them instances of structs, Swift allows these data types to be copied and passed around safely.

Reference Counting and Deinitialization

Swift classes have additional features, like reference counting, to manage memory, and you can add deinitializers to free up resources. Structures do not have deinitializers.

class SomeClass {
   deinit {
       print("The instance is being deinitialized.")
   }
}

Identity Operators

Since classes are reference types, it's possible to check if two references point to the same instance using identity operators (=== and !==).

if circle1 === circle2 {
   print("Both circles refer to the same object.")
}

Structures do not have this capability since they are value types and are copied when assigned or passed to a function.

In summary, both classes and structs are foundational to Swift programming, and understanding when to use each is crucial. Classes offer more flexibility but come with the cost of additional complexity. Structures offer safety and are usually more straightforward, making them the better choice for simple data encapsulation.