Swift 等效于 C++ 指针/引用约定？

Question

作为一名开始使用 Swift 的 C++ 开发人员，我想知道如何在结构或其他类中存储指向另一个类的另一个对象的属性的“指针”或“引用”。

例如 - 一个 controlResponder 类(或结构)，它监听事件以修改 effect 类中目标的值 target .

控制响应器:

struct controlResponder {
    var ccNum : Int!  // CC number to respond to
    var target : Double! // Points to the variable of another object
    var min : Double!
    var max : Double!
}

在我的例子中，Effects 可以属于不同的类，但是将要修改的目标总是 Double像 AKVariableDelay.time, 或者 AKMoogLadderFilter.cutoff )

任何见解将不胜感激，谢谢!

下面是我的一些实际(非功能性)代码的删节版:

import Foundation
import AudioKit
import SwiftyJSON

class Effect : AKNode, AKMIDIListener {

  enum CustomError: Error {
    case badEffectName
  }

  struct ccListener {
    var ccNum : Int!
    var target : Int!
    var min : Double!
    var max : Double!
  }

  var listeners : [ccListener]

  var effectType = ""
  var effect = AKNode()
  var channel = 0
  var midi : AKMIDI

  init(connectionInput : AKNode, midi : AKMIDI, subJson : JSON, channel : Int) throws {

    self.midi = midi
    self.channel = channel
    var insertType = subJson["type"]

    if insertType == "distortion" {
      print("Adding a DISTORTION")
      effect = AKTanhDistortion(connectionInput)

      if let efx = effect as? AKTanhDistortion {
        let gainVal = random(subJson["gain random low"].doubleValue, subJson["gain random high"].doubleValue)
        print("gainVal: \(gainVal)")
        efx.pregain = gainVal
      }

    }
    else if insertType == "moog" {

      print("Adding a MOOG FILTER")
      /// CUTOFF
      let cutoffVal = random(subJson["cutoff random low"].doubleValue, subJson["cutoff random high"].doubleValue)
      print("cutoffVal: \(cutoffVal)")
      /// RESONANCE
      let resonanceVal = random(subJson["resonance random low"].doubleValue, subJson["resonance random high"].doubleValue)
      print("resonanceVal: \(resonanceVal)")

      effect = AKMoogLadder(connectionInput,
        cutoffFrequency: cutoffVal,
        resonance: resonanceVal)
    }
    else {
      print("BAD EFFECT TYPE: \(insertType)")
      throw CustomError.badEffectName
    }

    /////// MIDIZ

    midi.openInput("vIn")

    super.init()

    for (key, cc) in subJson["ccs"] as JSON {
      let efx = effect as! AKMoogLadder
      listeners.append(ccListener(ccNum: cc["cc number"].intValue, target: efx.cutoffFrequency, min: cc["min"].doubleValue, max: cc["max"].doubleValue))
    }

    midi.addListener(self)
    print("End of Effect init()")
  }


  func receivedMIDIController(_ controller: MIDIByte, value: MIDIByte, channel: MIDIChannel) {
    print("Self channel: \(self.channel), incoming channel: \(Int(channel))")
      if self.channel == Int(channel){
        print("Effect got a CC!")
      }
    }

    func changeVal(ccNum: Int, newValue: Int) {

      for listener in listeners {
        if listener.ccNum == ccNum {
          listener.target = newValue
        }
      }

    }

  }

Answer 1

在 Swift 中，唯一可以可靠存储的指针是使用 UnsafeMutablePointer.allocate 分配的指针。 .您可以从地址运算符和 withUnsafeMutablePointer 获得的指针是作弊，它们只在短时间内有效；超出该点使用它们将产生不可预知的结果。

这意味着，一般来说，您不能存储指向使用“automatic storage”(借用 C++ 术语)分配的值类型(struct 实例)的指针。如果您需要共享值类型，则需要在某个方便的级别将它们包装在引用类型(class 实例)中。

最通用的方法是使用一对闭包，一个返回值，另一个设置值。但是，对于您的特定情况，可能有一种不太通用但更有用的方法。