C Programming, A Modern Approach - K.N.KING으로 C언어를 공부하면서 정리한 내용입니다.

---

17.1 Dynamic Storage Allocation
17.2 Dynamic Allocated Strings
17.3 Dynamic Allocated Arrays
17.4 Deallocating Storage
17.5 Linked Lists
17.6 Pointers to Pointers
17.7 Pointers to Functions

---

📍 Dynamic Storage Allocation (동적 메모리 할당)

고정된 사이즈 자료구조를 이용할 경우 프로그램을 수정하고, 다시 컴파일하지 않고는 size를 변경할수가 없다.

따라서 C는 동적 메모리 할당(Dynamic Storage Allocation) 기능을 제공한다. 이는 실행 시간동안 사용할 메모리 공간을 할당받는 것을 말한다.

📌 Memory Allocation Functions (메모리 할당 함수들)

🔎 메모리 할당 함수들

• malloc : 메모리를 할당받고, 초기화는 하지 않는다.
• calloc : 메모리를 할당받고, 0으로 초기화한다.
• realloc : malloc이나 calloc으로 할당받는 메모리의 크기를 변경할 때 사용한다.

보통 malloc이 가장 많이 쓰인다.

어떤 타입이 할당될지 모르기 때문에 함수는 void* 형식을 반환한다. void*은 어떤 타입으로도 변신이 가능하다.

📌 Null Pointers (널 포인터)

동적 할당 함수를 호출할 때, 그만큼 충분한 공간이 남아있지 않을 가능성이 있다. 그럼 함수는 null pointer를 반환한다.
null pointer는 아무것도 가리키지 않는 포인터이다. 따라서 함수의 반환값을 포인터 변수에 저장한 후에 반드시 null pointer인지 검사를 해주어야 한다.

null pointer는 매크로에 의해 NULL로 선언되어있다. 보통 #include <stdlib.h>를 이용한다.
따라서 malloc의 반환 값을 아래와 같이 테스트할 수 있다.

p = malloc(10000);
if (p == NULL) { 
	/* allocation failed */
}

p == NULL이라고 쓰는 대신
if (!p) ... 도 가능하다.

---

📍 Dynamic Allocated Strings

(동적 할당된 문자열)

📌 Using malloc to Allocate Memoery for a String (malloc으로 문자열 함수에 메모리 할당하기)

🔎 malloc 함수

void *malloc(size_t size); 

malloc은 size만큼의 메모리를 할당하고 포인터를 반환한다.

char의 size는 1이기 때문에 malloc을 이용하여 문자열 함수에 메모리를 할당하는 것은 쉽다.

🔎 문자열 함수에 n개의 문자를 저장할 공간 할당하기

p = malloc(n+1);

그럼 할당을 할 때 p는 char* 이 된다.

📌 Using Dynamic Storage Allocation in String Functions (문자열 함수에서 동적 메모리 할당하기)

두 문자열이 주어졌을 때, 둘다 바꾸지 않고 문자열을 합쳐보자.
그러려면 먼저 두 문자열의 길이를 측정한 다음 malloc을 이용하면 된다.
그 다음 첫번째 문자열을 새 공간에 복사한다음 strcat을 호출하여 두번째 문자열을 연결한다.

🔎 malloc을 이용하여 문자열 합치기

char* concat(const char* s1, const char* s2)
{
	char* result;

	result = malloc(strlen(s1) + strlen(s2) + 1);
	if (result == NULL) {
		printf("Error : malloc failed in concat\n");
		exit(EXIT_FAILURE);
	}
	strcpy(result, s1);
	strcat(result, s2);
	return result; 
}

📌 Arrays of Dynamically Allocated Strings (동적 할당 문자열의 배열)

앞서 문자열을 2차원 배열에 저장하면 공간이 낭비된다는 문제로 인해, 문자열을 포인터로 가리키는 배열을 이용하였다. 이는 동적 할당된 문자열에도 이용될 수 있다.

📌 [Program] Printing a One-Month Reminder List (Revisited) (한 달 리마인더 목록 프린트하기)

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

#define MAX_REMIND (50)
#define MSG_LEN (60)

int read_line(char str[], int n);

int main()
{
	char* reminders[MAX_REMIND];
	char day_str[3], msg_str[MSG_LEN + 1];
	int day, i, j, num_remind = 0;

	for (;;) {
		if (num_remind == MAX_REMIND) {
			printf("-- No space left --\n");
			break; 
		}

		printf("Enter day and reminder : ");
		scanf("%2d", &day);
		if (day == 0)
			break;
		sprintf(day_str, "%2d", day);
		read_line(msg_str, MSG_LEN);

		for (i = 0; i < num_remind; i++)
			if (strcmp(day_str, reminders[i] < 0))
				break;
		for (j = num_remind; j > i; j--)
			reminders[j] = reminders[j - 1];

		reminders[i] = malloc(2 + strlen(msg_str) + 1);
		if (reminders[i] == NULL) {
			printf("-- No space left --\n");
			break; 
		}

		strcpy(reminders[i], day_str);
		strcat(reminders[i], msg_str);

		num_remind++;
	}

	printf("\nDay Reminder\n");
	for (i = 0; i < num_remind; i++)
		printf(" %s\n", reminders[i]);

	return 0; 
}

int read_line(char str[], int n)
{
	int ch, i = 0;

	while ((ch = getchar()) != '\n')
		if (i < n)
			str[i++] = ch;
	str[i] = '\0';
	return i; 
}

---

📍 Dynamic Allocated Arrays (동적 할당된 배열)

C에서는 프로그램이 실행 중에 배열에 공간을 할당할 수 있다.

📌 Using malloc to Allocate Storage for an Array (malloc으로 배열 메모리 할당하기)

문자열에서와 가장 큰 차이점은 요소의 크기가 반드시 1byte가 아니라는 점이다. 따라서 sizeof 연산자를 이용하여 크기를 계산해주어야 한다.

n개의 정수를 담는 array를 만들어보자.

먼저 포인터 변수를 선언해준다.

int *a;

n이 이미 선언되어 있을 때, 아래와 같이 malloc을 이용하여 공간을 할당할 수 있다.

a = malloc(n * sizeof(int));

이렇게 하고 나면 a를 배열의 이름으로 사용할 수 있다.

📌 The calloc Function (calloc 함수)

calloc은 <stdlib.h>에 선언되어 있다.

🔎 calloc 함수

void *calloc(size_t nmemb, size_t size);

calloc은 size 크기의 변수를 nmemb개 만큼 저장할 수 있도록 한다.

메모리를 할당한 다음 calloc은 0으로 초기화한다.

🔎 calloc 함수 사용 예시

a = calloc(n, sizeof(int)); 

struct point { int x, y; } *p;
p = calloc(1, sizeof(struct point)); 

📌 The realloc Function (realloc 함수)

realloc은 할당된 메모리(ex.array)의 크기를 조절한다.

🔎 realloc 함수

void *realloc(void *ptr, size_t size);

ptr은 반드시 malloc, calloc, realloc에 의해 얻어진 메모리 블록을 가리켜야한다. size는 블록의 새로운 사이즈를 말한다. 보통은 재할당된 메모리를 ptr이 다시 가리킨다.

메모리 블록의 크기를 줄이라는 요청을 받았을 때 realloc은 블록에 저장된 데이터를 이동시키지 않고 축소해야 한다. 확장할 때도 마찬가지이다. 만약 블록 뒤에 오는 바이트가 사용되고 있어 확장할 수 없을 때, realloc은 새 블록을 다른 곳에 할당한 다음 이전 블록의 내용을 새 블록에 복사한다.

---

📍 Deallocating Storage (메모리 해제)

malloc과 다른 메모리 할당 함수는 힙(heap)이라고 하는 저장소 풀(storage pool)에서 메모리 블록을 가져온다. 이러한 함수를 너무 자주 호출하거나 큰 메모리 블록을 요청하면 힙이 소진되어 함수가 널 포인터를 반환할 수 있습니다.
심지어 할당된 메모리를 추적하지 못해 공간을 낭비할 수 있다.

p = malloc(...);
q = malloc(...);
p = q; 

위 예제의 경우 아래처럼 되므로 첫번째 block은 영원히 쓰이지 않는다.

이렇게 더 이상 쓰이지 않는 메모리를 garbage라고 부른다. 이런 garbage가 발생하는 프로그램에서는 메모리 누수(memory leak)이 발생한다. 몇몇 언어에서는 garbage collector을 제공하여 자동으로 처리해주나 C는 그렇지 않다. 대신 free 함수를 이용하여 불필요한 메모리를 해제해 주어야 한다.

📌 The free function (free 함수)

free 함수는 <stdlib.h>에 들어 있다.

🔎 free 함수

void free(void *ptr);

🔎 free 함수 사용 예시

p = malloc(...);
q = malloc(...);
free(p);
p = q;

이렇게 하여 p가 가리키는 메모리 블락을 해제할 수 있다. 이 때 free의 인수는 메모리 할당 함수에 의해 반환된 포인터이어야 한다.

📌 The "Dangling Pinter" Problem ("매달린 포인터" 문제)

free(p)는 p가 가리키는 것은 해제하지만 p 자체를 바꾸지는 않는다.
따라서 아래와 같이 사용하게 되면 혼돈을 야기한다.

char *p = malloc(4);
...
free(p);
...
strcpy(p, "abc"); /*** WRONG ***/

여러 포인터들이 같은 메모리 블록을 가리킬 수 있기 때문에 매달린 포인터들은 찾기 어려울 수 있다. 블록이 해제되면 모든 포인터가 매달린 상태로 유지된다.

---

📍 Linked Lists (연결 리스트)

연결 리스트(linked list)는 각 노드가 데이터와 포인터를 가지고 한 줄로 연결되어 있는 것을 말한다.

마지막 노드는 null pointer를 가지고 있다.

연결 리스트는 배열의 대안이 될 수 있다. 연결 리스트를 이용하면 쉽게 요소를 추가하고 삭제할 수 있다. 그러나 "random access"는 불가능하다. 어레이의 경우 모든 요소에 접근하는데 동일한 시간이 소요되지만 연결 리스트의 경우 가까울수록 빠르다.

📌 Declaring a Node Type (노드형 선언하기)

노드가 정수와 다음 노드를 가리키는 포인터만을 가지고 있다고 가정하자.

struct node {
	int value; /* data stored in the node */
	struct node* next; /* pointer to the next node */
};

list가 어디에서부터 시작하는지를 추적하기 위해 첫번째 노드를 가리키는 변수가 필요하다. 이를 first라고 하였다.

struct node *first = NULL:

처음엔 비어 있으므로 first에 NULL값을 부여하였다.

📌 Creating a Node (노드 생성하기)

노드를 아래 3단계로 생성한다.

1) 노드를 위한 메모리를 할당한다.
2) 노드에 데이터를 저장한다.
3) 리스트에 노드를 넣는다.

노드를 생성할 때 노드를 목록에 삽입할 때까지 노드를 일시적으로 가리킬 수 있는 변수가 필요하다. 이를 new_node라고 하자.

struct node *new_node;

malloc을 사용하여 새 노드에 메모리를 할당하고 반환 값을 new_node에 저장한다.

new_node = malloc(sizeof(struct node)); 

다음으로, 데이터를 새 노드의 value에 저장한다.

(*new_node).value = 10;

📌 The -> Operator (-> 연산자)

-> 연산자 : 포인터를 사용하여 구조체의 멤버에 접근

🔎 -> 연산자 사용 예시

new_node->value = 10; 

-> 연산자는 *과 .의 결합이라고 보면 된다. new_node가 가리키는 값을 찾은다음 그 구조체의 멤버를 선택한다.

-> 연산자는 lvalue를 생성한다.

🔎 -> 연산자 사용 예시 (2) - scnaf에서

scanf("%d", &new_node->value); 

📌 Inserting a Node at the Beginning of a Linked List (연결 리스트 시작점에 노드 추가하기)

new_node : node가 삽입되는 지점을 가리킨다.
first : 연결리스트의 첫번째 노드를 가리킨다.

이 두가지를 이용하여 연결 리스트의 첫번째에 노드를 추가할 수 있다.

먼저 new_node의 next 멤버가 첫번째 노드에 저장된 것을 가리키게 한다.

new_node->next = first;

두번째로, first가 new_node를 가리키게 한다.

first = new_node 

🔎 비어있는 연결 리스트에 10 추가 후 20 추가

이러한 과정을 add_to_list라는 이름의 함수로 만들어보자. 파라미터는 list(추가 전 리스트의 첫번째 노드를 가리키는 포인터), n(첫번째 노드에 저장할 정수) 두가지 이다.

struct node* add_to_list(struct node* list, int n)
{
	struct node* new_node;

	new_node = malloc(sizeof(struct node));
	if (new_node == NULL) {
		printf("Error : malloc failed in add_to_list\n");
		exit(EXIT_FAILURE);
	}
	new_node->value = n;
	new_node->next = list;
	return new_node; 
}

first가 가리키는 지점은 변하지 않았으므로 add_to_list를 다시 호출하기 전에 반환값을 first에 저장해주어야 한다.

first = add_to_list(first, 10);
first = add_to_list(first, 20);

🔎 add_to_list 사용 예시 - 사용자가 입력한 정수 넣기

struct node read_numbers(void)
{
struct node first = NULL;
int n;

printf("Enter a series of integers (0 to terminate) : ");
for (;;) {
	scanf("%d", &n);
	if (n == 0)
		return first;
	first = add_to_list(first, n);
}

}

📌 Searching a Linked List (연결 리스트에서 탐색하기)

🔎 포인터 p를 이용하여 노드 추적

for (p = first; p != NULL; p = p->next) {
	...
}

🔎 search_list (1)

struct node* search_list(struct node* list, int n)
{
	struct node* p;

	for (p = list; p != NULL; p = p->next)
		if (p->value == n)
			return p;
	return NULL
}

🔎 search_list (2)

두번째 방법은 p를 이용하지 않고 list 자체를 이용하는 것이다.

struct node* search_list(struct node* list, int n)
{
	for (; list != NULL; list = list->next)
		if (list->value == n)
			return list;
	return NULL;
}

list는 복사본이기 때문에 바꿔도 상관없다.

🔎 search_list (3)

세번째 방법은 while 문을 이용하는 것이다.

struct node* search_list(struct node* list, int n)
{
	while (list != NULL && list->value != n)
		list = list->next;
	return list;
}

📌 Deleting a Node from a Linked List (연결 리스트에서 노드 삭제하기)

연결리스트의 큰 장점은 노드를 삭제하기가 쉽다는 것이다. 노드를 삭제하는 것은 다음 3단계로 이루어진다.

1) 지울 노드가 있는 곳으로 간다.
2) 삭제된 노드를 "통과"하도록 이전 노드를 변경한다.
3) free를 호출하여 삭제된 노드가 사용하던 공간을 지운다.

1번 단계에서 지울 노드가 있는 곳으로 가면 2번 단계에서 이전 단계에 대한 일을 수행할 수가 없다.
이 문제를 "trailing pointer" 기술을 이용하여 해결할 수 있다.
1단계에서 목록을 검색할 때 현재 노드를 가리키는 포인터(cur) 뿐만 아니라 이전 노드를 가리키는 포인터(prev)도 있게 한다.

for (cur = list, prev = NULL; cur != NULL && cur->value != n; prev = cur, cur = cur->next); 

30 -> 40 -> 20 -> 10 이 연결되어 있는 연결리스트에서 20을 찾는다고 할 때 위 구문을 이용하여 1단계를 수행하면 아래와 같이 된다.

여기서 2단계를 수행하면 다음과 같다.

🔎 삭제할 노드의 이전 노드와 다음 노드를 연결해주기

prev->next = cur-> next;

🔎 20 삭제

free(cur);

이 세가지 과정을 통해 원하는 정수를 삭제하도록 하는 함수를 만들어보면 다음과 같다.

🔎 delete_from_list

struct node* delete_from_list(struct node* list, int n)
{
	struct node* cur, * prev;

	for (cur = list, prev = NULL; cur != NULL && cur->value != n; prev = cur, cur = cur->next);

	if (cur == NULL)
		return list; /* n was not found */
	if (prev == NULL)
		list = list->next; /* n is in the first node */
	else
		prev->next = cur->next; /* n is in some other node */
	free(cur);
	return list; 
}

📌 Ordered Lists (정렬된 리스트)

정렬된 리스트 : 노드들이 순서대로 정렬되어 있는 경우
이 경우 노드를 삽입하는 것은 더 어렵지만 검색은 더 빠르다.

📌 [Program] Maintaining a Prats Database (Revisited) (부품 데이터베이스 유지관리 (재방문))

🔎 inventory2.c

/* Maintains a parts database (linked list version) */

#include <stdio.h>
#include <stdlib.h>
#include "readline.h"

#define NAME_LEN (25)

struct part {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
	struct part* next;
};

struct part* inventory = NULL; /* points to first part */

struct part* find_part(int number);
void insert(void);
void search(void);
void update(void);
void print(void);

int main(void)
{
	char code;

	for (;;) {
		printf("Enter operation code : ");
		scanf(" %c", &code);
		while (getchar() != '\n');
		switch (code) {
		case 'i': insert();
			break;
		case 's': search();
			break;
		case 'u': update();
			break;
		case 'p': print();
			break;
		case 'q': return 0;
		default: printf("Illegal code\n");
		}
		printf("\n");
	}
}

struct part* find_part(int number)
{
	struct part* p;

	for (p = inventory; p != NULL && number > p->number; p = p->next);
	if (p != NULL && number == p->number)
		return p;
	return NULL;
}

void insert(void)
{
	struct part* cur, * prev, * new_node;

	new_node = malloc(sizeof(struct part));
	if (new_node == NULL) {
		printf("Database is full; can't add more parts.\n");
		return;
	}

	printf("Enter part number : ");
	scanf("%d", &new_node->number);

	for (cur = inventory, prev = NULL; cur != NULL && new_node->number > cur->number; prev = cur, cur = cur->next);
	if (cur != NULL && new_node->number == cur->number) {
		printf("Part already exists.\n");
		free(new_node);
		return; 
	}

	printf("Enter part name : ");
	read_line(new_node->name, NAME_LEN);
	printf("Enter quantity on hand : ");
	scanf("%d", &new_node->on_hand);

	new_node->next = cur;
	if (prev == NULL)
		inventory = new_node;
	else
		prev->next = new_node; 
}

void search(void)
{
	int number;
	struct part* p;

	printf("Enter part number : ");
	scanf("%d", &number);
	p = find_part(number);
	if (p != NULL) {
		printf("Part name : %s\n", p->name);
		printf("Quantity on hand : %d\n", p->on_hand);
	} 
	else {
		printf("Part not found.\n");
	}
}

void update(void)
{
	int number, change;
	struct part* p;

	printf("Enter part number : ");
	scanf("%d", &number);
	p = find_part(number);
	if (p != NULL) {
		printf("Enter change in quantity on hand : ");
		scanf("%d", &change);
		p->on_hand += change;
	}
	else
		printf("Part not found.\n");
}

void print(void)
{
	struct part* p;
	printf("Part Number Part Name Quantity on Hand");
	for (p = inventory; p != NULL; p = p->next)
		printf("%7d		%-25s11d\n", p->number, p->name, p->on_hand);
}

---

📍 Pointers to Pointers (포인터의 포인터)

포인터를 매개변수로 받는 함수가 다른 곳을 가리키게 함으로써 변수를 수정하고자 할 때 포인터의 포인터를 이용한다.

앞서 작성한 add_to_list에서는 new_node를 반환한다. 여기서 new_node를 반환하는 대신에 list가 new_node를 가리키도록 바꾼다고 해보자.

list = new_node 

포인터는 pass by value기 때문에 위 구문은 잘 작동하지 않는다.

올바른 코드는 다음과 같다.

🔎 포인터의 포인터를 이용한 add_to_list

void add_to_list(struct node** list, int n)
{
	struct node* new_node;

	new_node = malloc(sizeof(struct node));
	if (new_node == NULL) {
		printf("Error : malloc failed in add_to_list\n");
		exit(EXIT_FAILURE);
	}
	new_node->value = n;
	new_node->next = *list;
	*list = new_node; 
}

이렇게 하면 new_node의 next가 원래 list가 가리키던 곳(첫번째였던 노드)를 가리키게 되고, list가 가리키는 곳은 new_node로 변한다.

---

📍 Pointers to Functions (함수 포인터)

함수들도 메모리 위치를 차지하기 때문에 C에서는 포인터가 함수를 가리키는 것도 가능하다.

📌 Function Pointers as Arguments (입력변수로서의 함수 포인터)

점 a부터 b까지 적분하는 함수를 만든다고 할 때 f를 함수에 대한 포인터로 선언할 것이다.

double integrate(double (*f) (double), double a, double b);

f앞에 포인터를 붙여서 f가 포인터를 반환하는 함수가 아니라 함수에 대한 포인터임을 나타낸다. * 없이 그냥 함수처럼 보이게 쓰는 것도 가능하다.

double integrate(double f(double), double a, double b);

integrate를 호출할 때 첫 번째 인수로 함수 이름을 제공한다. 예를 들어 아래 함수는 sin 함수를 0부터 ㅠ/2까지 적분한다.

result = integrate(sin, 0.0, PI/2);

컴파일러는 함수 호출을 위한 코드를 생성하는 대신 함수에 대한 포인터를 생성한다. 따라서 위 코드에서 sin을 호출하는 것이 아니라 integrate에 sin의 포인터를 전달하는 것이 된다.

이 개념은 a가 배열의 이름인 경우 a[i]는 배열의 한 요소를 나타내고, a 자체는 배열에 대한 포인터 역할을 하는 것과 유사하다.

마찬가지로 f가 함수라면 f(x)는 함수의 호출로 생각하지만, f 그자체는 함수에 대한 포인터로 취급한다.

integrate에서 아래와 같이 f가 가리키는 함수를 호출한다.

y = (*f)(x);

*f가 f가 가리키는 함수를 나타내기 때문에, integrate(sin, 0.0, PI/2) 가 실행되는 동안 *f의 호출은 사실상 sin의 홀출과 같다.

📌 The qsort Function (qsort 함수)

C 라이브러리의 유용한 함수들의 대부분이 함수 포인터를 인수로 받는다. 그 중 하나가 <stdlib.h>의 qsort 함수이다.

qsort는 우리가 선택한 기준에 따라 모든 배열을 정렬할 수 있는 기능이다.

정렬되는 배열의 요소들은 어떤 타입이든 될 수 있기 때문에, 구조체나 공유체 타입의 qsort는 두 배열 요소 중 어떤 것이 "더 작은"지 결정하는 방법을 가르쳐야 한다. 비교 함수(comparison function)을 작성하여 qsort에게 정보를 제공할 것이다.

void qsort(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*));

base : 어레이의 첫 번째 원소를 가리킨다.
nmemb : 정렬되어야 할 원소의 갯수
size : 각 원소의 사이즈 (바이트 단위)
compar : 비교할 함수를 가리키는 포인터

🔎 qsort 사용 예시

qsort(inventory, num_parts, sizeof(structpart), compare_parts);

🔎 compare_parts 함수 작성하기

qsort에서는 매개변수로 void 유형을 받지만, void 포인터를 통해 part 구조체의 멤버에 접근할 수가 없다. 이 멤버들은 struct part* 유형의 포인터가 필요하다.

이러한 문제 해결을 위해 compare_parts의 매개변수 p, q를 struct part*의 변수에 할당하여 원하는 유형으로 변환하였다.

int compare_parts(const void* p, const void* q)
{
	const struct part* p1 = p;
	const struct part* q1 = q;

	if (p1->number < q1->number)
		return -1;
	else if (p1->number == q1->number)
		return 0;
	else
		return 1; 
}

p와 q는 const 포인터기 때문에 const로 선언된 변수에만 할당될 수 있다.

📌 Other Uses of Function Pointers (함수 포인터의 여러 응용)

함수 포인터를 변수에 저장하거나 배열의 요소 또는 구조체나 공용체의 멤버로서 사용할 수 있다. 함수 포인터를 반환하는 함수를 작성할 수도 있다.

🔎 함수에 대한 포인터를 저장할 수 있는 변수

void (*pf)(int);

pf는 int형의 파라미터를 받고, 반환 값이 void 형인 모든 함수를 가리킬 수 있다.

pf가 가리키는 함수를 호출하는 방법은 다음과 같다.

(*pf)(i);

또는

pf(i);

🔎 요소가 함수 포인터인 배열

void (*file_cmd[])(void) = { new_cmd, open_cmd, close_cmd, close_all_cmd };

배열 첨자를 이용하여 함수를 호출할 수 있다.

(*file_cmd[n]))(); /* or file_cmd[n](); */

📌 [Program] Tabulating the Trigonometric Functions (삼각함수 표로 보여주기)

🔎 cos, sin 및 tan 함수의 값을 보여주는 표를 출력

/* Tabulates values of trigonometric functions */

#include <math.h>
#include <stdio.h>

void tabulate(double (*f)(double), double first, double last, double incr);

int main(void)
{
	double final, increment, initial;

	printf("Enter initial value : ");
	scanf("%lf", &initial);

	printf("Enter final value : ");
	scanf("%lf", &final);

	printf("Enter increment : ");
	scanf("%lf", &increment);

	printf("\n      x	       cos(x)"
			  "\n   -------    -------\n");
	tabulate(cos, initial, final, increment);

	printf("\n      x	       sin(x)"
		"\n   -------    -------\n");
	tabulate(sin, initial, final, increment);

	printf("\n      x	       tan(x)"
		"\n   -------    -------\n");
	tabulate(tan, initial, final, increment);

	return 0; 
}

void tabulate(double (*f)(double), double first, double last, double incr)
{
	double x;
	int i, num_intervals;

	num_intervals = ceil((last - first) / incr);
	for (i = 0; i <= num_intervals; i++) {
		x = first + i * incr;
		printf("%10.5f %10.5f\n", x, (*f)(x));
	}
}

📌 [C99] Restricted Pointers (제한 포인터)

🔎 restrict

int* restrict p;

위처럼 restrict로 선언된 포인터를 제한 포인터(restricted pointer)라고 부른다.

이렇게 선언하면 p가 가리키는 개체가 담긴 메모리에는 다른 포인터가 접근할 수 없다.

객체에 접근하는 두 가지 이상의 방법을 aliasing이라고 한다.

int* restrict p;
int* restrict q;

p = malloc(sizeof(int));

q = p;
*q = 0; /* casus undefined behavior */

p가 제한 포인터이기 때문에, *q = 0 이 정의되지 않는다.

제한된 포인터 p가 외부 저장소 클래스 없이 로컬 변수로 선언되면, restrict는 p로 선언된 블록이 실행될 때만 p에 적용된다.

restrict 사용법을 더 알아보기 위해 <string.h>에 있는 memcpy와 memmove를 알아보자.

🔎 memcpy

void *memcpy(void* restrict s1, const void* restrict s2, size_t n); 

memcpy는 한 개체에서 다른 개체로 바이트를 복사한다.

• s2 : 복사할 데이터
• s1 : 복사본의 대상
• n : 복사할 바이트 수
  s1, s2에 restrict를 사용하는 것은 복사할 것과 복사본의 대상이 겹치지 않아야 한다는 것을 나타낸다.

반대로 memmove에서는 restrict를 사용하지 않는다.

🔎 memmove

void *memmove(void *s1, const void *s2, size_t n);

차이점은 소스와 타깃이 겹치더라도 memmove는 작동이 된다는 것이다.

예를 들어, memmove를 이용하여 어레이의 원소들을 한칸씩 옮길 수 있다.

memmove(&a[0], &a[1], 99 * sizeof(int));

restrict는 컴파일러에 정보를 제공하여 보다 효율적인 코드를 생성함으로써 최적화(optimization)을 한다.

그러나 모든 컴파일러가 최적화를 시도하는 것은 아니기 때문에 대부분의 프로그래머가 제한을 사용하지 않는다.

📌 [C99] Flexible Array Members (유동적 배열 멤버)

문자열 저장을 좀 더 유동적이게 할 수 있는 방법을 알아보자

struct vstring {
	int len;
	char chars[N];
};

이런 고정 메모리 배열은 문자열의 길이를 제한하고 메모리를 낭비한다.

C 프로그래머들은 전통적으로 문자 길이를 1로 선언하고 각 문자열을 동적으로 할당함으로써 이 문제를 해결해왔다.

struct vstring {
	int len;
	char chars[1];
};
...
struct vstring* str = malloc(sizeof(struct vstring) + n - 1);
str->len = n;

이런 바법은 "struct hack"이란 이름으로 알려져 있다.

struct hack의 유용성 때문에 C99에서는 유동적 배열 멤버(flexible array member) 기능이 추가되었다.

🔎 flexible array member

struct vstring {
	int len;
	char chars[]; /* flexible array member - C99 only */
};
...
struct vstring* str = malloc(sizeof(struct vstring) + n);
str->len = n;

유동적 배열 멤버를 담고 있는 구조체는 완전하지 않은 유형(incomplete type)이다. 이러한 타입은 다른 구조체의 멤버가 되거나 어레이의 원소가 될 수 없다. 하지만 어레이가 이 구조체를 가리키는 포인터를 포함할 수는 있다.