Question

作为一个接收Swift的C ++开发人员，我想知道如何在结构或其他类中存储＆＃34;指针＆＃34;或＆＃34;参考＆＃34;对另一个阶级的另一个对象的属性。

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

控制响应者：

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!
}

在我的情况下，效果可以是不同的类，但是针对修改的目标始终是Double（准确地说 - 我正在使用AudioKit并且我正在定位像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分配的指针。您可以从address-of运算符和withUnsafeMutablePointer获得的指针是作弊，它们仅在短时间内有效;超过这一点使用它们将产生不可预测的结果。

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

你可以获得的最通用的是使用一对闭包，一个返回值，另一个设置它。但是，对于您的特定情况，可能会有一个不那么通用但更有用的方法。

Swift相当于C ++指针/引用约定？

1 个答案: