포인터는 C에서 가장 중요하고, 또 가장 혼란을 많이 겪는 부분. 이 중요성 때문에 세장에 걸쳐, 11, 12, 17장에서 다룬다.
챕터11은 포인터의 기본을 중점적으로, 12, 17은 advanced uses를 소개
11.1 memory address와 pointer variable간의 관계
11.2 address, indirection operators
11.3 pointer assignment
11.4 how to pass pointers to functions
11.5 returning pointers from functions
11.1 Pointer Variables
pointer가 machine level에서 어떤 것을 나타내는가?
main memory는 bytes로 나누어지고, 각각의 byte는 여덟개의 bit를 저장한다.
각각의 byte는 메모리의 다른 바이트로부터 구분하기 위한 고유의 address를 가진다.
만약 메모리에 n byte가 있다면, 0부터 n-1까지를 각 바이트의 주소라고 가정해 볼 수 있다.
Address |
Contents |
0 |
01010011 |
1 |
01110101 |
2 |
01110011 |
3 |
01100001 |
4 |
01101110 |
|
... |
n-1 |
01000011 |
executable program은 code와 data로 이루어짐. 각각의 프로그램은 하나 이상의 byte를 메모리에서 점유한다.
변수가 점유한 바이트 중 첫번째 바이트가, 그 변수의 주소이다.
위 그림처럼, 변수 i가 주소 2000, 2001의 바이트를 점유하고 있다면, i의 주소는 2000이 된다.
비록 주소가 숫자로 표현되기는 하지만, 그 값의 범위가 integer type이 허용하는 범위와 다를 수 있기 때문에 - 범위를 초과할 수 있기 때문에 - 평범한 integer 변수에 주소를 저장해서는 안된다. 대신, 특별한 pointer variable에 저장한다.
pointer variable p에 변수 i의 주소를 저장할 때, p "points to" i라고 말한다. 다시 말해, 포인터는 그냥 주소이다. 그리고 포인터 변수는 그 주소를 저장하는 변수이다.
Declaring Pointer Variables
평범한 변수를 정의하는 것과 비슷하다. 단지 별표가 변수 이름 앞에 와야 한다.
위 선언은, p가 type int의 object를 가리키는 포인터 변수라는 것을 나타낸다.
p가 변수에 속하지 않는 메모리 영역을 가리킬 수도 있을 때, variable 대신 object용어를 사용할 것임. 자세한 것은 17, 19장에서 설명됨
int i, j, a[10], b[20], *p, *q;
이렇게 다른 변수들과 같이 선언하는 것도 가능하다.
모든 포인터 변수는 오로지 지정된 타입의 object만을 가리켜야 한다(the referenced type).
int *p; /* points only to integers */
double *q; /* points only to doubles */
char *r; /* points only to characters */
referenced type에 대한 제한은 없다. 심지어, 포인터 변수는 다른 포인터를 가리킬 수도 있다.
11.2 The Address and Indirection Operators
포인터 만을 위한 연산자가 두 개 있다.
1. 변수의 주소를 찾을 때, & (address) operator를 사용한다. 만약 x가 변수라면, &x는 그 변수가 있는 메모리의 주소이다.
2. 포인터가 가리키는 object에 접근하기 위해서는 * (indirection) operator를 사용한다. p가 포인터라면, *p는 p가 가리키는 object를 나타낸다.
The Address Operator
포인터를 선언하면 포인터를 위한 공간을 set(?) 하지만, 그 포인터는 어떤 object도 가리키지 않는다.
int *p; /* points nowhere in particular */
p를 사용하기 전에 초기화하는 것이 중요하다. 포인터를 초기화하는 방법 하나는, 어떤 변수의 주소(더 일반적으로 말하자면 lvalue)를 할당하는 것이다. 이 때 &연산자를 사용한다.
int i, *p;
...
p = &i; /* i의 주소를 변수 p에 할당함으로써, 이 statement는 p가 i를 가리키도록 만든다. */
포인터를 선언하면서 초기화하는 것도 가능하다.
int i;
int *p = &i;
//심지어 i가 먼저 선언되었다는 전제 하에, i의 선언과 p의 선언/초기화를 동시에 할 수도 있다.
int i, *p = &i;
The Indirection Operator
포인터 변수가 object를 가리키게 되면, * (indirection) operator를 사용해 그 object에 저장된 것에 접근할 수 있다.
예를 들어 p가 i를 가리키고 있다면, 다음과 같이 i의 값을 print 할 수 있다.
이러면 printf 함수는 i의 주소가 아닌 i의 값을 표시해 준다.
변수에 &연산자를 적용하면, 그 변수의 포인터가 된다.
포인터에 *연산자를 적용하면, 다시 원래 변수가 된다.
j = *&i; /* same as j = i; */
p가 i를 가리킨다면, *p는 i의 다른 표현방법이다. *p는 i와 같은 값을 가지고 있을 뿐 아니라, *p의 값을 바꾸는 것 또한 i의 값을 바꾸게 된다.
(*p는 lvalue이기 때문에, 그것에 assign하는 것은 legal이다.)
주의:
초기화되지 않은 포인터 변수에 * 연산자를 적용해서는 안 된다. -> undefined behavior.
다음과 같은 코드는 쓰레기값을 띄우거나, 프로그램이 깨지거나, 또는 다른 이상한 결과를 발생시킬 수 있다.
int *p;
printf("%d", *p); /*** WRONG ***/
*p에 값을 할당하는 것은 특히 위험하다. 만약 p가 우연히 유효한 메모리 값을 가지고 있었다면, *p에 값을 할당하는 것은 그 주소의 원래 데이터 값을 바꾸게 된다.
int *p;
*p = 1; /*** WRONG ***/
11.3 Pointer Assignment
포인터를 복사하기 위해 assignment operator를 쓰는 것이 허용된다. 단 그 변수들이 같은 type 이어야만 한다.
int i, j, *p, *q;
p = &i;
q = p;
이제 *p를 바꾸든, *q를 바꾸든 i의 값이 따라서 바뀌게 된다.
위에서 q=p; 와 *q = *p; 는 전혀 다르다.
p = &i;
q = &j;
i = 1;
*q = *p;
이 코드는 p가 가리키는 변수의 값(즉 i의 값)을 복사해서 q가 가리키는 변수(j)에 할당하게 된다.
11.4 Pointers as Arguments
9.3에서 변수가 argument로 함수로 전달될 때, 그 변수의 값은 변하지 않음을 다뤘었다(because C passes arguments by value).
이 특성은 함수로 변수의 값을 바꾸고 싶을 때 골칫거리가 된다.
그러나 포인터를 활용하면 이 문제를 해결할 수 있다. 변수 자체가 아닌 변수의 포인터를 전달하면 된다.
함수를 통해 변수 x의 값을 바꾸고 싶을 때, 함수의 argument로 x가 아닌 &x, 즉 x의 포인터를 전달한다. 그리고 대응하는 파라미터 p(포인터)를 정의한다.
함수가 호출되었을 때, p는 &x의 값을 가지고 *p(p가 가리키는 object)는 x의 alias가 된다. function의 body에 나오는 *p는 x의 indirect reference가 되며, 함수가 x의 값을 읽기도 하고 수정할 수도 있게 한다.
// 배열에서 가장 작은 원소와 큰 원소 찾기
void max_min(int a[], int n, int *max, int *min);
int main(void) {
int b[N], i, big, small;
printf("Enter %d numbers: ", N);
for (i = 0; i < N; i++)
scanf("%d", &b[i]);
max_min(b, N, &big, &small);
printf("Largest: %d\n", big);
printf("Smallest: %d\n", small);
return 0;
}
void max_min(int a[], int n, int *max, int *min) {
int i;
*max = *min = a[0];
for (i = 1; i < n; i++) {
if (a[i] > *max)
*max = a[i];
else if (a[i] < *min)
*min = a[i];
}
}
Using const to Protect Arguments
x의 값을 함수에 전달하고는 싶지만, x의 값이 변하지 않게 하려면?
(굳이 변수의 값을 바꾸고 싶지도 않은데 포인터를 이용하는 이유는 효율성 때문이다. 변수가 많은 양의 저장공간을 필요로 한다면, 변수의 '값'을 전달하는 것은 시간과 공간을 낭비할 수 있다.)
변수의 주소는 함수에 전달되지만, 값을 바꾸지 않게 하고 싶다면 변수 선언시 파라미터 앞에 const를 써 준다.
void f(const int *p) {
*p = 0; // WRONG: expression must be a modifiable lvalue라고 뜬다.
}
11.5 Pointers as Return Values
포인터를 함수로 pass할 뿐 아니라, 함수가 포인터를 return할 수 있다. 이러한 함수들을 챕터13에서 다룰 것.
int *max(int *a, int *b) {
if (*a > *b)
return a;
else
return b;
}
int main(void) {
int *p, i, j;
p = max(&i, &j);
}
위 함수는 두 정수의 포인터를 받아서, 더 큰 쪽의 변수를 리턴한다.
max 함수를 호출하면, 두 정수 변수의 포인터가 전달되고 결과의 포인터가 리턴된다.
함수는 external variable의 포인터, 또는 static으로 선언된 local variable의 포인터를 리턴할 수도 있다.
4번
#include <stdio.h>
void swap(int *p, int *q) {
int temp = *q;
*q = *p;
*p = temp;
}
int main(void) {
int i = 3, j = 5;
swap(&i, &j);
printf("%d %d\n", i, j);
}
5번
#include <stdio.h>
#define MINUTES 60
#define SECONDS 60
#pragma warning(disable:4996)
void split_time(long total_sec, int *hr, int *min, int *sec) {
*sec = total_sec % SECONDS;
*min = total_sec / SECONDS;
*hr = *min / MINUTES;
*min = *min % MINUTES;
}
int main(void) {
int hr, min, sec;
long total_sec;
printf("enter total seconds: ");
scanf("%ld", &total_sec);
split_time(total_sec, &hr, &min, &sec);
printf("HH: %d, MM: %d, SS: %d\n", hr, min, sec);
return 0;
}
6번 배열에서 가장 큰 수, 두번째로 큰 수 구하기
#include <stdio.h>
void find_two_largest(int a[], int n, int *largest, int *second_largest) {
int first, second, i;
if (a[0] > a[1])
first = a[0], second = a[1];
else
first = a[1], second = a[0];
for (i = 2; i < n; i++) {
if (a[i] > first) {
second = first;
first = a[i]; }
else if (a[i] > second)
second = a[i];
}
*largest = first;
*second_largest = second;
}
int main(void) {
int largest, second_largest;
int a[] = { 10,9,8,7,6,5,4,3,2,1,13,15 };
find_two_largest(a, 12, &largest, &second_largest);
printf("%d %d\n", largest, second_largest);
}
7번
#include <stdio.h>
#include <stdbool.h>
#pragma warning(disable:4996)
void split_date(int day_of_year, int year, int *month, int *day) {
bool leap;
int m = 0;
int day_of_month[12] = { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
/* 윤년 확인 */
if (year % 4 == 0) {
if (year % 100 == 0) {
if (year % 400 == 0) leap = true;
else leap = false;
}
else leap = true;
}
else leap = false;
if (leap) day_of_month[1] = 29;
else day_of_month[1] = 28;
while (1) {
if (day_of_year - day_of_month[m] < 1)
break;
day_of_year -= day_of_month[m];
m++;
}
*month = m + 1;
*day = day_of_year;
}
int main(void) {
int day_of_year, year, month, day;
printf("Enter day_of_year:");
scanf("%d", &day_of_year);
printf("Enter year: ");
scanf("%d", &year);
split_date(day_of_year, year, &month, &day);
printf("%d월 %d일\n", month, day);
}
8번
#include <stdio.h>
int *find_largest(int a[], int n) {
int i, j = 0, largest = a[0];
for (i = 1; i < n; i++) {
if (a[i] > largest)
{
largest = a[i];
j = i;
}
}
return &a[j];
}
int main(void) {
int a[6] = { 3,4,5,1,2,7 };
printf("%d\n", *find_largest(a, 6));
}
1번
#include <stdio.h>
#pragma warning(disable:4996)
void pay_amount(int dollars, int *twenties, int *tens,
int *fives, int *ones) {
*twenties = dollars / 20;
dollars %= 20;
*tens = dollars / 10;
dollars %= 10;
*fives = dollars / 5;
*ones = dollars % 5;
}
int main(void) {
int twenties, tens, fives, ones, dollars;
printf("Enter Dollars: ");
scanf("%d", &dollars);
pay_amount(dollars, &twenties, &tens, &fives, &ones);
printf("Twenties: %d, Tens: %d, Fives: %d, Ones: %d\n", twenties, tens, fives, ones);
return 0;
}
2번->pass
3번
#include <stdio.h>
#pragma warning(disable:4996)
void reduce(int numerator, int denominator,
int *reduced_numerator, int *reduced_denominator);
int gcd(int i, int j);
int main(void) {
int i, j;
scanf("%d/%d", &i, &j);
int reduced_numerator, reduced_denomiator;
reduce(i, j, &reduced_numerator, &reduced_denomiator);
printf("%d/%d\n", reduced_numerator, reduced_denomiator);
}
void reduce(int numerator, int denominator,
int *reduced_numerator, int *reduced_denominator) {
int d = gcd(numerator, denominator);
*reduced_numerator = numerator / d;
*reduced_denominator = denominator / d;
}
int gcd(int m, int n) {
int temp;
if (m < n) {
temp = m;
m = n;
n = temp;
}
while (n > 0) {
temp = m%n;
m = n;
n = temp;
}
return m;
}
4번 poker.c 를 포인터를 사용해 external variable을 모두 main함수에 집어넣기
/* #include directives go here */
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
/* #define directives go here */
#define NUM_RANKS 13
#define NUM_SUITS 4
#define NUM_CARDS 5
/* prototypes */
void read_cards(int num_in_rank[], int num_in_suit[]);
void analyze_hand(int num_in_rank[], int num_in_suit[], bool *straight, bool *flush, bool *four, bool *three, int *pairs);
void print_result(bool straight, bool flush, bool four, bool three, int pairs);
/******************************************************************
main: calls read_cards, analyze_hand, and print_result
repeatedly.
******************************************************************/
int main(void) {
int num_in_rank[NUM_RANKS];
int num_in_suit[NUM_SUITS];
bool straight, flush, four, three;
int pairs; /* can be 0, 1, or 2 */
for (;;) {
read_cards(num_in_rank, num_in_suit);
analyze_hand(num_in_rank, num_in_suit, &straight, &flush, &four, &three, &pairs);
print_result(straight, flush, four, three, pairs);
}
}
/******************************************************************
read_cards: reads the cards into external variables;
checks for bad cards and duplicate cards.
******************************************************************/
void read_cards(int num_in_rank[], int num_in_suit[]) {
bool card_exists[NUM_RANKS][NUM_SUITS];
char ch, rank_ch, suit_ch;
int rank, suit;
bool bad_card;
int cards_read = 0;
for (rank = 0; rank < NUM_RANKS; rank++) {
num_in_rank[rank] = 0;
for (suit = 0; suit < NUM_SUITS; suit++)
card_exists[rank][suit] = false;
}
for (suit = 0; suit < NUM_SUITS; suit++)
num_in_suit[suit] = 0;
while (cards_read < NUM_CARDS) {
bad_card = false;
printf("enter a card: ");
rank_ch = getchar();
switch (rank_ch) {
case '0': exit(EXIT_SUCCESS);
case '2': rank = 0; break;
case '3': rank = 1; break;
case '4': rank = 2; break;
case '5': rank = 3; break;
case '6': rank = 4; break;
case '7': rank = 5; break;
case '8': rank = 6; break;
case '9': rank = 7; break;
case 't': case 'T': rank = 8; break;
case 'j': case 'J': rank = 9; break;
case 'q': case 'Q': rank = 10; break;
case 'k': case 'K': rank = 11; break;
case 'a': case 'A': rank = 12; break;
default: bad_card = true;
}
suit_ch = getchar();
switch (suit_ch) {
case 'c': case 'C': suit = 0; break;
case 'd': case 'D': suit = 1; break;
case 'h': case 'H': suit = 2; break;
case 's': case 'S': suit = 3; break;
default: bad_card = true;
}
while ((ch = getchar()) != '\n')
if (ch != ' ') bad_card = true;
if (bad_card)
printf("bad card; ignored.\n");
else if (card_exists[rank][suit])
printf("duplicate card; ignored.\n");
else {
num_in_rank[rank]++;
num_in_suit[suit]++;
card_exists[rank][suit] = true;
cards_read++;
}
}
}
/******************************************************************
analyze_hand: determines whether the hand contains a
straight, a flush, four-of-a-kind,
and/or three-of-a-kind; determines the number of pairs;
stores the results into external variables.
******************************************************************/
void analyze_hand(int num_in_rank[], int num_in_suit[], bool *straight, bool *flush, bool *four, bool *three, int *pairs) {
int num_consec = 0;
int rank, suit;
*straight = false;
*flush = false;
*four = false;
*three = false;
*pairs = 0;
/* check for flush */
for (suit = 0; suit < NUM_SUITS; suit++)
if (num_in_suit[suit] == NUM_CARDS)
*flush = true;
/* check for straight */
rank = 0;
while (num_in_rank[rank] == 0) rank++;
for (; rank < NUM_RANKS && num_in_rank[rank] > 0; rank++)
num_consec++;
if (num_consec == NUM_CARDS) {
*straight = true;
return;
}
/* check for 4-of-a-kind, 3-of-a-kind, and pairs */
for (rank = 0; rank < NUM_RANKS; rank++) {
if (num_in_rank[rank] == 4) *four = true;
if (num_in_rank[rank] == 3) *three = true;
if (num_in_rank[rank] == 2) *pairs++;
}
}
/******************************************************************
print_result: notifies the user of the result, using
the external variables set by analyze_hand.
******************************************************************/
void print_result(bool straight, bool flush, bool four, bool three, int pairs) {
if (straight && flush) printf("straight flush");
else if (four) printf("four of a kind");
else if (three &&
pairs == 1) printf("full house");
else if (flush) printf("flush");
else if (straight) printf("straight");
else if (three) printf("three of a kind");
else if (pairs == 2) printf("two pairs");
else if (pairs == 1) printf("pair");
else printf("high card");
printf("\n\n");
}