As your Swift programs become larger, storing data in separate variables becomes difficult to manage.

For example:

let name = "Alex"
let age = 25
let email = "alex@example.com"
let isActive = true

These values all describe the same thing: a user.

Instead of managing them separately, Swift allows you to group related data and behavior into custom types using structures and classes.

A structure is created using:

struct

A class is created using:

class

For example:

struct User {
    let name: String
    let age: Int
}

and:

class User {
    let name: String
    let age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

At first, structures and classes may look almost identical.

However, there is one fundamental difference:

Structures are value types, while classes are reference types.

Understanding this difference is essential for writing correct Swift applications.

In this guide, you will learn:

What structures are
What classes are
How to create instances
Stored properties
Computed properties
Methods
Initializers
Mutating methods
Value types
Reference types
Copying behavior
Inheritance
Method overriding
Type casting
Identity operators
Deinitializers
Struct vs class differences
When to use a struct
When to use a class
Practical examples
Common beginner mistakes

What Is a Structure in Swift?

A structure, commonly called a struct, is a custom Swift type that can group related properties and methods.

Basic syntax:

struct TypeName {
    // Properties
    // Methods
}

Example:

struct User {
    let name: String
    let age: Int
}

Here we created a new type called:

User

It contains two properties:

name → String
age  → Int

Now we can create a User.

let user = User(
    name: "Alex",
    age: 25
)

Access the properties using dot notation:

print(user.name)
print(user.age)

Output:

Alex
25

What Is a Class in Swift?

A class is another way to create a custom type containing related data and behavior.

Basic syntax:

class TypeName {
    // Properties
    // Methods
}

Example:

class User {

    let name: String
    let age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

Create an instance:

let user = User(
    name: "Alex",
    age: 25
)

Access its properties:

print(user.name)
print(user.age)

Output:

Alex
25

At this point, the struct and class versions look very similar.

The important differences appear when we start copying and modifying instances.

Structure vs Instance

When you write:

struct User {
    let name: String
    let age: Int
}

you define a type.

When you write:

let user = User(
    name: "Alex",
    age: 25
)

you create an instance of that type.

Think of it like:

User
 ↓
Blueprint / Type
 ↓
User Instance

You can create multiple instances:

let user1 = User(name: "Alex", age: 25)
let user2 = User(name: "Emma", age: 22)
let user3 = User(name: "John", age: 30)

Each instance contains its own values.

Properties in Swift Structures and Classes

Properties store information associated with an instance.

Example:

struct Product {
    let name: String
    let price: Double
    var quantity: Int
}

Here:

name
price
quantity

are properties.

Create a product:

var product = Product(
    name: "MacBook",
    price: 1299.99,
    quantity: 1
)

Access:

print(product.name)
print(product.price)
print(product.quantity)

let vs var Properties

Properties can be constants or variables.

Constant property:

let name: String

Variable property:

var quantity: Int

A let property cannot be changed after initialization.

A var property can be changed when the instance allows mutation.

Example:

struct Product {
    let name: String
    var quantity: Int
}

var product = Product(
    name: "iPhone",
    quantity: 1
)

product.quantity = 2

This works.

But:

product.name = "MacBook"

does not work because name is declared with let.

Stored Properties

Properties that directly store values are called stored properties.

Example:

struct User {
    let name: String
    var age: Int
}

Both:

name
age

are stored properties.

Their values are stored as part of each User instance.

Default Property Values

Properties can have default values.

Example:

struct User {
    let name: String
    var isActive: Bool = true
}

Now:

let user = User(name: "Alex")

automatically gets:

isActive = true

You don’t have to provide it manually unless the initializer permits overriding it.

Memberwise Initializers for Structures

Swift automatically provides a memberwise initializer for many structures.

For example:

struct User {
    let name: String
    let age: Int
}

Swift allows:

let user = User(
    name: "Alex",
    age: 25
)

without manually creating:

init(...)

This is one convenient feature of structures.

Classes Need Initialization

Consider:

class User {
    let name: String
    let age: Int
}

Swift needs to know how these stored properties receive values.

A common solution is to define an initializer:

class User {

    let name: String
    let age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

Now:

let user = User(
    name: "Alex",
    age: 25
)

works.

What Is init in Swift?

An initializer prepares a new instance for use.

Syntax:

init(parameters) {
    // Initialize properties
}

Example:

struct Car {

    let brand: String
    let model: String

    init(brand: String, model: String) {
        self.brand = brand
        self.model = model
    }
}

Create:

let car = Car(
    brand: "Toyota",
    model: "Camry"
)

What Does self Mean?

Inside an instance, self refers to that current instance.

Example:

init(name: String) {
    self.name = name
}

There are two identifiers named name:

self.name → Property

name → Initializer parameter

So:

self.name = name

means:

Store the name parameter inside this instance’s name property.

Custom Initializers

You can create your own initializer.

struct Rectangle {

    let width: Double
    let height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
}

Create:

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

Multiple Initializers

A type can provide multiple initializers when different creation paths are useful.

Example:

struct User {

    let name: String
    let age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    init(name: String) {
        self.name = name
        self.age = 18
    }
}

Now both work:

let user1 = User(
    name: "Alex",
    age: 25
)

let user2 = User(
    name: "Emma"
)

For user2:

age = 18

Methods in Structures and Classes

A method is a function associated with a type.

Example:

struct User {

    let name: String

    func greet() {
        print("Hello, my name is \(name)")
    }
}

Create:

let user = User(name: "Alex")

Call:

user.greet()

Output:

Hello, my name is Alex

Methods with Parameters

Methods can accept parameters.

struct Calculator {

    func add(_ a: Int, _ b: Int) -> Int {
        return a + b
    }
}

Use:

let calculator = Calculator()

let result = calculator.add(10, 20)

print(result)

Output:

Methods with Return Values

Example:

struct Rectangle {

    let width: Double
    let height: Double

    func calculateArea() -> Double {
        return width * height
    }
}

Use:

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

print(rectangle.calculateArea())

Output:

50.0

Computed Properties

A computed property calculates a value instead of directly storing it.

Example:

struct Rectangle {

    let width: Double
    let height: Double

    var area: Double {
        return width * height
    }
}

Use:

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

print(rectangle.area)

Output:

50.0

Notice:

rectangle.area

not:

rectangle.area()

because area is a property rather than a method.

Stored vs Computed Properties

Stored property:

let width: Double

It directly stores a value.

Computed property:

var area: Double {
    width * height
}

It calculates its value whenever accessed.

A simple comparison:

Stored Property	Computed Property
Stores data	Calculates data
Has stored value	Derived from other values
Example: `width`	Example: `area`

Getters and Setters

Computed properties can also have getters and setters.

Example:

struct Temperature {

    var celsius: Double

    var fahrenheit: Double {

        get {
            return (celsius * 9 / 5) + 32
        }

        set {
            celsius = (newValue - 32) * 5 / 9
        }
    }
}

Create:

var temperature = Temperature(celsius: 0)

Read:

print(temperature.fahrenheit)

Output:

32.0

Update:

temperature.fahrenheit = 212

Now:

print(temperature.celsius)

Output is approximately:

100.0

Mutating Methods in Structures

Structures are value types.

If a struct method needs to modify one of its properties, mark the method:

mutating

Example:

struct Counter {

    var value = 0

    mutating func increment() {
        value += 1
    }
}

Create a mutable instance:

var counter = Counter()

counter.increment()

print(counter.value)

Output:

Without mutating, a struct instance method cannot directly change stored properties.

Why Does the Struct Instance Need var?

This does not work:

let counter = Counter()

counter.increment()

because:

let

makes the structure instance immutable.

Use:

var counter = Counter()

when its stored state needs to change.

Classes Do Not Need mutating

Consider:

class Counter {

    var value = 0

    func increment() {
        value += 1
    }
}

Use:

let counter = Counter()

counter.increment()

This works even though:

counter

was declared with let.

Why?

Because the constant prevents counter from being reassigned to another class instance. It does not automatically make all mutable properties of that referenced object immutable.

This behavior comes from classes being reference types.

The Most Important Difference: Value vs Reference Types

This is the central difference between structures and classes.

Struct → Value Type

Class → Reference Type

Let’s understand this with examples.

Structures Are Value Types

Consider:

struct User {
    var name: String
}

Create:

var user1 = User(name: "Alex")

Copy it:

var user2 = user1

Now change:

user2.name = "Emma"

Print:

print(user1.name)
print(user2.name)

Output:

Alex
Emma

Changing user2 does not change user1.

Conceptually:

user1
 └── Alex

COPY
 ↓

user2
 └── Alex

Change user2
 ↓

user1 → Alex
user2 → Emma

Each variable behaves as its own value.

Classes Are Reference Types

Now use a class:

class User {

    var name: String

    init(name: String) {
        self.name = name
    }
}

Create:

let user1 = User(name: "Alex")

Assign:

let user2 = user1

Change:

user2.name = "Emma"

Print:

print(user1.name)
print(user2.name)

Output:

Emma
Emma

Why?

Because both variables refer to the same class instance.

Conceptually:

user1 ─────┐
           │
           ▼
        User Object
        name: Alex
           ▲
           │
user2 ─────┘

Change the object through user2:

name = Emma

Now both references observe:

Emma

Struct Copy vs Class Reference

This difference is worth memorizing.

Struct

Original Value
     ↓
   Copy
     ↓
Independent Value

Class

Reference 1 ──┐
              ├── Same Instance
Reference 2 ──┘

This affects how data changes throughout your application.

Value Types in Swift

Structures are not the only value types.

Many common Swift types use value semantics.

Examples include:

Int
Double
Bool
String
Array
Set
Dictionary
Struct
Enum

For example:

var first = 10
var second = first

second = 20

Now:

first  = 10
second = 20

Changing the second value does not change the first.

Reference Types in Swift

Classes provide reference semantics.

Example:

class Settings {
    var darkMode = false
}

Create:

let settings1 = Settings()
let settings2 = settings1

Change:

settings2.darkMode = true

Now:

print(settings1.darkMode)

outputs:

true

Both variables reference the same Settings instance.

Identity Operators for Classes

Because classes are reference types, Swift lets you check whether two variables reference the exact same instance.

Use:

===

and:

!==

Example:

class User {
}

let user1 = User()
let user2 = user1

Check:

print(user1 === user2)

Output:

true

They reference the same instance.

`==` vs `===`

These operators have different purposes.

==   → Value equality

===  → Reference identity

=== is used with class instances to ask:

Are these two references pointing to the exact same object?

Value equality with == depends on the type supporting equality, commonly through Equatable.

Structures Can Conform to Equatable

Example:

struct User: Equatable {
    let id: Int
    let name: String
}

Now:

let user1 = User(id: 1, name: "Alex")
let user2 = User(id: 1, name: "Alex")

print(user1 == user2)

Output:

true

They are two values with equal stored data.

Class Inheritance

Classes support inheritance.

Structures do not.

Inheritance allows one class to build on another class.

Example:

class Animal {

    func makeSound() {
        print("Animal sound")
    }
}

Create a subclass:

class Dog: Animal {
}

Now:

let dog = Dog()

dog.makeSound()

Output:

Animal sound

Dog inherited the method from Animal.

What Is a Superclass?

In:

class Dog: Animal

Animal is the:

Superclass / Parent Class

Dog is the:

Subclass / Child Class

Conceptually:

Animal
  ↓
 Dog

The child class can inherit behavior from its parent.

Overriding Methods

A subclass can provide its own implementation of an inherited method.

Use:

override

Example:

class Animal {

    func makeSound() {
        print("Animal sound")
    }
}

class Dog: Animal {

    override func makeSound() {
        print("Woof!")
    }
}

Use:

let dog = Dog()

dog.makeSound()

Output:

Woof!

Calling the Parent Implementation with super

Sometimes you want to use the parent’s implementation and then add more behavior.

Use:

super

Example:

class Animal {

    func makeSound() {
        print("Animal sound")
    }
}

class Dog: Animal {

    override func makeSound() {
        super.makeSound()
        print("Woof!")
    }
}

Output:

Animal sound
Woof!

Overriding Properties

Classes can also override certain inherited properties.

Example:

class Animal {

    var description: String {
        return "Animal"
    }
}

class Dog: Animal {

    override var description: String {
        return "Dog"
    }
}

Use:

let dog = Dog()

print(dog.description)

Output:

Dog

final Classes

Sometimes you don’t want a class to be subclassed.

Use:

final

Example:

final class UserManager {
}

Now another class cannot inherit from UserManager.

You can also mark individual methods or properties as final to prevent overriding.

Structures Do Not Support Class Inheritance

This is invalid:

struct Dog: Animal {
}

if Animal is being treated as a superclass.

Structures don’t participate in class inheritance hierarchies.

However, structures can adopt protocols, which is extremely important in Swift.

Example:

protocol IdentifiableItem {
    var id: Int { get }
}

Then:

struct User: IdentifiableItem {
    let id: Int
}

Swift often favors protocol-based composition over deep inheritance hierarchies.

Type Properties

Properties can belong to the type itself rather than individual instances.

For a struct:

struct AppConfig {
    static let appName = "My App"
}

Access:

print(AppConfig.appName)

You don’t need:

AppConfig()

to access it.

Static Methods

You can also create methods belonging to the type.

struct MathHelper {

    static func square(_ number: Int) -> Int {
        return number * number
    }
}

Use:

print(MathHelper.square(5))

Output:

Class Type Methods

Classes can use static for type methods that cannot be overridden.

They can also use:

class

for type methods that subclasses may override.

Example:

class Animal {

    class func typeName() -> String {
        return "Animal"
    }
}

Lazy Stored Properties

A lazy property isn’t initialized until it is first accessed.

Use:

lazy

Example:

class DataManager {

    lazy var data: [String] = {
        print("Loading data...")
        return ["Swift", "Kotlin", "Dart"]
    }()
}

Create:

let manager = DataManager()

The data hasn’t necessarily been created yet.

Access:

print(manager.data)

At this point the lazy property’s initialization runs.

Lazy properties can be useful when creating a value is expensive and may not always be needed.

Property Observers

Swift allows you to observe changes to stored properties.

Two observers are:

willSet
didSet

Example:

class Counter {

    var value: Int = 0 {

        willSet {
            print("Value will become \(newValue)")
        }

        didSet {
            print("Value changed from \(oldValue)")
        }
    }
}

Use:

let counter = Counter()

counter.value = 10

Output:

Value will become 10
Value changed from 0

Deinitializers

Classes can define a deinitializer.

Use:

deinit

Example:

class UserSession {

    init() {
        print("Session created")
    }

    deinit {
        print("Session destroyed")
    }
}

A deinitializer runs before a class instance is deallocated.

Structures do not use class-style deinit because they have different lifetime semantics.

Automatic Reference Counting

Class instances are managed using Automatic Reference Counting, commonly called:

ARC

Swift keeps track of strong references to class instances.

When an instance is no longer strongly referenced, it can be deallocated.

Example:

class User {
    let name: String

    init(name: String) {
        self.name = name
    }

    deinit {
        print("\(name) removed")
    }
}

Then:

var user: User? = User(name: "Alex")

user = nil

If there are no other strong references to that instance, it can be deinitialized.

ARC becomes especially important when learning:

weak
unowned
retain cycles
closures
delegates

Reference Cycles

Because classes use references, two objects can sometimes keep strong references to each other.

Conceptually:

Object A → Object B
   ↑          ↓
   └──────────┘

If both references are strong, ARC may be unable to deallocate the objects.

Swift provides:

weak
unowned

to help model relationships without unnecessary strong ownership.

This is a more advanced topic, but it is an important reason to understand reference semantics.

Type Casting with Classes

Inheritance sometimes requires checking an object’s runtime type.

Suppose:

class Animal {
}

class Dog: Animal {
    func bark() {
        print("Woof")
    }
}

class Cat: Animal {
    func meow() {
        print("Meow")
    }
}

Create:

let animals: [Animal] = [
    Dog(),
    Cat(),
    Dog()
]

You can check a type using:

is

Example:

for animal in animals {

    if animal is Dog {
        print("Found a dog")
    }
}

Downcasting with as?

You can safely attempt to convert a reference to a more specific type.

Example:

for animal in animals {

    if let dog = animal as? Dog {
        dog.bark()
    }
}

as? returns an optional.

If the cast fails, it returns nil.

This is safer than forcing a cast.

as! and Forced Casting

Swift also provides:

as!

Example:

let dog = animal as! Dog

If animal isn’t actually a Dog, the application will crash.

Therefore:

Prefer as? unless you are certain the cast cannot fail.

Structures Can Adopt Protocols

One major reason Swift structures are powerful is protocol conformance.

Example:

protocol Displayable {
    func display()
}

Struct:

struct User: Displayable {

    let name: String

    func display() {
        print("User: \(name)")
    }
}

Use:

let user = User(name: "Alex")

user.display()

Output:

User: Alex

Classes can adopt protocols too.

Struct Example: Product Model

A product is a good example of data that can often be represented by a struct.

struct Product {

    let id: Int
    let name: String
    let price: Double
    var quantity: Int

    var totalPrice: Double {
        price * Double(quantity)
    }
}

Create:

var product = Product(
    id: 1,
    name: "MacBook",
    price: 1299,
    quantity: 2
)

Use:

print(product.name)
print(product.totalPrice)

Output:

MacBook
2598.0

Struct Example: API Model

Suppose an API returns:

{
  "id": 1,
  "name": "Alex",
  "email": "alex@example.com"
}

A Swift model could be:

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

Using structs for model data is extremely common in Swift applications.

Struct Example: SwiftUI Model

Structures are also central to SwiftUI.

For example:

struct Product {
    let name: String
    let price: Double
}

A SwiftUI view itself is commonly declared as a struct:

import SwiftUI

struct ContentView: View {

    var body: some View {
        Text("Hello, Swift!")
    }
}

This is one reason understanding structures is essential before learning SwiftUI.

Class Example: Shared Manager

Classes are useful when shared identity and mutable state are important.

Example:

class UserSession {

    var isLoggedIn = false
    var username: String?

    func login(username: String) {
        self.username = username
        isLoggedIn = true
    }

    func logout() {
        username = nil
        isLoggedIn = false
    }
}

Create:

let session = UserSession()

session.login(username: "Alex")

print(session.isLoggedIn)

Output:

true

Class Example: Bank Account

A bank account has an identity and state that changes over time.

class BankAccount {

    let accountNumber: String
    private(set) var balance: Double

    init(
        accountNumber: String,
        balance: Double
    ) {
        self.accountNumber = accountNumber
        self.balance = balance
    }

    func deposit(_ amount: Double) {
        balance += amount
    }

    func withdraw(_ amount: Double) {

        guard amount <= balance else {
            print("Insufficient balance")
            return
        }

        balance -= amount
    }
}

Use:

let account = BankAccount(
    accountNumber: "ABC123",
    balance: 1000
)

account.deposit(500)

account.withdraw(200)

print(account.balance)

Output:

1300.0

What Does private(set) Mean?

In:

private(set) var balance: Double

Access Control with Classes and Structures

Swift provides access-control levels such as:

open
public
package
internal
fileprivate
private

For beginners, the most commonly encountered are:

internal
private
public

For example:

struct User {

    let name: String

    private let password: String
}

password can only be accessed according to its private scope.

Access control helps protect implementation details and create cleaner APIs.

Struct vs Class Comparison

Here is the most important comparison:

Feature	Struct	Class
Custom properties	Yes	Yes
Methods	Yes	Yes
Initializers	Yes	Yes
Computed properties	Yes	Yes
Protocols	Yes	Yes
Extensions	Yes	Yes
Value semantics	Yes	No
Reference semantics	No	Yes
Class inheritance	No	Yes
Identity with `===`	No	Yes
ARC reference management	No	Yes
Deinitializer	No class-style deinit	Yes
Memberwise initializer	Commonly synthesized	Not automatically in the same way

The biggest difference remains:

Struct → Value

Class → Reference

When Should You Use a Struct?

A struct is often a good choice when:

The type primarily represents data
Independent copies are desirable
Identity isn’t important
Value semantics make sense
You don’t require class inheritance
You want safer local reasoning about mutation

Common examples include:

User model
Product model
API response
Coordinates
Configuration values
Form data
SwiftUI views

Example:

struct Product {
    let id: Int
    let name: String
    let price: Double
}

When Should You Use a Class?

A class may be appropriate when:

Identity matters
Multiple parts of your program should refer to the same instance
Shared mutable state is intentional
You need class inheritance
Object lifetime/deinitialization matters
You are working with APIs/frameworks that require class semantics

Examples might include certain:

Managers
Coordinators
Controllers
Sessions
Services
Framework-specific objects

Example:

class SessionManager {

    var currentUser: User?

    func logout() {
        currentUser = nil
    }
}

Should Beginners Use Struct or Class by Default?

A useful starting rule in Swift is:

Prefer a struct when value semantics correctly represent your data, and use a class when you specifically need reference semantics or class-only behavior.

Do not choose a class merely because classes are common in another programming language.

Swift gives value types an important role in application design.

Struct vs Class Example Side by Side

Struct

struct User {
    var name: String
}

var user1 = User(name: "Alex")
var user2 = user1

user2.name = "Emma"

print(user1.name)
print(user2.name)

Output:

Alex
Emma

Class

class User {

    var name: String

    init(name: String) {
        self.name = name
    }
}

let user1 = User(name: "Alex")
let user2 = user1

user2.name = "Emma"

print(user1.name)
print(user2.name)

Output:

Emma
Emma

If you remember only one example from this article, remember this one.

Common Beginner Mistake: Assuming Class Assignment Creates a Copy

Consider:

let original = User(name: "Alex")
let copy = original

If User is a class:

copy

is not automatically an independent duplicate.

Both references point to the same instance.

Changing through one reference can therefore be visible through the other.

Common Beginner Mistake: Forgetting mutating

Incorrect:

struct Counter {

    var value = 0

    func increment() {
        value += 1
    }
}

Correct:

struct Counter {

    var value = 0

    mutating func increment() {
        value += 1
    }
}

Common Beginner Mistake: Using let for a Mutable Struct

Incorrect:

let counter = Counter()

counter.increment()

Correct:

var counter = Counter()

counter.increment()

Common Beginner Mistake: Expecting let Class Instances to Be Fully Immutable

Consider:

let user = User(name: "Alex")

If User is a class with:

var name: String

this may still be valid:

user.name = "Emma"

The let prevents the variable from being reassigned to a different instance.

It does not make every mutable property inside that referenced instance constant.

Common Beginner Mistake: Using Inheritance Everywhere

Inheritance can be useful, but deep inheritance hierarchies often make code harder to understand.

Instead of automatically designing:

A
↓
B
↓
C
↓
D
↓
E

consider whether protocols and composition provide a clearer design.

Swift heavily supports protocol-oriented programming.

Common Beginner Mistake: Using Classes for Every Model

A basic API model such as:

class Product {
}

does not necessarily need to be a class.

If it simply represents independent data, a struct may be clearer:

struct Product: Codable {
    let id: Int
    let name: String
}

Choose based on semantics rather than habit.

Practical Example: Shopping Cart

Let’s combine structures and classes.

Product:

struct Product {

    let id: Int
    let name: String
    let price: Double
}

Cart item:

struct CartItem {

    let product: Product
    var quantity: Int

    var total: Double {
        product.price * Double(quantity)
    }
}

Cart manager:

class ShoppingCart {

    private(set) var items: [CartItem] = []

    func add(_ item: CartItem) {
        items.append(item)
    }

    func totalPrice() -> Double {
        items.reduce(0) {
            $0 + $1.total
        }
    }
}

Use:

let phone = Product(
    id: 1,
    name: "iPhone",
    price: 999
)

let item = CartItem(
    product: phone,
    quantity: 2
)

let cart = ShoppingCart()

cart.add(item)

print(cart.totalPrice())

Output:

1998.0

Here:

Product → Struct
CartItem → Struct
ShoppingCart → Class

This demonstrates how value and reference types can work together.

Practical Example: Student

struct Student {

    let id: Int
    let name: String
    let marks: [Double]

    var average: Double {

        guard !marks.isEmpty else {
            return 0
        }

        return marks.reduce(0, +) / Double(marks.count)
    }

    func displayProfile() {
        print("ID: \(id)")
        print("Name: \(name)")
        print("Average: \(average)")
    }
}

Create:

let student = Student(
    id: 1,
    name: "Alex",
    marks: [80, 90, 85]
)

student.displayProfile()

This is a good example of grouping:

Data + Related Behavior

inside a structure.

Practical Example: Employee Inheritance

class Employee {

    let name: String

    init(name: String) {
        self.name = name
    }

    func work() {
        print("\(name) is working")
    }
}

Developer:

class Developer: Employee {

    override func work() {
        print("\(name) is writing code")
    }
}

Designer:

class Designer: Employee {

    override func work() {
        print("\(name) is creating designs")
    }
}

Use:

let developer = Developer(name: "Alex")
let designer = Designer(name: "Emma")

developer.work()
designer.work()

Output:

Alex is writing code
Emma is creating designs

This demonstrates class inheritance and polymorphic behavior.

Swift Structures and Classes Cheat Sheet

Structure

struct User {
    let name: String
}

Class

class User {

    let name: String

    init(name: String) {
        self.name = name
    }
}

Create Struct Instance

let user = User(name: "Alex")

Method

func greet() {
    print("Hello")
}

Computed Property

var fullName: String {
    "\(firstName) \(lastName)"
}

Mutating Struct Method

mutating func update() {
    value += 1
}

Class Inheritance

class Dog: Animal {
}

Override

override func makeSound() {
}

Parent Implementation

super.makeSound()

Prevent Inheritance

final class UserManager {
}

Type Property

static let appName = "My App"

Identity

object1 === object2

Safe Type Cast

object as? Dog

Deinitializer

deinit {
}

Practice Exercises

Try these exercises before moving to the next Swift topic.

Exercise 1: Book Structure

Create:

struct Book

with:

title
author
price

Then create three book instances.

Exercise 2: Rectangle

Create a structure with:

width
height

Add a computed property:

area

Expected:

width = 10
height = 5
area = 50

Exercise 3: Counter

Create:

struct Counter

with:

value
increment()
decrement()
reset()

Remember that methods changing struct properties need appropriate mutation handling.

Exercise 4: Bank Account

Create a class containing:

accountNumber
balance
deposit()
withdraw()

Prevent external code from directly changing the balance.

Exercise 5: Animal Inheritance

Create:

Animal
 ↓
Dog
 ↓
GermanShepherd

Add and override methods to understand inheritance.

Exercise 6: Struct Copy

Create:

var first = User(...)
var second = first

Change second.

Check whether first changes.

Exercise 7: Class Reference

Repeat the previous exercise using a class.

Observe the difference.

This is one of the most important exercises in the article.

Frequently Asked Questions

What is a struct in Swift?

A struct is a custom value type that can contain properties, methods, initializers, computed properties, and protocol conformances.

Structures use value semantics.

What is a class in Swift?

A class is a reference type that can contain properties, methods, initializers, computed properties, and other functionality.

Classes additionally support features such as class inheritance, reference identity, and deinitializers.

What is the biggest difference between a struct and class?

The fundamental difference is:

Struct → Value Type
Class → Reference Type

Assigning a struct generally gives you independent value semantics, while assigning a class instance copies a reference to the same object.

Can structs have methods?

Yes.

Example:

struct User {

    func greet() {
        print("Hello")
    }
}

Can structs have initializers?

Yes.

Swift can automatically synthesize memberwise initializers for many structures, and you can also create custom initializers.

Can structs inherit from other structs?

No.

Swift structures do not support class-style inheritance.

They can adopt protocols.

Can classes inherit from other classes?

Yes.

Example:

class Dog: Animal {
}

Can a Swift class inherit from multiple classes?

No. Swift classes use single class inheritance.

A class can, however, conform to multiple protocols.

Why does a struct method need mutating?

Because a structure is a value type.

A method that changes the structure’s stored state must be marked mutating.

Why can a let class instance change its properties?

A constant class variable prevents the reference from being reassigned.

Mutable properties of the referenced object can still change.

What does === mean in Swift?

=== checks whether two class references point to the exact same instance.

Should Swift models be structs or classes?

Many simple data models work naturally as structs because independent value semantics are useful.

However, the correct choice depends on whether the model requires shared identity, reference semantics, inheritance, or other class-specific behavior.

Are SwiftUI views classes or structs?

SwiftUI views are commonly structures conforming to the View protocol.

Example:

struct ContentView: View {

    var body: some View {
        Text("Hello")
    }
}

Are structs faster than classes?

Avoid choosing between them based on a blanket claim that one is always faster.

Their semantics are more important.

Choose:

Struct → when value semantics fit the model

Class → when reference semantics fit the model

Then optimize performance based on actual profiling if necessary.

What Should You Learn After Classes and Structures?

A strong Swift learning sequence is:

Variables & Data Types
        ↓
Arrays, Sets & Dictionaries
        ↓
Functions
        ↓
Optionals
        ↓
Structures & Classes
        ↓
Enums
        ↓
Closures
        ↓
Protocols
        ↓
Extensions
        ↓
Generics
        ↓
Error Handling
        ↓
Async/Await
        ↓
SwiftUI

After understanding structures and classes, protocols and extensions become particularly important because they show how Swift types can share behavior without relying entirely on inheritance.

Final Thoughts

Swift structures and classes both allow you to create powerful custom types containing data and behavior.

They share many capabilities:

Properties
Methods
Initializers
Computed Properties
Protocols
Extensions

But their semantics are different.

Remember:

STRUCT
   ↓
Value Type
   ↓
Assignment creates independent value semantics
   ↓
No class inheritance
   ↓
Great for many data models


CLASS
   ↓
Reference Type
   ↓
Multiple references can share one instance
   ↓
Supports inheritance
   ↓
Has identity and ARC-managed lifetime

For example:

struct Product {
    let id: Int
    let name: String
}

is a natural representation of product data.

While something like:

class SessionManager {
    var currentUser: User?
}

may intentionally use shared reference semantics.

The most important question is therefore not:

“Are structs better than classes?”

Instead ask:

“Should this type behave like an independent value or a shared object with identity?”

If it should behave like a value, a struct is often the natural choice.

If it needs shared identity or class-specific behavior, a class may be the right choice.

Once you understand this distinction, Swift architecture, SwiftUI state, models, services, protocols, and application design become much easier to understand.

Swift Classes and Structures Explained: Complete Beginner’s Guide

What Is a Structure in Swift?

What Is a Class in Swift?

Structure vs Instance

Properties in Swift Structures and Classes

let vs var Properties

Stored Properties

Default Property Values

Memberwise Initializers for Structures

Classes Need Initialization

What Is init in Swift?

What Does self Mean?

Custom Initializers

Multiple Initializers

Methods in Structures and Classes

Methods with Parameters

Methods with Return Values

Computed Properties

Stored vs Computed Properties

Getters and Setters

Mutating Methods in Structures

Why Does the Struct Instance Need var?

Classes Do Not Need mutating

The Most Important Difference: Value vs Reference Types

Structures Are Value Types

Classes Are Reference Types

Struct Copy vs Class Reference

Struct

Class

Value Types in Swift

Reference Types in Swift

Identity Operators for Classes

== vs ===

Structures Can Conform to Equatable

Class Inheritance

What Is a Superclass?

Overriding Methods

Calling the Parent Implementation with super

Overriding Properties

final Classes

Structures Do Not Support Class Inheritance

Type Properties

Static Methods

Class Type Methods

Lazy Stored Properties

Property Observers

Deinitializers

Automatic Reference Counting

Reference Cycles

Type Casting with Classes

Downcasting with as?

as! and Forced Casting

Structures Can Adopt Protocols

Struct Example: Product Model

Struct Example: API Model

Struct Example: SwiftUI Model

Class Example: Shared Manager

Class Example: Bank Account

What Does private(set) Mean?

Access Control with Classes and Structures

Struct vs Class Comparison

When Should You Use a Struct?

When Should You Use a Class?

Should Beginners Use Struct or Class by Default?

Struct vs Class Example Side by Side

Struct

Class

Common Beginner Mistake: Assuming Class Assignment Creates a Copy

Common Beginner Mistake: Forgetting mutating

Common Beginner Mistake: Using let for a Mutable Struct

Common Beginner Mistake: Expecting let Class Instances to Be Fully Immutable

Common Beginner Mistake: Using Inheritance Everywhere

Common Beginner Mistake: Using Classes for Every Model

Practical Example: Shopping Cart

Practical Example: Student

Practical Example: Employee Inheritance

Swift Structures and Classes Cheat Sheet

Structure

Class

Create Struct Instance

`==` vs `===`