Protocols in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Protocol Requirements

Given the protocol and struct below, what will be the output when calling print(user.description)?

iOS Swift

protocol Describable {
  var description: String { get }
}

struct User: Describable {
  var name: String
  var description: String {
    return "User: \(name)"
  }
}

let user = User(name: "Alice")
print(user.description)

A Alice

B User

C User: Alice

D Compilation error: missing protocol requirement

💡 Hint

Check how the description property is implemented in the struct.

The struct User conforms to Describable by implementing the description property. It returns "User: Alice" when accessed.

❓ ui_behavior

intermediate

Protocol and UIViewController Behavior

If a UIViewController conforms to a protocol with a method setupUI() and calls it inside viewDidLoad(), what happens when the view loads?

iOS Swift

protocol UISetup {
  func setupUI()
}

class MyViewController: UIViewController, UISetup {
  override func viewDidLoad() {
    super.viewDidLoad()
    setupUI()
  }
  func setupUI() {
    view.backgroundColor = .blue
  }
}

A Compilation error: UIViewController cannot conform to protocols.

B The app crashes because setupUI() is not called.

C The view background color remains default (white).

D The view background color becomes blue when the view loads.

💡 Hint

Look at when setupUI() is called and what it does.

The setupUI() method is called inside viewDidLoad(), so the background color changes to blue when the view loads.

❓ lifecycle

advanced

Protocol Extension and Method Dispatch

What will be printed when running the code below?

iOS Swift

protocol Greetable {
  func greet()
}

extension Greetable {
  func greet() {
    print("Hello from protocol extension")
  }
}

class Person: Greetable {
  func greet() {
    print("Hello from Person class")
  }
}

let p: Greetable = Person()
p.greet()

A Hello from Person class

B Hello from protocol extension

C Compilation error: greet() ambiguous

D Runtime error: method not found

💡 Hint

Consider how Swift chooses methods when a class implements a protocol method and the protocol has a default implementation.

Swift uses dynamic dispatch for class methods. Since Person implements greet(), that method is called instead of the protocol extension's default.

📝 Syntax

advanced

Protocol with Associated Type Syntax

Which option correctly declares a protocol with an associated type and a method using it?

A protocol Container { associatedtype ItemType func append(_ item: ItemType) }

B protocol Container { typealias ItemType func append(_ item: ItemType) }

C protocol Container { associatedtype ItemType func append(item: ItemType) -> Void }

D protocol Container { associatedtype ItemType func append(item: ItemType) }

💡 Hint

Look for the correct keyword to declare an associated type and method parameter syntax.

Option A correctly uses associatedtype and a method with a parameter labeled with underscore to omit external label, matching Swift syntax.

🔧 Debug

expert

Resolving Protocol Conformance Ambiguity

Given the code below, what error will the compiler produce?

iOS Swift

protocol Drawable {
  func draw()
}

extension Drawable {
  func draw() {
    print("Drawing from extension")
  }
}

class Shape: Drawable {
}

let shape = Shape()
shape.draw()

A Error: Type 'Shape' does not conform to protocol 'Drawable' because 'draw()' is not implemented

B No error; prints "Drawing from extension"

C Error: Ambiguous use of 'draw()'

D Runtime error: method 'draw()' not found

💡 Hint

Check if protocol extension provides a default implementation and if the class must implement it explicitly.

The protocol extension provides a default implementation of draw(), so Shape conforms without implementing it explicitly.

Practice

1. What is the main purpose of a protocol in Swift?

easy

A. To create a new class with default behavior

B. To define a blueprint of methods and properties that a type must implement

C. To store data persistently on the device

D. To handle user interface layout automatically

Solution

1. Step 1: Understand what a protocol defines

   A protocol specifies methods and properties that a type must implement, acting as a blueprint.

2. Step 2: Differentiate from other concepts

   Protocols do not create classes or store data; they only define requirements.

3. Final Answer:

   To define a blueprint of methods and properties that a type must implement -> Option B

4. Quick Check:

   Protocol purpose = blueprint [OK]

Hint: Protocols define required methods and properties [OK]

Common Mistakes:

• Confusing protocols with classes
• Thinking protocols store data
• Assuming protocols handle UI layout

2. Which of the following is the correct syntax to declare a protocol named Drivable in Swift?

easy

A. struct Drivable { func drive() }

B. class Drivable { func drive() }

C. func protocol Drivable() { drive() }

D. protocol Drivable { func drive() }

Solution

1. Step 1: Identify correct protocol declaration syntax

   Protocols are declared with the keyword protocol followed by the name and curly braces.

2. Step 2: Check method declaration inside protocol

   Methods inside protocols are declared without implementation, just the signature.

3. Final Answer:

   protocol Drivable { func drive() } -> Option D

4. Quick Check:

   Protocol syntax = keyword 'protocol' + name + method signatures [OK]

Hint: Use 'protocol' keyword, not class or struct [OK]

Common Mistakes:

• Using class or struct instead of protocol
• Adding method implementation inside protocol
• Incorrect keyword order

3. Consider this Swift code:

protocol Greetable {
  func greet() -> String
}

struct Person: Greetable {
  func greet() -> String {
    return "Hello!"
  }
}

let p = Person()
print(p.greet())

What will be printed when this code runs?

medium

A. Hello!

B. greet()

C. Error: Missing protocol implementation

D. nil

Solution

1. Step 1: Check protocol and struct conformance

   The struct Person adopts Greetable and implements the required greet() method returning "Hello!".

2. Step 2: Understand the print statement output

   Calling p.greet() returns "Hello!", which is printed.

3. Final Answer:

   Hello! -> Option A

4. Quick Check:

   Implemented method returns "Hello!" [OK]

Hint: Implemented protocol methods run normally [OK]

Common Mistakes:

• Expecting protocol name printed
• Thinking missing implementation error occurs
• Assuming nil is printed

4. What is wrong with this Swift code?

protocol Runnable {
  func run()
}

struct Athlete: Runnable {
  // Missing run() implementation
}

medium

A. No error, code is valid

B. Error: run() must have a return type

C. Error: Athlete does not implement required method run()

D. Error: Protocol Runnable cannot be adopted by struct

Solution

1. Step 1: Check protocol requirements

   The protocol Runnable requires a method run() with no return value.

2. Step 2: Verify struct conformance

   The struct Athlete adopts Runnable but does not implement run(), causing a compile error.

3. Final Answer:

   Error: Athlete does not implement required method run() -> Option C

4. Quick Check:

   Missing required method causes error [OK]

Hint: All protocol methods must be implemented [OK]

Common Mistakes:

• Assuming structs can't adopt protocols
• Thinking missing method is allowed
• Expecting run() to require return type

5. You want to create a protocol Vehicle with a property speed that can be read and set. Which of these protocol declarations is correct?

hard

A. protocol Vehicle { var speed: Int { get set } }

B. protocol Vehicle { var speed: Int }

C. protocol Vehicle { func speed() -> Int }

D. protocol Vehicle { let speed: Int }

Solution

1. Step 1: Understand property requirements in protocols

   To require a property to be readable and writable, use { get set } in the protocol.

2. Step 2: Analyze each option

   protocol Vehicle { var speed: Int { get set } } correctly declares speed as a variable property with get set. protocol Vehicle { var speed: Int } misses get set, so it's read-only. protocol Vehicle { func speed() -> Int } declares a method, not a property. protocol Vehicle { let speed: Int } uses let, which is not allowed in protocols.

3. Final Answer:

   protocol Vehicle { var speed: Int { get set } } -> Option A

4. Quick Check:

   Writable property = var with get set [OK]

Hint: Use 'var' with { get set } for read-write properties [OK]

Common Mistakes:

• Using 'let' in protocol properties
• Omitting { get set } for writable properties
• Confusing methods with properties