Btukfyl

I get so confused about 2D arrays in Swift. Let me describe step by step. And would you please correct me if I am wrong.

First of all; declaration of an empty array:

class test{

    var my2Darr = Int()

}

Secondly fill the array. (such as my2Darr[i][j] = 0 where i, j are for-loop variables)

class test {

    var my2Darr = Int()

    init() {

        for(var i:Int=0;i<10;i++) {

            for(var j:Int=0;j<10;j++) {

                my2Darr[i][j]=18   /*  Is this correct?  */

            }

        }

    }

}

And Lastly, Editing element of in array

class test {

    var my2Darr = Int()

    init() {

        ....  //same as up code

    }

    func edit(number:Int,index:Int){

        my2Darr[index][index] = number

        // Is this correct? and What if index is bigger

        // than i or j... Can we control that like 

        if (my2Darr[i][j] == nil) { ...  }   */

    }

}

Define mutable array

// 2 dimensional array of arrays of Ints 

var arr = [[Int]]() 

OR:

// 2 dimensional array of arrays of Ints 

var arr: [[Int]] =  

OR if you need an array of predefined size (as mentioned by @0x7fffffff in comments):

// 2 dimensional array of arrays of Ints set to 0. Arrays size is 10x5

var arr = Array(count: 3, repeatedValue: Array(count: 2, repeatedValue: 0))



// ...and for Swift 3+:

var arr = Array(repeating: Array(repeating: 0, count: 2), count: 3)

Change element at position

arr[0][1] = 18

OR

let myVar = 18

arr[0][1] = myVar

Change sub array

arr[1] = [123, 456, 789] 

OR

arr[0] += 234

OR

arr[0] += [345, 678]

If you had 3x2 array of 0(zeros) before these changes, now you have:

[

  [0, 0, 234, 345, 678], // 5 elements!

  [123, 456, 789],

  [0, 0]

]

So be aware that sub arrays are mutable and you can redefine initial array that represented matrix.

Examine size/bounds before access

let a = 0

let b = 1



if arr.count > a && arr[a].count > b {

    println(arr[a][b])

}

Remarks:
Same markup rules for 3 and N dimensional arrays.

From the docs:

You can create multidimensional arrays by nesting pairs of square brackets, where the name of the base type of the elements is contained in the innermost pair of square brackets. For example, you can create a three-dimensional array of integers using three sets of square brackets:

var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

When accessing the elements in a multidimensional array, the left-most subscript index refers to the element at that index in the outermost array. The next subscript index to the right refers to the element at that index in the array that’s nested one level in. And so on. This means that in the example above, array3D[0] refers to [[1, 2], [3, 4]], array3D[0][1] refers to [3, 4], and array3D[0][1][1] refers to the value 4.

You should be careful when you're using Array(repeating: Array(repeating: {value}, count: 80), count: 24).

If the value is an object, which is initialized by MyClass(), then they will use the same reference.

Array(repeating: Array(repeating: MyClass(), count: 80), count: 24) doesn't create a new instance of MyClass in each array element. This method only creates MyClass once and puts it into the array.

Here's a safe way to initialize a multidimensional array.

private var matrix: [[MyClass]] = MyClass.newMatrix()



private static func newMatrix() -> [[MyClass]] {

    var matrix: [[MyClass]] = 



    for i in 0...23 {

        matrix.append(  )



        for _ in 0...79 {

            matrix[i].append( MyClass() )

        }

    }



    return matrix

}

According to Apple documents for swift 4.1 you can use this struct so easily to create a 2D array:

Link: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html

Code sample:

struct Matrix {

let rows: Int, columns: Int

var grid: [Double]

init(rows: Int, columns: Int) {

    self.rows = rows

    self.columns = columns

    grid = Array(repeating: 0.0, count: rows * columns)

}

func indexIsValid(row: Int, column: Int) -> Bool {

    return row >= 0 && row < rows && column >= 0 && column < columns

}

subscript(row: Int, column: Int) -> Double {

    get {

        assert(indexIsValid(row: row, column: column), "Index out of range")

        return grid[(row * columns) + column]

    }

    set {

        assert(indexIsValid(row: row, column: column), "Index out of range")

        grid[(row * columns) + column] = newValue

    }

}

}