D Программирование - Массивы

Язык программирования D предоставляет структуру данных с именем arrays, который хранит последовательную коллекцию фиксированного размера элементов одного и того же типа. Массив используется для хранения набора данных. Часто бывает более полезно думать о массиве как о коллекции переменных одного типа.

Вместо объявления отдельных переменных, таких как number0, number1, ... и number99, вы объявляете одну переменную массива, такую ​​как числа, и используете числа [0], числа [1] и ..., числа [99] для представления отдельные переменные. Доступ к определенному элементу в массиве осуществляется по индексу.

Все массивы состоят из непрерывных ячеек памяти. Самый низкий адрес соответствует первому элементу, а самый высокий адрес - последнему элементу.

Объявление массивов

Чтобы объявить массив на языке программирования D, программист указывает тип элементов и количество элементов, необходимых для массива, следующим образом:

type arrayName [ arraySize ];

Это называется одномерным массивом. ArraySize должно быть целым числом константа больше нуля и тип может быть любым допустимым D программирования типа данных языка. Например, чтобы объявить массив из 10 элементов с именем balance типа double, используйте этот оператор:

double balance[10];

Инициализация массивов

Вы можете инициализировать элементы массива языка программирования D либо один за другим, либо с помощью одного оператора, как показано ниже.

double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];

Количество значений в квадратных скобках [] справа не может быть больше количества элементов, объявленных вами для массива между квадратными скобками []. В следующем примере назначается один элемент массива -

Если вы не укажете размер массива, будет создан массив, достаточно большой, чтобы вместить инициализацию. Следовательно, если вы напишете

double balance[] = [1000.0, 2.0, 3.4, 17.0, 50.0];

тогда вы создадите точно такой же массив, как и в предыдущем примере.

balance[4] = 50.0;

Вышеупомянутый оператор присваивает элементу 5-му в массиве значение 50.0. Массив с 4-м индексом будет 5-м, т. Е. Последним элементом, потому что все массивы имеют 0 как индекс своего первого элемента, который также называется базовым индексом. Следующее графическое представление показывает тот же массив, который мы обсуждали выше -

Доступ к элементам массива

Доступ к элементу осуществляется путем индексации имени массива. Это делается путем помещения индекса элемента в квадратные скобки после имени массива. Например -

double salary = balance[9];

Приведенный выше оператор берет 10- ^й элемент из массива и присваивает значение переменной salary . В следующем примере реализуется объявление, присваивание и доступ к массивам:

import std.stdio;  
void main() { 
   int n[ 10 ]; // n is an array of 10 integers  
   
   // initialize elements of array n to 0 
   for ( int i = 0; i < 10; i++ ) { 
      n[ i ] = i + 100; // set element at location i to i + 100 
   }
   
   writeln("Element \t Value");
   
   // output each array element's value 
   for ( int j = 0; j < 10; j++ ) { 
      writeln(j," \t ",n[j]); 
   } 
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

Element   Value 
0         100 
1         101 
2         102 
3         103 
4         104 
5         105 
6         106 
7         107 
8         108 
9         109

Статические массивы и динамические массивы

Если при написании программы указана длина массива, этот массив является статическим. Если длина может измениться во время выполнения программы, этот массив является динамическим.

Определение динамических массивов проще, чем определение массивов фиксированной длины, потому что отсутствие длины делает динамический массив -

int[] dynamicArray;

Свойства массива

Вот свойства массивов -

Sr. No.	Описание недвижимости
1	.init Статический массив возвращает литерал массива, каждый элемент которого является свойством .init типа элемента массива.
2	.sizeof Статический массив возвращает длину массива, умноженную на количество байтов на элемент массива, в то время как динамические массивы возвращают размер ссылки на динамический массив, который составляет 8 в 32-битных сборках и 16 в 64-битных сборках.
3	.length Статический массив возвращает количество элементов в массиве, в то время как динамические массивы используются для получения / установки количества элементов в массиве. Длина имеет тип size_t.
4	.ptr Возвращает указатель на первый элемент массива.
5	.dup Создайте динамический массив такого же размера и скопируйте в него содержимое массива.
6	.idup Создайте динамический массив такого же размера и скопируйте в него содержимое массива. Копия печатается как неизменяемая.
7	.reverse Изменяет порядок элементов в массиве на обратный. Возвращает массив.
8	.sort Сортирует порядок элементов в массиве. Возвращает массив.

пример

В следующем примере объясняются различные свойства массива -

import std.stdio;

void main() {
   int n[ 5 ]; // n is an array of 5 integers 
   
   // initialize elements of array n to 0 
   for ( int i = 0; i < 5; i++ ) { 
      n[ i ] = i + 100; // set element at location i to i + 100 
   }
   
   writeln("Initialized value:",n.init); 
   
   writeln("Length: ",n.length); 
   writeln("Size of: ",n.sizeof); 
   writeln("Pointer:",n.ptr); 
   
   writeln("Duplicate Array: ",n.dup); 
   writeln("iDuplicate Array: ",n.idup);
   
   n = n.reverse.dup; 
   writeln("Reversed Array: ",n);
   
   writeln("Sorted Array: ",n.sort); 
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

Initialized value:[0, 0, 0, 0, 0] 

Length: 5 
Size of: 20 

Pointer:7FFF5A373920 
Duplicate Array: [100, 101, 102, 103, 104]
iDuplicate Array: [100, 101, 102, 103, 104] 
Reversed Array: [104, 103, 102, 101, 100] 
Sorted Array: [100, 101, 102, 103, 104]

Многомерные массивы в D

Программирование на языке D позволяет создавать многомерные массивы. Вот общая форма объявления многомерного массива -

type name[size1][size2]...[sizeN];

пример

Следующее объявление создает трехмерный 5. 10. 4 целочисленный массив -

int threedim[5][10][4];

Двумерные массивы в D

Простейшей формой многомерного массива является двумерный массив. Двумерный массив - это, по сути, список одномерных массивов. Чтобы объявить двумерный целочисленный массив размера [x, y], вы должны написать следующий синтаксис:

type arrayName [ x ][ y ];

где type может быть любым допустимым типом данных программирования D и arrayName будет действительным идентификатором программирования D.

Где type может быть любым допустимым типом данных программирования D, а arrayName - допустимым идентификатором программирования D.

Двумерный массив можно представить как таблицу, в которой есть x строк и y столбцов. Двумерный массивa содержащий три строки и четыре столбца, можно показать, как показано ниже -

Таким образом, каждый элемент в массиве a идентифицируется элементом как a[ i ][ j ], где a это имя массива, а i и j индексы, которые однозначно идентифицируют каждый элемент в.

Инициализация двумерных массивов

Многомерные массивы можно инициализировать, задав значения в квадратных скобках для каждой строки. В следующем массиве 3 строки, а каждая строка - 4 столбца.

int a[3][4] = [   
   [0, 1, 2, 3] ,   /*  initializers for row indexed by 0 */ 
   [4, 5, 6, 7] ,   /*  initializers for row indexed by 1 */ 
   [8, 9, 10, 11]   /*  initializers for row indexed by 2 */ 
];

Вложенные фигурные скобки, обозначающие предполагаемую строку, необязательны. Следующая инициализация эквивалентна предыдущему примеру -

int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];

Доступ к двумерным элементам массива

Доступ к элементу в 2-мерном массиве осуществляется с помощью нижних индексов, что означает индекс строки и индекс столбца массива. Например

int val = a[2][3];

Вышеупомянутый оператор берет 4-й элемент из 3-й строки массива. Вы можете проверить это в приведенной выше биграмме.

import std.stdio; 
  
void main () { 
   // an array with 5 rows and 2 columns. 
   int a[5][2] = [ [0,0], [1,2], [2,4], [3,6],[4,8]];  
   
   // output each array element's value                       
   for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 2; j++ ) {
      writeln( "a[" , i , "][" , j , "]: ",a[i][j]); 
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

a[0][0]: 0 
a[0][1]: 0 
a[1][0]: 1 
a[1][1]: 2 
a[2][0]: 2 
a[2][1]: 4 
a[3][0]: 3 
a[3][1]: 6 
a[4][0]: 4 
a[4][1]: 8

Общие операции с массивами в D

Вот различные операции, выполняемые с массивами -

Нарезка массива

Мы часто используем часть массива, и нарезка массива часто оказывается весьма полезной. Ниже показан простой пример нарезки массива.

import std.stdio;
  
void main () { 
   // an array with 5 elements. 
   double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0]; 
   double[] b;
   
   b = a[1..3]; 
   writeln(b); 
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

[2, 3.4]

Копирование массива

Мы также используем копирующий массив. Ниже показан простой пример копирования массива.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0]; 
   double b[5]; 
   writeln("Array a:",a); 
   writeln("Array b:",b);  
   
   b[] = a;      // the 5 elements of a[5] are copied into b[5] 
   writeln("Array b:",b);  
   
   b[] = a[];   // the 5 elements of a[3] are copied into b[5] 
   writeln("Array b:",b); 
   
   b[1..2] = a[0..1]; // same as b[1] = a[0] 
   writeln("Array b:",b); 
   
   b[0..2] = a[1..3]; // same as b[0] = a[1], b[1] = a[2]
   writeln("Array b:",b); 
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

Array a:[1000, 2, 3.4, 17, 50] 
Array b:[nan, nan, nan, nan, nan] 
Array b:[1000, 2, 3.4, 17, 50] 
Array b:[1000, 2, 3.4, 17, 50] 
Array b:[1000, 1000, 3.4, 17, 50] 
Array b:[2, 3.4, 3.4, 17, 50]

Настройка массива

Ниже показан простой пример установки значения в массиве.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5]; 
   a[] = 5; 
   writeln("Array a:",a); 
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

Array a:[5, 5, 5, 5, 5]

Объединение массивов

Ниже показан простой пример объединения двух массивов.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5] = 5; 
   double b[5] = 10; 
   double [] c; 
   c = a~b; 
   writeln("Array c: ",c); 
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

Array c: [5, 5, 5, 5, 5, 10, 10, 10, 10, 10]