Neden hem pürüzlü diziye hem de çok boyutlu diziye sahibiz?

1. Tırtıklı dizi ile Çok boyutlu dizi arasındaki fark nedir. Birinin diğerine faydası var mı?

2. Ve neden Visual Studio bir

   MyClass[][] abc = new MyClass[10][20];
   

   (Bunu C ++ 'da yapardık, ancak C #' da kırmızı kıvrımlı bir çizgi ile [20] 'nin altını çiziyor. Geçersiz sıra belirleyicisi diyor)

   ama mutlu

   MyClass[,] abc = new MyClass[10,20];
   

3. Son olarak bunu tek bir satırda nasıl başlatabilirim (basit dizide yaptığımız gibi {new xxx...}{new xxx....})

   MyClass[][,][,] itemscollection;
   

1. Sivri uçlu dizi, diziler dizisidir, bu nedenle bir int[][]dizi int[], her biri farklı uzunluklarda olabilir ve bellekte kendi bloğunu işgal edebilir. Çok boyutlu bir dizi ( int[,]), tek bir bellek bloğudur (esasen bir matristir).

2. MyClass[10][20]Her bir alt dizinin ayrı nesneler olduğu için ayrı olarak başlatılması gerektiğinden bir oluşturamazsınız :

   MyClass[][] abc = new MyClass[10][];
   
   for (int i=0; i<abc.Length; i++) {
       abc[i] = new MyClass[20];
   }
   

   A MyClass[10,20]tamam, çünkü tek bir nesneyi 10 satır ve 20 sütunlu bir matris olarak başlatıyor.

3. A MyClass[][,][,]şu şekilde başlatılabilir (derleme testi yapılmaz):

   MyClass[][,][,] abc = new MyClass[10][,][,];
   
   for (int i=0; i<abc.Length; i++) {
       abc[i] = new MyClass[20,30][,];
   
       for (int j=0; j<abc[i].GetLength(0); j++) {
           for (int k=0; k<abc[i].GetLength(1); k++) {
               abc[i][j,k] = new MyClass[40,50];
           }
       }
   }
   

CLR'nin tek boyutlu dizi erişimi için büyük ölçüde optimize edildiğini unutmayın, bu nedenle pürüzlü bir dizi kullanmak aynı boyuttaki çok boyutlu bir diziden muhtemelen daha hızlı olacaktır.

Pürüzlü dizi, bir dizi dizisidir. Her dizinin aynı boyutta olması garanti edilmez. Alabilirdin

int[][] jaggedArray = new int[5][];
jaggedArray[0] = new[] {1, 2, 3}; // 3 item array
jaggedArray[1] = new int[10];     // 10 item array
// etc.

Bir dizi ilişkili dizidir.

Öte yandan çok boyutlu bir dizi, düzensiz uzunlukların olmadığı bir kutu, masa, küp vb. Gibi daha çok uyumlu bir gruplamadır. Demek ki

int i = array[1,10];
int j = array[2,10]; // 10 will be available at 2 if available at 1

Dikdörtgen bir dizi, her satır için her zaman aynı miktarda sütuna sahiptir.

MyClass[,] x = new MyClass[10,30]

Her satırın 30 sütunu vardır, oysa pürüzlü bir dizide bu gerekli değildir. Bu nedenle, pürüzlü bir dizideki her 'satırı' ayrı ayrı başlatmanız gerektiğini düşünüyorum:

MyClass[][] x = new MyClass[10][];

for(int i = 0; i < 10; i++)
{
    x[i] = new MyClass[30];
}

Aslında bu, pürüzlü dizideki her satırın aynı sayıda öğe içermemesi gerektiği anlamına gelir. (Benim örneğimde, aynı sayıda öğeye sahip, ancak bu gerekli değil).

Bunu mükemmel bir şekilde yapabilirsiniz, örneğin:

MyClass[][] x = new MyClass[10][];

for(int i = 0; i < 10; i++)
{
    x[i] = new MyClass[(30 + i)];
}

Bu senin için ilginç bir makale olabilir.

Ad 3) Böyle bir canavarı başlatmak için aşağıdaki gibi bir [][,][,]şey yapabilirsiniz:

        int [,][,] multiArr1 = { { new int[,] { { 2, 2 }, { 1, 1 } },
                                     new int[,] { { 2, 2 }, { 1, 1 } } },
                                     { new int[,] { { 2, 2 }, { 1, 1 } },
                                         new int[,] { { 2, 2 }, { 1, 1 } } } };
        int [,][,] multiArr2 = { { new int[,] { { 2, 2 }, { 1, 1 } },
                                     new int[,] { { 2, 2 }, { 1, 1 } } },
                                     { new int[,] { { 2, 2 }, { 1, 1 } },
                                         new int[,] { { 2, 2 }, { 1, 1 } } } };

        int [][,][,] superMultiArray = { multiArr1, multiArr2 };

Sınırları belirlenmiş çok boyutlu bir dizi arıyorsanız, her zaman [,]stil sözdizimini kullanın. Bu, her kısmın eşit boyutta olmasını sağlayacaktır.

[][]Gerçekte olanı kullandığınızda , bir dizi dizi oluşturuyorsunuz. Bu, her dizinin farklı boyutlandırılabileceği anlamına gelir. Örneğin:

int[][] jaggedArray = new int[5][]
for(int index = 0; index < jaggedArray.Length ; ++index)
{
    jaggedArray[index] = new int[index + 1];
}

Satır içi bildirim şuna benzer:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };

# 1 için bu SO sorusuna bakın

Pürüzlü veya çok boyutlu satır içi diziler için şu programlama kılavuzuna bakın :

// Three-dimensional array.
int[, ,] array3D = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } },
{ { 7, 8, 9 }, { 10, 11, 12 } } };

// Same array with dimensions specified at declaration.
int[, ,] array3Da = new int[2, 2, 3] { { { 1, 2, 3 }, { 4, 5, 6 } },
{ { 7, 8, 9 }, { 10, 11, 12 } } };

Boyutları (dizi3D) belirtmeniz gerekmez, ancak bunların asla değişmeyeceğini biliyorsanız, hangi boyutları kullandığınızı bilmeniz yararlı olur (dizi3Da).

Çift dizinlemenin tek bir dizine dönüştürülmesi dışında, çok boyutlu dizinin tek boyutlu bir dizi olarak hareket ettiği dizinin dahili çalışmasını anlamanız gerekir.

C # 'daki Jagged diziniz, sırayla dizilen nesneler dizisidir.

C # 'da 2d pürüzlü diziler bellek ayırmasının C ++ ve C'de 2d diziler gibi olduğunu düşünüyorum. Çünkü 2d pürüzlü diziler, bu işaretçilerin her birinin bir dizi öğe (örneğin tamsayı öğeleri) işaret ettiği işaretçiler dizisine işaret eden bir göstericiye sahiptir; C ++ 'daki bu kod gibi,

int** 2DArr {new int* [number1]};
for (int i = 0; i < number1; i++)
{
   2DArr[i] = new int[number2];
}

aşağıdaki kodun bellek tahsisi, C # 'daki 2d pürüzlü dizilerle aynıdır. Ama şüpheliyim, yanlış düşünürsem biraz daha açıklar mısınız?

Bu yazı eski ama işte bununla ilgili düşüncelerim.

Tırtıklı diziler çok boyutlu dizilerdir. Çok boyutlu diziler iki çeşittir: dikdörtgen ve pürüzlü. Dikdörtgen diziler, n boyutlu bir bellek bloğunu temsil eder ve pürüzlü diziler, dizilerin dizileridir.

Dikdörtgen diziler

Dikdörtgen diziler, her bir boyutu ayırmak için virgül kullanılarak bildirilir. Aşağıdaki ifade, boyutların 3 × 3 olduğu dikdörtgen iki boyutlu bir dizi bildirir:

int[,] matrix = new int [3, 3]; 

Pürüzlü diziler

Tırtıklı diziler, her bir boyutu temsil etmek için ardışık köşeli parantezler kullanılarak bildirilir. Burada, en dıştaki boyutun 3 olduğu pürüzlü iki boyutlu bir dizi bildirmeye bir örnek verilmiştir:

int[][] matrix = new int[3][];

Çok boyutlu bir dizi için bir kutu veya dikdörtgen düşünün. Her satır aynı uzunluktadır ve her sütun aynı uzunluktadır.

Sivri uçlu bir dizide, satırlar ve sütunlar aynı boyutta olmayabilir. Örneğin, sütunlar veya satırlar farklı boyutlarda olabilir. Bu, dikdörtgen gibi yanlardan aşağı doğru düz bir çizgi olmayabilecek bir şekle yol açar. Bunun yerine kenarlar pürüzlü olabilir .

Şimdi bu örnek için 2 boyut / 2 dizi kullandım, ancak bu daha fazlası için geçerli.