• 7.1 Osoitintyypit ja Taulukot
• 7.2 Osoittimet ja Merkkijonot
• 7.3 Osoittimet ja Moniuloitteiset Taulukot
• 7.4 Osoittimet ja Dynaamisen muistin varaaminen
• 7.5 Osoittimet Funktioihin

7 Osoittimet

Ohjelmassa oleva muuttuja on nimetty alkio, jonka arvo voi vaihdella. Kääntäjä ja linkkeri varaa tietyn määrän muistia, jossa kyseisen muuttujan arvoa säilytetään. Varatun muistin koko riippuu muuttujan tyypistä.

Muuttujaa määritellessä kääntäjälle ilmoitetaan kaksi asiaa: muuttujan nimi ja tyyppi. Esimerkiksi: määritellään k nimien muuttuja, jonka tyyppi on integer:

    int k;

Jos myöhemmin kirjoitamme:

    k = 2;

Tavallaan muuttujaan k on liitetty kaksi arvoa. Toinen on varsinainen muuttujan arvo (eli 2 yllä olevassa esimerkissä) ja toinen on muistiosoite, jossa muuttujan arvoa säilytetään. Kurssikirjassa näistä käytetään nimiä rvalue (right value, äännetään "are value") ja lvalue (left value, äännetään "el value"). Kurssikirjan K&R (sivu 197) määritelmä lvalue termille on: "An object is a named region of storage; an lvalue is an expression referring to an object." eli vapaasti suomennettuna: "olio on nimetty muistialue: lvalue on ilmaisu, joka viittaa olioon". Esimerkiksi:

   int j, k;

   k = 2;
   j = 7;    <-- rivi 1
   k = j;    <-- rivi 2

Oletetaan, että haluamme muuttujan säilyttävän lvalue arvon (siis osoitteen). Kyseisen muuttujan koko riippuu arkkitehtuurista. Tällaista muuttujaa kutsutaan osoitinmuuttujaksi (pointer). C-kielessä osoitinmuuttuja määritellään kirjoittamalla muuttujanimen eteen tähtimerkin. Osoitinmuuttujalla pitää myös olla tyyppi, joka kertoo minkä tyyppistä tietoa osoittimen osoittamassa muistipaikassa säilytetään. Esimerkiksi:

   int *ptr;

Osoitinmuuttuja voi osoittaa myös nk. tyhjään eli NULL osoitteeseen. NULL vakion arvo ei välttämättä kaikissa järjestelmissä ole 0. Eli osoitteen järkevyyttä kannattaa testata lauseella if ( ptr == NULL ).

Tallennetaanpa osoitinmuuttujan ptr arvoksi muuttujan k osoite. Tämä tapahtuu unaarisella operaattorilla &. Eli:

    ptr = &k;

Epäsuoran osoituksen operaattori on tähtimerkki ja sitä käytetään seuraavasti:

    *ptr = 8;

 printf("%d\n",*ptr);

Otetaanpa hieman pidempi esimerkki:

#include <stdio.h>

int j, k;
int *ptr;

int main(void)
{
    j = 1;
    k = 2;
    ptr = &k;
    printf("\n");
    printf("j has the value %d and is stored at %p\n", j, (void *)&j);
    printf("k has the value %d and is stored at %p\n", k, (void *)&k);
    printf("ptr has the value %p and is stored at %p\n", ptr, (void *)&ptr);
    printf("The value of the integer pointed to by ptr is %d\n", *ptr);

    return 0;
}

7.1 Osoitintyypit ja taulukot

     int *ptr;
     *ptr = 2;

    ptr + 1;

Vastaavasti voisi tietysti käyttää muotoja ++ptr ja ptr++. Nyt näemme kiinnostavan yhteyden taulukoiden ja osoitinmuuttujien välillä. Esimerkiksi:

    int my_array[] = {1,23,17,4,-5,100};
    int *ptr;
    ptr = &my_array[0];       /* point our pointer at the first
                                 integer in our array */ 

#include <stdio.h>

int my_array[] = {1,23,17,4,-5,100};
int *ptr;

int main(void)
{
    int i;
    ptr = &my_array[0];     /* point our pointer to the first
                                      element of the array */
    printf("\n\n");
    for (i = 0; i < 6; i++)
    {
      printf("my_array[%d] = %d   ",i,my_array[i]);   /*<-- A */
      printf("ptr + %d = %d\n",i, *(ptr + i));        /*<-- B */
    }
    return 0;
}

    printf("ptr + %d = %d\n",i, *ptr++);

    printf("ptr + %d = %d\n",i, *(++ptr));

    ptr = &my_array[0]; /* Vaihtoehto 1 */
    ptr = my_array;     /* Vaihtoehto 2 */

    ptr = my_array; /* Sallittua */
    my_array = ptr; /* Virhe!!!!!*/

"An object is a named region of storage; an lvalue is an expression referring to an object".

Tämä nostaa esille mielenkiintoisen ongelman. Koska my_array on nimetty muistialue (region of storage), niin miksi my_array ei ole yllä olevassa sijoituksessa lvalue ? Tätä perustellaan sillä, että taulukon nimi on vakio-osoitin.

Otetaan esille jo aikaisemmin esimerkissä ilmaantunut void * ilmaisu. Tähän mennessä on nähty osoittimia kokonaislukuihin (int) ja merkkeihin (char). Myöhemmin tulemme vielä käsittelemään osoittimia rakenteisiin ja osoittimia osoittimiin. Lisäksi muistamme, että osoitinmuuttujan koko saattaa vaihdella eri järjestelmissä. Osoitinmuuttujan koko voi vaihdella myös käytetyn tyypin perusteella. Siksi saataa tulla ongelmia jos yrittää sijoittaa long integer tyyppistä muuttujaa short integer tyyppiseen muuttujaa. Vastaavasti ongelmia saattaa tulla myös osoitinmuuttujien sijoittamisessa.

Tämän ongelman minimoimiseksi C-kieli tarjoaa osoitinmuuttujan, jonka tyyppi on void. Tällaisen muuttujan voi määritellä kirjoittamalla:

void *vptr;

7.2 Osoittimet ja Merkkijonot

#include <stdio.h>

char strA[80] = "A string to be used for demonstration purposes";
char strB[80];

int main(void)
{

    char *pA;     /* a pointer to type character */
    char *pB;     /* another pointer to type character */
    puts(strA);   /* show string A */
    pA = strA;    /* point pA at string A */
    puts(pA);     /* show what pA is pointing to */
    pB = strB;    /* point pB at string B */
    putchar('\n');       /* move down one line on the screen */
    while(*pA != '\0')   /* line A (see text) */
    {
        *pB++ = *pA++;   /* line B (see text) */
    }
    *pB = '\0';          /* line C (see text) */
    puts(strB);          /* show strB on screen */
    return 0;
}

Kirjoitetaanpa oma strcpy funktio. Ensimmäinen versio saattaisi näyttää seuraavalta:

   char *my_strcpy(char *destination, char *source)
   {
       char *p = destination;
       while (*source != '\0')
       {
           *p++ = *source++;
       }
       *p = '\0';
       return destination;
   }   

#include <stdio.h>

char strA[80] = "A string to be used for demonstration purposes";
char strB[80];

char *my_strcpy(char *destination, char *source);

int main(void)
{
    my_strcpy(strB, strA);
    puts(strB);
}

Itseasiassa seuraavat kaksi lausetta ovat syntaksin mukaan mahdollisia:

    char a[10];
    a[3] = 'x';
    3[a] = 'x';

    dest[i] = source[i];

    *(dest + i) = *(source + i);

void strcpy(char *to, char *from)
{
    while(*to++ = *from++ ); /* Pysähtyy jos ja vain jos *from = '\0' = 0 */
}

7.3 Osoittimet ja Moniuloitteiset Taulukot

    char multi[5][10];

    multi[0] = {'0','1','2','3','4','5','6','7','8','9'}
    multi[1] = {'a','b','c','d','e','f','g','h','i','j'}
    multi[2] = {'A','B','C','D','E','F','G','H','I','J'}
    multi[3] = {'9','8','7','6','5','4','3','2','1','0'}
    multi[4] = {'J','I','H','G','F','E','D','C','B','A'}

    multi[0][3] = '3';
    multi[1][7] = 'h';
    multi[4][0] = 'J';

    0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA
    |_____ taulukon alkuosoite eli &multi[0][0]

    *(*(multi + row) + col)
    multi[row][col]

#include <stdio.h>
#define ROWS 5
#define COLS 10

int multi[ROWS][COLS];

int main(void)
{
    int row, col;
    for (row = 0; row < ROWS; row++)
    {
        for (col = 0; col < COLS; col++)
        {
            multi[row][col] = row*col;
        }
    }

    for (row = 0; row < ROWS; row++)
    {
        for (col = 0; col < COLS; col++)
        {
            printf("\n%d  ",multi[row][col]);
            printf("%d ",*(*(multi + row) + col));
        }
    }

    return 0;
}

    int array[3] = {'1', '5', '7'};
    void a_func(int *p);
    /* Tosin tuon edellisen voi kirjoittaa myös muodossa : */
    void b_func(int p[]);

7.4 Osoittimet ja Dynaamisen muistin varauminen

Muistia varattaessa funktiolla kuten malloc() palautuu funktiosta osoitin. Esimerkiksi jos haluamme varata tilaa 10 kokonaisluvulle (int):

    int *iptr;
    iptr = (int *)malloc(10 * sizeof(int));
    if (iptr == NULL)
    { .. VIRHEENKÄSITTELYRUTIINI .. }

Tähän on useita tapoja. Tapa1:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int nrows = 5;     /* Both nrows and ncols could be evaluated */
    int ncols = 10;    /* or read in at run time */
    int row;
    int **rowptr;
    rowptr = malloc(nrows * sizeof(int *));

    if (rowptr == NULL)
    {
        puts("\nFailure to allocate room for row pointers.\n");
        exit(0);
    }

    printf("\n\n\nIndex   Pointer(hex)   Pointer(dec)   Diff.(dec)");

    for (row = 0; row < nrows; row++)
    {
        rowptr[row] = malloc(ncols * sizeof(int));

        if (rowptr[row] == NULL)
        {
            printf("\nFailure to allocate for row[%d]\n",row);
            exit(0);
        }

        printf("\n%d         %p         %d", row, rowptr[row], rowptr[row]);

        if (row > 0)
            printf("              %d",(int)(rowptr[row] - rowptr[row-1]));
    }

    return 0;
}

    osoitintaulukkoon             1     kutsu
    riveille                      5     kutsua
                                 -----
    yhteensä                      6     kutsua

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int **rptr;
    int *aptr;
    int *testptr;
    int k;
    int nrows = 5;     /* Both nrows and ncols could be evaluated */
    int ncols = 8;    /* or read in at run time */
    int row, col;

    /* Varataan muistia taulukolle */

    aptr = malloc(nrows * ncols * sizeof(int));
    if (aptr == NULL)
    {
        puts("\nFailure to allocate room for the array");
        exit(0);
    }

    /* Varataan tilaa riveillä oleville osoittimille */

    rptr = malloc(nrows * sizeof(int *));
    if (rptr == NULL)
    {
        puts("\nFailure to allocate room for pointers");
        exit(0);
    }

    /* Asetetaan osoittimet paikoilleen */

    for (k = 0; k < nrows; k++)
    {
        rptr[k] = aptr + (k * ncols);
    }

    /* Now we illustrate how the row pointers are incremented */

    printf("\n\nIllustrating how row pointers are incremented");
    printf("\n\nIndex   Pointer(hex)  Diff.(dec)");

    for (row = 0; row < nrows; row++)
    {
        printf("\n%d         %p", row, rptr[row]);
        if (row > 0)
            printf("              %d",(rptr[row] - rptr[row-1]));
    }
    printf("\n\nAnd now we print out the array\n");
    for (row = 0; row < nrows; row++)
    {
        for (col = 0; col < ncols; col++)
        {
            rptr[row][col] = row + col;
            printf("%d ", rptr[row][col]);
        }
        putchar('\n');
    }

    puts("\n");

    /* and here we illustrate that we are, in fact, dealing with
       a 2 dimensional array in a contiguous block of memory. */
    printf("And now we demonstrate that they are contiguous in memory\n");

    testptr = aptr;
    for (row = 0; row < nrows; row++)
    {
        for (col = 0; col < ncols; col++)
        {
            printf("%d ", *(testptr++));
        }
        putchar('\n');
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>

int X_DIM=16;
int Y_DIM=5;
int Z_DIM=3;

int main(void)
{
    char *space;
    char ***Arr3D;
    int y, z;
    ptrdiff_t diff;

    /* first we set aside space for the array itself */

    space = malloc(X_DIM * Y_DIM * Z_DIM * sizeof(char));

    /* next we allocate space of an array of pointers, each
       to eventually point to the first element of a
       2 dimensional array of pointers to pointers */

    Arr3D = malloc(Z_DIM * sizeof(char **));

    /* and for each of these we assign a pointer to a newly
       allocated array of pointers to a row */

    for (z = 0; z < Z_DIM; z++)
    {
        Arr3D[z] = malloc(Y_DIM * sizeof(char *));

        /* and for each space in this array we put a pointer to
           the first element of each row in the array space
           originally allocated */

        for (y = 0; y < Y_DIM; y++)
        {
            Arr3D[z][y] = space + (z*(X_DIM * Y_DIM) + y*X_DIM);
        }
    }

    /* And, now we check each address in our 3D array to see if
       the indexing of the Arr3d pointer leads through in a
       continuous manner */

    for (z = 0; z < Z_DIM; z++)
    {
        printf("Location of array %d is %p\n", z, *Arr3D[z]);
        for ( y = 0; y < Y_DIM; y++)
        {
            printf("  Array %d and Row %d starts at %p", z, y, Arr3D[z][y]);
            diff = Arr3D[z][y] - space;
            printf("    diff = %d  ",diff);
            printf(" z = %d  y = %d\n", z, y);
        }
    }
    return 0;
}

7.5 Osoittimet Funktioihin

Kokonaislukuja lajitteleva kuplalajittelu voidaan kirjoittaa seuraavasti:

#include <stdio.h>

int arr[10] = { 3,6,1,2,3,8,4,1,7,2};

void bubble(int a[], int N);

int main(void)
{
    int i;
    putchar('\n');
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    bubble(arr,10);
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

void bubble(int a[], int N)
{
    int i, j, t;
    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
            if (a[j-1] > a[j])
            {
                t = a[j-1];
                a[j-1] = a[j];
                a[j] = t;
            }
        }
    }
}

Aluksi siirretään vertailuoperaatio omaan funktioon. Uudelleenkirjoittamalla sadaan tulokseksi:

#include <stdio.h>

int arr[10] = { 3,6,1,2,3,8,4,1,7,2};

void bubble(int a[], int N);
int compare(int m, int n);

int main(void)
{
    int i;
    putchar('\n');
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    bubble(arr,10);
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

void bubble(int a[], int N)
{
    int i, j, t;
    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
            if (compare(a[j-1], a[j]))
            {
                t = a[j-1];
                a[j-1] = a[j];
                a[j] = t;
            }
        }
    }
}

int compare(int m, int n)
{
    return (m > n);
}

#include <stdio.h>

int arr[10] = { 3,6,1,2,3,8,4,1,7,2};

void bubble(int *p, int N);
int compare(int *m, int *n);

int main(void)
{
    int i;
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    bubble(arr,10);
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

void bubble(int *p, int N)
{
    int i, j, t;
    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
            if (compare(&p[j-1], &p[j]))
            {
                t = p[j-1];
                p[j-1] = p[j];
                p[j] = t;
            }
        }
    }
}

int compare(int *m, int *n)
{
    return (*m > *n);
}

#include 

int arr[10] = { 3,6,1,2,3,8,4,1,7,2};

void bubble(int *p, int N);
int compare(void *m, void *n);

int main(void)
{
    int i;
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    bubble(arr,10);
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

void bubble(int *p, int N)
{
    int i, j, t;
    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
            if (compare((void *)&p[j-1], (void *)&p[j]))
            {
                t = p[j-1];
                p[j-1] = p[j];
                p[j] = t;
            }
        }
    }
}

int compare(void *m, void *n)
{
    int *m1, *n1;
    m1 = (int *)m;
    n1 = (int *)n;
    return (*m1 > *n1);
}

#include <stdio.h>
#include <string.h>

long arr[10] = { 3,6,1,2,3,8,4,1,7,2};

void bubble(void *p, size_t width, int N);
int compare(void *m, void *n);

int main(void)
{
    int i;
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    bubble(arr, sizeof(long), 10);
    putchar('\n');

    for (i = 0; i < 10; i++)
    {
        printf("%ld ", arr[i]);
    }

    return 0;
}

void bubble(void *p, size_t width, int N)
{
    int i, j;
    unsigned char buf[4];
    unsigned char *bp = p;

    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
            if (compare((void *)(bp + width*(j-1)),
                        (void *)(bp + j*width)))  /* 1 */
            {
/*              t = p[j-1];   */
                memcpy(buf, bp + width*(j-1), width);
/*              p[j-1] = p[j];   */
                memcpy(bp + width*(j-1), bp + j*width , width);
/*              p[j] = t;   */
                memcpy(bp + j*width, buf, width);
            }
        }
    }
}

int compare(void *m, void *n)
{
    long *m1, *n1;
    m1 = (long *)m;
    n1 = (long *)n;
    return (*m1 > *n1);
}

#include <stdio.h>
#include <string.h>

#define MAX_BUF 256

char arr2[5][20] = {  "Mickey Mouse",
                      "Donald Duck",
                      "Minnie Mouse",
                      "Goofy",
                      "Ted Jensen" };

void bubble(void *p, int width, int N);
int compare(void *m, void *n);

int main(void)
{
    int i;
    putchar('\n');

    for (i = 0; i < 5; i++)
    {
        printf("%s\n", arr2[i]);
    }
    bubble(arr2, 20, 5);
    putchar('\n\n');

    for (i = 0; i < 5; i++)
    {
        printf("%s\n", arr2[i]);
    }
    return 0;
}

void bubble(void *p, int width, int N)
{
    int i, j, k;
    unsigned char buf[MAX_BUF];
    unsigned char *bp = p;

    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
          k = compare((void *)(bp + width*(j-1)), (void *)(bp + j*width));
          if (k > 0)
            {
             memcpy(buf, bp + width*(j-1), width);
             memcpy(bp + width*(j-1), bp + j*width , width);
             memcpy(bp + j*width, buf, width);
            }
        }
    }
}

int compare(void *m, void *n)
{
    char *m1 = m;
    char *n1 = n;
    return (strcmp(m1,n1));
}

Osoittimet funktioihin täytyy sopia osoittamiinsa funktioihin sekä paluutyyppi että argumenttien lukumäärä ja tyypit pitää olla samoja. Eli esimerkissämme funktio-osoitin määriteltäisiin lauseella:

   int (*fptr)(const void *p1, const void *p2);

    int *fptr(const void *p1, const void *p2);

Voimme nyt määriteelä buble() funktion uudestaan lisäämällä neljännen argumentin, joka on osoite funktioon:

    void bubble(void *p, int width, int N,
                int(*fptr)(const void *, const void *));

#include 
#include 

#define MAX_BUF 256

long arr[10] = { 3,6,1,2,3,8,4,1,7,2};
char arr2[5][20] = {  "Mickey Mouse",
                      "Donald Duck",
                      "Minnie Mouse",
                      "Goofy",
                      "Ted Jensen" };

void bubble(void *p, int width, int N,
            int(*fptr)(const void *, const void *));
int compare_string(const void *m, const void *n);
int compare_long(const void *m, const void *n);

int main(void)
{
    int i;
    puts("\nBefore Sorting:\n");

    for (i = 0; i < 10; i++)               /* show the long ints */
    {
        printf("%ld ",arr[i]);
    }
    puts("\n");

    for (i = 0; i < 5; i++)                  /* show the strings */
    {
        printf("%s\n", arr2[i]);
    }
    bubble(arr, 4, 10, compare_long);          /* sort the longs */
    bubble(arr2, 20, 5, compare_string);     /* sort the strings */
    puts("\n\nAfter Sorting:\n");

    for (i = 0; i < 10; i++)             /* show the sorted longs */
    {
        printf("%d ",arr[i]);
    }
    puts("\n");

    for (i = 0; i < 5; i++)            /* show the sorted strings */
    {
        printf("%s\n", arr2[i]);
    }
    return 0;
}

void bubble(void *p, int width, int N,
            int(*fptr)(const void *, const void *))
{
    int i, j, k;
    unsigned char buf[MAX_BUF];
    unsigned char *bp = p;

    for (i = N-1; i >= 0; i--)
    {
        for (j = 1; j <= i; j++)
        {
            k = fptr((void *)(bp + width*(j-1)), (void *)(bp + j*width));
            if (k > 0)
            {
                memcpy(buf, bp + width*(j-1), width);
                memcpy(bp + width*(j-1), bp + j*width , width);
                memcpy(bp + j*width, buf, width);
            }
        }
    }
}

int compare_string(const void *m, const void *n)
{
    char *m1 = (char *)m;
    char *n1 = (char *)n;
    return (strcmp(m1,n1));
}

int compare_long(const void *m, const void *n)
{
    long *m1, *n1;
    m1 = (long *)m;
    n1 = (long *)n;
    return (*m1 > *n1);
}