Our Stack
implementation is now complete. We can push
, pop
, and peek
values on the Stack
. As we know if we attempt too many pop
s eventually nil
is returned as there are no Node
s on the stack.
However, what happens if we keep adding nodes onto the Stack
? There is nothing limiting the size of the stack! As we know with dishes, if the pile of dishes gets too high we may have a crash! This is the same for us, Stack
s take up memory and in many cases, we will want a limit on the size.
In this exercise, we will extend our Stack
class to have the concept of maximum size.
Instructions
We need to set the maximum size of the Stack
.
First, let’s create a private var property called size
in our Stack
struct and set the initial value to 0.
Next, we will add private var property called maxSize
which we will initialize in the init()
function. Set the type
of this to be Int
.
With structs, all properties need to be initialized inline where the property is declared as size
was or we need to initialize it in the init()
function.
Create an initializer and pass in a maxSize
parameter of type Int
.
For our exercise let’s set the default value to 2.
Initializers have the format init(<variable name>:<type> = <default value>)
Be sure to save the maxSize
parameter into the maxSize
property.
Now that we have size
and maxSize
properties we can add these into push()
and pop()
.
In push()
add a guard statement in the first line of the method to check that size < maxSize
. If the else is invoked we want to print out The stack is full! No room to add \(str)
and return.
If we do not enter the else, we know we will be adding on to the stack. In this case, increment the size
property by 1 before we call addToHead()
.
In pop()
we already have a guard
statement allowing us confidence that there is a node
that has been removed. We simply need to add a decrement of size
by 1 before we return node.data
.
Give it a try! In this case our defensive code should only allow two plates on the stack!