Objective-Oriented Swift 2.0 - Custom Initializers

thanks!!

No problem!

Hi Michael,

Yes, the value passed into the init method (red: Double) is assigned to the stored property inside the struct: let red: Double. That's what the init method does; it allows the user to send in stored properties at the time the instance is created.

The hard coding that I was referring to was when the init method had self.red = 86.0. So whatever number was passed into the method was ignored and the value 86 assigned to red irrespective. Further, you can't amend the value assigned to red after the instance is created as it is defined with let not var.

Whatever you pass in with the hard-coded init method (the one with the specific numbers in it), the parameters won't affect the object that is created. Every object will be created with the same numbers which can't be changed after instantiation.

Take this from my above post:

    init(red: Double, green: Double, blue: Double, alpha: Double){
        self.red = 86.0
        self.green = 191.0
        self.blue = 131.0
        self.alpha = 1.0
        self.description = "red: \(red), green: \(green), blue: \(blue), alpha: \(alpha)"
    }

var myRGB = RGBColor(red: 30.0, green: 100.0, blue: 41.0, alpha: 15.0)

The values in the last line, the parameters passed to the init method are used only in description - they are correctly interpolated into the string with \(red) \(green), etc. They aren't used in the stored properties as those are assigned the values coded into the init method. Every instance of this struct will have the values set inside the initializer, not passed to it by the user.

Happy with that explanation?

Steve.

That does pass, which is a shame because the code isn't correct as the initializer shouldn't hard-code the values. Your init method takes four parameters and then totally ignores them and assigns fixed-values into the stored properties. Whatever you pass into the constructor/init method, an object with the same 4 values is created. The thread above explains why that is the case; shout if you don't see what that's about.

I'll report this as a bug and get it fixed! One for Pasan Premaratne , I think!

Steve.

I've let the guys know and I will keep you posted as to progress.

It's interesting; the description will be correct as that uses the passed-in values, but the object won't be as that doesn't. The tests aren't picking up on that.

Yes, it is a bug. The hard-coded example shouldn't work.

Hi Raphael,

The values for the RGBA elements given in the challenge are examples only. You can use them to test the init method, but you want the RGBColor struct to work for any color.

So, the values you use inside he init are those that get passed in when the user creates an instance of the struct. Using the numbers in the question, to create a struct, you would type something like:

let exampleColor = RGBColor(red: 86.0, green: 191.0, blue: 131.0, alpha: 1.0)

Those numbers could be any number between zero and 255. That covers all the colors! So, to get your code to work, you just need to change the numbers to the argument names. Change 86.0 to red (that's the value passed in above, right?), change 191.0 to green and so on.

Your final init method looks like:

init(red: Double, green: Double, blue: Double, alpha: Double){
  self.red = red
  self.green = green
  self.blue = blue
  self.alpha = alpha
  /// define description here
}

The description piece is a little trickier and needs you to use some string interpolation. Have a go and shout back if you need a hand.

Steve.

The description is just another stored property of the struct. It is there for a user to access if they wish. The struct itself doesn't concern itself with printing it out - it just stores the value.

So, using string interpolation, the (var) thing, we can build the sentence that the challenge is asking for:

self.description = "red: \(red), green: \(green), blue: \(blue), alpha: \(alpha)"

With the code we wrote above, that would mean that description will now hold a string that says, red: 86.0, green: 191.0, blue: 131.0, alpha: 1.0. Should anyone using the struct, like the one we created above (exampleColor), want to print out that string, they can use something like:

print(exampleColor.description)

That accesses the stored property of the struct using dot notation. The description property is not passed into the initmethod as a parameter, it is created from the other stored properties that are passed in as parameters. So, all instances of RGBColor structs will have four numbers held as stored properties, the RGBA bits, and a nice string description that can all be accessed using the notation, like above.

I hope that helps.

Steve.

There's nothing wrong with that code, as far as I can tell. However, the challenge compiler thinks you are using a default initializer, rather than having created your own. The error it throws implies that - I can't tell you more than that, I am afraid. I don't know why it fails - the code looks good to me.

Yeah, I think this might be one of the very rare instances where "it works in Xcode" is relevant. Be wary of posting that line - you'll see it a lot in the forum posts. 'Working in Xcode' and doing what the challenge wants are often two totally different things! This one, I think you're right, though. I just changed, r for red etc. and the code passed the tests. I'll flag it with Support as it is a strange one that warrants explanation, I think. I'll let you know when I get that!

Cheers,

Steve.

I've submitted the request and will let you know what I get back. Something to do with your code looking like an auto-generated initializer, I think as the error was: Don't use the memberwise initializer Swift creates. Add your own custom initializer as specified in the directions

So the issue here is that for the challenge I have to look for the declaration of specific parameters in the initializer. The error message is vague...that can be fixed, but the reason for requiring specific parameters is just because of what Swift allows me to do under the hood for these challenges

Thanks Pasan Premaratne ,

But why is r not a specific parameter, while red is? The above code, which fails, is identical to the code that passes except for the shorter names, r rather than red, g rather than green etc.

Steve.

Steve Hunter

I chose "red", "green", etc..because if Swift created a memberwise initializer automatically for you, it would use the property names. That's the convention.

The challenge is hardcoded to look for "red" specifically because there's an infinite number of parameter names you can chose from and I can't account for every single one. I went with that most common, if that makes sense.

For what its worth (not that we test this), I'd go as far as to say "r" is a wrong choice of name. Swift and iOS have pretty strict conventions around naming and the guideline is to be verbose and descriptive with your names.

But yeah, "r" works in Xcode because Xcode is not looking for anything specific, while I am.

Thanks Pasan,

I hadn't realised you'd tested the names of the parameters - that makes sense now. I thought you tested that the initializer created an object properly, in accordance with the instructions.

Thanks,

Steve.

I'd love not to test the parameter names to be honest, but there's no way around it. Initializers are pretty hardcoded to their names under the hood.

Hiya,

The/one correct way is marked as 'Best Answer' in this thread. That code performs the same as your code in your later post. My reference to a bug related to your first post which contained incorrect code which passed the challenge.

I think it is more important to understand why the code in your first post isn't correct, rather than getting immersed in being right. Do you see that?

Steve.

Hi Rzgar,

Each object your code created is hard coded to the extent that their properties are determined by the code, not the user's choice of values passed to the parameter. We're talking about your original post here, the one I flagged as an issue with the compiler.

Take the init method:

    init(red: Double, green: Double, blue: Double, alpha: Double){
        self.red = 86.0
        self.green = 191.0
        self.blue = 131.0
        self.alpha = 1.0
        self.description = "red: \(red), green: \(green), blue: \(blue), alpha: \(alpha)"
    }

Let's say we create a variable instance of this and pass in:

var myRGB = RGBColor(red: 30.0, green: 100.0, blue: 41.0, alpha: 15.0)

Then, the objects created by this will always have the same colour properties; only their description will be different and contradictory to the acual contents of the object. Let's focus on red. We've passed in 30. What will myRGB.red have in it? 86.0. But the description will say "red: 30.0". Can we change this value? No - it is a constant even if the myRGB variable isn't. So myRGB.red = 86.0 fails because red is initialized and cannot be changed after that.

So, whilst your stored properties might not be hard-coded inside the struct; they are inside the constructor. Every object will hold the same values of red, green, blue and alpha that will not be changable in code.

That is how I meant the values are hard-coded. Make sense?

Steve.

Hey, no problem!

Hi Perry,

Which bit is causing the confusion? This thread covered a lot of ground!!

Steve.

As long as you're OK to continue, that's great.

Of course I can try to help - can you link me to the challenge? This is a very old thread on an out-of-date Swift version! I'll look at the challenge and get your code fixed if you can link me.

Steve.

Ohh. Thanks, I finally got it!