목차:
＊포인터의 개념
＊변수의 주소
* 포인터의 선언
* 간접 참조 연산자
* 포인터 연산
* 포인터와 배열
* 포인터와 함수
1. 포인터의 개념
정의) 주소를 저장하는 변수 (데이터를 저장하는 변수 X)
tip) 변수는 메모리에 저장되며, 메모리는 바이트 단위이고, 각각의 바이트 마다 주소가 부여가 됨.
ex) int = 4byte , char = 1byte , float = 4byte
2. 변수의 주소
정의) 해당하는 변수의 주소를 계산하는 연산자 : &(앤퍼센트)
- referencing연산자,대상의 주소를 얻어오는 연산자
ex) 변수 i의 주소 -> &i
변수 i의 값 -> i=10
#include <stdio.h>
int main(void)
{
int i = 10;
char c = 69;
float f = 12.3;
printf("i의 주소: %u\n", &i); // &(앤퍼센트) 기호로 주소값 호출중
printf("c의 주소: %u\n", &c);
printf("f의 주소: %u\n", &f);
return 0;
}
i의 주소: 1769731892 //시스템에 임의로 부여한 주소값임.
c의 주소: 1769731924
f의 주소: 17697319563. 포인터의 선언
정의) 변수의 주소를 가지고(저장) 있는 변수
syntax) int * p ;
= 정수를(원하는 type)/ 가리키는(포인터 입니다)/ 포인터p(변수명)
주의) (1) 실제 가르키는 변수의 type에 따라 알맞게 포인터의 type을 선언해야함
(2) 포인터의 초기화는 꼭 하자 NULL 사용.
// 포인터와 변수의 연결
int i = 10; // 정수형 변수 i 선언
int*p; // 포인터 변수 p 선언
p=&i // 변수 i의 주소가 포인터p로 할당됨
//위와 동일함
int i = 10; // 정수형 변수 i 선언
int*p=&i; // 포인터 변수 p 선언과 동시에 변수i의 주소가 할당됨<주의 해야할 점(1)>
char c = 'A' // 문자형 변수 c 선언
flaot f = 36.5; // 실수형 변수 f 선언
double d = 3.141592; // 실수형 변수 d 선언
char*pc = &c; // 문자형을 가리키는 포인터pc
float*pf = &f; // 실수형을 가리키는 포인터pf
double *pd = &d; // 실수형을 가리키는 포인터pd
<주의 해야할 점(2)>
int i = 10;
int*pi=NULL; // 포인터의 초기화는 필수!!
pi=&i;
print("%u,%u",pi,&i);
>>>1768820 1768820 // 동일한 주소값이 출력이 됨
4. 간접(역) 참조 연산자 *
정의) 포인터가 가리키는 값을 가져오는 연산자
-deferencing 연산자, referencing의 역과정으로 주소로부터 대상변수를 얻어오는 것
int i=10; // i에 10을 할당함
int *p=&i; // 포인터p에 i의 주소를 할당함.
printf("%d",*p)
>>> 10 // 10 이 출력됨
#include <stdio.h>
int main(void)
{
int x=3;
int *ptr_x=&x
print("주소=%5d\n",ptr_x); // 주소 값 출력
print("값= %5d\n",*ptr_x); // 주소가 지칭하는 값 출력
return 0;
}
0x0061FF08
3정리) & 연산자
* 연산자
| 의미 | 읽는법 | |
| &연산자 | 변수의 주소를 반환 함 | &x -> x의 주소 |
| *연산자 | 포인터가 가리키는 곳의 내용을 반환 함 | *x -> x의 포인터 |
포인터 예제#1
#include <stdio.h>
int main(void)
{
int i = 3000;
int* p = NULL;
p = &i; //이렇게 해야 연결이 됨
printf("i=%d\n", i); // 변수의 i 의값 출력
printf("&i= %u\n", &i); // 변수 i 의 주소 출력
printf("p=%u\n",p); // 포인터의 값 출력
printf("*p=%d\n", *p); // 포인터를 통한 간접 참조 값 출력
return 0;
}
>>>
i=3000
&i=1245024
p=1245025
*p=3000포인터 예제#2
#include <stdio.h>
int main(void)
{
int i = 10;
int* p = NULL;
p = &i; //이렇게 해야 연결이 됨
printf("i=%d\n", i);
*p = 20; // 포인터르 통하여 변수의 값을 변경한다, i=*p=20 과 동일한 의미
printf("i=%d\n", i);
return 0;
}
>>>
i=10
i=205. 포인터 연산
- 가능한 연산: 증가, 감소, 덧셈, 뺄셈 연산
- 증가 연산의 경우 증가되는 값은 포인터가 가리키는 객체의 크기
| 포인터 타입 | ++연산후 증가되는 값 |
| char | 1 |
| short | 2 |
| int | 4 |
| float | 4 |
| double | 8 |
<증가연산 예제 (바이트만큼 커진다는것을 알 수 있다.)(감소도 동일함)>
#include <stdio.h>
int main(void)
{
char* pc;
int* pi;
double* pd;
pc = (char*)10000;
pi = (int*)10000;
pd = (double*)10000;
printf("증가 전 pc=%d,pi=%d,pd=%d\n", pc, pi, pd);
pc++; //증가된 후에 저장이 되어서 증가된값들이 pc,pi,pd가 됨.
pi++;
pd++;
printf("증가 후 pc=%d,pi=%d,pd=%d\n", pc, pi, pd );
printf("pc+2=%d, pi+2=%d, pd+2=%d\n", pc + 2, pi + 2, pd + 2);
return 0;
}
>>>
증가 전 pc=10000,pi=10000,pd=10000
증가 후 pc=10001,pi=10004,pd=10008
pc+2=10003, pi+2=10012, pd+2=10024<간접 참조 연산자와 증감 연산자>
● *p++ : 주소를 증가
-> p(주소)가 가리키는 위치에서 값을 가져온 후에 p(주소)를 증가함.
●(*p)++ : 값을 증가
-> p가 가리키는 위치의 값을 증가한다.
#include <stdio.h>
int main(void)
{
int i = 10;
int* pi = &i;
printf("i=%d, pi=%p\n", i, pi);
(*pi)++; // pi가 가리키는 위치의 값을 증가한다.
printf("i=%d, pi=%p\n", i, pi);
printf("i=%d, pi=%p\n", i, pi);
*pi++; // pi가 가리키는 위치에서 값을 가져온 후에 pi를 증가한다.
printf("i=%d, pi=%p\n", i, pi);
return 0;
}
>>>
i=10, pi=00000015E119FB44
i=11, pi=00000015E119FB44 // i 의 값이 증가됨을 알 수 있다.
i=11, pi=00000015E119FB44
i=11, pi=00000015E119FB48 // 주소값이 4byte(int임으로)증가함을 알수있다.<포인터의 형변환>
syntax: double*pd=&f;
int *pi;
pi=(*int)pd;
<인수 전달 방법>
->함수 호출 시에 인수 전달 방법
(1) 값에 의한 호출(call by value)
-> 함수로 값의 복사본이 전달됨
-> 기본적인 방법
(2) 참조에 의한 호출(call by reference)
-> 함수로 주소가(원본이) 전달됨.
-> C에서는 포인터를 이용하여 흉내 낼 수 있다.
<swap함수 #1 값에 의한 호출>
#include <stdio.h>
void swap(int x, int y)
{
int tmp;
printf("x=%d y=%d\n", x, y);
tmp = x;
x = y;
y = tmp;
printf("x=%d y=%d\n", x, y);
}
int main(void)
{
int a = 100, b=200;
printf("a=%d b=%d\n", a, b);
swap(a, b);
printf("a=%d b=%d\n", a, b);
return 0;
}
>>>
a=100 b=200
x=100 y=200
x=200 y=100 // 로컬 변수 이기 때문에 함수 내부에서만 유지됨.
a=100 b=200<swap함수 #2 참조에 의한 호출>
#include <stdio.h>
void swap(int *px, int *py) //주소에 있는 값 전달
{
int tmp;
tmp = *px;
*px = *py;
*py = tmp;
}
int main(void)
{
int a = 100, b=200;
printf("a=%d b=%d\n", a, b);
swap(&a, &b);
printf("a=%d b=%d\n", a, b);
return 0;
}
>>>
a=100 b=200
a=200 b=100
6. 포인터와 배열
-> 포인터는 배열처럼 사용할 수 있다.
-> 인덱스 표기법을 포인터에 사용할 수 있다.
// 포인터와 배열의 관계 예시
#include<stdio.h>
int main(void)
{
int a[] = { 10,20,30,40,50 }; //각각의 배열이 4바이트씩 차지함.
printf("&a[0]=%u\n", &a[0]);
printf("&a[1]=%u\n", &a[1]);
printf("&a[2]=%u\n", &a[2]);
printf("a=%u\n", a);
return 0;
}
>>>
&a[0]=2503932216
&a[1]=2503932220 // 다음 int 공간에서 가장작은 값 나옴
&a[2]=2503932224 // 다음 int 공간에서 가장작은 값 나옴
a=2503932216 // a는 가장 작은 주소를 가리킨다//포인터를 배열처럼 사용 예시
#include<stdio.h>
int main(void)
{
int a[] = { 10,20,30,40,50 }; //각각의 배열이 4바이트씩 차지함.
int* p;
p = a; // p에다가 a의 주소 가져옴
printf("a[0]=%d a[1]=%d a[2]=%d \n", a[0],a[1],a[2]); // line 10,11을 보고 배열은 결국
printf("p[0]=%d p[1]=%d p[2]=%d \n", p[0],p[1],p[2]); // 포인터로 구현 된다는것을 알수있다.
p[0] = 60; //포인터를 통해 배열원소를 변경할수 있다.
p[1] = 70;
p[2] = 80;
printf("a[0]=%d a[1]=%d a[2]=%d \n", a[0], a[1], a[2]);
printf("p[0]=%d p[1]=%d p[2]=%d \n", p[0], p[1], p[2]);
return 0;
}
>>>
a[0]=10 a[1]=20 a[2]=30
p[0]=10 p[1]=20 p[2]=30
a[0]=60 a[1]=70 a[2]=80
p[0]=60 p[1]=70 p[2]=807. 포인터와 함수
//포인터와 함수의 관계
#include <stdio.h>
void sub(int b[], int n[]);
int main(void)
{
int a[3] = { 1,2,3 };
printf("%d%d%d\n", a[0], a[1], a[2]);
sub(a, 3);
printf("%d%d%d\n", a[0], a[1], a[2]);
return 0;
}
void sub(int b[], int n) // ( 배열을 받은 포인터, 개수)
{
b[0] = 4;
b[1] = 5;
b[2] = 6;
}
>>>
123
456// 다음 두가지 방법은 완전히 동일함
//방법1_ 배열 매개변수
void sub(int b[], int size[]) //(b[] 배열의 이름과 포인터는 근복적으로 같다.
{
b[0] = 4;
b[1] = 5;
b[2] = 6;
}
//방법 2_ 포인터 매개변수
void sub(int* b, int size)
{
b[0] = 4; //line18,19,20 배열 표기법을 사용하여 배열에 접근
b[1] = 5;
b[2] = 6;
}
