C Programming, A Modern Approach - K.N.KING으로 C언어를 공부하면서 정리한 내용입니다.
번역본 https://wikidocs.net/book/2494 을 참고하였습니다.

---

16.1 Structure Variables
16.2 Structure Types
16.3 Nested Arrays and Structures
16.4 Unions
16.5 Enumerations

---

📍 Structures, Unions, and Enumerations

구조체 : 서로 다른 형을 가질 수도 있는 값(구성원)의 집합
공용체 : 구조체와 유사하나 각 구성원이 같은 저장 공간을 공유, 그렇기에 공용체는 한 번에 동시에 모든 구성원을 저장할 수 없고, 한 구성원만을 저장
열거형 : 프로그래머가 명명한 값으로 된 정수형

📍 Structure Variables

구조체의 원소(member)는 같은 형일 필요가 없다.
구조체의 구성원들에겐 이름이 존재하여 특정 구성원을 선택하려면 위치가 아닌 이름을 특정해주어야 한다.

📍 Declaring Structure Variables

🔎 부품 번호, 부품 이름, 부품 개수 저장하기

struct {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} part1, part2;

구조체의 구성원(member) : number, name, on_hand
형 : struct
변수 : part1, part2

NAME_LEN의 값이 25라고 하면, 변수 part1은 다음과 같이 메모리에 저장된다.

각 구조체는 새로운 스코프를 갖는다. C 용어로 말하면 각 구조체는 구성원들에 대해 서로 다른 이름 공간 (namespace)를 갖는다고 한다.

예를 들어 아래와 같이 선언할 수 있다.

struct {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} part1, part2;

struct {
	char name[NAME_LEN + 1];
	int number;
	char sex;
} employee1, employee2;

---

📍 Initializing Structure Variables

🔎 구조체 선언 시에 초기화하기

struct {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} part1 = { 528, "Disk drive", 10 }, 
part2 = { 914, "Printer cable", 5 };

초기화할 구조체의 구성원 수보다 적은 수의 초기자가 주어질 경우 나머지 초깃값은 0이 된다. 특히 문자형 배열의 나머지 바이트들은 0이 되어 비어있는 문자열이 된다.

---

📍 [C99] Designated Initializers

🔎 지정 초기자

{.number = 528, .name = "Disk drive", .on_hand = 10}

지정자(designator) : 구두점(.) + 구성원 이름

🔎 지정 초기자의 장점

1) 구조체의 구성원과 초기자 값의 대응을 볼 수 있어 코드가 읽기 쉽다.

2) 초기자의 값들이 구조체의 구성원과 같은 순서일 필요가 없다.
즉, 순서가 중요하지 않다.

지정 초기자에 있는 모든 값이 반드시 지정자를 적어주어야 하는 것은 아니다.

{.number = 528, "Disk drive", .on_hand = 10}

---

📍 Operations on Structures

구조체 내의 구성원에 접근하려면, (구조체의 이름).(구성원의 이름)으로 접근할 수 있다.

🔎 part1의 구성원 값들 출력

printf("Part number: %d\n", part1.number);
printf("Part name: %s\n", part1.name);
printf("Quantity on hand: %d\n", part1.on_hand);

구조체의 구성원은 lvalue이다.

구두점(.)은 연산자로, ++, -- 등과 같은 연산 순서를 가진다.

또한 구조체는 = 연산자를 이용하여 복사가 가능하다.

part2 = part1;

위 구문은 part1.number을 part2.number2에 복사, part1.name은 part2.name에 복사한다.

배열은 = 연산자로 복사가 불가능하지만 구조체 안에 존재하는 배열은 해당 구조체가 복사될 때 같이 복사된다.

🔎 구조체 내 배열 복사

struct { int a[10]; } a1, a2;

a1 = a2; 

= 연산자는 호환 가능한 구조체 간에만 사용할 수 있다. 동시에 선언된 두 구조체나, 같은 구조체 태그를 갖고 선언된 구조체, 같은 형명을 갖는 구조체들이 서로 호환될 수 있다.

할당 이외에는 추가적인 연산이 제공되지 않는다.

---

📍 Structure Types

변수를 한 번만 선언하는 경우는 괜찮지만, 다른 곳에서 또 선언해야 하는 경우에는 복잡해진다.

🔎 여러 번 선언

struct {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} part1;

struct {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} part2;

이렇게 했을 때의 문제점은 part1과 part2가 호환이 되지 않는다는 점이다. part1은 part2에 할당될 수 없고, part2는 part1에 할당될 수 없다. 또한 part1, part2의 형 이름이 무엇인지 알 수 없어 함수 호출에서 인수로 사용할 수 없다.

이런 어려움들을 피하기 위해 구조체의 이름을 정의한다.

🔎 structure의 이름 짓기

1) 구조체 태그(structure tag)를 선언하기
2) typedef를 사용하여 형 이름 정의하기

📍 Declaring a Structure Tag

구조체 태그(structure tag) : structure의 종류를 식별하는데 사용되는 이름

🔎 구조체 태그(part) 선언하기

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

이제 part를 변수 선언에 이용할 수 있다.

struct part part1, part2;

이 때 struct를 빼먹으면 안 된다. part는 형 이름은 아니다.

structure tag를 선언함과 동시에 변수 선언도 가능하다.

struct part {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} part1, part2;

---

📍 Defining a Structure Type

typedef를 이용하여 실제 형 이름(type name)을 정의할 수 있다.

🔎 typedef를 이용하여 형 이름을 Part로 선언하기

typedef struct {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} Part;

Part는 형 이름이므로 structure tag에서와는 다르게 Part만을 이용하여 변수를 선언해줄 수 있다.

Part part1, part2;

🔎 Structure tag vs Typedef

구조체가 linked list로 사용될 때는 Structure tag가 필수적이다. 따라서 이 책의 대부분의 예에서는 typedef 대신 structure tag를 사용하였다.

---

📍 Structures as Arguments and Return Values

함수는 인자(argument)와 반환 값(return value)로 구조체를 가질 수 있다.

🔎 구조체가 인자

void print_part(struct part p)
{
	printf("Part number : %d\n", p.number);
	printf("Part name : %s\n", p.name);
	printf("Quantity on hand : %d\n", p.on_hand);
}


print_part(part1); 

🔎 구조체가 반환값

struct part build_part(int number, const char* name, int on_hand)
{
	struct part p;

	p.number = number;
	strcpy(p.name, name);
	p.on_hand = on_hand;
	return p;
}

이 때 구조체를 함수에 전달하는 것과, 구조체를 반환할 때 모두 구조체 내 모든 구성원의 복사가 일어난다.

따라서 구조체 자체를 전달하기보다 포인터를 전달하는 것이 권장될 때가 있다. 반환 값에서도 포인터를 반환할 수 있다.

또한 열린 파일의 상태에서 작업을 수행하는 경우에도 포인터를 사용하는 것이 효과적이다. 예를 들어 <stdio.h>는 FILE이라는 형식의 type 이름을 가지고 있는데, 각 FILE 구조는 열린 파일의 상태에 대한 정보를 저장하므로 프로그램에서 고유해야 한다. 따라서 이 경우도 포인터를 이용한다.

경우에 따라 함수 내부의 구조체를 다른 구조체로 초기화시킬 수 있다.

🔎 part2를 part1와 동일한 값으로 초기화

void f(struct part part1)
{
	struct part part2 = part1;
	...
}

---

📍 [C99] Compound Literals (복합리터럴)

구조체에서 복합 리터럴은 먼저 변수를 저장하지 않고 "즉시" 구조를 만드는데 사용될 수 있다. 그 결과물(구조체)는 파라미터로 전달될 수 있고, 함수에 의해 반환될 수 있고, 변수에 할당될 수 있다.

일반적으로 복합리터럴은 괄호 안의 형식 이름과, 중괄호로 둘러싸인 값의 집합으로 구성된다.

🔎 복합리터럴을 이용하여 함수에 전달

print_part((struct part) {528, "Disk drive", 10});

복합리터럴은 part라는 구조체를 만든다.

🔎 복합리터럴을 이용하여 변수에 할당

part1 = (struct part) {528, "Disk drive", 10};

복합리터럴은 지정자(designators)를 포함할 수 있다.

🔎 지정자가 포함된 복합 리터럴

print_part((struct part) {
		.on_hand = 10,
		.name = "Disk drive",
		.number = 528
});

---

📍 Nested Arrays and Structures

구조체는 어레이의 구성요소로 들어갈 수 있고 어레이는 구조체의 구성요소가 될 수 있다.

---

📍 Nested Structures

아래와 같은 구조체가 있을 때,

struct person_name {
	char first[FIRST_NAME_LEN + 1];
	char middle_initial;
	char last[LAST_NAME_LEN + 1];
};

구조체 안에 구조체를 넣을 수 있다.

struct student {
	struct person_name name;
	int id, age;
	char sex;
} student1, student2;

이 때 student1의 name 중에서도 first에 접근하고자 한다면 아래와 같이 구두점(.)을 이용하면 된다

strcpy(student1.name.first, "Fred"); 

🔎 name을 구조체로 만든 것의 장점

name을 데이터의 단위로써 다룰 수 있다. name을 출력하는 함수를 만들고자 할 때, 인수로 하나만 전달하면 된다.

🔎 name을 출력하는 함수

display_name(student1.name);

🔎 person_name 구조체에서 name을 student 구조체의 member로 복사하기

struct person_name new_name;
...
student1.name = new_name;

---

📍 Arrays of Structures

어레이와 구조체의 결합에서 자주 쓰이는 것 중 하나는 구조체가 어레이를 이루는 것이다.

아래 예시 구조체 part의 어레이는 part 100개의 정보를 저장할 수 있다

struct part inventory[100];

이 어레이의 요소에 접근하려면 배열첨자[ ]를 이용하면 된다.

print_part(inventory[i]);

구조체 part의 구성원(member)에 접근하려면 배열첨자와 구두점을 이용하여 멤버를 선택하면 된다.

🔎 inventory[i]의 구성원 number에 883 할당하기

inventory[i].number = 883;

name의 문자 하나에 접근하려면 마찬가지로 배열 첨자를 이용하면 된다.

🔎 inventory[i]에 저장된 name을 빈 문자열로 만들기

inventory[i].name[0] = '\0';

---

📍 Initializing an Array of Structures

구조체 어레이를 초기화 하는 것은 다차원 어레이를 초기화하는 것과 거의 동일하다.
구조체 어레이를 초기화하는 이유 중 하나는 이를 실행 중 값이 변하지 않는 데이터베이스 취급하기 위해서 이다.

🔎 구조체를 이용하여 국가번호 저장하기

struct dialing_code {
	char* country;
	int code;
};

🔎 위 구조체를 담고 있는 어레이 초기화 하기

const struct dialing_code country_codes[] = {
	{"Argentina",		54}, {"Bangladesh",		880},
	{"Brazil",		55}, {"Burma (Myanmar)",	 95}
    ...
};

struct part inventory[100] =
{ [0] .number = 528, [0].on_hand = 10, [0].name[0] = '\0' };

---

📍 [PROGRAM] Maintaining a Parts Database

창고에 남아있는 부품들을 표시하는 프로그램을 작성해보자
들어갈 정보는 부품 번호, 이름, 수량이다.

• 새로운 부품 번호, 이름, 남은 수량을 추가할 수 있도록 한다. 만약 이미 해당 부품이 있거나 가득찬 경우 에러 메세지를 출력한다.

• 부품 번호가 주어지면 이름, 남은 수량을 출력할 수 있도록 한다. 만약 해당 부품이 데이터베이스에 없다면 에러 메세지를 출력한다.

• 부품 번호가 주어지면 남은 수량을 변경할 수 있도록 한다. 만약 해당 부품이 데이터베이스에 없다면 에러 메세지를 출력한다.

• 데이터베이스에 담긴 정보 전체를 출력할 수 있도록 한다. 입력한 순서대로 출력되도록 한다.

• 프로그램 실행 종료

이 행동들을 하기 위해 i(insert), s(search), u(update), p(print), q(quit)을 이용한다.

🔎 inventory.c

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

#define NAME_LEN 25
#define MAX_PARTS 100

struct part {
	int number;
	char name[NAME_LEN + 1];
	int on_hand;
} inventory[MAX_PARTS];

int num_parts = 0;

int 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");
	}
}

int find_part(int number)
{
	int i;

	for (i = 0; i < num_parts; i++)
		if (inventory[i].number == number)
			return i;
	return -1;
}

void insert(void)
{
	int part_number;

	if (num_parts == MAX_PARTS) {
		printf("Database is full; can't add more parts.\n");
		return;
	}

	printf("Enter part number : ");
	scanf("%d", &part_number);

	if (find_part(part_number) >= 0) {
		printf("Part already exists.\n");
		return;
	}

	inventory[num_parts].number = part_number;
	printf("Enter part name : ");
	read_line(inventory[num_parts].name, NAME_LEN);
	printf("Enter quantity on hand : ");
	scanf("%d", &inventory[num_parts].on_hand);
	num_parts++;
}

void search(void)
{
	int i, number;

	printf("Enter part number : ");
	scanf("%d", &number);
	i = find_part(number);
	if (i >= 0) {
		printf("Part name : %s\n", inventory[i].name);
		printf("Quantity on hand : %d\n", inventory[i].on_hand);
	}
	else
		printf("Part not found.\n");
}

void update(void)
{
	int i, number, change;

	printf("Enter part number : ");
	scanf("%d", &number);
	i = find_part(number);
	if (i >= 0) {
		printf("Enter change in quantity on hand : ");
		scanf("%d", &change);
		inventory[i].on_hand += change;
	}
	else
		printf("Part not found.\n");
}

void print(void)
{
	int i;

	printf("Part Number		Part Name			"
		"Quantity on Hand\n");
	for (i = 0; i < num_parts; i++)
		printf("%7d			%-25s%11d\n", inventory[i].number,
			inventory[i].name, inventory[i].on_hand);
}

🔎 readline.h

#ifndef READLINE_H
#define READLINE_H

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

#endif

🔎 readline.c

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

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

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

---

📍 Unions

공용체(union)는 구조체 처럼 하나 이상의 서로 다른 유형의 구성원(member)을 가질 수 있다. 그러나 컴파일러는 가장 큰 구성원을 위한 공간만을 할당하고, 서로 이 공간을 공유한다.

🔎 공용체 선언

union {
	int i;
	double d;
} u;

🔎 공용체 vs 구조체

struct {
	int i;
	double d;
} u;

가 있다고 가정할 때 둘의 차이는 메모리의 주소에 있다.

🔎 공용체 선언 - u의 구성원 i에 82 할당하기

u.i = 82;

공용체의 경우 한 멤버를 변경하면 다른 멤버에 저장되어 있던 값들이 변화한다.
따라서 이 경우 u.d의 값을 변화시켜주면 u.i에 저장된 값은 사라진다.

따라서 공용체 u는 i, d 둘다가 아닌 i나 d 중 하나를 저장시키는 공간이다.

공용체의 특성은 구조체와 거의 동일하다. tag와 type을 동일한 방법으로 선언할 수 있으며 = 연산자를 이용하여 할당할 수 있다.

다만 공용체에서는 첫번째 구성원만 초기화가 가능하다.

union {
	int i;
	double d;
} u = { 0 };

C99에서는 어떤 구성원을 초기화할지 지정할 수 있다. 구성원 하나만 초기화가 가능하나, 꼭 첫번째일 필요는 없다.

union {
	int i;
	double d;
} u = { .d = 10.0 };

---

📍 Using Unions to Save Space

아래의 선물 목록을 저장하고자 할 때,

Books : Title, author, number of pages
Mugs : Design
Shirts : Design, colors avialable, sizes available

구조체를 만들면 다음과 같다.

struct catalog_item {
	int stock_number;
	double price;
	int item_type;
	char title[TITLE_LEN + 1];
	char author[AUTHOR_LEN + 1];
	int num_pages;
	char design[DESIGN_LEN + 1];
	int colors;
	int sizes;
};

BOOK, MUG, SHIRT 모두 item_type을 가지고 있지만, colors, size 등은 shirts만 가지고 있는 것이기 때문에 공간 낭비가 일어나게 된다. 즉 책의 경우 design, colors, sizes를 저장할 필요가 없다.

이 경우 구조체에 공용체를 넣으면 공간낭비를 줄일 수 있다. 공용체의 구성원은 각각의 특수한 목록을 담은 구조체이어야 한다. 즉 겹치지 않는 것들은 구조체 내 공용체에 담으면 된다.

🔎 공용체를 이용한 catalog_item

struct catalog_item {
	int stock_number;
	double price;
	int item_type;
	union {
		struct {
			char title[TITLE_LEN + 1];
			char author[AUTHOR_LEN + 1];
			int num_pages
		} book;
		struct {
			char design[DESIGN_LEN + 1];
		} mug;
		struct {
			char design[DESIGN_LEN + 1];
			int colors;
			int sizes;
		} shirt;
	} item;
};

만약 c가 책을 가리키는 catalog_item 구조체라면, 다음과 같이 책의 title을 출력할 수 있다.

printf("%s", c.item.book.title);

만약 mug의 design에 "Cats"를 할당한다면, 공용체 내 다른 구조체의 design에도 똑같이 "Cats"가 할당된다.

strcpy(c.item.mug.design, "Cats");

printf("%s", c.item.shirt.design); /* prints "Cats" */

---

📍 Using Unions to Build Mixed Data Structures

union을 활용하여 다양한 유형의 데이터가 혼합된 데이터 구조를 생성할 수 있다.

만약 int와 double이 혼합된 어레이를 만든다고 가정하자. 어레이는 한 가지의 유형만 가질 수 있으므로 불가능한 것처럼 보이지만 공용체를 사용하면 가능하다.

먼저 서로 다른 종류의 데이터를 담는 공용체를 만든다.

typedef union {
	int i;
	double d;
} Number;

그 후, 요소가 Number인 어레이를 제작하면 된다.

Number number_array[1000];

그럼 number_array에는 int 와 double 모두를 저장할 수 있다.

number_array[0].i = 5;
number_array[1].d = 8.395;

---

📍 Adding a "Tag Field" to a Union

Union에는 치명적인 단점이 있다. 최근에 어떤 구성원이 변경되었는지 알 수 없어 의미없는 값이 담겨있어도 알 수가 없다.

우리는 조합에 현재 저장되어 있는 것을 상기시키는 것을 목적으로 태그 필드(tag field) 또는 차별자(discriminant)를 구조체 안에 공용체를 포함시킬 수 있다.

앞서 catalog_item 구조체에서는 item_type이 이러한 역할을 수행한다.

🔎 tag field를 이용하여 구조체 선언

#define INT_KIND 0
#define DOUBLE_KIND 1

typedef struct {
	int kind; /* tag field */
	union {
		int i;
		double d;
	} u;
} Number; 

kind는 INT_KIND거나 DOUBLE_KIND이다.

u의 구성원에 값을 할당할 때 마다 수정사항을 상기키시기 위해 kind도 함께 변경시키면 된다.

🔎 n이 Number의 변수인 경우 u의 i 멤버를 할당하기

n.kind = INT_KIND;
n.u.i = 82;

이렇게 하면 Number 변수에 지정된 숫자를 검색해야 할 때, kind는 어떤 공용체가 마지막으로 값을 할당받았는지 알려준다.

void print_number(Number n)
{
if (n.kind == INT_KIND)
printf("%d", n.u.i);
else
printf("%g", n.u.d);
}

---

📍 Enumerations

많은 프로그램에서, 단지 작은 의미 있는 값들의 집합만을 가진 변수들이 필요할 것이다.
예를 들어 카드 게임에서 카드명을 저장하는 변수는 "클로버" "다이아몬드" "하트" "스페이드" 4가지의 값이 필요하다.

이러한 변수를 처리하는 확실한 방법은 가능한 변수의 값과 정수를 매치시키는 것이다.

int s; /* s will store a suit */
...
s = 2; /* 2 represents "hearts" */

이러한 경우 총 4가지의 변수를 가지고 있다는 점이나, 2가 의미하는 바 등이 직관적이지 않다.

매크로를 이용하여 suit의 유형과 이름을 정의할 수 있다.

#define SUIT int 
#define CLUBS 0
#define DIAMONDS 0
#define HEARTS 0
#define SPADES 0

이 경우 좀 더 읽기 쉽도록 만들어진다

SUIT s;
...
s = HEARTS;

그러나 완벽한 해결책은 아니다. 프로그램을 읽는 사람에게는 매크로가 동일한 "유형"의 값을 나타낸다는 표시가 없다. 또한 정의한 이름은 전처리에 의해 제거되므로 디버깅 중에 사용할 수 없다.

C는 가능한 값의 수가 적은 변수를 위해 특별히 설계된 특수한 유형을 제공한다. 열거형(enumerated type)은 프로그래머에 의해 값이 나열되는 유형이며, 프로그래머는 각 값에 대한 이름(enumeration constant)을 생성해야 한다.

🔎 변수 s1과 s2에 할당할 수 있는 값을 열거

enum {CLUBS, DIAMONDS, HEARTS, SPADES} s1, s2; 

열거형이 함수 내부에서 선언되면 해당 상수는 함수 외부에서 사용할 수 없다.

📍 Enumeration Tags and Type Names

구조체, 공용체와 함께 열거형의 이름을 지을 두가지 방법이 있다. tag를 선언하거나 typedef를 사용하여 실제 형 이름을 만드는 것이다.

열거형 태그는 구조체, 공용체 태그와 유사하다.

🔎 suit 태그 정의

enum suit {CLUBS, DIAMONDS, HEARTS, SPADES};

🔎 suit의 변수 정의

enum suit s1, s2;

대안으로 Suit를 형 이름으로 만들기 위해 typedef를 이용할 수 있다

typedef enum {CLUBS, DIAMONDS, HEARTS, SPADES} Suit; 
Suit s1, s2;

---

📍 Enumerations as Integers

C는 열거형 변수들을 정수처럼 다룬다. 컴파일러는 각각의 열겨형들에 0, 1, 2.. 를 할당한다. 앞서 suit 열거형을 예시로 들면, CLUBS, DIAMONDS, HEARTS, SPADES는 각각 0, 1, 2, 3에 대응된다.

다른 상수를 넣고 싶다면 원하는 값을 할당해줄 수도 있다.

enum suit {CLUBS = 1, DIAMONDS = 2, HEARTS = 3, SPADES = 4};

같은 상수를 갖는 것도 가능하다.
열거형은 결국 정수이므로 다른 정수와 섞는 것도 가능하다.

int i;
enum {CLUBS, DIAMONDS, HEARTS, SPADES} s;

i = DIAMONDS;
s = 0;
s++;
i = s + 2; 

컴파일러는 s를 정수처럼 다룬다.

---

📍 Using Enumerations to Declare "Tag Fields"

앞서 16.4 절에서 다루었던, 최근에 수정된 값들을 파악하는데 열거형은 효과적이다.
예를 들어 kind 변수를 int 대신 열거형으로 만들면 다음과 같다.

🔎 열거형을 이용해 kind 만들기

typedef struct {
	enum {INT_KIND, DOUBLE_KIND} kind;
	union {
		int i;
		double d;
	} u;
} Number;

---