Como criar uma matriz de objetos de tamanho fixo

Em Swift, estou tentando criar uma matriz de 64 SKSpriteNode. Quero inicializá-lo vazio primeiro, depois colocaria Sprites nas primeiras 16 células e nas últimas 16 células (simulando um jogo de xadrez).

Pelo que entendi no documento, esperava algo como:

var sprites = SKSpriteNode()[64];

ou

var sprites4 : SKSpriteNode[64];

Mas não funciona. No segundo caso, recebo um erro dizendo: "Arrays de comprimento fixo ainda não são suportados". Isso pode ser real? Para mim, isso soa como um recurso básico. Preciso acessar o elemento diretamente por seu índice.

Arrays de comprimento fixo ainda não são suportados. O que isso realmente significa? Não que você não possa criar uma matriz de nmuitas coisas - obviamente, você pode apenas fazer let a = [ 1, 2, 3 ]para obter uma matriz de três Ints. Significa simplesmente que o tamanho do array não é algo que você possa declarar como informação de tipo .

Se você quiser um array de nils, você primeiro precisará de um array de um tipo opcional - [SKSpriteNode?], não [SKSpriteNode]- se você declarar uma variável de tipo não opcional, seja um array ou um único valor, não pode ser nil. (Observe também que [SKSpriteNode?]é diferente de [SKSpriteNode]?... você deseja uma matriz de opcionais, não uma matriz opcional.)

O Swift é muito explícito por design sobre como exigir que as variáveis ​​sejam inicializadas, porque as suposições sobre o conteúdo das referências não inicializadas são uma das maneiras pelas quais os programas em C (e algumas outras linguagens) podem se tornar problemáticos. Portanto, você precisa pedir explicitamente uma [SKSpriteNode?]matriz que contenha 64 nils:

var sprites = [SKSpriteNode?](repeating: nil, count: 64)

Na verdade, isso retorna um [SKSpriteNode?]?, porém: uma matriz opcional de sprites opcionais. (Um pouco estranho, já init(count:,repeatedValue:)que não deve ser capaz de retornar nil.) Para trabalhar com a matriz, você precisará desembrulhá-la. Existem algumas maneiras de fazer isso, mas, neste caso, prefiro a sintaxe de ligação opcional:

if var sprites = [SKSpriteNode?](repeating: nil, count: 64){
    sprites[0] = pawnSprite
}

O melhor que você poderá fazer agora é criar uma matriz com uma contagem inicial repetindo nulo:

var sprites = [SKSpriteNode?](count: 64, repeatedValue: nil)

Você pode então preencher os valores que desejar.

Em Swift 3.0 :

var sprites = [SKSpriteNode?](repeating: nil, count: 64)

Esta pergunta já foi respondida, mas para algumas informações extras no momento do Swift 4:

Em caso de desempenho, deve-se reservar memória para o array, no caso de criá-lo dinamicamente, como adicionar elementos com Array.append().

var array = [SKSpriteNode]()
array.reserveCapacity(64)

for _ in 0..<64 {
    array.append(SKSpriteNode())
}

Se você sabe a quantidade mínima de elementos que vai adicionar, mas não a quantidade máxima, você deve usar array.reserveCapacity(minimumCapacity: 64).

Declare um SKSpriteNode vazio, para que não haja necessidade de desempacotamento

var sprites = [SKSpriteNode](count: 64, repeatedValue: SKSpriteNode())

Por enquanto, semanticamente mais próximo seria uma tupla com número fixo de elementos.

typealias buffer = (
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode,
    SKSpriteNode, SKSpriteNode, SKSpriteNode, SKSpriteNode)

Mas isso é (1) muito desconfortável de usar e (2) o layout da memória é indefinido. (pelo menos desconhecido para mim)

Swift 4

Você pode pensar nisso de alguma forma como uma matriz de objetos versus uma matriz de referências.

• [SKSpriteNode] deve conter objetos reais
• [SKSpriteNode?] pode conter referências a objetos ou nil

Exemplos

1. Criação de uma matriz com 64 padrão SKSpriteNode :

   var sprites = [SKSpriteNode](repeatElement(SKSpriteNode(texture: nil),
                                              count: 64))
   

2. Criação de uma matriz com 64 slots vazios (também conhecidos como opcionais ):

   var optionalSprites = [SKSpriteNode?](repeatElement(nil,
                                         count: 64))
   

3. Convertendo uma matriz de opcionais em uma matriz de objetos (recolhendo [SKSpriteNode?]em [SKSpriteNode]):

   let flatSprites = optionalSprites.flatMap { $0 }

   O countresultado do resultado flatSpritesdepende da contagem de objetos em optionalSprites: opcionais vazios serão ignorados, ou seja, ignorados.

Se o que você deseja é um array de tamanho fixo e inicializa-o com nilvalores, você pode usar um UnsafeMutableBufferPointer, alocar memória para 64 nós com ele e, em seguida, ler / gravar de / para a memória subscrevendo a instância do tipo de ponteiro. Isso também tem a vantagem de evitar verificar se a memória deve ser realocada, o que é Arrayverdade. No entanto, ficaria surpreso se o compilador não otimizasse isso para matrizes que não têm mais chamadas para métodos que podem exigir redimensionamento, exceto no local de criação.

let count = 64
let sprites = UnsafeMutableBufferPointer<SKSpriteNode>.allocate(capacity: count)

for i in 0..<count {
    sprites[i] = ...
}

for sprite in sprites {
    print(sprite!)
}

sprites.deallocate()

No entanto, isso não é muito amigável. Então, vamos fazer um invólucro!

class ConstantSizeArray<T>: ExpressibleByArrayLiteral {
    
    typealias ArrayLiteralElement = T
    
    private let memory: UnsafeMutableBufferPointer<T>
    
    public var count: Int {
        get {
            return memory.count
        }
    }
    
    private init(_ count: Int) {
        memory = UnsafeMutableBufferPointer.allocate(capacity: count)
    }
    
    public convenience init(count: Int, repeating value: T) {
        self.init(count)
        
        memory.initialize(repeating: value)
    }
    
    public required convenience init(arrayLiteral: ArrayLiteralElement...) {
        self.init(arrayLiteral.count)
        
        memory.initialize(from: arrayLiteral)
    }
    
    deinit {
        memory.deallocate()
    }
    
    public subscript(index: Int) -> T {
        set(value) {
            precondition((0...endIndex).contains(index))
            
            memory[index] = value;
        }
        get {
            precondition((0...endIndex).contains(index))
            
            return memory[index]
        }
    }
}

extension ConstantSizeArray: MutableCollection {
    public var startIndex: Int {
        return 0
    }
    
    public var endIndex: Int {
        return count - 1
    }
    
    func index(after i: Int) -> Int {
        return i + 1;
    }
}

Agora, esta é uma classe, não uma estrutura, portanto, há alguma sobrecarga de contagem de referência incorrida aqui. Você pode alterá-lo para um struct, mas como o Swift não oferece a capacidade de usar inicializadores de cópia e deinitem estruturas, você precisará de um método de desalocação ( func release() { memory.deallocate() }) e todas as instâncias copiadas da estrutura farão referência à mesma memória.

Agora, essa aula pode ser boa o suficiente. Seu uso é simples:

let sprites = ConstantSizeArray<SKSpriteNode?>(count: 64, repeating: nil)

for i in 0..<sprites.count {
    sprite[i] = ...
}

for sprite in sprites {
    print(sprite!)
}

Para obter mais protocolos para implementar a conformidade, consulte a documentação do Array (role até Relacionamentos ).

Uma coisa que você poderia fazer seria criar um dicionário. Pode ser um pouco desleixado, considerando que você está procurando 64 elementos, mas dá conta do recado. Não tenho certeza se é a "maneira preferida" de fazer isso, mas funcionou para mim usando uma série de estruturas.

var tasks = [0:[forTasks](),1:[forTasks](),2:[forTasks](),3:[forTasks](),4:[forTasks](),5:[forTasks](),6:[forTasks]()]