Getters e setters de propriedades

Com esta classe simples, estou recebendo o aviso do compilador

Tentativa de modificar / acessar xdentro de seu próprio setter / getter

e quando eu uso assim:

var p: point = Point()
p.x = 12

Eu recebo um EXC_BAD_ACCESS. Como posso fazer isso sem ivars de apoio explícitos?

class Point {

    var x: Int {
        set {
            x = newValue * 2 //Error
        }
        get {
            return x / 2 //Error
        }
    }
    // ...
}

Setters e Getters se aplicam a computed properties; essas propriedades não têm armazenamento na instância - o valor do getter deve ser calculado a partir de outras propriedades da instância. No seu caso, não há xcomo atribuir.

Explicitamente: "Como posso fazer isso sem ivars de apoio explícitos". Você não pode - precisará de algo para fazer backup da propriedade computada. Tente o seguinte:

class Point {
  private var _x: Int = 0             // _x -> backingX
  var x: Int {
    set { _x = 2 * newValue }
    get { return _x / 2 }
  }
}

Especificamente, no Swift REPL:

 15> var pt = Point()
pt: Point = {
  _x = 0
}
 16> pt.x = 10
 17> pt
$R3: Point = {
  _x = 20
}
 18> pt.x
$R4: Int = 10

Setters / getters no Swift são bem diferentes do ObjC. A propriedade se torna uma propriedade calculada, o que significa que não possui uma variável de suporte, como _xteria no ObjC.

No código da solução abaixo, você pode ver xTimesTwoque não armazena nada, mas simplesmente calcula o resultado de x.

Consulte Documentos oficiais sobre propriedades computadas .

A funcionalidade que você deseja também pode ser Observadores de propriedades .

O que você precisa é:

var x: Int

var xTimesTwo: Int {
    set {
       x = newValue / 2
    }
    get {
        return x * 2
    }
}

Você pode modificar outras propriedades dentro do setter / getters, para que servem.

Você pode personalizar o valor configurado usando o observador de propriedades. Para fazer isso, use 'didSet' em vez de 'set'.

class Point {

var x: Int {
    didSet {
        x = x * 2
    }
}
...

Quanto a getter ...

class Point {

var doubleX: Int {
    get {
        return x / 2
    }
}
...

Para elaborar a resposta do GoZoner:

Seu problema real aqui é que você está chamando recursivamente o seu parceiro.

var x:Int
    {
        set
        {
            x = newValue * 2 // This isn't a problem
        }
        get {
            return x / 2 // Here is your real issue, you are recursively calling 
                         // your x property's getter
        }
    }

Como o comentário do código sugere acima, você está chamando infinitamente o getter da propriedade x, que continuará sendo executado até obter um código EXC_BAD_ACCESS (você pode ver o botão giratório no canto inferior direito do ambiente de playground do seu Xcode).

Considere o exemplo da documentação do Swift :

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct AlternativeRect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

Observe como a propriedade computada ao centro nunca se modifica ou retorna na declaração da variável.

Para substituir settere getterpara variáveis ​​rápidas, use o código abaixo

var temX : Int? 
var x: Int?{

    set(newX){
       temX = newX
    }

    get{
        return temX
    }
}

Precisamos manter o valor da variável em uma variável temporária, pois tentar acessar a mesma variável cujo getter / setter está sendo substituído resultará em loops infinitos.

Podemos invocar o setter simplesmente assim

x = 10

O Getter será chamado ao disparar abaixo da linha de código fornecida

var newVar = x

Você está definindo recursivamentex com x. Como se alguém lhe perguntasse quantos anos você tem? E você responde: "Tenho o dobro da minha idade". O que não tem sentido.

Você deve dizer que tenho o dobro da idade de John ou qualquer outra variável que não seja você.

variáveis ​​computadas são sempre dependentes de outra variável.

A regra do polegar é não acessar a propriedade em si a partir de dentro do getter ie get. Porque isso desencadearia outro getque desencadearia outro. . . Nem imprima. Porque a impressão também exige 'obter' o valor antes que ela possa ser impressa!

struct Person{
    var name: String{
        get{
            print(name) // DON'T do this!!!!
            return "as"
        }
        set{
        }
    }
}

let p1 = Person()

Como isso daria o seguinte aviso:

Tentativa de acessar 'nome' de dentro do seu próprio getter.

O erro parece vago assim:

Como alternativa, você pode querer usar didSet. Com didSetvocê manterá o valor que foi definido antes e acabou de ser definido. Para mais, veja esta resposta .

Atualização: Swift 4

Na classe abaixo, setter e getter são aplicados à variável sideLength

class Triangle: {
    var sideLength: Double = 0.0

    init(sideLength: Double, name: String) { //initializer method
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }

    var perimeter: Double {
        get { // getter
            return 3.0 * sideLength
        }
        set(newValue) { //setter
            sideLength = newValue / 4.0
        }
   }

Criando objeto

var triangle = Triangle(sideLength: 3.9, name: "a triangle")

Getter

print(triangle.perimeter) // invoking getter

Normatizador

triangle.perimeter = 9.9 // invoking setter

Tente usar isto:

var x:Int!

var xTimesTwo:Int {
    get {
        return x * 2
    }
    set {
        x = newValue / 2
    }
}

Essa é basicamente a resposta de Jack Wu, mas a diferença é que, na resposta de Jack Wu, sua variável x é var x: Int, na minha, minha variável x é assim: var x: Int!então tudo o que fiz foi torná-la um tipo opcional.

Atualização para o Swift 5.1

A partir do Swift 5.1, agora você pode obter sua variável sem usar a palavra-chave get . Por exemplo:

var helloWorld: String {
"Hello World"
}

Setters e getters no Swift se aplicam a propriedades / variáveis ​​calculadas. Na verdade, essas propriedades / variáveis ​​não são armazenadas na memória, mas computadas com base no valor das propriedades / variáveis ​​armazenadas.

Consulte a documentação Swift da Apple sobre o assunto: Swift Variable Declarations .

Aqui está uma resposta teórica. Isso pode ser encontrado aqui

Uma propriedade {get set} não pode ser uma propriedade armazenada constante. Deve ser uma propriedade calculada e get e set devem ser implementados.