
출처 : codeland

강좌 시샾 김재홍님

㈜ 사이버이메지네이션 입사 기술연구소
Window창전용 2D 게임 스프라이트 툴 개발
ftp, http 실시간 업데이트 모듈 개발
ActiveX 메신져 클라이언트 & 메신져 서버 개발
IOCP 멀티 플래시 게임 서버 개발
현) 나비야 게임개발 회사에서 클라이언트 & (주업무) 웹 게임 서버 개발 


< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기

프로그래밍을 하려면 포인터라는 관문을 꼭 거쳐가야합니다. 만약 관문을 통과하지 못하면

결국은 포기해야할 수도 있습니다.

지금부터 포인터에 대한 너무 어려운 설명보다는 실전에 쓰이면서도 반드시 이해할 수 있는

강의를 진행 하겠습니다.

여러분들은 글을 쭉쭉 읽어 나간후 예제를 풀이 해보는 방식으로 편안하게 강의를 읽어 주시면 됩니다.

우선 포인터란 무엇인가? 포인터에 대해 간단하게 가리킨다라고 생각하시면 됩니다.

예를들어 농구선수들이 등번호가 있습니다 각각 번호가 틀립니다. 그중에 등번호에 해당하는

사람의 이름을 알고 싶다면 그 번호가 해당하는 사람을 가리키며 누구누구다라고 말할 것입니다.

자 예를 또 들어봅시다. C언어의 포인터도 마찬가지 입니다.

A라는 변수가 있습니다. 그러면 A라는 변수는 컴퓨터 내부에 기억된 주소를 갖게 됩니다.

그러면 A의 주소를 알고 싶다면 어떡하면 되겠습니까?

가리키면 됩니다. 가리키기 위해서는 포인터를 사용해야 합니다.

포인터는 변수의 주소를 가리키는데 사용합니다.

가리키는 이유는 그 주소를 알기 위해서입니다. 주소를 왜 알아야 하는지? 그 이유는 

찾아 가기 위해서입니다. 우리는 그 주소를 알지 못합니다. 하지만 어떠한 주소가 있다는 것은

분명히 알고 있습니다. 그 주소를 알기 위해서 포인터를 사용하고 포인터를 사용해 그 주소를 얻어

그 주소가 가리키는 변수를 찾아가 그 변수가 가지고 있는 값을 그대로 얻어 올수 있습니다.

예를 들어 우리는 아파트에 개똥이가 살고 있는 것을 알고 있다고 칩시다.

우리는 그 개똥이가 아파트에 살고 있다는 것을 알고 있지만 몇동 몇호에 사는지는 알수가 없습니다.

그러므로 개똥이네 집에 찾아 갈수가 없습니다.

찾아가기 위해서는 반드시 개똥이의 주소를 정확히 알아야 합니다.

마찬가지로 포인터도 그 변수의 값을 얻고 참조 하기 위해서는 반드시 주소를 알고 찾아 가야합니다.

그럼 여기서 정리해봅시다. 반드시 주소를 알게 된다면 우리가 원하는 답을 얻을 수가 있다는 것입니다.

자 그럼 예제를 하나 들어봅시다. int a; 라고 선언을 했습니다.

printf("%d",a);로 화면에 a라는 값을 출력했습니다. 결과는 -858993460이러한 값이 나오게 됩니다.

초기값을 주지 않아 이런 결과를 갖게 되었습니다. 

프로그래밍을 하다보면 초기값을 주지 않고 실수하는 경우가 많습니다.

int a = 10; 
printf("%d",a);

이렇게 해주면 10이 출력되는 것을 볼수 있습니다. 초기값을 주었기 때문에 별문제 없이 사용할수 있습니다

자 그럼 여기서 a가 살고 있는집은 어디일까요?

프로그램이 실행되면 주소가 정해지는데 a의 주소도 정해지겠지요. 왜냐하면 a라는 변수도

자기가 살고 있는 곳은 메모리입니다. 그 메모리가 아파트라고 생각하십시요 

a는 평수가 4Byte크기의 메모리라는 아파트에서 살고 있습니다.

아파트 주소는 우리가 모르고 있습니다.

단지 a가 메모리라는 아파트의 a라는 변수의 4Byte라는것만 알고 있습니다.

자 여기서 a가 10원을 가지고 있습니다. 그러면 10원을 찾기 위해서는 a가 살고 있는 아파트를

찾아가야 합니다. 그러기 위해서는 주소를 알아야 합니다.

여기서 주소를 알기 위해서는 포인터를 사용해야 합니다.

포인터는 무조건 초기화가 되어야 합니다. 근데 아래 예는 초기화가 되어있지 않습니다.

초기화를 해줘야 그 주소를 찾아 갈수 있습니다.

int a = 10;
int *p;

자 여기서 p라는 변수에 *붙어 있습니다. *이 붙으면 포인터 변수가 됩니다.

포인터 변수는 다른 주소를 가리킬 수 있습니다.

다음과 같이 해주면 p포인터 변수가 a라는 변수가 어디에 사는지 가르쳐 줄 것입니다.

int a = 10;
int *p = &a;

자 여기서 a라는 주소를 p라는 포인터변수 즉 주소를 기록했습니다.

a앞에 &를 붙임으로서 a의 주소를 포인터 변수 p에 넣는다는 뜻입니다.

이렇게 되면 다음부터는 a라는 주소를 알기 위해서는 p라는 포인터 변수를 찾아가서 물어 봐야겠죠?

printf("%d",p); 다음과 같이 p를 화면에 출력해 주었습니다.

p값이 a의 주소를 가지고 있습니다.

printf("%d",*p); 앞에 *를 붙여주면 p가 가리키는 주소의 10을 출력해 줍니다.

다음 그림으로 구조를 한번 봅시다.

--------------
메모리 아파트-
--------------
주소 : 1234  -
--------------
이름 : a     -
--------------
평수 : 4Byte -
--------------
가진돈 : 10  -
--------------

--------------
경비실
--------------
주소 : 1818
--------------
이름 : p
--------------
평수 : 4Byte   (포인터는 변수형에 상관없이 4Byte의 메모리만 가질수 있다)
--------------
알고있는주소:1234
--------------

p는 경비실이 되고 a는 아파트가 됩니다.

p는 1234의 주소를 찾아서 10원을 찾을수 있습니다


void main()
{
   int a = 10;
   int *p = &a;
 
   printf("a값:%d a주소:%d\r\n", a, &a);
   printf("a주소:%d p주소:%d p가 가리키는 값:%d", p, &p, *p);
}

결과:
a값:10 a주소:1245052
a주소:1245052 p주소:1245048 p가 가리키는 값:10

주소는 컴퓨터마다 틀리겠지만 결과는 이런식으로 나오게 됩니다.

자 여기서 a에 10을 넣었고 p는 a에 주소로 초기화 되었습니다.

여기서 p는 a를 항상 가리킬수 있습니다.

p는 a의 주소를 출력할 수 있습니다.

p도 주소가 있습니다. 이것도 나중에 p포인터를 찾으려면 필요한 것이지요.

각각 모든 변수들은 주소를 가지고 있습니다. 꼭 이해 하시기 바랍니다.

*를 붙여주게 되면 p는 포인터가 가리키는 주소 바로 a의 주소의 값 10을 출력해 줍니다.

자 오늘은 여기까지 이해하기 바랍니다. 다음주에는 2차원 포인터에 대해서 배우도록 하겠습니다.

아직도 포인터의 갈길이 멀지만 이해하면서 넘어가면 쉽게 포인터를 마스타할 수 있습니다.

그럼 다음 시간에 뵙겠습니다 수고하세요!


------------------------------------

< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기 [2] 
 

 
 


이번 시간에는 2차원 포인터에 대해서 알아 보겠습니다.

아직 포인터에 대한 많은 관문이 남아 있지만 우선 2차원 포인터를 짚고 넘어 가야 겠습니다.

저번장에서 1차원 포인터는 반드시 다른 변수의 주소로 초기화해야 한다는 것을 배웠습니다.

그럼 이법칙을 꼭 머리속에 생각하고 있어야 합니다.

'1차원 포인터는 반드시 다른 변수의 주소값으로 초기화 되어야 한다'

'1차원 포인터는 자기가 가진 주소를 찾아 갈수 있다'

'1차원 포인터는 변수 앞에 *를 반드시 붙여줘야 한다'

자 그럼 2차원 포인터는 1차원 포인터와 다른점은 *를 두개 붙인다는 점입니다.

int **pp; 이렇게 **를 붙여서 선언 하게 되면 2차원 포인터가 선언된 것입니다.

자 여기서 1차원 포인터는 다른 변수의 주소를 가질 수 있었지만, 2차원 포인터는

다른 변수의 주소를 가질 수 없습니다. 2차원 포인터는 1차원 포인터의 주소를 가질 수 있습니다.

자 여기서 머리속이 점점 복잡해 집니다. 그렇지만 간단하게 생각하세요 법칙이라고 생각 하셔야합니다.

1차원 포인터는 변수의 주소를 가질 수 있고 2차원 포인터는 1차원 포인터의 주소를 가질 수 있다.

그리고 주소는 찾아가기 위한 것이다. 자 아래와 같은 내용을 꼭 알아두셔야 겠죠.

1차원 포인터 ----> 일반변수의 주소를 가질 수 있다.
2차원 포인터 ----> 1차원 포인터의 주소를 가질 수 있다.

int a = 10; a에 10원을 넣는다
int *p = &a; a의 주소를 p포인터에 넣는다
int **pp = &p; p의 주소를 pp포인터에 넣는다

자 이런식으로 사용할 수 있습니다.

자 그럼 예를 하나 들어 봅시다.

int a = 10; // a는 10원을 가지고 있다

printf("a의 전재산:%d\r\n", a);

int *p = &a; // 경비실 p는 a의 주소를 가지고 있어 10원을 가져 갈 수 있다.

*p = *p - 10; // 경비실 p는 a의 주소로 찾아가 10원을 가져 갔다.

printf("a의 전재산:%d\r\n", a); 

int **pp = &p; // 복권 당첨금을 전달하러온 pp직원은 경비원의 주소를 알고 있다.

**pp = **pp + 100; // pp직원은 100원을 전달 해주었다

printf("a의 전재산:%d\r\n", a);

-결과-
 
a의 전재산:10   -> 10원 전재산
a의 전재산:0    -> 관리비 10원 p경비원이 가져감
a의 전재산:100  -> pp직원이 복권 당첨금 100원을 전달함

자 여기서 a의 주소를 1차원 포인터에 넣었습니다.

그리고 1차원 포인터의 주소를 2차원 포인터에 넣었습니다. 주소연산자 &붙여서 주소값을 넣었지요.

자 이렇게 되면 a라는 메모리 아파트에 p라는 경비원이 주소를 알기 때문에 항상 관리비를 받으러

a가 살고있는 주소로 찾아 갈 수 있습니다. a는 아파트 관리비 10원을 경비원에게 주었습니다.

10원을 주니 a는 돈이 한푼없는 빈털털이가 되었습니다.

그러던 어느날 a는 복권에 당첨이 되었습니다. ^^

그래서 pp라는 직원은 a에게 당첨금을 전달해 주기 위해서 집을 찾아가야 합니다.

그렇지만 pp직원은 a라는 주소는 모르고 메모리 아파트의 경비원 p라는 주소를 알고 있습니다.

그래서 pp직원은 자기가 알고 있는 경비실로 향해 갔습니다.

자 여기서 경비실의 p경비원은 a의 주소를 알고 있습니다. 그래서 p경비원은 pp직원에게

a의 주소를 알려 주었습니다.

pp직원은 a의 주소를 받고 a에게 찾아가 당첨금 100원을 전달해 주었습니다.

자 그런데 이해가 안가 신다구요? 다시 한번 봅시다

int a = 10;
int *p = &a;
int **pp = &p;

a는 10을 가지고 있습니다.

p는 a의 주소를 가지고 있습니다.

printf("%d",p)를 해주게 되면 p가 가지고 있는 주소 a의 주소가 출력됩니다.

printf("%d",&p)를 해주면 p의 주소가 출력됩니다. p의 주소는 2차원 포인터에게 가르쳐 주었죠.

printf("%d",*p)여기서 p앞에 *를 붙임으로서 p가 가리키는 주소 a의 변수의 값 10을 출력하게 됩니다.

자 여기서 2차원 포인터도 볼까요.

printf("%d",pp); 1차원 포인터의 주소가 출력됩니다.

printf("%d",&pp); 2차원 포인터의 주소가 출력됩니다.

여기서 2차원 포인터도 주소를 가지고 있죠. 포인터 끼리도 서로가 주소를 가르쳐주면

마음대로 값을 바꿀 수가 있습니다.

printf("%d",*pp); 2차원 포인터에 *를 한개 해주면 pp가 가진 주소의 값으로 찾아가게 됩니다.

pp가 가진 값은 p의 주소입니다. p의 주소로 찾아 가게 되면 p는 a의 주소값을 가지고 있습니다.

그래서 *를 붙임으로써 *pp는 a의 주소값을 가지게 됩니다.

printf("%d",**pp); 이것도 마찬가지로 *을 하나 더 붙였습니다.

*pp일때는 a의 주소값을 가지고 있는 상태입니다. *를 하나 더붙였으니 a의 주소의 값을 찾을 수 있습니다.

결론적으로 **pp는 *pp가 가리키는 주소의 값 즉 a의 값을 가지게 되는 것입니다.

이해가 안가면 몇번이고 읽어 보시기 바랍니다.

자 여기서 포인터끼는 더욱더 간단합니다 그냥 주소만 넣어주면 끝나겠죠?

int **pp = &p; 1차원 포인터의 주소를 2차원 포인터 pp에게 넣어 주었죠.

자 그럼 pp의 주소를 자기 친구에게 그대로 알려 줄 수 있습니다.

aa라는 친구에게 그대로 다음과 같이 알려 주었습니다.

제가 말했죠? 포인터는 주소 값으로 초기화가 된다고 pp의 주소값을 **aa에 넣었으니 주소값으로 

초기화가 되었으니 법칙에 어긋나지 않죠?

int **aa = pp;

이렇게 하면 **aa는 pp의 주소를 가지고 있으니깐 pp와 똑같이 되는 것입니다!

그럼 결론적으로 aa도 pp의 주소를 알고 있으니 p의 주소를 찾을 수 있고 a를 찾아 갈 수 있습니다.

1차원 포인터도 마찬가지 입니다.

int a = 10;
int *p1 = &a;
int *p2 = p1;

여기서 p1의 주소를 p2에게 알려 주었죠.

이렇게 되면 p2도 a의 주소를 알고 똑같이 p1과 같이 접근 할 수 있습니다.

그럼 다음 시간에 뵙겠습니다 수고하세요!

 
 

--------------------------------
< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기 [3] 
 

 
 


포인터 잡느라 고생이 많습니다.

포인터를 때려잡기 위해서는 우리가 조금 더 노력을 해야겠습니다.

오늘은 문자에 대한 포인터에 대해서 간단하게 이해를 해봅시다.

char *a;가 있습니다.

자 이것은 문자의 주소를 가리키는 포인터입니다.

여기서 *a는 포인터이기 때문에 4Byte입니다.

포인터가 아니였다면 1Byte였겠지요? 포인터는 형에 관계없이 무조건 4Byte라고 저번 시간에 배웠습니다.

자 그러면 예제를 하나 들어봅시다.

char b = 'c';
char *a = &b;
printf("%c",*a);

b에 c라는 문자를 집어 넣습니다.

b의 주소를 문자를 가리키는 포인터 a에 집어 넣습니다.

문자를 가리키는 포인터 a는 b의 주소를 가지고 있기 때문에 'c'에 접근할 수 있습니다.

여기서 *를 붙여주어 *a는 자기가 가진 주소b의 값 'c'를 출력하게 되었습니다.

여기까지는 우리가 위에서 보았던 포인터와 방식이 똑같습니다.

자 그럼 다음 문장을 봅시다.

char *p = "abc";

자 머리가 돌기 시작하는군요? 자 분명히 저번 시간에 포인터는 주소 값을 가진다고 했는데

왜 문자열이 쫙 달라 붙었을까요?

이것은 문자열의 첫번째 문자를 가리키는 포인터라고 하는데요!! 자 여기서 중요한것!!

문자를 가리키는 포인터는 반드시 문자열의 선두번지를 가리킨다!!!!!! 라는 것입니다.

*p <-- 이것은 문자의 주소만을 가질 수 있습니다.

자 그런데 "abc"를 집어 넣었죠?

이렇게 되면 실행과 동시에 메모리에는 다음과 같이 저장이 됩니다.

a           [1000번지] <char형은 1Byte이므로 주소도 1Byte씩 증가된다>
b           [1001번지]
c           [1002번지]
\0(널문자)  [1003번지]

char *p = "abc"를 함으로써 p에는 a의 주소 1000번지가 저장이 됩니다.

그리고 끝이 납니다.

여기서 p는 주소 1000번지를 알고 있습니다. 

p에 1을 증가시키면 1001번지에도 갈수 있습니다. 1을 빼주면 다시 1000번지로 갈수 있습니다.

미리 시작할때 abc가 메모리에 등록이 되면서 자동으로 뒤에 널이 붙게 됩니다.

널은 문자열의 끝을 알리기 위한 아스키 코드값 0을 말합니다.

메모리 상에는 이렇게 |a|b|c|\0| 순서대로 들어 가게 됩니다.

printf("%s", p)를 해주면 printf는 p의 선두번지 1000번지의 값 a를 출력 해줍니다.

그리고 다음번지로 이동해서 b를 출력해주고 널을 만날때까지 출력을 해줍니다.

결론적으로 abc가 출력이 되고 끝납니다.

char *p = "abc"; -> a의 선두번지 1000번지를 포인터 p에 저장시킨다
printf("%s",p);  -> printf는 p가 가리키는 주소의 값을 출력 해주고 
                    널을 만날때까지 다음번지로 증가 되면서 출력 해준다

자 다음 예제를 봅시다.

int i = 0;
char *p="okay";
while( *p++ != NULL )
{
  i++;
}

printf("갯수:%d",i);  

위에서 i에 값을 0으로 초기화 시켰습니다.

*p에 "okay"문자열의 선두번지 o의 주소를 등록 시켰습니다.

while문은 참일때는 계속 {와 }사이의 루핑을 돌게 됩니다.

또는 1일때는 참이고 0일때는 거짓으로 인식합니다.

여기서 while( *p++ != NULL ) 문장을 보시면

*p는 자기가 가리키는 문자이지요? 뒤에 ++를 붙였기 때문에 *p가 실행이 되고 난 다음에

*p가 가리키는 곳이 다음으로 진행되겠지요 

그러면 *p++ != NULL이면 현재 p가 가리키는 문자가 널이 아니면 계속 루프를 돈다는 것입니다.

그리고 다음 문자를 가리키게 되고 i++로 i값이 1증가 됩니다.

결과로 보았을때 4가 출력되는 것을 볼 수 있습니다.

루프를 돌면서 널문자를 만날때 까지 i값을 증가시켜 "okay"의 길이를 구하였습니다.

나중에 문자열을 가지고 놀려면 이부분을 잘 이해해야 합니다.

포인터로 값을 증가시키거나 빼거나 해서 가리키는 곳의 값을 이동하며 여러분들이 원하는

코딩을 할수 있을 것입니다.

자 여기서 혼동 하지 마십시요.

char *cp = "abcdefg"; 

int *ip = 12345;

문자를 가리키는 포인터는 문자열의 선두 번지를 저장 할 수 있고, 정수형 포인터는 

정수형 포인터를 저장 할 수 있습니다.

여기서 *ip = 12345는 당연히 주소가 아니기 때문에 에러가 발생할 것입니다.

그러나 *cp는 문자열의 선두번지가 저장되기 때문에 "abcdefg"를 해주면 문자a의 주소가 cp에 저장이 될것이고

우리는 그 선두번지를 알기때문에 abcdefg를 NULL문자로 체크 하여 제어할 수 있습니다.

배열을 예를 들어 봅시다.

char ar[10] = "abcdefghi";배열을 우리가 선언했습니다.

a[0] 1000번지 -> a
a[1] 1001번지 -> b
a[2] 1002번지 -> c
a[3] 1003번지 -> d
a[4] 1004번지 -> e
a[5] 1005번지 -> f
a[6] 1006번지 -> g
a[7] 1007번지 -> h
a[8] 1008번지 -> i
a[9] 1009번지 -> \0(널문자)

딱 10개의 배열을 메모리에 잡았지요. 배열은 반드시 [0]부터 시작합니다!!!

배열은 간단히 char a라고 했을 경우 한개의 문자가 메모리에 생성되지만 char a[10]이라고 하면

문자 10개가 메모리에 문자열로 생성이 됩니다. 배열 맨뒤에는 반드시 NULL이 붙습니다.

a[0]부터 a[9]까지 모두 할당이 되었습니다.

이주소를 char *p = &a[0]; 이런식으로 a[0]의 주소 1000번지 a값을 가리키도록 할 수 있겠죠.

이렇게 되면 char *p를 printf("%s",p);를 해주면 abcdefghi가 출력이 됩니다.

물론 널을 만나게 되어 i까지만 출력이 되겠죠.

그리고 문자를 가리키는 포인터는 배열처럼 사용 할 수 있습니다

이것도 법칙입니다.

무조건 배열처럼 사용 하면 값을 그대로 얻을 수 있습니다.

for(int i = 0 ; i < 10 ; i++) printf("%c",p[i]);

이렇게 해주면 p[0]~p[9]까지 abcdefghi가 출력이 되겠지요.

우리가 여기서 문자를 가리키는 포인터는 배열로 쓸수 있는 것을 배웠습니다.

배열과 포인터의 동일한 결과를 얻을 수 있고 똑같은 주소를 얻을 수 있습니다.

그러나 배열은 상수이고 포인터는 주소값을 같는 변수입니다.

꼭 기억해둬야 합니다.

마지막 예제를 봅시다.

char a = 'c';
char ar[10]="abcdefghi";
char *cp1 = &a;
char *cp2 = "abcdefg";
char *cp3 = &ar[0];

printf("a의값 %c\r\n",a);

printf("ar의값 %s\r\n",ar);

printf("cp1의 값 %c\r\n",*cp1);

printf("cp2의 값 %s\r\n",cp2);

printf("cp3의 값 %s\r\n",cp3);

printf("cp2의 0 1 2번째의 값%c\r\n", cp2[2]);

예제를 풀이 해보세요

오늘은 여기까지~! 수고하셨습니다.

 
----------------------------------
< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기 [4] 
 

 
 


아직 문자를 가리키는 포인터에 대해서 우리가 좀더 짚고 넘어가야 겠습니다.

char *p="abcd";

char p[5]="abcd";

자 이렇게 하면 메모리 상에는 이렇게 됩니다

*p포인터 변수

   100     101     102     103     104
|   a   |   b   |   c   |   d   |   \0   |
*(p+0)   *(p+1)  *(p+2)  *(p+3)   *(p+4)
  p[0]    p[1]    p[2]    p[3]    p[4]


p배열
   100     101     102     103     104
|   a   |   b   |   c   |   d   |   \0   |
  p[0]    p[1]    p[2]    p[3]    p[4]


자 문자를 가리키는 포인터 p는 배열 처럼 사용할 수 있고 가리키는곳을 1씩 증가시켜

접근 할 수 있습니다.

배열은 공간을 미리 확보한후 사용해야 하지만 문자를 가리키는 포인터는 공간 확보를 하지 않고

바로 주소값만 넣어 접근 할 수 있어 간단하게 처리할 수 있습니다.

배열은 상수이고 포인터는 변수 입니다.

그래서 바로 값을 넣기 위해서는

char *AA="abcd";

char BB[5]="abcd";

이런식으로 바로 넣어서 사용할 수 있습니다

하지만 AA = "abcd"게 사용한다면 포인터 변수 이기때문에 바로 주소값을 넣어 접근 할 수 있습니다.

그러나 배열은 상수이기 때문에

이런식으로 BB = "abcd"로 대입할 수 없습니다. 상수란 정해진 값으로 처음 초기값만 가지는 겁니다.

여기서 abcd가 상수이겠죠. 결론적으로 상수에 상수를 넣게 되므로 오류가 발생합니다.

그러나 포인터는 변수니깐 변수에 문자열 상수의 선두번지를 저장만 하는 겁니다.

여기서 AA는 포인터 배열로서 주소를 갖는 것이고 BB는 5개의 문자를 저장할 수 있는 공간을

확보한 배열입니다.

여기서 strcpy를 예를 들어 보도록 하겠습니다

strcpy는 문자열을 복사할때 쓰이는 함수입니다.

이 함수는 확보된 버퍼에만 복사를 할 수 있습니다.

여기서 확보된 버퍼는 BB가 되겠지요 AA는 확보된 버퍼를 가지고 있지 않고 그냥 문자의 선두번지를

가리키고만 있습니다.

strcpy(AA, "abcd");

이렇게 하게된다면 포인터는 확보된 공간이 없는곳에 abcd를 복사하기 때문에

실행시 프로그램이 다운될수 있습니다. 

strcpy(BB, "abcd");

그러나 이런식으로 5개를 저장할 수 있는 배열을 확보한 BB는 abcd를 그대로 확보된 곳에 복사할 수 있습니다.

자 어느정도 이해하셨습니까?

여기서 의문점이 남습니다. 그럼 포인터에는 저장을 못한단 말인가? 라고 생각할 수 있습니다.

그러나 포인터가 가리키는곳을 확보된 공간을 가리키도록 하는것입니다!

포인터에게 엉뚱한 곳을 가리키면 오류가 발생하는것 처럼.

포인터에게 확보된 영역을 가리키도록 하면 그 확보된 영역에 복사할 수 있습니다.

char *AA  = new char[5];

strcpy(AA,"abcd");

printf("%s",AA);

delete[] AA;

여기서 free store(힙 or 동적메모리)를 할당하는 new를 사용 하였는데 new를 

사용하여 할당을하고 delete로 해제를 해주었습니다.

malloc() free()로도 쓸수 있지만 new delete가 안전하고 확장성이 더 좋기 때문에

new delete를 많이 사용합니다.

여기서 new로 char형 5Byte를 할당했습니다. 이로서 

   1000         1001        1002          1003         1004
| 쓰레기값  |  쓰레기값  |  쓰레기값  |  쓰레기값  |  쓰레기값  | 

5개를 집어 넣을 수 있는 공간의 선두번지를 AA 포인터가 가리키게 되었습니다.

strcpy로 1000번지부터 널까지 복사한후 끝나게 됩니다

   1000         1001        1002        1003         1004
|    a      |     b     |    c      |     d      |    \0(널)   | 

이렇게 복사가 되었습니다.

출력해보면 abcd가 출력이 됩니다.

이렇게 포인터는 프로그래머가 할당할 수 있는 힙이라는 영역에서 할당한 선두번지를

가리킬 수 있습니다.

동적메모리는 힙이라는 영역에서 할당을 하는데 프로그램이 종료되면

운영체제가 메모리를 해제해 주지 않습니다.

그래서 따로 프로그래머가 delete를 해주어야 합니다.

만약 delete를 해주지 않으면 Memory Leak가 나게 됩니다.

프로그래머들이 큰 프로그램을 짜다보면 delete를 빼먹거나 적절하게 사용하지 못해

Memory Leak가 발생하는 경우가 있습니다.

또는 서버 프로그램이나 장기간 띄워놓고 메모리를 빈번하게 할당하는 프로그램이라면

Memory Leak가 쌓여 프로그램이 다운될수 있기 때문에 메모리풀을 사용하게 됩니다. 

메모리풀은 프로그램 시작할때 사용할 만큼 할당한후

재사용하기 때문에 Memory Leak가 일어나지 않습니다.

프로그래머는 힙이라는 남겨진 메모리 영역을 할당하여 사용하게 됩니다.

이럴때마다 힙의 메모리는 변하게 되고 나중에 메모리가 바닥나는 경우도 있으니 

프로그래머는 적절하게 사용하는 것이 좋습니다.

너무 많은 메모리 할당은 시스템에 부하를 줄수도 있으니 배열로 버퍼를 잡아 쓰는것도 

적절한 사용 방법입니다.

힙의 메모리는 항상 변하는 것을 볼 수 있습니다. 그렇지만 프로그램이 끝날때 까지 변하지 않는

것이 있는데 그것을 static storage allocation(정적 기억 장소)라고 합니다.

이 정적 기억장소에 할당을 하면 동적 기억장소에 할당 하는것과는 달리 버퍼의 크기와 위치가 

컴파일하거나 프로그램 실행시 정해지게 되므로 융통성은 떨어집니다.

예를들어 전역으로 선언된 변수나 클래스 멤버등을 들수 있습니다.
 
그리고 함수안에서 만들어진 지역 변수는 동적 메모리 영역중 스택 공간에서 할당을 받습니다.

지역 변수는 함수를 벗어나거나 { }를 벗어날때 자동으로 스택에서 소멸됩니다.

스택과 힙은 양쪽 끝에 위치하여 관리하게 됩니다.


<메모리 구조>

---------------------------------

(정적 메모리 영역 )데이터 공간  - (프로그램이 실행되는 동안 계속 지속되는 영역)

---------------------------------

(동적 메모리 영역)스택 공간     - (함수와 변수들이 자동으로 저장되는 공간)

---------------------------------
                    
(동적 메모리 영역)힙 공간       - (순서와 규칙이 없이 자유롭게 할당과 삭제가 가능한 영역)

---------------------------------

어느 정도 이렇게 쓰이고 있다는 것만 확실하게 기억해 둡시다.
 
 
--------------------------------------
< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기 [5] 
 

 
 


저번 시간에 메모리 할당을 하여 포인터가 가리키도록 해서 데이타를

저장하는 법을 배웠습니다.

여기서 1차원 포인터는 배열처럼 쓰일수 있다는 것을 배웠습니다.

포인터는 변수이므로 어떠한 주소를 가리킬수 있다고 했습니다.

여기서 우리는 포인터 배열에 대해서 배워 보도록 하겠습니다.

포인터 배열이란 배열에 포인터를 붙인 것입니다.

char a[10]; 이렇게 해주면 10개의 공간이 확보된 배열을 선언한 것입니다.

이 배열 앞에 *를 붙임으로써 char *a[10]; 10개의 공간이 확보된 포인터 배열 즉

포인터 10개가 만들어져서 각각의 포인터는 주소를 가리킬 수 있습니다.

아주 간단하게 이해가 될것입니다.

자 여기서 우리는 주소를 가리키는 포인터를 배열로해서 10개를 만들었습니다.

단지 기능을 하나로 봤을때 1차원 포인터와 똑같다고 보시면 됩니다.

a의 이름 자체는 상수이지만 a[n]일경우에는 하나의 포인터 변수로 볼 수 있습니다.

다음 예는 포인터 배열로 선언해서 포인터 배열 0번부터 ~ 2번까지 각각 

문자의 선두번지를 가리키도록 초기화 시켰습니다.

char *p[3];   포인터 3개를 선언 (포인터배열)
p[0]="1234";  1234의 선두번지를 저장
p[1]="5678";  5678의 선두번지를 저장
p[2]="abcd";  abcd의 선두번지를 저장
printf("%s %s %s",p[0], p[1], p[2]); 번지에 저장된 값을 출력

자 그럼 p[0],p[1],p[2]들은 각각 하나의 변수라고 볼 수도 있습니다.

자 p[0]이 가리키는 것은 1234의 선두 번지입니다.

여러분의 이해를 돕기 위해.. p[0]이 예를들어 *hi라고 생각해 봅시다.

그러면 메모리 상에

메모리 |   1   |   2   |   3   |   4   |  \0   |
        *(hi+0) *(hi+1) *(hi+2) *(hi+3) *(hi+4)

자 1차원 포인터와 똑같이 생각해 보면 증가를 시켜 접근을 할수 있죠?

결론적으로 hi를 p[0]으로 바꾸고 다시 생각해볼때

*(p[0]+0)은 1을 가리킨다
*(p[0]+1)은 2을 가리킨다
*(p[0]+2)은 3을 가리킨다
*(p[0]+3)은 4을 가리킨다
*(p[0]+4)은 널을 가리킨다

이라는 것을 알 수 있습니다.

p[0]은 1234의 선두번지를 가리킨다는 것을 여러분은 알고 있습니다.

자 이런식으로 포인터로 접근을 할 수 있습니다.

이름 자체일 경우는 선두번지를 가리키고 *를 붙이게 되면 가리키는 주소의 데이타를 건드릴 수 있습니다.

자 다시한번!

(p[0])여기 앞에 *() 붙이면 *(p[0])이 되겠고

자 p[0]이 가리키는 첫번째 주소는 1234중 1의 주소겠죠..

앞에 *()로 감싸주었기 때문에 가리키는 주소의 데이타값 1을 그대로 얻어 올수 있습니다.

자 그러면,

*(p[0]) 이것은 값 1을 가리키고
*(p[1]) 이것은 값 5를 가리키고
*(p[2]) 이것은 값 a를 가리킨다는 것을 알았습니다.

전부다 선두번지의 문자를 가리키고 있습니다.

여기에 각각 +,-를 해줌으로써 다음 문자나 이전 문자를 가리킬 수 있다는 것을 알았습니다.

괄호를 해준 이유는 우선순위 때문에 해준것 입니다.

예를들어 우선순위가 p[0]이 가리키는 주소의 포인터기 때문에 p[0]이 우선이 되어야 하기때문에

p[0]에 괄호를 넣고 바깥에 *를 넣은 것입니다.

이렇게 해줌으로써 p[0]이 가리키는 주소의 값은 1이 되는 것입니다.

이로써 포인터 배열의 구조를 한번 훑어 봤습니다.

더이상 복잡하게 할필요 없이 여기까지만 알고 계시면 충분하리라고 봅시다.

다음 예제를 보시면 알겠지만 배열로 선언했을 뿐이지 거이 똑같다고 느껴지실 겁니다..

char *p[3];
p[0]="1234";
p[1]="5678";
p[2]="abcd";

printf("%s %s %s\r\n",p[0], p[1], p[2]);
printf("%c %c %c\r\n",*(p[0]),*(p[1]),*(p[2]));
printf("%c %c %c\r\n",*(p[0]+1),*(p[0]+2),*(p[0]+3));

char *p1="1234";
char *p2="5678";
char *p3="abcd";

printf("%s %s %s\r\n",p1, p2, p3);
printf("%c %c %c\r\n",*p1,*p2,*p3);
printf("%c %c %c",*(p1+1),*(p1+2),*(p1+3));

<결과>
1234 5678 abcd
1 5 a
2 3 4
1234 5678 abcd
1 5 a
2 3 4

자 이해하셨겠죠?

여기서 끝이 아닙니다.

혹시 실수로 빼먹을 수도 있겠죠???

무엇일까요. 메모리 할당입니다.

포인터는 가리키는 것으로 쓰이고 있습니다. 그러나, 데이타를 저장, 복사 등등 작업을 하려면

메모리를 할당하여 확보한후 그곳을 가리키게 한후 저장을 해야 합니다.

그렇지 않으면 포인터가 가리키는 곳 없이 엉뚱한 곳을 가리키게 되어 오류가 발생합니다.

마지막 예제를 보고 이해를 하시기 바랍니다.

char *p[3];

p[0] = new char[10]; // 문자 10개를 넣을 수 있는 메모리를 확보
p[1] = new char[10]; // 문자 10개를 넣을 수 있는 메모리를 확보
p[2] = new char[10]; // 문자 10개를 넣을 수 있는 메모리를 확보

//메모리할당을 하지 않고 만약 확보된 영역이 없는 상태에서 할 경우 오류 발생

gets(p[0]); // 한줄을 입력 받아 할당된 메모리에 저장
gets(p[1]); // 한줄을 입력 받아 할당된 메모리에 저장
gets(p[2]); // 한줄을 입력 받아 할당된 메모리에 저장

printf("%s",p[0]); // p[0]이 가리키는 주소의 데이타를 출력
printf("%s",p[1]); // p[1]이 가리키는 주소의 데이타를 출력
printf("%s",p[2]); // p[2]이 가리키는 주소의 데이타를 출력

delete p[0]; // p[0]이 가리키는 확보된 영역을 힙에서 제거
delete p[1]; // p[1]이 가리키는 확보된 영역을 힙에서 제거
delete p[2]; // p[2]이 가리키는 확보된 영역을 힙에서 제거 

자 이해하셨죠?

이해를 돕기위해 줄줄이 예제를 for문 없이 사용했는데 나중에는 

for(int i = 0 ; i < 3 ; i++)
{
   p[i] = new char[10]; 
}

이런식으로 사용할 수 있겠죠..

아무튼 포인터로 작업할경우 대부분 주소를 저장하여 가리키거나 메모리 할당을 하여

사용 합니다. 잘 이해해 두시기 바랍니다.

지금껏 char형 1차원 포인터와 포인터 배열에 대해서 배웠습니다.

자 그럼 마지막으로 한가지가 더 남아 있습니다.

char형 2차원 포인터입니다.

한가지를 알면 나머지는 비슷하게 그대로 응용만 하면 됩니다.

자 예제를 봅시다.

char **pp;  

char형 2차원 포인터를 선언 했습니다. 

포인터의 주소를 저장하고 그 주소의 데이타를 가리킬수 있습니다

pp = new char* [3]; 

2차원 포인터는 1차원 포인터의 주소를 가리키므로 char에 *가 붙어 char*의 

1차원 포인터 3개를 할당 했습니다.
 
여기서 포인터 3개니깐 총 4 X 3 = 12Byte를 할당한 것이다.

포인터는 무조건 4Byte라고 했죠?

pp 2차원 포인터는 3개의 포인터 변수를 할당한 메모리의 선두번지를 가리키고 있습니다.

단지 1차원 포인터 변수를 3개 메모리상에 만들기만 했습니다.

pp-> [ ][ ][ ] 우선은 메모리 할당을 하지 않았으니 가리키는 곳이 빈상태가 되겠죠

1차원 포인터에 각각 메모리를 할당하여 가리키도록 할 수 있습니다.                     
                    
pp[0] = new char [10]; or *(pp+0) = new char [10];
pp[1] = new char [10]; or *(pp+1) = new char [10];
pp[2] = new char [10]; or *(pp+2) = new char [10];

2가지 방식으로 할당할 수 있습니다. 포인터는 배열로 쓸수 있다고 말했죠?

대부분 배열이 보기 쉽기 때문에 배열로 많이 사용합니다!

자! 3개의 1차원 포인터에 10Byte씩 할당한 메모리의 선두번지를 각각 가리키도록 했습니다.

pp-> [10Byte][10Byte][10Byte] 자 힙에서 총 30Byte를 할당 했군요

몽땅 합쳐서 12 + 30 = 42Byte를 할당한 것입니다

4Byte짜리 포인터 3개와 10Byte짜리 메모리 3개죠..

자 이로서 2차원 포인터는 3개의 메모리를 할당한 선두번지를 가리키고 있습니다.

pp[0]이나 *pp는 할당한 곳의 선두번지의 값을 얻을 수 있겠죠?

pp[1]은 *(pp+1)이 되겠고 pp[2]은 *(pp+2)가 되겠죠? 아주 간단하게 생각 하시면 됩니다.

gets(*pp);     or gets(pp[0]); 123을 입력하고 엔터
gets(*(pp+1)); or gets(pp[1]); 456을 입력하고 엔터
gets(*(pp+2)); or gets(pp[2]); 789를 입력하고 엔터

자 gets로 각각 할당한 메모리에 값을 저장 시켰습니다.

*pp는 "123"의 1의 주소를 가지고 있고 *(pp+1)는 "456"의 4의 주소를 가지고 있고

*(pp+2)는 "789"의 7의 주소를 가지고 있습니다.

1씩 증가시키면 다음 포인터의 선두번지를 가리키게 되는 겁니다.

그래서 다음문자를 가리키고 싶다면

*( pp[0] + 1 ) or *(  *(pp)+1 ) 자 이런식으로 단어별로 접근할 수 있습니다.

pp[0]이나 *(pp)이나 똑같이 가리키는것은 문자 1을 가리키고 있습니다.

pp[0]+1을 해주면 다음 단어의 주소를 얻어오게 되고 *()로 그 주소안에 있는 값을 2를 얻어오게 됩니다.

*(pp)도 마찬가지로 *pp가 가리키는것은 1값의 주소를 가리키고 있겠죠.

1을 증가시켜 2를 가리키도록 했습니다 다시 *()로 감싸주어 2를 가리키는 주소의 값을 얻어오게 됩니다.

여기서 *(pp+1)과 *(pp)+1은 엄현히 다릅니다!!

*(pp+1)은 자기가 가리키는 주소의 값을 1증가시켜 4byte가 이동이 되어 다음 포인터로 이동하게 됩니다.

*(pp)+1현재 가리키는 단어에 1을 증가시켜 1Byte 앞으로 이동하게 되어 다음 단어의 주소를 가리키게 됩니다.

모두 *()로 감싸져 자기가 가리키는 주소의 데이타에 접근할 수 있겠죠.

다른것들도 이 방식으로 접근을 하면 됩니다.

좀 복잡하게 보일지는 모르겠지만 방법은 다 똑같습니다. 계속 이부분을 읽어서 이해를 시키세요..

마지막으로 값을 사용했다면 힙에서 제거 해야 합니다.

지금 메모리 상태를 먼져 볼까요?

pp
pp[0] == *(pp)   
[1] 1Byte             
[2] 1Byte             
[3] 1Byte             

pp[1] == *(pp+1) 
[4] 1Byte
[5] 1Byte
[6] 1Byte

pp[2] == *(pp+2)
[7] 1Byte
[8] 1Byte
[9] 1Byte


자 여기서 delete를 해주어 각각 3개의 포인터에 할당된 메모리를 제거 시켜주면 되겠습니다.

delete pp[0];  pp[0]이 가리키는곳 10Byte할당된 부분을 힙에서 제거합니다
delete pp[1];  pp[1]이 가리키는곳 10Byte할당된 부분을 힙에서 제거합니다
delete pp[2];  pp[2]이 가리키는곳 10Byte할당된 부분을 힙에서 제거합니다

이로서 30Byte가 메모리에서 제거 되었습니다

나머지 포인터 3개가 할당된 12Byte를 제거 해야겠죠

3개의 포인터의 선두번지를 가리키는 pp를 제거 해주면 이로서 12Byte가 힙에서 제거 됩니다.

delete pp;

자 이렇게 하면 말끔하게 마무리가 되는 겁니다.

깔끔한 예제를 봅시다

약간 변형시킨 거지만 이것을 풀어보세요. 이해하셨다면 지금까지 잘따라 오신겁니다.

char **pp; // 2차원 포인터 배열 선언

pp = new char* [3]; // 1차원 포인터 3개를 메모리에서 할당하여 선두번지를 가리키도록 한다

*(pp+0) = new char [100]; // 첫번째 1차원 포인터에 100Byte를 할당
pp[1] = new char [100]; // 두번째 1차원 포인터에 100Byte를 할당
pp[2] = new char [100]; // 세번째 1차원 포인터에 100Byte를 할당

gets(*pp);   // 첫번째 1차원 포인터가 가리키는 메모리에 입력된 값을 저장
gets(pp[1]); // 두번째 1차원 포인터가 가리키는 메모리에 입력된 값을 저장
gets(pp[2]); // 세번째 1차원 포인터가 가리키는 메모리에 입력된 값을 저장


printf("%s\r\n", *(pp+0)); //첫번째 1차원 포인터가 가리키는 문자를 널을 만날때까지 출력
printf("%s\r\n", *(pp+1)); //두번째 1차원 포인터가 가리키는 문자를 널을 만날때까지 출력
printf("%s\r\n", *(pp+2)); //세번째 1차원 포인터가 가리키는 문자를 널을 만날때까지 출력

printf("%c\r\n", *(pp[1]+1)); //두번째 1차원 포인터가 가리키는 문자의 다음 문자를 출력

printf("%c\r\n", *(*(pp+1)+1)); //두번째 1차원 포인터가 가리키는 문자의 다음 문자를 출력

delete *(pp); //첫번째 포인터가 가리키는 할당된 메모리를 힙에서 제거
delete pp[1]; //두번째 포인터가 가리키는 할당된 메모리를 힙에서 제거
delete pp[2]; //세번째 포인터가 가리키는 할당된 메모리를 힙에서 제거

delete pp; //할당한 3개의 포인터를 힙에서 제거

자 수고하셨습니다.

다음 시간에 봅시다.
 
 

---------------------------------------------------
< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기 [6] 
 

 
 


이번 시간에는 NULL 포인터와 void형 포인터에 대해서 배워 보도록 하겠습니다.

NULL 포인터는 가리키는 곳이 0x0000을 가리키는 포인터입니다.

NULL 포인터는 값이 0이라는 뜻이죠.. 실제로 NULL은 #define NULL 0으로 정의 되어있습니다.

한마디로 가리키는값이 0입니다. 가리키는 값이 없다는 뜻입니다.

대부분 널로 초기화 한후 실제 확보된 메모리 영역을 포인터로 가리키도록 합니다.

그리고 다시 메모리를 반납한후 NULL로 초기화 시키곤 합니다.

만약 포인터의 값이 NULL이라면 예외처리를 해줘야 합니다.

다음 예제를 보면 포인터의 주소값과 포인터에 저장된 값을 출력해줍니다.

int *p = NULL;

printf("%d %d", &p, p);

결과

1245052 0

이런식으로 나오게 됩니다.

포인터의 주소는 있지만 포인터가 가지고 있는 주소는 NULL이 되겠죠

그러므로 가리키는 곳이 NULL이 됩니다.

만약 printf("%d", *p);를 해주면 실행시 오류가 발생하게 됩니다.

NULL포인터는 가리키는 곳이 없는데 가리키는 값을 출력하라고 했기 때문에

Access Violation 에러가 나게 됩니다.

포인터를 예외처리를 할 경우에는 대부분 NULL로 체크를 합니다.

if(p == NULL)
{
   return FALSE;
}

이런식으로 코딩을 하면 NULL일경우 FALSE를 리턴 하도록 하면 Access Violation을 막을 수 있겠죠?

다음 예제를 봅시다.  프로그램 종료시에 만약 NULL이면 이미 반납이 된것으로 처리하여

그냥 종료를 시켜주고 NULL이 아니면 가리키는 영역이 있기 때문에 

포인터가 가리키는 힙의 영역을 제거 시키고 종료하게 됩니다.

if(p == NULL)
{
  return;
}
else
{
  delete p;
}

초기화 할경우도 마찬가지 입니다.

만약에 포인터가 이미 힙에서 할당한 부분을 가리키고 있는데 또 메모리 할당을 할경우

메모리 Leak이 발생할수 있습니다.

그러므로 다음과 같은 처리를 사용할 수 있습니다.

NULL일 경우에만 할당하겠죠?

if(p == NULL)
{
  p = new char[100];
}

이와 같은 방법은 클래스 멤버의 포인터나 전역으로 선언한 포인터 변수에서 사용 합니다.

자 NULL포인터에 대해서 간단하게 이해만 하시면 됩니다.

다음은 void형 포인터에 대해서 배워 봅시다.

void형은 함수에서도 많이 쓰이는데 리턴 함수에 void가 들어가면 아무값도

리턴할 수 없다는 뜻이 됩니다.

또는 파라미터에 void가 들어가면 값을 전달 할수가 없다는 뜻입니다.

실제 뜻을 보면 '아무것도 없는' '(텅)빈'이란 뜻을 가지고 있습니다.

그럼 void형 포인터는 무엇이라고 생각하십니까?

void형 포인터는 가리키는 것을 어떤 형이든지 가리킬 수 있습니다.

결론 적으로 가리키는 것을 알수가 없으니 아무거나 가리킬수 있다는 뜻입니다.

다음 예제를 봅시다.

int a = 10; // a에 10을 저장 한다.

void *p = (int*) &a; // a의 주소를 void형 포인터 p에 저장한다.

printf("%d",*(int*)p); // void형 포인터가 가리키는 주소 a의 값 10을 출력 한다.

자 a는 int형입니다. 이렇게 되면 int형 포인터로 선언한 값에 주소가 저장이 되어야 하는데

void형 포인터에 주소를 저장했습니다.

void형 포인터에 주소를 저장하는 대신에 cast연산자를 사용해서 void형 포인터가 int형을 해석

할수 있도록 (int*) 형변환을 해줘야 합니다.

고로 &a의 주소값은 int형 포인터로 받아야 한다. 라고 알려주는 겁니다.

알려주는 방법은 (int*) 이것을 추가시키면 되겠죠.

뜻을 해석하면 int형 포인터로 a의 주소값을 저장 시킨다.

()는 우선순위를 주기 위해서 붙여 준것이구요.

자 값을 출력 할때도 void형이 가리키는 값이 어떤형인지 또 몇바이트인지 알아야 합니다. 

그래야 정확하게 컴파일러가 해석할 수 있습니다.

그게 법칙이구요.

printf("%d",p); 이렇게 하면 a의 주소값이 출력이 되겠죠? 그러나 형변환을 해주지 않으면

법칙에 어긋나는 행동입니다. 컴파일이 될수는 있으나 나중에 치명적인 오류가 발생할 수도 있겠지요..

그러므로 printf("%d",(int*) p); 앞에 (int*)을 붙여주면 int형을 가리키는 포인터형으로 변환하여

p에 저장된 값을 출력 합니다. 

void형 포인터는 int를 받으면 int형 포인터로 형변환을 해줘야 합니다.

또 char형이면 char형 포인터로 형변환이 되어야 하구요. 반드시 형에 맞게 형변환을 해줘야 합니다.

주소가 가리키는 실제 값을 출력해봅시다.

printf("%d", (int*) p); 는 주소값을 출력하는 것이고 앞에 *를 붙이게 되면 그 주소가 가리키는

값을 출력 한다고 했지요?

(int*)p <-- 이것 자체가 p를 (int*)형으로 변환한 주소 입니다. 그 앞에 *를 붙이게 되면

*(int*)p <-- 이것은 p를 (int*)형으로 변환한 주소 값의 데이터를 가리키게 되는 겁니다.

실제로 중간에 (int*)만 추가된것 뿐이지 다른건 없습니다.

원래 예제를 봅시다.

<int형 포인터로 선언한 예>

int a = 10;

int *p = &a;

printf("%d",*p);


<void형 포인터로 선언한 예>

int a = 10;

void *p = (int*)&a; //void가 a의 주소값을 받을때 int형 포인터로 받는다.

printf("%d",*(int*)p); //p주소를 가리키는 void형은 int형으로 변환되어 가리키는 주소의 값을 출력한다.

반드시 void형에 저장되는 형의 값은 반드시 캐스트 연산자를 사용하여 사용해야 합니다.

포인터 끼리도 마찬가지 입니다.

int a = 10;

int *pp = &a;

void *p = (int*)pp; // pp형 가리키는 데이터값이 int형이므로 int형 포인터로 변환하여 주소값을 저장한다.

printf("%d",*(int*)p);

자 (int*)형으로 변환하여 pp의 주소값을 저장했지요.

만약 p가 int형 포인터였다면 (int*)가 필요 없이 int *p = pp;를 사용했겠지만 현재 p는 void형 포인터기 때문에

(int*)형으로 형변환하여 사용한 것은 당연한 것입니다.

이상으로 간단한 NULL포인터와 void형 포인터에 대해서 알아봤습니다.
 
 
--------------------------------------------------
< C/C++ 기초 Tip & Trick > 1장 포인터 맛보기 [7] 
 

 
 


오늘은 함수 포인터에 대해서 배워 보겠습니다.

함수 포인터는 말 그대로 함수를 가리키는 포인터 변수입니다. 여태껏 배워왔던 포인터와 똑같습니다.

여태껏 변수만을 가리키는 방법을 배워왔습니다.

하지만 포인터 변수는 함수도 가리킬수 있는 강력한 권한이 있습니다.  

저번에도 얘기했듯이 포인터 변수는 모두 4Byte입니다.

여지껏 배워온 포인터의 또다른 기법을 배워야 할것입니다.

포인터 변수에 함수의 시작번지를 저장시키고 저장된 시작번지의 주소를 가리키게 한후 실제 함수를 

호출 하게 하면 끝입니다..

선언 하는 방법도 함수와 비슷하게 선언해줘야 합니다.

그래야 함수를 가리키는 포인터라고 인식을 하는거죠..

예를들어 다음과 같이 Start라는 함수가 있다고 봅시다.

이것을 포인터 변수가 가리키도록 해볼까요?

void Start()
{
   printf("안녕하세요");
}

void (*p)(); //함수를 가리키는 포인터 변수 4Byte짜리를 선언한다.

p = Start; // Start함수의 선두번지의 주소를 p포인터 변수가 가리킬수 있도록 p에 저장한다.

(*p)(); // p에 *를 붙이고 뒤에 ();를 붙여서 p가 가리키는 함수를 호출한다.

자 여기서 (*p)빼고는 Start와 리턴형과 파라미터가 없는것이 비슷합니다.

Start함수를 가리키기 위해서는 가리키는 함수와 똑같이 파라미터와 리턴값을 맞춰줘야 합니다.

void Start()
void (*p)() 

자 (*p)와 이름만 틀릴뿐 비슷하죠?

자 여기서 *p가 붙어 함수를 가리키는 포인터 변수가 선언이 된것입니다.

함수를 가리키는 포인터 변수만 선언이 된것이지요.

포인터 변수에 Start함수의 시작주소를 저장시켜 볼까요?

p = Start;

Start 이름 자체는 함수의 시작번지를 가지고 있는 상수입니다!!!!!

그러므로 Start의 시작번지를 p에 저장하는 것입니다.

p가 가리키는 함수를 호출 해볼까요?

앞에 *를 붙여주면 자신이 가리키는 주소를 찾아가죠. 그리고 뒤에 ();를 붙여 함수를 찾아가라고 

인식을 시켜줘야 합니다.

(*p)();를 호출하면 결국 Start();로 호출하는거와 똑같은 결과가 나타납니다.

결국 p가 가리키는 함수의 시작번지를 찾아가 Start()를 호출하는거죠.

자 다른 예제를 봅시다. 리턴값과 파라미터에 값을 전달하는 것입니다.

int Sum(int a, int b)
{
 printf("합은 [%d] 입니다",a+b);
 return a+b;
}

void main()
{
 int (*p)(int a, int b); //함수를 가리킬 수 있도록 포인터 변수 선언( 함수와 비슷하게 )

 p = Sum; //Sum함수의 선두번지를 p포인터에 저장

 int Value = (*p)(10,10); // p포인터가 가리키는 함수를 호출 리턴값을 Value에 저장

 printf("\r\n리턴값:%d", Value);
}

<결과>

합은 [20] 입니다
리턴값:20

다똑같죠 단지 (*p)이것만 해줬을 뿐이죠.

int Sum(int a, int b)를 가리키려면 반드시

int (*p)(int a, int b); <-- 이렇게 똑같은 형태로 변수를 선언해야 합니다.

(*p)이름을 변수처럼 자유롭게 사용할수 있죠..

포인터 변수라고 우선순위를 주기 위해서 괄호를 넣어 준것이구요.

아무튼 약간 이상해 보일지도 모르겠지만 이렇게 사용한다고 이해를 해두셔야 합니다.

마지막으로 알아야 할것은 함수를 가리키는 포인터 변수는 파라미터로 받을 수 있습니다.

당연히 변수니깐 파라미터로 받겠죠.

다음 예제를 봅시다.

void Hello()
{
  printf("Hello");
}

void Okay(void (*p)()) //파라미터를 함수를 가리키는 포인터로 파라미터를 받았습니다.
{
  (*p)(); //파라미터로 넘겨받은 선두번지를 찾아가 Hello함수를 실행합니다.
}

void main()
{
  Okay(Hello); // Hello함수의 선두번지를 파라미터로 넘겨준다.
}

이런식으로 아주 간단하게 넘길 수가 있습니다.

Okay파라미터에 void (*p)()를 그대로 넣어 줬습니다. 

왜냐 함수를 가리키는 포인터는 변수이고 함수를 가리키기 위해서는 포인터 변수를 함수처럼

(*p)만 빼고 똑같이 선언해줘야 한다고 배웠습니다.

아무튼 리턴값과 파라미터는 항상 똑같이 해주어야 합니다 결코 잊지 마세요!

이상 함수 포인터를 마치겠습니다.