Путаница с зубчатыми массивами

Question

Я хотел создать неровный массив матриц , в котором будут храниться девять 1d-массивов, которые будут представлять матрицу чисел от 0 до 9. Я не написал все числа от нуля до девяти, но все они имеют одинаковый размер, и единственная разница - это позиции 1 и 0. Эта часть была успешной, и как только я напечатал результат InitializeMatrices(), я действительно получил тот результат, который хотел. matrices [0] [34] будет печатать 35-й элемент "нулевой" матрицы, matrice [1] [2] будет печатать 3-й элемент "one" матрицы и и так далее.

Проблема началась, когда внутри DistortMatrices() я попытался сделать копии матрицы (36 копий, где индексы 0-17 были бы копиями нулевой матрицы) внутри matrixToLearn, поэтому я бы изменил одну копию матрицы, а не сама матрица и сохранить изменения внутри matrixToLearn. К сожалению, это не работает так, как я себе представлял. Например

matrixToLearn [0] = matrices [0]; // копирует нулевой массив, как задумано

matrixToLearn [0] [34] = 0; // Это относится к матрицам [0] [34], а также ко всем 18 копиям matrixToLearn, даже если после этого я вызову:

matrixToLearn [17] [7] = 0 // он будет применяться к матрицам [0] [34], matrixToLearn [0] [34] и все копии будут одинаковыми

Похоже, это работает как указатель или что-то в этом роде.

Как я могу это исправить, чтобы она копировала матрицы [0] в matrixtoLearn [0-17], а изменения в matrixToLearn [0-17] применялись только к себе и соответствующему индексу и оставляли матрицы такими, как есть ? Посмотрите на ---> Ожидаемые результаты под кодом.

public partial class Form1 : Form
{

    int[] zero, one, two, three, four, five, six, seven, eight, nine;

    int[][] matrices;
    int[][] matrixToLearn = new int[36][];


    private void InitializeMatrices()
    {
        zero =
        new int[] {
            1, 1, 1, 1, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 1,
        };

        //And so on up to nine

        matrices = new int[][]{ zero, one, two, three, four, five, six, seven, eight, nine};
    }

    //index = 0
    private void DistortMatrices(int index)
    {
        int z = 0;
        for (; z < 18; z++)
        {
            matrixToLearn[z] = matrices[index];
        }
        matrixToLearn[0][34] = 0;
        matrixToLearn[17][7] = 1;
    }
}

Ожидаемые результаты

Expected result

            matrixToLearn[0]
            1, 1, 1, 1, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 0,

            matrixToLearn[17] 
            1, 1, 1, 1, 1,
            1, 0, 1, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 1,

            matrice[0] 
            1, 1, 1, 1, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 1,

How it looks right now:

            matrixToLearn[0]
            1, 1, 1, 1, 1,
            1, 0, 1, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 0,

            matrixToLearn[17]
            1, 1, 1, 1, 1,
            1, 0, 1, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 0,

            matrices[0]
            1, 1, 1, 1, 1,
            1, 0, 1, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 1, 1, 1, 0,

РЕДАКТИРОВАТЬ: кажется, идет еще дальше, и это также изменяет "нулевую" матрицу

Answer 1

matrixToLearn[0] = matrices[0];

Копирует ссылку на вложенный массив. Это как

float[] x = ...;
float[] y = x; //copies the reference, not the object contents

Я обычно использую (float[])myArray.Clone() для клонирования массивов. Я превращаю это в небольшой общий метод расширения.