Fighting history of CGFloat in Swift

CGFloat
2016/9/28 Hirohito Kato

• try! Swift 2016  
Swift (@RGfox) 
• ( )

CGFloat
• Core Graphics
•
• SpriteKit/SceneKit UIKit
•

CGFloat
• double / ﬂoat typedef
• CPU
• double

• CGFloat
• NSNumber CGFloat
• double
• iOS iPhone5 or iPhone5S

let value1: CGFloat = 240 // OK

let value1: CGFloat = 240 // OK
let value2: CGFloat = 80.0 // OK

let a = CGFloat(10)
let b = 30

let a = CGFloat(10)
let b = 30
let value = a + b // ERROR!

let a = CGFloat(10)
let b = 30
let value = a + CGFloat(b) // OK

let pos = CGPoint(x: 160, y: 80.0)

// OK

// OK
let a = 160

// OK
let a = 160
let pos = CGPoint(x: a, y: 80.0)

// OK
let a = 160
let pos = CGPoint(x: a, y: 80.0)
// ERROR!

let x = 32
let y = 120.0
let w = Float(44.0)

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
view.rect = CGRect(x: x,

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: y,

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: y,
width: w,

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: y,
width: w,
height: h)

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: y,
width: w,
height: h)
// ERROR!

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
view.rect = CGRect(x: CGFloat(x),

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: CGFloat(y),

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: CGFloat(y),
width: CGFloat(w),

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: CGFloat(y),
width: CGFloat(w),
height: h)

let x = 32
let y = 120.0
let w = Float(44.0)
let h = CGFloat(24)
y: CGFloat(y),
width: CGFloat(w),
height: h)
// OK

•
•
•
• Swift Objective-C

Float/Double CGFloat
•
•
• /
• …

extension Double {
var cgf:CGFloat { return CGFloat(self) }
}
let y = 1 + 10.0.cgf // OK, yay!

extension Double {
}
extension Int {
}
extension Float {
}

extension Double {
var c:CGFloat { return CGFloat(self) }
}
extension Int {
}
extension Float {
}
extension Float80 {
}
extension UInt {
}
extension UInt8 {
}
extension UInt16 {
}
extension UInt32 {
}
extension UInt64 {
}
extension Int8 {
}
extension Int16 {
}
extension Int32 {
}
extension Int64 {
}
extension UInt64 {
}
extension MyNumberType {
}
extension MyNumberTypeB {
}
:
…

OK
let a: Float = 190.0
let b: Int = 3
let value = CGFloat(a) + CGFloat(b)

CGFloat
public struct CGFloat {
public init()
public init(_ value: Float)
public init(_ value: Double)
public init(_ value: Float80)
public init(_ value: CGFloat)
public init(_ value: UInt8)
public init(_ value: Int8)
:

Protocol =
• API
•
• Java/C# Interface Ruby mix-in C++

• ( ) protocol
• extension
• /
protocol
extension Int: MyCustomProtocol {}
Swift protocol

Swift protocol
• init
•
protocol CGFConvertible {
init (_ value: Int)
init (_ value: Float)
init (_ value: Double)
init (_ value: CGFloat)
}
//
extension Int: CGFConvertible {}
extension Float: CGFConvertible {}
extension Double: CGFConvertible {}
extension CGFloat: CGFConvertible {}

•
… Swift  
extension CGFConvertible {
fileprivate func convert
<T: CGFConvertible>() -> T {
return T(self)
}
}

func checkType<T>(_ x: T) {
switch x {
case _ as CGFloat: print("(x) is a CGFloat")
case _ as Float: print("(x) is a Float")
case _ as Int: print("(x) is a Int")
case _ as Double: print("(x) is a Double")
default: print("(x) is unknown..")
}
}
Swift Workaround
RTTI

fileprivate func convert<T: CGFConvertible>() -> T {
switch self {
case let x as CGFloat: return T(x)
case let x as Float: return T(x)
case let x as Int: return T(x)
case let x as Double: return T(x)
default:
fatalError("Unsupported format")
}
}
public var c: CGFloat { return convert() }
}
K

…
•
• CGFloat
• Int,Float,Double
let value: Double = Double(CGFloat(3) + 5.cgf)

• / …
let a = CGFloat(10)
let b = 30
let value = a + 3.14 // ERROR!

let a = 3
let x: CGFloat = a + CGFloat(4.2) // OK
let y: CGFloat = a * 4.2 // OK, yay!

private typealias CombineType = (Double,Double) -> Double
fileprivate func operate<T:CGFConvertible, V:CGFConvertible>
(b:T, combine: CombineType) -> V {
let x:Double = self.convert()
let y:Double = b.convert()
return combine(x,y).convert()
}
}
func + <T:CGFConvertible, U:CGFConvertible,V:CGFConvertible>
(lhs: T, rhs: U) -> V { return lhs.operate(b: rhs, combine: + )
}
func - <T:CGFConvertible, U:CGFConvertible,V:CGFConvertible>
(lhs: T, rhs: U) -> V { return lhs.operate(b: rhs, combine: - )
}

a.
protocol CGFConvertible {
init (_ value: Int)
init (_ value: Float)
init (_ value: Double)
init (_ value: CGFloat)
}
extension Int: CGFConvertible {}
extension Float: CGFConvertible {}
extension Double: CGFConvertible {}
extension CGFloat: CGFConvertible {}
fileprivate func convert<T: CGFConvertible>() -> T
{ return T(x) }
}
•

b.
private typealias CombineType = (Double,Double) -> Double
fileprivate func operate<T:CGFConvertible, V:CGFConvertible>
(b:T, combine: CombineType) -> V {
let x:Double = self.convert()
let y:Double = b.convert()
return combine(x,y).convert()
}
}
func + <T:CGFConvertible, U:CGFConvertible,V:CGFConvertible>
(lhs: T, rhs: U) -> V { return lhs.operate(b: rhs, combine: + )
}
func - <T:CGFConvertible, U:CGFConvertible,V:CGFConvertible>
(lhs: T, rhs: U) -> V { return lhs.operate(b: rhs, combine: - )
}
func * <T:CGFConvertible, U:CGFConvertible,V:CGFConvertible>
(lhs: T, rhs: U) -> V { return lhs.operate(b: rhs, combine: * )
}
•

CGFloat ≠ Float/Double/…
• Objective-C
•
•
•
• /
•
• Swift

• CGFloat
• CGFloat
• Round up a CGFloat in Swift
• Swift

Fighting history of CGFloat in Swift

Fighting history of CGFloat in Swift

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Semelhante a Fighting history of CGFloat in Swift

Semelhante a Fighting history of CGFloat in Swift (20)

Mais de Hirohito Kato

Mais de Hirohito Kato (6)

Último

Último (20)

Fighting history of CGFloat in Swift