💾C언어 포인터 개념

포인터(Pointer)란?

C언어의 포인터는 데이터의 메모리 주소를 저장하는 변수로 이를 통해 메모리 주소에 직접 접근하거나 다른 변수의 값을 간접적으로 조작할 수 있다.

Javascript에서 변수를 선언하면(Heap Memory) 에 공간이 할당되는것 과 같음.
이를 C언어에서는 포인터 개념을 사용하여 직접 주소를 접근하여 조작할 수가 있음.

포인터의 선언

자료형 *포인터_변수명 = &변수명;

자료형* 포인터_변수명 = &변수명;

// *는 자료형 or 포인터_변수명 어느쪽이든 붙여도 상관없음

메모리 주소 : 모든 변수는 메모리에 저장되며, 각 변수는 고유한 메모리 주소를 가진다.

포인터 변수 : 포인터는 변수의 메모리 주소를 저장하는 변수로 이를 통해 다른 변수를 간접적으로 참조하고 조작할 수 있다.

역참조(Dereferencing) : 포인터를 통해 메모리 주소에 저장된 값을 접근하는 것을 역참조라고 하며 * 연산자를 사용한다.

포인터 사용 예시

#include <stdio.h>

int main(){
	int a = 100; // a라는 변수에 100을 할당
    int* b = &a // 포인터변수 b는 a의 주소값을 가르킴
    
    printf("%d %d" , *b, *(&a)); // 100 100
    
    return 0
}

*b 는 현재 a의 주소값을 가르키고 있음으로 100 출력
*(&a) 는 a의 주소값을 가르키고 있음으로 100 출력

*(&a)에서 *는 주소값에 해당되는 값을 의미하고 &는 주소값을 의미함으로 * 와 &는 서로 상반됨으로 상쇄된다.
상반되는 것이 서로 영향을 받아 효과가 없어진다는 의미

1차원 배열 포인터

배열의 i번지 주소

배열+i == &배열[i]

&배열[i] 는 배열[i]값의 주소를 뜻하며 배열+i도 동일한 의미를 갖는다.

배열의 i번지 값

*(배열+i) == 배열[i]

(배열+i) 주소에 *가 있으면 결국 주소가 가르키는 값을 뜻하며 이는 곧 배열[i] 값과 같다.

1차원 포인터 예시

#include <stdio.h>

int main(){
	int a[3] = {1,2}; // a[0]==1 , a[1]==2 , a[2]==0 
    int *p = a; // 포인터변수 p는 a의 주소값을 가르킴
    
    printf("%d %d\n" , a[0],a[1],a[2]);   // 1 2 0
    printf("%d %d\n" , *a,*(a+1),*(a+2)); // 1 2 0
    printf("%d %d\n" , *p,*(p+1),*(p+2)); // 1 2 0  
    printf("%d %d\n" , p[0],p[1],p[2]);   // 1 2 0 
    
    return 0
}

p는 a배열의 주소값을 가르키고 있음으로 위의 출력값은 모두 1 2 0 이 된다.

2차원 배열과 1차원 포인터

2차원 배열일때 값과 주소를 구분하는 방식은 다음과 같다.

a[i][j] --> 값

a[i] --> 주소 (1차원 포인터)

a --> 주소 (2차원 포인터)

2차원 배열의 경우에는 배열명[요소] , *(배열명+요소)는 1차원 포인터와 동일하고, 1차원 포인터에 대해서 *과 []을 이용해야 값을 가르킬 수가 있다.

2차원 배열과 1차원 포인터 예시

#include <stdio.h>

int main(){
	int a[3][2] = {{1,2},{3,4},{5,6}}; // a[0][0]==1, a[0][1]==2, a[1][0]==3, a[1][1]==4, a[2][0]==5, a[2][1]==6, 
    int *p = a[1]; // 포인터변수 p는 a[1]의 주소값을 가르킴
    
    printf("%d %d %d\n" , *a[0],*a[1],*a[2]);   // 1 3 5
    printf("%d %d %d\n" , **a,**(a+1),**(a+2)); // 1 3 5 
    printf("%d %d\n" , *p,*(p+1));   			  // 3 4
    printf("%d %d\n" , p[0],p[1]);   			  // 3 4
    
    return 0
}

*a[0] *a[1] *a[2] 는 1차원 포인터로 해당 주소값과 동일히다.
&a[0][0] == a[0] &a[0][0] == a[0] &a[0][0] == a[0]

**로 주소값을 두번 참조하는 것은 곧 2차원 포인터 --> 1차원 포인터 --> 값 을 가르킨다고 볼 수 있다.

p[0] 과 p[1] 에서 참조에 의해 p == a[1] 이므로 p[0] == a[1][0] p[1] == a[1][1]로 뒤에 붙여진다고 생각하면 쉽다.

2차원 배열과 포인터 배열 예시

#include <stdio.h>

int main(){
	int a[3][2] = {{1,2},{3,4},{5,6}}; // a[0][0]==1, a[0][1]==2, a[1][0]==3, a[1][1]==4, a[2][0]==5, a[2][1]==6, 
    int *p[3] = {a[2],a[0],a[1]}; // 포인터 변수 p배열은 각 값을 가르킴 p[0] == a[2] , p[1] == a[2] , p[2] == a[1]
    
     printf("%d %d %d\n" , a[0][0],a[1][0],a[2][0]);  // 1 3 5
     printf("%d %d %d\n" , *a[0],*a[1],*a[2]);  	  // 1 3 5
     printf("%d %d %d\n" , p[1][0],p[2][0],p[0][0]);  // 1 3 5
     printf("%d %d %d\n" , *p[1],*p[2],*p[0]);	 	  // 1 3 5
    
    return 0
}

p[1][0] p[2][0] p[0][0]에서 p[1] p[2] p[0] 은 역참조에 의해 a[]값을 가르킴으로
p[1][0] == a[1][0] p[2][0] == a[2][0] p[0][0] == a[0][0] 과 같다고 볼 수 있다.

2차원 배열과 2차원 포인터 예시
2차원 배열일 때 배열명[요소][[요소] , *배열명[요소], **(배열명+요소)일 경우 값을 가르킨다.

#include <stdio.h>

int main(){
	int a[3][2] = {{1,2},{3,4},{5,6}}; // a[0][0]==1, a[0][1]==2, a[1][0]==3, a[1][1]==4, a[2][0]==5, a[2][1]==6, 
	int (*p)[2] = a; 	// p==a , q==a+1 (뒤의 [2]는 열이 2개인 값을 가르키는 포인터 변수라는 뜻)
    int (*q)[2] = a+1;
    
    printf("%d %d %d\n" , a[0][0],a[0][1],a[1][0]);	// 1 2 3 		
    printf("%d %d %d\n" , p[0][0],p[0][1],p[1][0]);	// 1 2 3 
    printf("%d %d %d\n" , q[0][0],q[0][1],q[1][0]);	// 3 4 5	
        
    return 0
}

p의 경우는 쉽게 유추할 수 있으나 q의 경우는 조금 복잡하게 느껴질 수가 있다.
쉽게 풀이하자면 q == a+1로 a[1]의 값인 3을 가르킨다. 이때 q가 가르키는 값인 a[1] 메모리를 기준으로 a[1]번째 메모리 부터 [0][0] 그 다음은 [0][1] 다음은 [1][0]... 의 순서로 가르킨다고 볼 수가 있다.

구조체와 포인터

구조체는 포인터로 접근할 시 -> 로 접근하게 된다. 일반적인 구조체 변수로 접근할 때의 . 과 동일한 의미라고 이해하면 쉽다.

구조체 포인터 예시

#include <stdio.h>

// 구조체 정의
struct Person {
    char name;
    int age;
};

int main() {
    struct Person ptr = {'jack',25};
    struct Person *p = &ptr;

    // 포인터를 통해 구조체 멤버의 값 출력
    printf("%c %d\n", ptr.name, ptr.age);          // jack 25
    printf("%c %d\n", (&ptr)->name, (&ptr)->age);  // jack 25
    printf("%c %d\n", p->name, p->age);  		   // jack 25
    printf("%c %d\n", p[0].name, p[0].age,);	   // jack 25

    return 0;
}

1차원 구조체 배열과 1차원 구조체 포인터 예시

#include <stdio.h>

// 구조체 정의
struct Person {
    char name;
    int age;
};

int main() {
    struct Person ptr[3] = {'jane',21, 'jack',20, 'sam',24}; // 'jane',21==s[0] , 'jack',20==s[1] , 'sam',24==s[2]
    struct Person *p = ptr;

    // 포인터를 통해 구조체 멤버의 값 출력
    printf("%c %d\n", ptr[0].name, ptr[0].age);	  // jane 21
    printf("%c %d\n", (*s).name, (*s).age);		  // jane 21
    printf("%c %d\n", s->name, s->age);			  // jane 21
    printf("%c %d\n", (s+1)->name, (s+1)->age);	  // jack 20
    printf("%c %d\n", p[0].name, p[0].age);		  // jane 21
    printf("%c %d\n", (*p).name, (*p).age);		  // jane 21
    printf("%c %d\n", p->name, p->age);			  // jane 21
    printf("%c %d\n", (p+1)->name, (p+1)->age);	  // jack 20

    return 0;
}

포인터로 접근할 시 -> 로 접근하게 된다의 개념만 이해하고 있다면 위의 배열과 포인터 개념과 동일하기 때문에 너무 복잡하게 접근할 필요가 없다.

함수 포인터

함수 포인터란 함수의 주소를 저장하고, 해당 주소의 함수를 호출하는데 사용하는 포인터이다.

리턴타입(*함수_포인터)(함수 파라미터);

함수 포인터 예시

#include <stdio.h>
void fn1(){
	print("fn1 함수\n");
 }
 int fn2(int a){
 	print("fn2 함수:\n", a);
    retirn 0;
 }
 int main(){
   void (*pf1)();   // 파라미터는 받지 않고 void타입을 리턴 
   int (*pf2)(int);	// 파라미터로 int값을 받고 int타입을 리턴
   fn1();	    // fn1 함수
   fn2(5);      // fn2 함수: 5
   pf1 = fn1;
   pf2 = fn2;
   pf1();		// fn1 함수		
   pf2(2);      // fn2 함수: 2
   return 0;
 }