Pekare

• Varje variabel har en adress

• En variabels adress ges av den unära adressoperatorn &

• Adresser hanteras kan lagras i variabler ("pekarvariabel")

• Den monära "avrefereringsoperatorn" * används dels vid deklaration av pekarvariabler och dels för att "komma åt" det som pekaren refererar

• Det går att utföra aritmetik med pekare

    int x = 1, y = 2
    int a[] = {4, 3, 2, 1};
    int *ip, *jp;

    ip  = &x;
    y   = *ip;
    *ip = 0;
    jp  = ip;
    *jp = *jp + 5;
    (*ip)++;
    jp  = 0;
    *jp = 2;   /* Illegalt! */

    ip  = &a[0];
    jp  = ip + 1;
    *jp = 0;
    *(ip+3) = *(ip+1) + 2;
    ip  = a;
    

Pekare som parametrar

void swap( int *x, int *y )  {

   int temp = *x;

   *x = *y;
   *y = temp;
}
   

   int a, b;
     
   ...
 
   swap( &a, &b);

Arrayer som parametrar

int strlen( char *s ) {
    int n=0;
    while ( *s != '\0' ) {
      s++;
      n++;
    }
    return n;
}

Alternativ:

int strlen( char *s ) {
    char *p = s;
    while ( *p != '\0' ) 
       p++;
    return p - s;
}

Fyra versioner av strängkopiering

void strcpy( char *s, char *t ) {
   int i = 0;
   while ((s[i] = t[i]) != '\0')
     i++;
}



void strcpy( char *s, char *t ) {
   while ((*s = *t) != '\0') {
     s++;
     t++;
   }
}

void strcpy( char *s, char *t ) {
   while ((*s++ = *t++) != '\0')
     ;
}



void strcpy( char *s, char *t ) {
   while (*s++ = *t++)
     ;
}

Arrayer med pekare

int main( int argc, char *argv[] ) {

    int i;

    for ( i = 1; i < argc; i++ )
      printf( "%s%s", 
              argv[i],
              (i < argc-1) ? " " : "" );
    printf( "\n" );
    return 0;
}
             
  

Pekare som funktionsvärde

char *findBlank(char *s) {
  while ( *s != ' ' && *s != '\0' ) s++;
  if ( *s == '\0' ) 
     return NULL;
  else
     return s;
}

Varningar

Felaktig av pekare är en mycket vanlig orsak till svårupptäckta fel!

Några vanliga fel:

• Försök att följa NULL-pekaren

• Användning av odefinerade pekare

• Användning av pekare till utrymme som är återlämnat

• Flera pekare som oavsiktligt refererar samma objekt

Preprocessorn

Filinkludering

#include "filnamn"
#include <filnamn>

Kan vara nästlade.

Macrofacilitet

#define namn utbytestext

Exempel:

  #define Euler  0.57721566
  #define TRUE   1
  #define FALSE  0
  #define begin  {
  #define end    }
  #define debug  1

  #define sqr(x)  (x)*(x)
  #define max(x,y) ((x) > (y) ? (x) : (y))
  

---

Villkorlig inkludering

   
   #if debug == 1
       printf("Nu är vi här\n");
   #endif

  

Mycket använt för deklarationsfiler (s.k. headerfiler):

 
   #ifndef _stack_
   #define _stack_

    ...

   #endif

Uppräkningstypen enum

Exempel

   enum Colour = { Green, Yellow, Red};

   enum Colour d;

   d = Green;
   ...
   switch (d) {
     case Green: 
          ... 
          break;

     case Red:
          ...
          break;
     ...
   }

Observera

• enum är en heltalstyp

• Green etc. blir konstanter med heltalsvärden 0, 1 etc.

• Variabler skall deklareras med enum Colour. Bättre att använda typedef (se nästa sida).

Definiera egna typer: typedef

Exempel

   typedef float Real;
   typedef unsigned char Digit;
   typedef enum Colour Colour;
   typedef char String[100];
   typedef int * IntPointer;

   Real x;
   String name, adress;
   IntPointer ip, jp;
   Colour c;

• typedef definierar en egen datatyp

• Syntaxen är exakt som en variabeldeklaration

• Ger möjlighet att lätt byta datatyp

• Använd typedef!

Sammansatta datatyper: struct

Exempel

  struct Point {
     double x, y;
  };

  typedef struct Point Point;

  struct Triangle {
     Point a, b, c;
  };

  typedef struct Triangle Triangle;

  Point    p1 = {0, 0};
  Point    p2;
  Triangle t;

  p2.x  = 1.;
  p2.y  = 0.;

  t.a   = p1;
  t.b   = p2;
  t.c.x = p1.x + 2;
  t.c.y = t.a.x + 1;