[C] 포인터 | 값에 의한 호출 | 참조에 의한 호출 | clock() | 형식 태크

int 철수 = 1;

메모리에 철수라는 공간이 생긴다. 그리고 철수라는 공간의 위치를 나타내는 주소가 있다. 우리는 101호라고 읽지만, 실제 메모리에서는 어떤 값일지 모른다. 주소값을 알아내려면 변수명 앞에 &를 붙여 출력하면 된다. 

주소값을 출력하고 싶다면 서식지정자 %d 대신 %p (포인터)를 사용한다. 그러면 메모리 주소를 16진수 형태로 출력한다.

#include <stdio.h>

int main(void) {
	int 철수 = 1;
	int 영희 = 2;
	int 민수 = 3;

	printf("철수네 주소 : %p, 암호 : %d\n", &철수, 철수);
	printf("영희네 주소 : %p, 암호 : %d\n", &영희, 영희);
	printf("민수네 주소 : %p, 암호 : %d\n", &민수, 민수);
	
	return 0;
}

주소값은 변수 철수가 메모리의 어느 위치에 있는지를 나타낸다. 즉, 변수의 주소

 

변수 앞에 *를 붙어 선언한 변수를 포인터 변수 또는 포인터라 한다. 포인터 변수는 메모리의 주소값을 저장하는 변수.

자료형 * 변수명;

#include <stdio.h>

int main(void) {
	int 철수 = 1;
	int 영희 = 2;
	int 민수 = 3;

	int * 미션맨;
	미션맨 = &철수;

	printf("미션맨이 방문한 곳의 주소 : %p, 암호 : %d\n", 미션맨, *미션맨);
	
	return 0;
}

 

포인터 변수를 사용하여 다른 변수의 주소와 값을 알아낼 수 있다.

알아낸 변수의 주소에 찾아가 값도 직접 바꿀 수 있다.

 

#include <stdio.h>

int main(void) {
	int 철수 = 1;
	int 영희 = 2;
	int 민수 = 3;

	int * 미션맨;
	미션맨 = &철수;
	*미션맨 = *미션맨 * 3;
	printf("미션맨이 암호를 바꾼 곳의 주소 : %p, 암호 : %d\n", &철수, 철수);
	return 0;
}

 

int * 스파이 = 미션맨;

스파이는 미션맨이 알아낸 누군가의 집 주소를 똑같이 알 수 있다. 포인터 변수 2개는 같은 주소, 즉 하나의 메모리 공간을 가리킬 수 있다. 그리고 포인터 변수로 주소를 알고 있으면 해당 주소에 가서 저장한 값을 가져올 수도 있고 값을 변경할 수도 있다.

#include <stdio.h>

int main(void) {
	int 철수 = 1;
	int 영희 = 2;
	int 민수 = 3;

	int * 미션맨;
	미션맨 = &철수;
	*미션맨 = *미션맨 * 3;
	
	int * 스파이 = 미션맨;
	*스파이 = *스파이 - 1; // 철수 = 철수 - 1;
	printf("스파이가 방문한 곳의 주소 : %p, 암호 : %d\n", 스파이, *스파이);

	return 0;
}

 

그렇게  바뀐 암호

#include <stdio.h>

int main(void) {
	int 철수 = 1;
	int 영희 = 2;
	int 민수 = 3;

	printf("철수의 주소 : %p, 암호 : %d\n", &철수, 철수);
	printf("영희의 주소 : %p, 암호 : %d\n", &영희, 영희);
	printf("민수의 주소 : %p, 암호 : %d\n", &민수, 민수);

	int * 미션맨;
	int * 스파이;

	미션맨 = &철수;
	*미션맨 = *미션맨 * 3;
	스파이 = 미션맨;
	*스파이 = *스파이 - 1;
	printf("미션맨이 방문한 곳의 주소 : %p, 암호 : %d\n", 미션맨, *미션맨);
	printf("스파이가 방문한 곳의 주소 : %p, 암호 : %d\n", 스파이, *스파이);

	미션맨 = &영희;
	*미션맨 = *미션맨 * 3;
	스파이 = 미션맨;
	*스파이 = *스파이 - 1;
	printf("미션맨이 방문한 곳의 주소 : %p, 암호 : %d\n", 미션맨, *미션맨);
	printf("스파이가 방문한 곳의 주소 : %p, 암호 : %d\n", 스파이, *스파이);

	미션맨 = &민수;
	*미션맨 = *미션맨 * 3;
	스파이 = 미션맨;
	*스파이 = *스파이 - 1;
	printf("미션맨이 방문한 곳의 주소 : %p, 암호 : %d\n", 미션맨, *미션맨);
	printf("스파이가 방문한 곳의 주소 : %p, 암호 : %d\n", 스파이, *스파이);

	printf("철수의 주소 : %p, 암호 : %d\n", &철수, 철수);
	printf("영희의 주소 : %p, 암호 : %d\n", &영희, 영희);
	printf("민수의 주소 : %p, 암호 : %d\n", &민수, 민수);

	return 0;
}

 

미션맨과 스파이 같은 포인터 변수는 어떤 변수의 주소를 값으로 가지고 있으며, 주소를 이용해 주소에 해당하는 변수의 값을 직접 바꿀 수 있다. 추가로, 포인터 변수인 미션맨과 스파이도 다른 변수와 마찬가지로 주소가 있다. 두 포인터 변수의 주소는 다음과 같이 출력 가능.

printf("미션맨의 주소 : %p\n", &미션맨);
printf("스파이의 주소 : %p\n", &스파이);

 

문제

int a = 10;
int * p = &a;
a = 15;
printf("%d\n", *p);

*p = 15;

 

p 는 a의 주소를 가리킨다. 10의 주소가 아니라 a의 주소. 따라서, *p는 a 변수의 값에 접근하기 위해 사용된다.

여기서 중요한 점은 *p와 a가 동일한 메모리 위치를 가리키고 있다는 것. 따라서 a의 값을 변경하면 *p도 변경된다.

 

포인터 변수에 배열을 값으로 넣으면 포인터 변수는 배열의 첫 번째 요소의 주소, 즉 배열의 시작 주소를 가리키게 된다. 그러면 포인터 변수는 시작 주소로 배열에 접근해 요소의  값을 하나씩 가져올 수 있다. 포인터 변수가 직접 배열의 각 요소에 접근해서 값을 바꿀 수 있다. 

#include <stdio.h>

int main(void) {
	int arr[3] = { 5,10,15 };
	for (int i = 0; i < 3; i++) {
		printf("배열 arr[%d]의 값 : %d\n", i, arr[i]);
	}

	int* ptr = arr;
	for (int i = 0; i < 3; i++) {
		printf("포인터 변수 ptr[%d]의 값 : %d\n", i, ptr[i]);
	}

	ptr[0] = 100;
	ptr[1] = 200;
	ptr[2] = 300;

	for (int i = 0; i < 3; i++) {
		printf("배열 arr[%d]의 값 : %d\n", i, arr[i]);
	}
	for (int i = 0; i < 3; i++) {
		printf("포인터 변수 ptr[%d]의 값 : %d\n", i, ptr[i]);
	}

	return 0;
}

 

int * ptr = arr; (O)

int arr[3] = ptr; (X)

 

printf("배열 arr[%d]의 값 : %d\n", i, arr[i]);
printf("배열 arr[%d]의 값 : %d\n", i, *(arr + i));

위 두 출력문은 같은 값을 출력한다. 문법적으로 완전히 같은 문장. ptr[i] = *(ptr + i)

arr은 arr배열이 시작되는 주소, 즉 첫 번째 요소의 주소를 가지고 있다. arr[i]는 배열 첫 번째 요소의 주소로부터 i번째에 해당하는 요소의 값을 가져온다는 의미

 

arr == &arr[0];

arr의 값은 arr 배열 첫 번째 요소의 주소와 같음

 

*(arr + i) == arr[i];

arr에서 i만큼 떨어진 곳에 저장된 값과 arr배열의 i인덱스 값은 같음

0은 생략해도 되기 때문에, *arr = arr[0]

 

포인터 변수 ptr에 arr을 넣으면 ptr도 arr 배열의 첫 번째 주소를 값으로 가지므로 배열의 요소에 접근해 값을 읽어 오거나 바꿀 수 있다. 

 

#include <stdio.h>

int main(void) {
	int arr[3] = { 5,10,15 };
	for (int i = 0; i < 3; i++) {
		printf("배열 arr[%d]의 값 : %d\n", i, arr[i]);
	}

	int* ptr = arr;
	for (int i = 0; i < 3; i++) {
		printf("포인터 변수 ptr[%d]의 값 : %d\n", i, ptr[i]);
	}

	ptr[0] = 100;
	ptr[1] = 200;
	ptr[2] = 300;

	printf("arr 자체의 값인 주소의 실제 값 : %d\n", *arr);
	printf("arr[0]의 실제 값 : %d\n", *&arr[0]);

	return 0;
}

 

 

 

*과 &를 함께 사용할 때

arr[0]의 실제 값을 출력할 때, *&arr[0]이라고 작성함. &는 주소, *은 주소의 값을 나타내기 때문에, 둘은 상쇄된다.

 

 

포인터로 두 변수의 값 교환하기

1. 값에 의한 호출(call by value) : 주소가 동일하지 않다.

#include <stdio.h>

void swap(int a, int b);

int main(void) {
	int a = 10;
	int b = 20;
	printf("swap() 함수 호출 전 => a : %d, b : %d\n", a, b);
	swap(a, b);
	printf("swap() 함수 호출 후 => a : %d, b : %d\n", a, b);

	return 0;
}

void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	printf("swap() 함수 안 => a : %d, b : %d\n", a, b);
}

 

 

2. 참조에 의한 호출(call by reference) : 주소가 동일하다.

int main(void) {
	int a = 10;
	int b = 20;
	printf("a의 주소 : %p\n", &a);
	printf("b의 주소 : %p\n", &b);

	printf("swap_addr() 함수 호출 전 => a : %d, b : %d\n", a, b);
	swap_addr(&a, &b);
	printf("swap_addr() 함수 호출 후 => a : %d, b : %d\n", a, b);

	return 0;
}

void swap_addr(int * a, int * b){
	printf("swap_addr() 함수 안에서 a의 주소 : %p\n", a);
	printf("swap_addr() 함수 안에서 b의 주소 : %p\n", b);
	int temp = *a;
	*a = *b;
	*b = temp;
	printf("swap_addr() 함수 안 => a : %d, b : %d\n", *a, *b);
}

 

 

포인터로 배열의 값 바꾸기

배열명 = 배열의 시작주소 = &arr2[0]

void changeArray(int* ptr);

int main(void) {
	int arr2[3] = { 10, 20, 30 };
	changeArray(arr2);
    changeArray(&arr2[0]); // 배열의 시작 주소 (첫 번째 요소의 주소) 전달
	for (int i = 0; i < 3; ++i) {
		printf("%d\n", arr2[i]);
	}

	return 0;
}

void changeArray(int* ptr) {
	ptr[2] = 50;
}

 

배열은 연속된 공간에 할당하므로 주소가 연속된다. 따라서 배열의 시작 주소인 첫 번째 요소의 주소를 전달하면 싲가 주소를 기준으로 지정한 요소의 위치를 찾아 값을 바꿀 수 있다.

 

물고기 키우기 게임

clock() : 프로그램 수행 시작 시점부터 현재까지 흐른 시간을 밀리초 단위로 반환하는 함수

 

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int level;
int arrayFish[6];
int* cursor; // 어항 배열에 접근할 포인터 변수 선언

void initData();
void printfFishes();
void decreaseWater(long elapsedTime);
int checkFishAlive();

int main(void) {
	long startTime = 0; // 게임 시작 시간을 담을 변수 선언 및 초기화
	int num;
	long totalElapsedTime = 0; // 총 경과시간
	long prevElapsedTime = 0; // 직전에 물을 준 시간 (물을 준 간격)

	initData();
	startTime = clock();
	cursor = arrayFish; // 포인터 변수에 어항 배열의 시작 주소 넣기

	while (1) {
		printfFishes();
		printf("몇 번 어항에 물을 줄까요? (1-6) ");
		scanf_s("%d", &num);

		if (num < 1 || num > 6) {
			printf("\n입력값이 잘못됐습니다.\n");
			continue;
		}

		totalElapsedTime = (clock() - startTime) / CLOCKS_PER_SEC; // 총 경과 시간 (초 단위로 표시)
		printf("총 경과 시간 : %ld초\n", totalElapsedTime);
		prevElapsedTime = totalElapsedTime - prevElapsedTime; // 직전에 물 준 시간 이후로 흐른 시간
		printf("최근 경과 시간 : %ld초\n", prevElapsedTime);

		decreaseWater(prevElapsedTime);
		if (cursor[num - 1] <= 0) {
			printf("%d번 어항의 물고기는 이미 죽었으므로 물을 주지 않습니다\n", num);
		}
		else if (cursor[num - 1] + 1 <= 100) {
			printf("%d번 어항에 물을 줍니다\n\n", num);
			// 물을 주면 물 높이 + 1(cursor[num-1] = cursor[num -1] + 1)
			cursor[num - 1] += 1;
		}

		if (totalElapsedTime / 20 > level - 1) { // 레벨업 확인(20초마다 한 번씩 수행. 몫을 확인)
			level++;
			printf("***축하합니다. %d레벨에서 %d레벨로 올랐습니다. *** \n\n", level - 1, level);

			if (level == 5) {
				printf("\n\n축하합니다. 최고 레벨을 달성했습니다. 게임을 종료합니다. \n\n");
				exit(0);
			}
		}

		if (checkFishAlive() == 0) {
			printf("모든 물고기가 죽었습니다. ㅠㅠ \n\n");
			exit(0);
		}
		else {
			printf("물고기가 아직 살아있어요!\n\n");
		}

		prevElapsedTime = totalElapsedTime;
	}
	return 0;
}

void initData() {
	level = 1; // 레벨 초기화 (레벨 범위 1~5)
	for (int i = 0; i < 6; ++i) {
		arrayFish[i] = 100; // 어항 물 높이 초기화 (물 높이 범위 0~100)
	}
}

void printfFishes() { // 어항 물 높이 출력 함수 정의
	printf("%3d번 %3d번 %3d번 %3d번 %3d번 %3d번\n", 1, 2, 3, 4, 5, 6);
	for (int i = 0; i < 6; ++i) {
		printf("  %3d ", arrayFish[i]); // 서식 지정자로 출력 결과 정렬
	}
	printf("\n\n");
}

void decreaseWater(long elapsedTime) { // 어항의 물을 증발(감소)시키는 함수 정의
	for (int i = 0; i < 6; ++i) {
		arrayFish[i] -= (level * 3 * (int)elapsedTime);

		if (arrayFish[i] < 0) {
			arrayFish[i] = 0;
		}
	}
}

int checkFishAlive() { // 모든 물고기가 죽었는지 확인하는 함수
	for (int i = 0; i < 6; ++i) {
		if (arrayFish[i] > 0) {
			return 1; // 참(true)
		}
	}

	return 0;
}

 

서식 지정자의 형식 태그

printfFishes() 함수에서 서식 지정자에 넣는 숫자 3은 서식 지정자에 옵션을 추가할 수 있는 형식 태그의 하나.

이 숫자는 출력할 값의 폭 또는 너비를 지정한다. 자릿수라고 보면 됨. 3을 넣으면 3자리로 지정한다.

만약 출력할 값이 지정한 너비보다 작으면 자릿수를 맞추기 위해 빈칸으로 채운다.

또한, %03d와 같이 % 뒤에 0을 추가하면 빈칸 대신 0으로 채운다. 결과를 정렬해서 출력하고 싶을 때 사용하면 유용하다.

 

짝수만 제곱하는 예시

#include <stdio.h>

void square(int* a);

int main(void) {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	for (int i = 0; i < 10; ++i) {
		square(&arr[i]);
	}

	for (int i = 0; i < 10; ++i) {
		printf("  %3d ", arr[i]);
	}

	return 0;
}

void square(int* a) {
	if (*a % 2 == 0) {
		*a = *a * *a;
	}
}