포인터2

다차원 배열

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

int arr[3][3]={1,2,3,4,5,6,7,8,8};

포인터의 포인터

이중 포인터 or 더블 포인터 : 포인터의 포인터, 변수를 가리키는 또 다른 포인터 변수

int main(void){
    double num=3.14;
    double * ptr=#
    double ** dptr=&ptr;
    
    *dptr=...  // *dptr은 포인터 변수 ptr을 의미
    *(*dptr)=... // *(*dptr)은 변수 num을 의미
}

ptr은 주소고(함수에 전달할땐 주소가 복사되서 ptr값 바꿀 수 없어. &ptr로 전달해야돼)

*ptr은 변수 num

 

다중 포인터 변수 : *연산자 2개이상

int main(void)
{
	int num=100;
	int *ptr=#
	int **dptr=&ptr;
	int ***tptr=&dptr;

	printf("%d %d \n", **dptr, ***tptr);
	return 0;
}

포인터의 필요성

자료구조 공부하면 알아

함수 내에서 함수 외부에 선언된 변수에 접근하는 방법을 제시

 

#include <stdio.h>

void MaxAndMin(int* arr, int size, int** maxPtr, int** minPtr) {
	int* max, * min;
	int i;
	max = min = &arr[0];
	for (i = 0; i < size; i++) {
		if (arr[i] < *min)
			min = &arr[i];
		if (*max < arr[i])
			max = &arr[i];
	}
	*maxPtr = max;
	*minPtr = min;
}

int main(void)
{
	int* maxPtr;
	int* minPtr;
	int arr[5];
	int i;
	for (i = 0; i < 5; i++) {
		printf("%d번째 입력", i + 1);
		scanf_s("%d", &arr[i]);
	}
	MaxAndMin(arr, sizeof(arr) / sizeof(int), &maxPtr, &minPtr);
	printf("%d, %d", *maxPtr, *minPtr);
	return 0;
}

 

다차원 배열과 포인터의 관계

arr과 arr[0]은 같은가??

arr은 첫번째 요소를 가리키면서 배열 전체를 의미한다. 하지만 arr2d[0]은 첫번째 요소를 가리키되 1행만을 의미한다.

 

두 포인터의 포인터 형이 같다면, 두 포인터를 대상으로 하는 증가 및 감소연산의  결과로 증가 및 감소하는 값의 크기 같다.

int arr1[3][2] 는 8씩증가(4+4)  sizeof(int)*2

int arr2[2][3] 은 12씩증가(4+4+4)  sizeof(int)*3

=> 2차원 배열이름의 포인터 형은 가로의 길이에 따라서도 달라진다.

 

int (*ptr) [4]    ptr은 포인터!

int (*ptr) [4]    int형 변수를 가리키는 포인터!

int (*ptr) [4]    포인터 연산 시 4칸씩 건너뛰는 포인터!

=> 배열 포인터 변수

 

int * whoA[4];  // 포인터 배열

int (*whoB)[4];  // 배열 포인터   (매개변수에서만 같아)( ==int whoB[][4])

#include <stdio.h>

int main(void)
{
	int num1 = 10, num2 = 20, num3 = 30, num4 = 40;
	int arr2d[2][4] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	int i, j;

	int* whoA[4] = { &num1, &num2, &num3, &num4 };  // 포인터 배열
	int(*whoB)[4] = arr2d;    // 배열 포인터

	printf("%d %d %d %d \n", *whoA[0], *whoA[1], *whoA[2], *whoA[3]);
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 4; j++)
			printf("%d ", whoB[i][j]);
		printf("\n");
	}
	return 0;
}

매개변수에서 int (*arr)[4] ===== int arr[][4]

세로길이 : sizeof(arr1)/sizeof(arr1[[0])

 

2차원 배열에서도 arr[i]와 *(arr+i)는 같다.

arr[2][1]=4;  == 

(*(arr+2))[1]=4;  *(arr[2]+1)=4;  *(*(arr+2)+1)=4;

함수 포인터와 void 포인터

변수만 메모리 공간에 저장되는 것이 아니라 함수들도 바이너리 형태로 메모리 공간에 저장되어서 호출시 실행된다.

배열의 이름이 배열의 시작주소 값을 의미하듯, 함수의 이름도 함수가 저장된 메모리 공간의 주소 값을 의미한다.

함수이름의 포인터 형은 반환형과 매개변수의 선언을 통해서 결정짓도록 약속되어 있다.

 

int (*fptr) (int)    fptr은 포인터!

int (*fptr) (int)   반환형이 int인 함수 포인터!

int (*fptr) (int)   매개변수 선언이 int 하나인 함수 포인터!

#include <stdio.h>

void SimpleAdder(int n1, int n2)
{
	printf("%d + %d = %d \n", n1, n2, n1 + n2);
}

void ShowString(char* str)
{
	printf("%s \n", str);
}

int main(void)
{
	char* str = "Function Pointer";
	int num1 = 10, num2 = 20;

	void (*fptr1)(int, int) = SimpleAdder;
	void (*fptr2)(char*) = ShowString;

	/* 함수 포인터 변수에 의한 호출 */
	fptr1(num1, num2);
	fptr2(str);
	return 0;
}

ㅇ

#include <stdio.h>

int WhoIsFirst(int age1, int age2, int (*cmp)(int n1, int n2))
{
	return cmp(age1, age2);
}

int OlderFirst(int age1, int age2)
{
	if (age1 > age2)
		return age1;
	else if (age1 < age2)
		return age2;
	else
		return 0;
}

int YoungerFirst(int age1, int age2)
{
	if (age1 < age2)
		return age1;
	else if (age1 > age2)
		return age2;
	else
		return 0;
}

int main(void)
{
	int age1 = 20;
	int age2 = 30;
	int first;

	printf("입장순서 1 \n");
	first = WhoIsFirst(age1, age2, OlderFirst);
	printf("%d세와 %d세 중 %d세가 먼저 입장! \n\n", age1, age2, first);

	printf("입장순서 2 \n");
	first = WhoIsFirst(age1, age2, YoungerFirst);
	printf("%d세와 %d세 중 %d세가 먼저 입장! \n\n", age1, age2, first);
	return 0;
}

void 형 포인터 변수 : void * ptr;

=> 어떠한 변수의 주소 값이든 담을 수 있다. 함수도 가능

     but 단점. 아무런 포인터 연산도 하지 못한다.

일단 주소 값에만 의미를 두고, 포인터의 형은 나중에 결정하는 경우에 유용

 

char * argv[]

char형 더블 포인터 변수, 이는 char형 포인터 변수로 이뤄진 1차원 배열의 이름을 전달받을 수 있는 매개변수