๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“–CS/๐Ÿ“™Data Structure

[์ž๋ฃŒ๊ตฌ์กฐ] Chapter2. Arrays and Structures(1)

by goguma.dev 2024. 10. 1.

โ€ป ์ด ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๊ธ€๋“ค์€ knu EK.Ryu ๊ต์ˆ˜๋‹˜์˜ <์ž๋ฃŒ๊ตฌ์กฐ> ์ˆ˜์—…์„ ๋“ฃ๊ณ  ๋‚˜๋ฆ„๋Œ€๋กœ ํ•„์ž๊ฐ€ ์ •๋ฆฌํ•œ ๊ธ€์ž…๋‹ˆ๋‹ค.

โ€ป ๋ถ€์กฑํ•œ ์„ค๋ช…์ด ์žˆ๊ฑฐ๋‚˜, ์ž˜๋ชป ์•Œ๊ณ  ์ž‘์„ฑํ•œ ๋ถ€๋ถ„์ด ๋ณด์ธ๋‹ค๋ฉด ํŽธํ•˜๊ฒŒ ๋Œ“๊ธ€๋กœ ์•Œ๋ ค์ฃผ์‹œ๋ฉด ์ •๋ง ๊ฐ์‚ฌํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค๐Ÿ˜Š

2.1 Arrays ๋ฐฐ์—ด

๋ฐฐ์—ด์€ ์ธ๋ฑ์Šค์™€ ๊ฐ’ <index, value>์˜ ์Œ์œผ๋กœ ๊ตฌ์„ฑ๋œ ์ง‘ํ•ฉ์œผ๋กœ์„œ, ์ •์˜๋œ ๊ฐ ์ธ๋ฑ์Šค๋Š” ๊ทธ ์ธ๋ฑ์Šค์™€ ๊ด€๋ จ๋œ ๊ฐ’์„ ๊ฐ€์ง‘๋‹ˆ๋‹ค.

๋ฐฐ์—ด์˜ ์ถ”์ƒ ๋ฐ์ดํƒ€ ํƒ€์ž…(ADT)์€ ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

โ€ปADT(์ถ”์ƒ ๋ฐ์ดํ„ฐ ํƒ€์ž…)๋ž€? ๊ฐ์ฒด์˜ ๋ช…์„ธ์™€ ๊ทธ ์—ฐ์‚ฐ์˜ ๋ช…์„ธ๊ฐ€ ๊ทธ ๊ฐ์ฒด์˜ ํ‘œํ˜„๊ณผ ์—ฐ์‚ฐ์˜ ๊ตฌํ˜„์œผ๋กœ๋ถ€ํ„ฐ ๋ถ„๋ฆฌ๋œ ๋ฐ์ดํ„ฐ ํƒ€์ž…์ž…๋‹ˆ๋‹ค. ์‰ฝ๊ฒŒ ๋งํ•ด, ADT๋Š” ๋ฐ์ดํ„ฐ์™€ ๊ทธ ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฃจ๋Š” ์—ฐ์‚ฐ์„ ์ถ”์ƒ์ ์œผ๋กœ ์ •์˜ํ•œ ๊ฒƒ์œผ๋กœ, ๊ตฌํ˜„ ์„ธ๋ถ€ ์‚ฌํ•ญ์— ๊ตฌ์• ๋ฐ›์ง€ ์•Š๊ณ  ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋ฅผ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๋Š” ๊ฐœ๋…์ž…๋‹ˆ๋‹ค.

 

(1)  C์–ธ์–ด์—์„œ์˜ ๋ฐฐ์—ด

๋จผ์ € 1์ฐจ์› ๋ฐฐ์—ด๋งŒ์„ ์ƒ๊ฐํ•ด๋ด…์‹œ๋‹ค.

C์—์„œ 1์ฐจ์› ๋ฐฐ์—ด์€ ๋ณ€์ˆ˜์˜ ์ด๋ฆ„ ๋์— [ ] ์™€ ๊ฐ™์€ ์ค‘๊ด„ํ˜ธ๋ฅผ ์ถ”๊ฐ€ํ•˜์—ฌ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.

int list[5], *plist[5];

์œ„์˜ ์„ ์–ธ์€ ๊ฐ๊ฐ 5๊ฐœ์˜ ์›์†Œ๋ฅผ ํฌํ•จํ•˜๋Š” ๋‘ ๋ฐฐ์—ด์„ ์„ ์–ธํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ฒซ ๋ฒˆ์งธ ๋ฐฐ์—ด์€ 5๊ฐœ์˜ ์ •์ˆ˜๋ฅผ ์ •์˜ํ•œ ๋ฐ˜๋ฉด, ๋‘ ๋ฒˆ์งธ๋Š” ์ •์ˆ˜์— ๋Œ€ํ•œ 5๊ฐœ์˜ ํฌ์ธํ„ฐ๋ฅผ ์ •์˜ํ–ˆ์Šต๋‹ˆ๋‹ค.

์ฆ‰, list[0], list[1], ... , list[4]๋Š” ๋ฐฐ์—ด ์›์†Œ์˜ ์ด๋ฆ„์ด๊ณ , ์ด๋“ค ๊ฐ์ž๋Š” ํ•˜๋‚˜์˜ ์ •์ˆ˜ ๊ฐ’(int ๊ฐ’)์„ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค.

๋งˆ์ฐฌ๊ฐ€์ง€๋กœ plist[0], plist[1], ... ์€ ์ •์ˆ˜์— ๋Œ€ํ•œ ํฌ์ธํ„ฐ๋ฅผ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค.

 

์˜ˆ์ œ๋ฅผ ๋จผ์ € ๋ด…์‹œ๋‹ค.

์˜ˆ์ œ 2.1 ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ฐฐ์—ด์„ ์„ ์–ธํ•  ๊ฒฝ์šฐ๋ฅผ ๊ฐ€์ •ํ•ด๋ด…์‹œ๋‹ค.

int one[] = {0, 1, 2, 3, 4};

 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void print1(int* ptr, int rows)
{
	int i;
	printf("Address Contents\n");
	for (i = 0; i < rows; i++)
		printf("%8u%5d\n", ptr + i, *(ptr + i));
	printf("\n");
}

int main()
{
	int one[] = {1, 2, 3, 4, 5};
	int rows = 5;
	print1(one, rows);
}

์œ„ ์‚ฌ์ง„์€ print1 ํ•จ์ˆ˜๋ฅผ ์‹คํ–‰ํ•ด์„œ ์–ป์€ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์—ฌ์ฃผ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.

์ด ํ”„๋กœ๊ทธ๋žจ์—์„œ i๊ฐ€ 1์”ฉ ์ฆ๊ฐ€ํ•ด๋„ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋Š” 4์”ฉ ์ฆ๊ฐ€ํ•˜๋Š” ๊ฒƒ์œผ๋กœ ๋ณด์ด๋Š” ์ด์œ ๋Š”, ๋ฐฐ์—ด์˜ ๊ฐ ์š”์†Œ๊ฐ€ 4๋ฐ”์ดํŠธ ํฌ๊ธฐ์˜ int์ด๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

 

2.2 Dynamically Allocated Array ๋™์ ์œผ๋กœ ํ• ๋‹น๋œ ๋ฐฐ์—ด

ํ”„๋กœ๊ทธ๋žจ์—์„œ 100์˜ ํฌ๊ธฐ๋ฅผ ๊ฐ€์ง€๋Š” ๋ฐฐ์—ด์„ ์„ ์–ธํ–ˆ๋‹ค๊ณ  ํ•ด๋ด…์‹œ๋‹ค.

int box[100];

๋งŒ์ผ ์ด ๋ฐฐ์—ด์— 100๊ฐœ๋ณด๋‹ค ๋งŽ์€ ์ˆ˜๋ฅผ ๋‹ด์œผ๋ ค๊ณ  ํ•œ๋‹ค๋ฉด, ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ• ๊นŒ์š”?

์ด์— ๋Œ€ํ•œ ์ข‹์€ ํ•ด๋‹ต์€, ์ด ๊ฒฐ์ •์„ ์‹คํ–‰ ์‹œ๊ฐ„๊นŒ์ง€ ๋ฏธ๋ฃจ์—ˆ๋‹ค๊ฐ€ ํ•„์š”ํ•œ ๋ฐฐ์—ด ํฌ๊ธฐ์˜ ์ ๋‹นํ•œ ์ถ”์ •์น˜๊ฐ€ ๋‚˜์˜ฌ ๋•Œ ๋ฐฐ์—ด์„ ํ• ๋‹นํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

int i, n, *list;
printf("Enter the number of number to generate: ");
scanf("%d, &n");

if(n < 1 )
{
	fprintf(stderr, "Improper value of n\n");
    exit(EXIT_FAILURE);
}
MALLOC(list, n * sizeof(int));

 

(1) 2์ฐจ์› ๋ฐฐ์—ด

C ์–ธ์–ด๋Š” ๋‹ค์ฐจ์› ๋ฐฐ์—ด์„ ํ‘œํ˜„ํ•˜๊ธฐ ์œ„ํ•˜์—ฌ ์†Œ์œ„ ๋ฐฐ์—ด์˜ ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

int x[3][5];

๋ผ๊ณ  ํ•˜๋ฉด, ์‹ค์ œ๋กœ ๊ธธ์ด๊ฐ€ 3์ธ 1์ฐจ์› ๋ฐฐ์—ด x๊ฐ€ ์ƒ์„ฑ๋˜๋Š”๋ฐ, ์ด x์˜ ๊ฐ ์›์†Œ๋Š” ๊ธธ์ด๊ฐ€ 5์ธ 1์ฐจ์› ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค.

์•„๋ž˜ ๊ทธ๋ฆผ์„ ํ†ตํ•ด ์ด์— ๋Œ€ํ•œ ๋ฉ”๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์ž์„ธํžˆ ๋ณผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์›์†Œ x[i][j]๋ฅผ ์ฐพ์„ ๋•Œ ์ œ์ผ ๋จผ์ € x[i]์— ์žˆ๋Š” ํฌ์ธํ„ฐ์— ์ ‘๊ทผํ•ฉ๋‹ˆ๋‹ค. ์ด ํฌ์ธํ„ฐ๋Š” ๋ฐฐ์—ด์˜ ํ–‰ i์˜ 0๋ฒˆ์งธ ์›์†Œ์˜ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์ œ๊ณตํ•˜๊ณ , ๊ทธ๋Ÿฌ๋ฉด ์ด ํฌ์ธํ„ฐ์— j * sizeof(int)๋ฅผ ๋”ํ•˜๋ฉด ํ–‰ i์˜ [j]๋ฒˆ์งธ ์›์†Œ(์ฆ‰, ์›์†Œ x[i][j])์˜ ์ฃผ์†Œ๊ฐ€ ๊ฒฐ์ •๋ฉ๋‹ˆ๋‹ค.

 

2.3 Structures and Unions ๊ตฌ์กฐ์™€ ์œ ๋‹ˆ์–ธ

๋ฐฐ์—ด์€ ๊ฐ™์€ ํƒ€์ž…์˜ ๋ฐ์ดํ„ฐ ๋ชจ์ž„์ž…๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด ๋‹ค๋ฅธ ํƒ€์ž…์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๊ทธ๋ฃนํ™”ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด ์žˆ์„๊นŒ์š”?
์ด๋ฅผ ๊ตฌ์กฐ์ฒด structure ๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

 

typedef struct {
	char name[50];
    int age;
    float gpa;
} Student;

typedef struct {
	int x, y;
} Point;

typedef struct {
	int day;
    int month;
    int year;
} Date;

์œ„์™€ ๊ฐ™์ด typedef ๋ช…๋ น๋ฌธ์„ ์‚ฌ์šฉํ•˜์—ฌ ๊ตฌ์กฐ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ์ƒ์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

typedef๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋งค๋ฒˆ struct ํ‚ค์›Œ๋“œ๋ฅผ ์“ฐ์ง€ ์•Š์•„๋„ ๋˜๋ฏ€๋กœ ์ฝ”๋“œ๊ฐ€ ๋” ๊ฐ„๊ฒฐํ•˜๊ฒŒ ์ž‘์„ฑ๋ฉ๋‹ˆ๋‹ค.

 

๊ตฌ์กฐ์ฒด๋“ค์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์ด ๊ฐ™์„ ๋•Œ person1 = person2์™€ ๊ฐ™์€ ๋ฐฉ์‹์œผ๋กœ ๋ณต์‚ฌ๊ฐ€ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ,

๋น„๊ต ์—ฐ์‚ฐ์ž๋Š” ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค. (Ex. if (person1 == person2) )

๋”ฐ๋ผ์„œ ๊ตฌ์กฐ์ฒด ๊ฐ„์˜ ๋น„๊ต๋ฅผ ์œ„ํ•ด์„œ๋Š” ์•„๋ž˜์˜ ๋ฐฉ์‹๊ณผ ๊ฐ™์ด ์ผ์ผ์ด ๋น„๊ต๋ฅผ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

#define FALSE 0
#define TRUE 1

int humansEqual (humanBeing person1, humanBeing person2)
{
	if(strcmp(person1.name, person2.name))
    	return FALSE;
    if(person1.age != person2.age)
    	return FALSE;
    if(person1.salary != person2.salary)
    	return FALSE;
    return TRUE;
}

 

 

 

๋˜ํ•œ ๊ตฌ์กฐ์ฒด ์†์— ๋˜ ๋‹ค๋ฅธ ๊ตฌ์กฐ์ฒด๋ฅผ ์ •์˜ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด humanBeing ๊ตฌ์กฐ์ฒด ์†์— ์ƒ๋…„์›”์ผ์„ ํฌํ•จํ•˜๊ณ ์ž ํ•˜๋Š” ๊ฒฝ์šฐ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

typedef struct {
	int month;
    int day;
    int year;
} date;

typedef struct {
	char name[10];
    int age;
    float salary;
    date dob;
} humanBeing;

humanBeing person1;
person1.dob.month = 12;
person1.dob.day = 8;
person1.dob.year = 1993;

 

(1) Unions ๊ณต์šฉ์ฒด

๊ณต์šฉ์ฒด์˜ ํŠน์ง•์€ ๊ณต์šฉ์ฒด ๋‚ด๋ถ€์˜ ํ•„๋“œ๋“ค์ด ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ๊ณต์šฉํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, ์•„๋ž˜ ๊ณต์šฉ์ฒด์˜ ํฌ๊ธฐ๋Š” ์–ผ๋งˆ์ธ์ง€ ๋ด…์‹œ๋‹ค.

union Data 
{
   int i;
   float f;
   char str[20];
};

์œ„์˜ ๊ณต์šฉ์ฒด์˜  ํฌ๊ธฐ๋Š” 20๋ฐ”์ดํŠธ์ž…๋‹ˆ๋‹ค. (๊ฐ€์žฅ ํฐ char str[20]์— ๋”ฐ๋ผ..)

 

๋ฐ˜๋ฉด, ๊ตฌ์กฐ์ฒด์˜ ํฌ๊ธฐ๋Š” ํ•ญ์ƒ 4์˜ ๋ฐฐ์ˆ˜์ž…๋‹ˆ๋‹ค.

๋˜ํ•œ, ๊ตฌ์กฐ์ฒด ๋‚ด ํ•„๋“œ์˜ ์ˆœ์„œ์— ๋”ฐ๋ผ ๊ตฌ์กฐ์ฒด์˜ ํฌ๊ธฐ๊ฐ€ ๋‹ฌ๋ผ์งˆ ์ˆ˜ ์žˆ์Šต๋‹ค.

#include <stdio.h>

typedef struct {
	char a;
    int b;
    char c;
} InefficientStruct;

typedef struct {
	int b;
    char a;
    char c;
} EfficientStruct;

int main()
{
	printf("%lu bytes\n", sizeof(InefficientStruct));
    printf("%lu bytes\n", sizeof(EfficientStruct));
    
    return 0;
}

 

์ด ๊ฒฝ์šฐ, InefficientStruct๋Š” 12๋ฐ”์ดํŠธ, EfficientStruct๋Š” 8๋ฐ”์ดํŠธ์ž…๋‹ˆ๋‹ค.

์ด ๋‘ ๊ตฌ์กฐ์ฒด์˜ ํฌ๊ธฐ๊ฐ€ ๋‹ค๋ฅธ ์ด์œ ๋Š” ๋ฉ”๋ชจ๋ฆฌ ํŒจ๋”ฉ(Memory Padding) ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ๋ฉ”๋ชจ๋ฆฌ ํŒจ๋”ฉ์€ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์„ฑ๋Šฅ์„ ์ตœ์ ํ™”ํ•˜๊ธฐ ์œ„ํ•ด ๊ตฌ์กฐ์ฒด์˜ ๋ฉค๋ฒ„๋“ค์„ ์ •๋ ฌ(Alignment)ํ•˜๋Š” ๊ณผ์ •์—์„œ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค. (์˜ˆ๋ฅผ ๋“ค์–ด int ํƒ€์ž…์€ 4๋ฐ”์ดํŠธ ๊ฒฝ๊ณ„์—์„œ ์ •๋ ฌ๋˜๋„๋ก ์„ค์ •๋จ)

๊ฒฐ๋ก ์ ์œผ๋กœ, ๊ตฌ์กฐ์ฒด์˜ ๋ฉค๋ฒ„ ์ˆœ์„œ์— ๋”ฐ๋ผ ํŒจ๋”ฉ์ด ๋‹ฌ๋ผ์ง€๋ฉฐ, ์ด๋Š” ๊ตฌ์กฐ์ฒด์˜ ์ „์ฒด ํฌ๊ธฐ์— ์˜ํ–ฅ์„ ๋ฏธ์นฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ, ํŒจ๋”ฉ์„ ์ตœ์†Œํ™”ํ•˜๋ ค๋ฉด, ๊ตฌ์กฐ์ฒด์˜ ๋ฉค๋ฒ„๋ฅผ ํฐ ๋ฐ์ดํ„ฐ ํƒ€์ž…๋ถ€ํ„ฐ ์ž‘์€ ๋ฐ์ดํ„ฐ ํƒ€์ž… ์ˆœ์„œ๋กœ ๋ฐฐ์น˜ํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.