9.1.2. Initializing structs with different initializers

We can define multiple initializers in a struct. At this point, we will define a new struct Car to demonstrate this concept. Let's define Car:

struct Car{
    var make:String
    var model:String
    var year:Int
    
    init(){
        make = "Not set"
        model = "Not set"
        year = 0
    }
}

//creating an instance of Car...
var car = Car()

//printing the instance...
print(car)

It prints:

Car(make: "Not set", model: "Not set", year: 0)

Here, we can see that all the default values were set when we created the instance.

Now, let's define another custom init() method along with the default one. This custom init() will accept parameters when we are creating the instance.

struct Car{
    var make:String
    var model:String
    var year:Int
    
    //default init...
    init(){
        make = "Not set"
        model = "Not set"
        year = 0
    }
    //custom init...
    init(make:String, model:String, year:Int) {
        self.make = make
        self.model = model
        self.year = year
    }
}

Do you see the self keyword? What do you think it is? - self is used to refer to the current instance of Car. See, we are using the same names for the parameters the method accepts as the properties of Car. By writing self.make = make, we are instructing the program to set the value of the current instance's make property to the value of the parameter make accepted by the init() method.

Now, we can create an instance of Car by calling the new init(make:String, model:String, year:Int) method. Let's try:

//creating an instance of Car using the custom init()...
var car2 = Car(make: "Toyota", model: "Corolla", year: 2020)
print(car2)

It prints:

Car(make: "Toyota", model: "Corolla", year: 2020)

So yes! We can create instances of a struct using multiple init() methods.

Struct initialization and Optionals

Let's continue with the same Car example. Let's assume that when we are creating an instance of Car struct, we only want to set the values for two parameters, make and model, and keep the value of year empty. We can write a new init() method like:

init(make:String, model:String){
    self.make = make
    self.model = model
    //year is left uninitialized...
}

If we add this method, we will see an error:

So it is saying that we need to initialize all stored properties (year is not initialized). Now, how can we initialize make and model without initializing year?

Remember Optional?

Yes, we can declare year as an Optional like the following:

struct Car{
    var make:String
    var model:String
    var year:Int? //Optional
    
    //omitted other codes...
    init(make:String, model:String){
        self.make = make
        self.model = model
    }
}

Now that we do not have the error anymore, we can create an instance of Car and initialize it:

//creating an instance of Car...
var car3 = Car(make: "Honda", model: "Civic")
print(car3)
//prints: Car(make: "Honda", model: "Civic", year: nil)

//Assigning a value of year after we create the instance
car3.year = 2022
print(car3)
//prints: Car(make: "Honda", model: "Civic", year: Optional(2022))

Do you see an issue? year is wrapped with Optional. So if you want to use it anywhere, we should use an unwrapping technique like if-let.

Source code

14KB

MyPlayground9.1.2.playground.zip

archive

Open