[C#] C #에서 다차원 배열과 배열 배열의 차이점은 무엇입니까?

다차원 배열은 멋진 선형 메모리 레이아웃을 만드는 반면, 들쭉날쭉 한 배열은 몇 가지 추가 수준의 간접 성을 의미합니다.

jagged[3][6]들쭉날쭉 한 배열에서 값 을 찾는 방법 var jagged = new int[10][5]은 다음과 같습니다. 인덱스 3에서 요소를 찾고 (배열) 해당 배열에서 인덱스 6에서 요소를 찾습니다 (값). 이 경우 각 차원마다 추가 조회가 있습니다 (고가의 메모리 액세스 패턴).

다차원 배열은 메모리에 선형으로 배치되며 실제 값은 인덱스를 곱하여 구합니다. 그러나 array가 주어지면 다차원 배열 var mult = new int[10,30]의 Length속성은 총 요소 수, 즉 10 * 30 = 300을 반환합니다.

Rank들쭉날쭉 한 배열 의 속성은 항상 1이지만 다차원 배열은 임의의 순위를 가질 수 있습니다. GetLength모든 배열 의 메소드를 사용하여 각 차원의 길이를 얻을 수 있습니다. 이 예의 다차원 배열의 경우 mult.GetLength(1)30을 반환합니다.

다차원 배열의 색인 작성이 더 빠릅니다. 예를 들어이 예제의 다차원 배열 mult[1,7]= 30 * 1 + 7 = 37이면 해당 인덱스 37에서 요소를 가져옵니다. 이는 하나의 메모리 위치 만 포함되기 때문에 더 나은 메모리 액세스 패턴입니다. 이는 배열의 기본 주소입니다.

따라서 다차원 배열은 연속 메모리 블록을 할당하는 반면 들쭉날쭉 한 배열은 정사각형 일 jagged[1].Length필요는 없습니다 ( 예 : 같을 필요는 없음 jagged[2].Length). 이는 다차원 배열에 해당됩니다.

공연

성능면에서는 다차원 배열이 더 빠릅니다. 훨씬 빠르지 만 실제로 CLR 구현이 잘못되어 그렇지 않습니다.

 23.084  16.634  15.215  15.489  14.407  13.691  14.695  14.398  14.551  14.252
 25.782  27.484  25.711  20.844  19.607  20.349  25.861  26.214  19.677  20.171
  5.050   5.085   6.412   5.225   5.100   5.751   6.650   5.222   6.770   5.305 

첫 번째 행은 들쭉날쭉 한 배열의 타이밍이고, 두 번째 행은 다차원 배열과 세 번째 행을 보여줍니다. 프로그램은 아래와 같습니다. 참고로 모노로 테스트했습니다. (Windows 타이밍은 주로 CLR 구현 변형으로 인해 크게 다릅니다).

윈도우에서 들쭉날쭉 한 배열의 타이밍은 다차원 배열이 어떻게 생겼는지에 대한 내 자신의 해석과 거의 동일합니다 .’Single () ‘을 참조하십시오. 안타깝게도 Windows JIT 컴파일러는 정말 어리 석고 불행히도 이러한 성능 토론을 어렵게 만들고 불일치가 너무 많습니다.

이것들은 내가 창문에 얻은 ​​타이밍입니다. 여기서 같은 거래입니다. 첫 번째 행은 들쭉날쭉 한 배열, 두 번째 다차원 및 세 번째 다차원의 자체 구현입니다. 모노에 비해 창에서 이것이 얼마나 느린 지 주목하십시오.

  8.438   2.004   8.439   4.362   4.936   4.533   4.751   4.776   4.635   5.864
  7.414  13.196  11.940  11.832  11.675  11.811  11.812  12.964  11.885  11.751
 11.355  10.788  10.527  10.541  10.745  10.723  10.651  10.930  10.639  10.595

소스 코드:

using System;
using System.Diagnostics;
static class ArrayPref
{
    const string Format = "{0,7:0.000} ";
    static void Main()
    {
        Jagged();
        Multi();
        Single();
    }

    static void Jagged()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var jagged = new int[dim][][];
            for(var i = 0; i < dim; i++)
            {
                jagged[i] = new int[dim][];
                for(var j = 0; j < dim; j++)
                {
                    jagged[i][j] = new int[dim];
                    for(var k = 0; k < dim; k++)
                    {
                        jagged[i][j][k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }

    static void Multi()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var multi = new int[dim,dim,dim];
            for(var i = 0; i < dim; i++)
            {
                for(var j = 0; j < dim; j++)
                {
                    for(var k = 0; k < dim; k++)
                    {
                        multi[i,j,k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }

    static void Single()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var single = new int[dim*dim*dim];
            for(var i = 0; i < dim; i++)
            {
                for(var j = 0; j < dim; j++)
                {
                    for(var k = 0; k < dim; k++)
                    {
                        single[i*dim*dim+j*dim+k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }
}

답변

int[,] data = new int[2,2];
data[0,0] = 1;
data[0,1] = 2;
data[1,0] = 3;
data[1,1] = 4;

int[][] jagged = new int[3][];
jagged[0] = new int[4] {  1,  2,  3,  4 };
jagged[1] = new int[2] { 11, 12 };
jagged[2] = new int[3] { 21, 22, 23 }; 

sub eax,[ecx+10]
cmp eax,[ecx+08]
jae oops //jump to throw out of bounds exception
sub edx,[ecx+14]
cmp edx,[ecx+0C]
jae oops //jump to throw out of bounds exception
imul eax,[ecx+0C]
add eax,edx
lea edx,[ecx+eax*4+18]

Debug (code optimalization disabled)
Running jagged
187.232 200.585 219.927 227.765 225.334 222.745 224.036 222.396 219.912 222.737

Running multi-dimensional
130.732 151.398 131.763 129.740 129.572 159.948 145.464 131.930 133.117 129.342

Running single-dimensional
 91.153 145.657 111.974  96.436 100.015  97.640  94.581 139.658 108.326  92.931


Release (code optimalization enabled)
Running jagged
108.503 95.409 128.187 121.877 119.295 118.201 102.321 116.393 125.499 116.459

Running multi-dimensional
 62.292  60.627  60.611  60.883  61.167  60.923  62.083  60.932  61.444  62.974

Running single-dimensional
 34.974  33.901  34.088  34.659  34.064  34.735  34.919  34.694  35.006  34.796