Programação D - Arrays

A linguagem de programação D fornece uma estrutura de dados, chamada arrays, que armazena uma coleção sequencial de tamanho fixo de elementos do mesmo tipo. Uma matriz é usada para armazenar uma coleção de dados. Geralmente, é mais útil pensar em um array como uma coleção de variáveis ​​do mesmo tipo.

Em vez de declarar variáveis ​​individuais, como número0, número1, ... e número99, você declara uma variável de matriz, como números e usa números [0], números [1] e ..., números [99] para representar variáveis ​​individuais. Um elemento específico em uma matriz é acessado por um índice.

Todas as matrizes consistem em locais de memória contíguos. O endereço mais baixo corresponde ao primeiro elemento e o endereço mais alto ao último elemento.

Declaração de matrizes

Para declarar uma matriz na linguagem de programação D, o programador especifica o tipo dos elementos e o número de elementos exigidos por uma matriz da seguinte maneira -

type arrayName [ arraySize ];

Isso é chamado de matriz de dimensão única. O arraySize deve ser uma constante inteira maior que zero e o tipo pode ser qualquer tipo de dados de linguagem de programação D válido. Por exemplo, para declarar uma matriz de 10 elementos chamada balance do tipo double, use esta instrução -

double balance[10];

Inicializando matrizes

Você pode inicializar os elementos do array da linguagem de programação D um por um ou usando uma única instrução como segue

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

O número de valores entre colchetes [] no lado direito não pode ser maior do que o número de elementos que você declara para a matriz entre colchetes []. O exemplo a seguir atribui um único elemento da matriz -

Se você omitir o tamanho do array, um array grande o suficiente para conter a inicialização é criado. Portanto, se você escrever

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

em seguida, você criará exatamente o mesmo array que no exemplo anterior.

balance[4] = 50.0;

A instrução acima atribui ao elemento número 5 na matriz um valor de 50,0. O array com o 4º índice será o 5º, ou seja, o último elemento, porque todos os arrays têm 0 como o índice do primeiro elemento, também chamado de índice base. A seguinte representação pictórica mostra a mesma matriz que discutimos acima -

Acessando Elementos de Matriz

Um elemento é acessado indexando o nome da matriz. Isso é feito colocando o índice do elemento entre colchetes após o nome da matriz. Por exemplo -

double salary = balance[9];

A declaração acima leva 10 ^th elemento da matriz e atribui o valor para a variável de vencimento . O exemplo a seguir implementa declaração, atribuição e acesso a matrizes -

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]); 
   } 
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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

Matrizes estáticas versus matrizes dinâmicas

Se o comprimento de um array for especificado durante a escrita do programa, esse array é um array estático. Quando o comprimento pode mudar durante a execução do programa, esse array é um array dinâmico.

Definir matrizes dinâmicas é mais simples do que definir matrizes de comprimento fixo porque omitir o comprimento cria uma matriz dinâmica -

int[] dynamicArray;

Propriedades da matriz

Aqui estão as propriedades dos arrays -

Sr. Não.	Descrição da Propriedade
1	.init Array estático retorna um literal de array com cada elemento do literal sendo a propriedade .init do tipo de elemento do array.
2	.sizeof A matriz estática retorna o comprimento da matriz multiplicado pelo número de bytes por elemento da matriz, enquanto as matrizes dinâmicas retornam o tamanho da referência da matriz dinâmica, que é 8 em compilações de 32 bits e 16 em compilações de 64 bits.
3	.length Matriz estática retorna o número de elementos na matriz, enquanto matrizes dinâmicas são usadas para obter / definir o número de elementos na matriz. O comprimento é do tipo size_t.
4	.ptr Retorna um ponteiro para o primeiro elemento da matriz.
5	.dup Crie uma matriz dinâmica do mesmo tamanho e copie o conteúdo da matriz nela.
6	.idup Crie uma matriz dinâmica do mesmo tamanho e copie o conteúdo da matriz nela. A cópia foi digitada como imutável.
7	.reverse Inverte a ordem dos elementos na matriz. Retorna a matriz.
8	.sort Classifica no local a ordem dos elementos na matriz. Retorna a matriz.

Exemplo

O exemplo a seguir explica as várias propriedades de uma matriz -

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); 
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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]

Matrizes multidimensionais em D

A programação em D permite arrays multidimensionais. Aqui está a forma geral de uma declaração de matriz multidimensional -

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

Exemplo

A declaração a seguir cria um 5 tridimensional. 10 4 matriz de inteiros -

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

Matrizes bidimensionais em D

A forma mais simples do array multidimensional é o array bidimensional. Um array bidimensional é, em essência, uma lista de arrays unidimensionais. Para declarar uma matriz de inteiro bidimensional de tamanho [x, y], você escreveria a sintaxe da seguinte maneira -

type arrayName [ x ][ y ];

Onde type pode ser qualquer tipo de dados de programação D válido e arrayName será um identificador de programação D válido.

Onde tipo pode ser qualquer tipo de dados de programação D válido e arrayName é um identificador de programação D válido.

Um array bidimensional pode ser pensado como uma tabela, que possui x número de linhas ey número de colunas. Uma matriz bidimensionala contendo três linhas e quatro colunas pode ser mostrado como abaixo -

Assim, cada elemento na matriz a é identificado por um elemento como a[ i ][ j ], Onde a é o nome da matriz, e i e j são os subscritos que identificam exclusivamente cada elemento em a.

Inicializando matrizes bidimensionais

As matrizes multidimensionais podem ser inicializadas especificando valores entre colchetes para cada linha. A seguinte matriz possui 3 linhas e cada linha possui 4 colunas.

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 */ 
];

As chaves aninhadas, que indicam a linha pretendida, são opcionais. A inicialização a seguir é equivalente ao exemplo anterior -

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

Acessando Elementos de Matriz Bidimensional

Um elemento em um array bidimensional é acessado usando os subscritos, significa índice de linha e índice de coluna do array. Por exemplo

int val = a[2][3];

A instrução acima pega o 4º elemento da 3ª linha da matriz. Você pode verificar isso no digrama acima.

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]); 
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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

Operações de array comuns em D

Aqui estão várias operações realizadas nos arrays -

Fatiamento de matriz

Freqüentemente, usamos parte de uma matriz, e fatiar a matriz costuma ser bastante útil. Um exemplo simples de divisão de matriz é mostrado abaixo.

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); 
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

[2, 3.4]

Cópia de matriz

Também usamos a cópia de array. Um exemplo simples de cópia de array é mostrado abaixo.

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); 
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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]

Configuração de matriz

Um exemplo simples para definir o valor em uma matriz é mostrado abaixo.

import std.stdio;

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

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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

Array Concatenation

Um exemplo simples de concatenação de duas matrizes é mostrado abaixo.

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); 
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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