Swift 如何声明包含结构引用的变量？

具有以下特征：

struct Person {
   var name = "Noname"
}

class World {
   var person: Person!

   func changePersonName(newName: String) {
      person.name = newName
   }
}

let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")

println(you.name) // not "Eve", still "Adam"

就我而言，我希望

person.name

变成“Eve”

---

我的问题是如何使

World

中的

person

变量不是一个副本，而是一个可以像对象引用一样修改其值的引用？

如果需要“引用类型”，而不是“值类型”，那么使用

类，而不是
结构

class Person {
  var name = "Noname"
}

class World {
  var person = Person()
  changePersonName (name: String) {
    person.name = name
  }
}

如果需要“引用类型”，而不是“值类型”，则使用
类，而不是
结构

class Person {
  var name = "Noname"
}

class World {
  var person = Person()
  changePersonName (name: String) {
    person.name = name
  }
}

如果需要“引用类型”，而不是“值类型”，则使用
类，而不是
结构

class Person {
  var name = "Noname"
}

class World {
  var person = Person()
  changePersonName (name: String) {
    person.name = name
  }
}

如果需要“引用类型”，而不是“值类型”，则使用
类，而不是
结构

class Person {
  var name = "Noname"
}

class World {
  var person = Person()
  changePersonName (name: String) {
    person.name = name
  }
}

如果你真的想引用一个结构，那么你可以选择
unsafemeutablepointer
，但我不建议你使用它。
如果你真的想引用一个结构，那么
unsafemeutablepointer
就是你的选择，但是我不建议使用它。
如果你真的想引用一个结构，那么
不可缓存指针是你的选择，但我不建议使用它。
如果你真的想引用一个结构，那么
不可缓存指针是你的选择，但我不建议使用它。
正如GoZoner正确地说的那样，如果你想通过其他引用改变一个人，那么你需要一个类，而不是一个结构。这正是类和结构之间的主要区别之一。结构是一种值类型；类是引用类型。因此，从您的示例代码开始并修复它，以便它实际编译：

struct Person {
    var name = "Noname"
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Adam"
print(world.person.name) // "Eve"

因此，您可以看到
you
和
world.person
是person的两个不同实例。它们不是对同一实例的引用。这通常被认为是一件好事，但如果出于某种原因，这不是您想要的，那么使用类：

class Person {
    var name = "Noname"
    init(name:String) {self.name = name}
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Eve"
print(world.person.name) // "Eve"

正如GoZoner正确地说的，如果你想通过其他引用来改变一个人，那么你需要的是一个类，而不是一个结构。这正是类和结构之间的主要区别之一。结构是一种值类型；类是引用类型。因此，从您的示例代码开始并修复它，以便它实际编译：

struct Person {
    var name = "Noname"
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Adam"
print(world.person.name) // "Eve"

因此，您可以看到
you
和
world.person
是person的两个不同实例。它们不是对同一实例的引用。这通常被认为是一件好事，但如果出于某种原因，这不是您想要的，那么使用类：

class Person {
    var name = "Noname"
    init(name:String) {self.name = name}
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Eve"
print(world.person.name) // "Eve"

正如GoZoner正确地说的，如果你想通过其他引用来改变一个人，那么你需要的是一个类，而不是一个结构。这正是类和结构之间的主要区别之一。结构是一种值类型；类是引用类型。因此，从您的示例代码开始并修复它，以便它实际编译：

struct Person {
    var name = "Noname"
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Adam"
print(world.person.name) // "Eve"

因此，您可以看到
you
和
world.person
是person的两个不同实例。它们不是对同一实例的引用。这通常被认为是一件好事，但如果出于某种原因，这不是您想要的，那么使用类：

class Person {
    var name = "Noname"
    init(name:String) {self.name = name}
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Eve"
print(world.person.name) // "Eve"

正如GoZoner正确地说的，如果你想通过其他引用来改变一个人，那么你需要的是一个类，而不是一个结构。这正是类和结构之间的主要区别之一。结构是一种值类型；类是引用类型。因此，从您的示例代码开始并修复它，以便它实际编译：

struct Person {
    var name = "Noname"
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Adam"
print(world.person.name) // "Eve"

因此，您可以看到
you
和
world.person
是person的两个不同实例。它们不是对同一实例的引用。这通常被认为是一件好事，但如果出于某种原因，这不是您想要的，那么使用类：

class Person {
    var name = "Noname"
    init(name:String) {self.name = name}
}
class World {
    var person: Person!
    func changePersonName(newName: String) {
        person.name = newName
    }
}
let you = Person(name: "Adam")
let world = World()
world.person = you
world.changePersonName("Eve")
print(you.name) // "Eve"
print(world.person.name) // "Eve"

正如s1ddok所指出的，您可以使用
unsafemeutablepointer
：

struct Person {
    var name = "Noname"
}

class World {
    var person: UnsafeMutablePointer<Person>!

    func changePersonName(newName: String) {
        person.memory.name = newName
    }
}

var you = Person(name: "Adam")
var ptr = UnsafeMutablePointer<Person>.alloc(1)
ptr.initialize(you)
let world = World()
world.person = ptr
world.changePersonName("Eve")

print(ptr.memory.name)

struct-Person{
var name=“Noname”
}
阶级世界{
var person:不可女性化的指针！
func changePersonName（新名称：字符串）{
person.memory.name=newName
}
}
var you=个人（姓名：“亚当”）
var ptr=unsafemeutablepointer.alloc（1）
初始化（你）
让世界=世界
world.person=ptr
world.changePersonName（“Eve”）
打印（ptr.memory.name）
正如s1ddok所指出的，您可以使用
不可靠指针
：

struct Person {
    var name = "Noname"
}

class World {
    var person: UnsafeMutablePointer<Person>!

    func changePersonName(newName: String) {
        person.memory.name = newName
    }
}

var you = Person(name: "Adam")
var ptr = UnsafeMutablePointer<Person>.alloc(1)
ptr.initialize(you)
let world = World()
world.person = ptr
world.changePersonName("Eve")

print(ptr.memory.name)

struct-Person{
var name=“Noname”
}
阶级世界{
var person:不可女性化的指针！
func changePersonName（新名称：字符串）{
person.memory.name=newName
}
}
var you=个人（姓名：“亚当”）
var ptr=unsafemeutablepointer.alloc（1）
初始化（你）
让世界=世界
world.person=ptr
world.changePersonName（“Eve”）
打印（ptr.memory.name）
正如s1ddok所指出的，您可以使用
不可靠指针
：

struct Person {
    var name = "Noname"
}

class World {
    var person: UnsafeMutablePointer<Person>!

    func changePersonName(newName: String) {
        person.memory.name = newName
    }
}

var you = Person(name: "Adam")
var ptr = UnsafeMutablePointer<Person>.alloc(1)
ptr.initialize(you)
let world = World()
world.person = ptr
world.changePersonName("Eve")

print(ptr.memory.name)

struct-Person{
var name=“Noname”
}
阶级世界{
var person:不可女性化的指针！
func changePersonName（新名称：字符串）{
person.memory.name=newName
}
}
var you=个人（姓名：“亚当”）
var ptr=unsafemeutablepointer.alloc（1）
初始化（你）
让世界=世界
world.person=ptr
world.changePersonName（“Eve”）
打印（ptr.memory.name）
正如s1ddok所指出的，您可以使用
不可靠指针
：

struct Person {
    var name = "Noname"
}

class World {
    var person: UnsafeMutablePointer<Person>!

    func changePersonName(newName: String) {
        person.memory.name = newName
    }
}

var you = Person(name: "Adam")
var ptr = UnsafeMutablePointer<Person>.alloc(1)
ptr.initialize(you)
let world = World()
world.person = ptr
world.changePersonName("Eve")

print(ptr.memory.name)

struct-Person{
var name=“Noname”
}
阶级世界{
var person:不可女性化的指针！
func changePersonName（新名称：字符串）{
person.memory.name=newName
}
}
var you=个人（姓名：“亚当”）
var ptr=unsafemeutablepointer.alloc（1）
初始化（你）
让世界=世界
world.person=ptr
world.changePersonName（“Eve”）
打印（ptr.memory.name）
person
变量在哪里声明？person
变量是什么？我认为这不会编译。你的意思是
println（world.person.name）
？这是