포인터 종류

1. 객체 포인터

예)

        int  *ip;

        -> ip는 int 타입의 객체를 가리키는 포인터

        char *cp;

        -> cp는 char 타입의 객체를 가리키는 포인터

2. 함수 포인터

예)

        int  (*fp)();

        -> fp는 int를 리턴하는 함수를 가리키는 포인터

관련 연산자

& : 주소 연산자, 변수의 포인터(주소) 값을 만든다.

* : 간접 연산자. 포인터(주소)가 가리키는 곳의 값

다음 프로그램을 살펴보고 결과를 예측하라.

pointerop.c

     1  #include <stdio.h>

     2

     3  main() {

     4      int i, j, *ip;

     5

     6      ip = &i;

     7      i = 22;

     8      j = *ip;

     9      *ip = 17;

    10

    11      printf("i = %dn", i);

    12      printf("j = %dn", j);

    13      printf("*ip = %dn", *ip);

    14  }

% a.out

i =  ?

j =  ?

*ip = ?

함수 호출에서 포인터 넘기기(call-by-value)

passing_pointer.c

     1  #include <stdio.h>

     2

     3  void h(int *p) {

     4      printf("In h() : &p = %p t p = %p t *p = %dn", &p, p, *p);

     5  }

     6

     7  main() {

     8      int  a = 10;

     9

    10      printf("In main : &a = %p t a = %d n", &a, a);

    11      h(&a);

    12  }

% a.out

In main : &a = effff9f8          a = 10 

In h() : &p = effff9dc   p = effff9f8    *p = 10

제네릭 포인터

모든 타입에 적용될 수 있는 포인터를 제네릭 포인터라고 한다.

ISO에서는 void * 를 제네릭 포인터로 지정하고 있다.

예)

        void  * gp;

        int   * ip;

        char  * cp;

        gp = ip;

        ip = gp;

        ip = (int *) cp;

genswap.c

     1  #include <stdio.h>

     2  #include <malloc.h>

     3  #include <sys/mem.h>

     4

     5  void swap(void *a, void *b, int n) {

     6      void *t = malloc(n);

     7

     8      memcpy(t, a, n);

     9      memcpy(a, b, n);

    10      memcpy(b, t, n);

    11      free(t);

    12  }

    13

    14  void main(void) {

    15      char   c1='A',    c2='B';

    16      int    i1=100,    i2=200;

    17      float  f1=3.14,   f2=33.33;

    18

    19      printf("nBefore : %c   %c",c1,c2);

    20      swap(&c1, &c2, sizeof(c1));

    21      printf("tAfter : %c  %c n",c1,c2);

    22

    23      printf("nBefore : %d  %d", i1, i2);

    24      swap(&i1, &i2, sizeof(int));

    25      printf("tAfter : %d   %dn",i1,i2);

    26

    27      printf("nBefore : %f  %f ",f1,f2);

    28      swap(&f1, &f2, sizeof(float));

    29      printf("tAfter : %f   %fn",f1,f2);

    30  }

% a.out

Before : A   B  After : B  A 

Before : 100  200       After : 200   100

Before : 3.140000  33.330002    After : 33.330002   3.140000

널(Null) 포인터

C 언어에서는 특별한 포인터인 널 포인터를 지원한다.

널 포인터는 0, 0L, (void *)0 등으로 표현될 수 있다. 

NULL 매크로는 3가지 널 포인터 중에서 한가지 형태를 갖을 수 있게 되어 있다.

예)

다음 문장

        if(ip)

            i = *ip;

는 아래 문장과 동일하다.

        if(ip != NULL)

            i = *ip;

포인터와 배열

배열과 포인터는 동일하지는 않지만 대부분의 경우에 동일하게 사용된다. 

특히 식(expression)에서는 배열과 포인터는 서로 교환되어 사용될 수 있다.

예)

        int  a[10];

        int *pa = &a[0];        /* int *pa = a; 와 동일 */

        

        

        a[5]는 *(a + 5)와 동일하다.

        sizeof(a) = ????

pnarray.c

     1  #include <stdio.h>

     2

     3  main() {

     4      int  a[10] = { 3, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

     5      int  *pa = a;

     6

     7      printf("a[5] = %dn", a[5]);

     8      printf("*(a+5) = %dn", *(a+5));

     9      printf("*(pa+5) = %dn", *(pa+5));

    10      printf("pa[5] = %dn", pa[5]);

    11      printf("n*a+5 = %dn", *a+5);

    12      printf("nsizeof(a) = %dn", sizeof(a));

    13  }

% a.out

a[5] = 6

*(a+5) = 6

*(pa+5) = 6

pa[5] = 6

*a+5 = 8

sizeof(a) = 40

예)

        int t[2][3];

        t[1][2]은 *(*(t+1)+2)와 동일하다.

예)

        int  squash[23][12];

or

        int * squash[23];

or

        int ** squash;

or

        int (* squash)[12]

*px++, (*px)++, *++px, ++*px

1.*px++ 는 *(px++) 와 동일하다. 결과적으로는 *px의 값을구하기는 하지만, 나중에 px를 1 만큼 증가시킨다. 

2.(*px)++ 는 먼저 *px 값을 구한 후 *px 자체를 1 만큼 증가시킨다. 

3.*++px 는 *(++px) 와 동일하다. 즉 먼저 px 를 1 만큼 증가시킨 후 *px 값을 구한다.

4.++*px 는 ++(*px) 와 동일하다. 즉 *px 의 값 자체를 1 만큼 증가시킨다. 

포인터의 포인터

Pointer to pointer 는 그 대상 자체가 포인터인 포인터 변수이다.

포인터 변수는 어떤 변수의 번지를 저장하는 변수이다. 그러므로, Pointer to pointer 는

포인터의 번지를 기억한다

함수 포인터

     1  #include <stdio.h>

     2

     3  void  say(char * msg) {

     4      printf("%sn", msg);

     5  }

     6

     7  void exe(void (*fun)(char *), char* msg) {

     8      fun(msg);

     9  }

    10

    11  main() {

    12      void (*hello)(char *);

    13

    14      hello = say;

    15      hello("Hello World");

    16      exe(hello, "HI~~");

    17  }

% a.out

Hello World

HI~~