您可以使用class-holder：

class Ref<T> {
  var value: T

  init(_ value: T) {
    self.value = value
  }
}

或者尝试阅读有关In-Out参数的信息，也许它会在某些方面对您有所帮助：

如上所述，变量参数只能在函数本身内更改。如果希望函数修改参数值，并且希望这些更改在函数调用结束后保持不变，请将该参数定义为in-out参数。
您可以在参数定义的开头放置inout保留字来写入in-out参数。in-out参数的值会传入函式，由函式修改，然后传回函式以取代原始值。
您只能将变数当做in-out参数的参数传递。您不能将常数或常值当做参数传递，因为常数和常值都无法修改。当您将变数当做参数传递给inout参数时，请在变数名称前直接放置&符号，以表示函数可以修改它。

func swapTwoInts(inout a: Int, inout _ b: Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// prints "someInt is now 107, and anotherInt is now 3"

在Swift中，我能想到的最类似的东西是inout变量，它们在Swift中被允许作为构造函数参数（但是将它们保存到变量中会使它们停止工作）：

class Demo {
    var value: Double

    init(inout value: Double) {
        value++
        self.value = value
    }
}

var value = 1.0
let demo = Demo(value: &value)
print(value) // 2.0

demo.value++
print(value) // 2.0

因此，我不相信你想要的语法是可能的。但是，如果你能重新解决这个问题，也许inout参数可以作为替代。

我用这个：

@propertyWrapper public struct Inout<T> {
    public init(wrappedValue: T) {
        storage = .init(value: wrappedValue)
    }

    private let storage: Storage

    public var wrappedValue: T {
        nonmutating get { storage.value }
        nonmutating set { storage.value = newValue }
    }

    private class Storage {
        init(value: T) {
            self.value = value
        }

        var value: T
    }
}

示例：

struct Example { 
    init(value: Inout<Int>) { 
        _value = value
    }

    @Inout var value: Int

    func performAction() { 
        value += 19
    }
}
let value = Inout(wrappedValue: 50)
let example = Example(value: value)
example.performAction()
print(value.wrappedValue) // 69