Swift structures and classes

• Structures and classes are general-purpose, flexible constructs that serve as the foundation for program code.
• Properties and methods are defined to enhance structures and classes
• Swift does not require separate interface and implementation files, defining a structure or class in a single file. The external interface is then made available for other code.

Comparing Structures and Classes

• Structures and classes in Swift share common features:

• Properties for storing values

• Methods for providing functionality

• Subscripts for accessing values via subscript syntax

• Initializers for setting up initial states

• Extensions for expanding functionality

• Conformance to protocols for standard functionality

• Classes possess additional capabilities that structures lack:

• Inheritance: a class can inherit characteristics from another class.

• Type casting: enables checking and interpreting the type of a class instance at runtime.

• Deinitializers: instances can free up assigned resources.

• Reference counting: allows multiple references to a class instance.

• The additional capabilities that classes support come at the cost of increased complexity. Prefer structures for their simplicity, and use classes when necessary. Most custom types will be structures and enumerations.

Definition Syntax

• Structures are introduced with struct, and classes with class.

struct SomeStructure {
    // structure definition goes here
}
class SomeClass {
    // class definition goes here
}

• Example structure and class definitions:

struct Resolution {
    var width = 0
    var height = 0
}
class VideoMode {
    var resolution = Resolution()
    var interlaced = false
    var frameRate = 0.0
    var name: String?
}

• Resolution structure describes a pixel-based display resolution:
• It has two stored properties: width and height, both inferred to be of type Int due to initialization with an integer value of 0.
• VideoMode class describes a specific video mode for video display:
• It has four variable stored properties: resolution, interlaced, frameRate, and name.
• resolution is initialized with a new Resolution structure instance.
• interlaced is initialized to false (noninterlaced video).
• frameRate is initialized to 0.0.
• name is an optional String with a default value of nil.

Structure and Class Instances

• Resolution and VideoMode only describe what a Resolution or VideoMode will look like.
• To create a specific resolution or video mode, instances of the structure or class are needed.

let someResolution = Resolution()
let someVideoMode = VideoMode()

• Structures and classes utilize initializer syntax for creating new instances, done by using the type name followed by empty parentheses:
• This initializes properties to their default values.

Accessing Properties

• Properties of an instance can be accessed using dot syntax:

print("The width of someResolution is \(someResolution.width)")
// Prints "The width of someResolution is 0"

• Subproperties can also be accessed:

print("The width of someVideoMode is \(someVideoMode.resolution.width)")
// Prints "The width of someVideoMode is 0"

• Dot syntax can also assign new values to a variable property:

someVideoMode.resolution.width = 1280
print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
// Prints "The width of someVideoMode is now 1280"

Memberwise Initializers for Structure Types

• Structures have an automatically generated memberwise initializer:
• To initialize the member properties of new structure instances.
• Initial values are passed by name:

let vga = Resolution(width: 640, height: 480)

• Class instances do not receive a default memberwise initializer.

Structures and Enumerations Are Value Types

• A value type is copied when assigned to a variable or constant, or when passed to a function.
• Basic types in Swift (integers, floating-point numbers, Booleans, strings, arrays, dictionaries) are value types implemented as structures.
• Structures and enumerations are value types - instances are copied when passed around in code.

let hd = Resolution(width: 1920, height: 1080)
var cinema = hd

• hd is a Resolution instance with width and height of 1920x1080.
• cinema is set to the value of hd, creating a copy.

cinema.width = 2048

• Modifying cinema does not affect hd:

print("cinema is now \(cinema.width) pixels wide")
// Prints "cinema is now 2048 pixels wide"

print("hd is still \(hd.width) pixels wide")
// Prints "hd is still 1920 pixels wide"

• The same behavior applies to enumerations:

enum CompassPoint {
    case north, south, east, west
    mutating func turnNorth() {
        self =.north
    }
}
var currentDirection = CompassPoint.west
let rememberedDirection = currentDirection
currentDirection.turnNorth()

print("The current direction is \(currentDirection)")
print("The remembered direction is \(rememberedDirection)")
// Prints "The current direction is north"
// Prints "The remembered direction is west"

• rememberedDirection is assigned a copy of currentDirection.

Classes Are Reference Types

• Reference types are not copied when assigned, but use a reference to the same existing instance.

let tenEighty = VideoMode()
tenEighty.resolution = hd
tenEighty.interlaced = true
tenEighty.name = "1080i"
tenEighty.frameRate = 25.0

• tenEighty refers to a new instance of the VideoMode class, with properties set accordingly.

let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0

• tenEighty and alsoTenEighty refer to the same VideoMode instance. Modifying one affects the other:

print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
// Prints "The frameRate property of tenEighty is now 30.0"

• Reference types can be harder to reason about. tenEighty and alsoTenEighty are constants, but tenEighty.frameRate and alsoTenEighty.frameRate can still be changed.

Identity Operators

• Swift provides identity operators to check if constants or variables refer to the same class instance:
• Identical to (===)
• Not identical to (!==)

if tenEighty === alsoTenEighty {
    print("tenEighty and alsoTenEighty refer to the same VideoMode instance.")
}
// Prints "tenEighty and alsoTenEighty refer to the same VideoMode instance."

• Identical to (===) means that two constants/variables of class type refer to the same class instance.
• Equal to (==) means that two instances are considered equal in value.
• Defining custom implementations of the == and != operators is necessary to detemine if instances are equal.

Pointers

• Swift constants/variables that refer to a reference type are similar to pointers in C, but are not direct memory address pointers.
• References are defined like any other constant or variable in Swift.
• The Swift standard library provides pointer and buffer types for direct pointer interaction.