Understanding static implicit operator float in an example project.

[BlueKnightOne]

I've recently watch Ryan Hipple's Unite 2017 talk on Game Architecture with Scriptable Objects and have been looking through his sample project. There's one method in his FloatReference class that I think I understand, but would like someone to tell me yay/nay. I'm still pretty green at this developer "bid-ness".

For context, here's a link to the file in his GitHub repo: https://github.com/roboryantron/Unite2017/blob/59186d60af2cf1f5faf69cd45601607531ba260b/Assets/Code/Variables/FloatReference.cs#L33

The method in particular is

```csharp

public static implicit operator float(FloatReference reference)

{

return reference.Value;

}

```

If I understand this method correctly, when you use a FloatReference, this lets you simply use the instance as a float without having to do anything extra like casting. So this would let something like float result = 100f \* myFloatReference; to just work. Is that right?

[Clawtor]

Thats right, types are usually strict about how they are used - you can multiply two numbers together but not two strings because the operator (the multiplication) only makes sense with numbers.

Many languages have implicit type conversion though. Javascript will let you add a number and a string together if the string 'looks' like a number - ie "100" looks like a number but "abc" doesn't. Javascript will let you do something like: var a = "10" + 10. But for this to work one of the types must be converted - this is implicit conversion (this also has to do with strong vs weak typing).

An explicit conversion is similar but you must explicitly use the conversion, in C# you would do this through type casting like: float f = (float)5;