potencia - El operador binario Swift ''+'' no se puede aplicar a dos operandos CGFloat

sumar dos numeros en swift

Question

Estoy escribiendo una función en Swift para detectar en qué hexágono estoy haciendo clic. Pero me encontré con un mensaje de error peculiar que indica que no puedo agregar dos CGFloats. Todo lo que hice, por ejemplo, cambiando let a var , declare y cesé por separado, no funcionó. Supongo que debe haber algo más mal, pero no puedo encontrarlo. El código es el siguiente:

func pointToCoordinate(position: CGPoint) -> (Int, Int) {
        var gridHeight = 2 * singleRadius / sqrt(CGFloat(3)) * 1.5
        var gridWidth = 2 * singleRadius
        var halfWidth = singleRadius

        var relativePosition = CGPoint(x: position.x - totalRadius / 2, y: position.y - totalRadius / 2)
        println((relativePosition.y / gridHeight))
        var row = -(cgfloatToInt)(relativePosition.y / gridHeight)
        var column: Int

        println((relativePosition.x + halfWidth * CGFloat(row + 1)) / (gridWidth))
        column = cgfloatToInt((relativePosition.x + halfWidth * CGFloat(row + 1)) / (gridWidth))

//        var innerY: CGFloat = CGFloat(relativePosition.y) + CGFloat(gridHeight * row)
        var innerX = relativePosition.x
        var innerY = relativePosition.y

        innerY = innerY - CGFloat(gridHeight * row)

        println((innerX, innerY))
        return (column, row)
    }

Answer 1

De hecho, hay algo más mal, esto funciona:

import QuartzCore

let a:CGFloat = 1
let b:CGFloat = 2

let c = a + b
var innerY: CGFloat = CGFloat(1.0) + CGFloat(2.0)

y CGFloat implementa el tipo FloatingPointType

Answer 2

El mensaje de error es incorrecto. El problema es que estás tratando de multiplicar un Int y un CGFloat .

Reemplazar:

innerY = innerY - CGFloat(gridHeight * row)

con:

innerY = innerY - gridHeight * CGFloat(row)

La respuesta anterior es para la versión actual de su código. Para la versión comentada que corresponde al mensaje de error que publicó:

Reemplazar:

var innerY: CGFloat = CGFloat(relativePosition.y) + CGFloat(gridHeight * row)

con

var innerY: CGFloat = CGFloat(relativePosition.y) + gridHeight * CGFloat(row)

Answer 3

Mirando a través de todas las respuestas, castings, conversiones y extensiones, creo que la mejor solución para Swift es la sobrecarga del operador . Ejemplo de código a continuación para Swift 3.0:

/// overloads -/+ between a cgfloat on the left and an int/double on the right
func - (left: CGFloat, right: Double) -> CGFloat {
    return left - CGFloat(right);
}

func - (left: CGFloat, right: Int) -> CGFloat {
    return left - CGFloat(right);
}

func + (left: CGFloat, right: Double) -> CGFloat {
    return left + CGFloat(right);
}

func + (left: CGFloat, right: Int) -> CGFloat {
    return left + CGFloat(right);
}

Ponga esto en un lugar global FUERA de cualquier clase. Ver la magia ocurre.

Answer 4

Tarde para unirse. Según la respuesta de Vacawama, todos saben que el problema no es tener el mismo tipo de datos.
CGFloat necesita ser escrito varias veces a veces. Encontré esto más fácil a través de la extensión. Así que compartiendo una respuesta. Puede crear una extensión simple como a continuación. Por supuesto, esta extensión se puede modificar aún más.

import CoreGraphics
extension Int {
    var cgf: CGFloat { return CGFloat(self) }
    var f: Float { return Float(self) }
}

extension Float {
    var cgf: CGFloat { return CGFloat(self) }
}

extension Double {
    var cgf: CGFloat { return CGFloat(self) }
}

extension CGFloat {
    var f: Float { return Float(self) }
}

Ahora podemos escribir

innerY = innerY - gridHeight * row.cgf