Swift Emulation von C-Array mit einer bestimmten Größe

Question

Ich möchte in der Lage sein, Variablen, die Arrays einer bestimmten Größe sind und vor-zugewiesen. In C könnte dies wie folgt gemacht werden:

typedef float vec16f[16]; 
vec4f myPresizedPreInitializedArray; 
myPresizedPreInitializedArray[2]=200.0f 

Wie würde man dies in Swift tun?

I habe versucht, die folgenden:

• typealias PositionVector = [Double] hat keine Größenbeschränkung noch Vorinitialisierung
• class Vector4D: Array<Any> {} Ergebnisse in dem Fehler Inheritance from non-protocol, non-class type 'Array<Any>'

Answer 1

Eine mögliche Lösung ist, eine Struktur mit einem statischen Elemente als Vorlage

struct Template { 
    static let vec4 = [Float](repeatElement(10.0, count: 4)) 
} 

var newVec = Template.vec4 
newVec[2] = 200.0 

Aufgrund der Werttyp-Semantik erhalten Sie immer eine Kopie von vec4.

Answer 2

Sie können eine Struktur schreiben, die ein Array wickelt und bietet eine [] Betreiber:

struct Vec4<T> { 
    private var array: [T] 

    init(_ x: T, _ y: T, _ z: T, _ w: T) { 
     array = [x, y, z, w] 
    } 

    subscript(index: Int) -> T { 
     get { 
      return array[index] 
     } 
     set { 
      array[index] = newValue 
     } 
    } 
} 

Oder es effizienter zu machen:

struct Vec4<T> { 
    private var x, y, z, w: T 

    init(_ x: T, _ y: T, _ z: T, _ w: T) { 
     (self.x, self.y, self.z, self.w) = (x, y, z, w) 
    } 

    subscript(index: Int) -> T { 
     get { 
      switch index { 
       case 0: return x 
       case 1: return y 
       case 2: return z 
       case 3: return w 
       default: preconditionFailure("invalid Vec4 subscript index") 
      } 
     } 
     set { 
      switch index { 
       case 0: x = newValue 
       case 1: y = newValue 
       case 2: z = newValue 
       case 3: w = newValue 
       default: preconditionFailure("invalid Vec4 subscript index") 
      } 
     } 
    } 
}