Array

En array är en datastruktur där man kan lagra flera olika saker av samma sort. Man kan tänka sig en rad med lådor. Alla lådor är lika stora och i varje låda kan man stoppa en sak. Sakerna behöver inte vara lika, men de ska vara av samma sort. Arrayens typ avgör vilken sorts saker man kan lägga i lådorna. Om det är en array av typen katt så kan man sätta en katt i varje låda. Katterna kan vara olika stora, olika gamla, vara av olika ras - det viktiga är att de är katter. Det går altså inte att sätta en hund i en av lådorna.

Katterna till trots så är nog det enklaste exemplet en array av heltal. Precis som man i en helt vanlig variabel av typen int kan lagra ett heltal, kan man i en array av typen int lagra ett antal heltal. Ofta kallar man en array av typen int för en int-array. Om vi till exempel skapar en int-array med tio lådor kan vi lagra tio stycken heltal i den.

Man brukar säga att man indexerar i arrayen, det betyder att man med hjälp av ett index kommer åt en speciell låda. Den första lådan i en array har normalt index 0, och sedan räknar man uppåt för varje låda.

[0][1][2][3][4][5][6][7][8][9]

En array med tio lådor har alltså index 0 till 9. För att komma åt själva lådan där man kan lagra sitt heltal använder man hakparenteser, [] (i många vanliga programmeringsspråk). När man använder arrayer i program så ger man dem även ett namn, precis som vanliga variabler. Hakparenteserna sätts efter namnet när man vill komma åt en låda i arrayen.

Ett exempel i Java

    public class ArrayTest
    {
       public static void main( String[] args )
       {
          int[] tal = new int[10];
          for (int i = 0; i < 10; i++) {
             tal[i] = i * i;
             System.out.println("Tal[" + i + "]: " + tal[i]);
          }
       }
    }
  
  • Programmet skapar en array med plats för tio heltal: new int[10]
  • Variabeln tal är av typen int-array och sätts att referera till den nya arrayen: int[] tal = ...
  • Sedan snurrar vi tio varv i en for-loop och för varje varv lägger vi in värdet av i (loop-indexet), gånger sig självt, i arrayen: tal[i] = i * i;
  • Sedan skriver vi ut värdet som vi precis lagrat: System.out.println("Tal[" + i + "]: " + tal[i]);

Som vi kan se i exemplet kan vi alltså referera till en position i arrayen som om det vore en vanlig heltalsvariabel. Man kan använda variabler för att indexera i arrayen som i exemplet, (index-variabeln måste då vara en heltalsvariabel), men det går även att indexera direkt med konstanter: tal[4] refererar till den femte positionen i arrayen.

När vi kör programmet kommer följande att skrivas ut:

    Tal[0]: 0
    Tal[1]: 1
    Tal[2]: 4
    Tal[3]: 9
    Tal[4]: 16
    Tal[5]: 25
    Tal[6]: 36
    Tal[7]: 49
    Tal[8]: 64
    Tal[9]: 81
  

Samma exempel i C

    int main(void)
    {
       int tal[10];
       int i;

       for (i = 0; i < 10; i++) {
          tal[i] = i * i;
          printf("Tal[%d]: %d\n", i, tal[i]);
       }
    }
  

Syntaxen för att indexera i en array är ungef???r den samma i de flesta moderna programmeringsspråk. Det som kan skilja är hur man deklarerar dem och hur de indexeras. De arrayer vi sett här indexeras från 0. Det betyder att första lådan i arrayen har index 0. Det finns många andra varianter på hur en array kan indexeras. I en del programmeringsspråk, till exempel i Pascal, har man valt att istället börja på 1. I språk som till exempel Ada kan man själv välja hur arrayen ska vara indexerad. Ada har även valt att använda vanliga parenteser istället för de hakparenteser som vi sett i exemplen här. Andra språk, som till exempel PHP, erbjuder möjligheten att indexera arrayen med hjälp av nyckerord såväl som med numeriska index. Detta blir en sorts kombination av array och hashtabell och ger ett mycket kraftfullt sätt att hantera data.

Överkurs

En array kan förstås innehålla vilken typ av data som helst. Byt bara ut int mot den typ av array du vill skapa. Till exempel double[] flyttal = new double[75]; skapar en array med plats för 75 stycken flyttal. Man kan även skapa arrayer av arrayer och på så sätt få något som liknar en matris: int[][] matris = new int[10][10]; För att komma åt positioner i matrisen anger man koordinaterna i varsin hakparentes: matris[3][6] blir position (3,6).

En sak som man måste vara medveten om när man skapar arrayer av större datastrukturer än de enkla typer som finns inbyggda i språket (int, double, char osv.) är att när man skapar arrayen skapas endast plats för referenser till data, inte datastrukturerna i sig. String[] ord = new String[42]; skapar plats för 42 stycken sträng-referenser, men de 42 strängarna måste skapas separat.

    String[] ord = new String[42];
    for (int i = 0; i < 42; i++)
       ord[i] = new String();
  

Detta gäller i de fall då arrayen ska innehålla referenser till datastrukturerna. I Java finns endast referenser till objekt så där gäller detta alltid. I C däremot kan man själv välja om arrayen ska innehålla referenser till strukturerna eller strukturerna själva. Exemplen nedan visar två arrayer i C där den ena innehåller referenser till spelkort, och den andra innehåller spelkorten direkt. För att tillgodogöra sig dessa exempel bör man kunna hantera pekare. Det finns flera exempel på arrayer och pekare i flera olika programmeringsspråk på Kodsidan.

    struct card {
       int rank;
       char suit;
    };

    /* En array med spelkort. */
    struct card kort[52];
    kort[0].rank = 1;
    kort[0].suit = 'H';
    kort[1].rank = 2;

    /* En array med referenser till spelkort. */
    struct card* kort[52];
    int i;

    for (i = 0; i < 52; i++)
       kort[i] = malloc(sizeof(struct card));

    kort[0]->rank = 1;
    kort[0]->suit = 'H';
    kort[1]->rank = 2;