โ 1. ํจ์์ ๊ตฌ์กฐ์ฒด
(1) ๊ตฌ์กฐ์ฒดํ ์๋ฃ๋ฅผ ํจ์์ ์ ๋ฌํ๋ 2๊ฐ์ง ๋ฐฉ์
- ๊ฐ์ ์ํ ์๋ฃ ์ ๋ฌ ๋ฐฉ์๊ณผ ์ฐธ์กฐ์ ์ํ ์๋ฃ ์ ๋ฌ ๋ฐฉ์ ๋ ๊ฐ์ง๋ก ๋๋จ.
(2) ๊ฐ์ ์ํ ๊ตฌ์กฐ์ฒดํ ์๋ฃ ์ ๋ฌ ๋ฐฉ์
- ๊ตฌ์กฐ์ฒด ์๋ฃ๋ฅผ ํจ์์ ์ ๋ฌํ๋ ๋ฐฉ์์ด๋ฉฐ, ํจ์์ ํ์ ๋งค๊ฐ๋ณ์๋ ๊ตฌ์กฐ์ฒดํ์ผ๋ก ์ ์ธํจ.
- ๊ตฌ์กฐ์ฒด ์ ์ฒด๋ฅผ ํ์ ๋งค๊ฐ๋ณ์์ ๋ณต์ฌํจ. ์ฆ, ํ์ ๋งค๊ฐ๋ณ์๋ ์ค ๋งค๊ฐ๋ณ์์ ๋ณต์ฌ๋ณธ์ด๋ฉฐ, ๋ค๋ฅธ ์ฃผ์๊ฐ์ ๊ฐ๊ฒ ๋จ.
- ๊ตฌ์กฐ์ฒด์ ์ฉ๋์ด ํฐ ๊ฒฝ์ฐ ์ธ์ ์ ๋ฌ์ด ๋นํจ์จ์ ์ผ ์ ์์.
- ๊ตฌ์กฐ์ฒด ์ ์ฒด๋ฅผ ๋ณต์ฌํ๋ฏ๋ก ๋ง์ ์๊ฐ์ ์๋นํ๋ฉฐ, ๊ตฌ์กฐ์ฒด ๋ณต์ฌ๋ณธ์ ์ ์ฅํ๊ธฐ ์ํด ํฐ ๊ธฐ์ต๊ณต๊ฐ์ ์ฌ์ฉํ๊ฒ ๋จ.
#include <stdio.h>
struct num calc(struct num); // ํจ์ ์ ์ธ
struct num {
int x;
int y;
int sum;
int mul;
};
int main() {
struct num number1;
number1.x = 10;
number1.y = 20;
number1 = calc(number1); // ๊ตฌ์กฐ์ฒด ์ ์ฒด๊ฐ ํต์งธ๋ก ๋ณต์ฌ๋์ด number1์ ๋ฎ์ด์์์ง.
printf("x:%d, y:%d, sum:%d, mul:%d\n",number1.x, number1.y, number1.sum, number1.mul);
getchar();
}
struct num calc(struct num number2) {
number2.sum = number2.x + number2.y;
number2.mul = number2.x * number2.y;
return(number2);
}
- ๋งจ ํ๋จ์ calc() ํจ์๋ ํ์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ๋ ์๋ฃํ์ ํ์ ์ struct ํ์ ์ด๊ณ , ๋ฐํ ํ์ ๋ struct ํ์ ์ผ๋ก ์ ์๋จ.
- ์์ ๊ฐ์ด number1 = calc(number1); number1 ์ ๋์ ๋๋ ๊ฐ์ผ๋ก๋ return ๋ฐ์ ํด๋น ๊ตฌ์กฐ์ฒด ๋ณต์ฌ๋ณธ์ number1 ์ ๋ฎ์ด์์ฐ๊ฒ ๋จ. ์์ ๋ ๋ถ๋ถ์ด๋ ์ถ๊ฐ ๋ ๋ถ๋ถ์ ๋ฉค๋ฒ๋ง ๋ฐ๊พธ๋๊ฒ ์๋, return ๋ฐ์ ๊ตฌ์กฐ์ฒด ์ ์ฒด๋ฅผ ๋ฎ์ด ์์ฐ๊ฒ ๋จ.
- ** ๋ง์ฝ ๋ณ์นญ์ ๋ถ์ฌํ๋ค๋ฉด, struct ํค์๋๋ฅผ ์ฐ์ง ์๊ณ ๋ณ์นญ์ผ๋ก ์จ๋ ๋จ. **
- ** ์ฆ, struct num calc(struct num number2) -> Num calc(Num number2) ์ ๊ฐ์ ํํ๊ฐ ๋ ์ ์์. **
(3) ์ฐธ์กฐ์ ์ํ ๊ตฌ์กฐ์ฒดํ ์๋ฃ ์ ๋ฌ ๋ฐฉ์ ( ํฌ์ธํฐ ๋ฐฉ์ )
- ๊ตฌ์กฐ์ฒด ํฌ์ธํฐ๋ฅผ ํจ์์ ์ ๋ฌํ๋ ๋ฐฉ์์ด๋ฉฐ, ํจ์์ ํ์ ๋งค๊ฐ๋ณ์๋ ๊ตฌ์กฐ์ฒด ํฌ์ธํฐํ์ผ๋ก ์ ์ธํจ.
- ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ๋ง ํ์ ๋งค๊ฐ๋ณ์์ ๋ณต์ฌํ๋ฉฐ, ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ์ค ๋งค๊ฐ๋ณ์์ ํด๋น๋๋ ๊ตฌ์กฐ์ฒด์ ๋ด์ฉ์ ์์ ํ ์๋ ์์.
- ๊ตฌ์กฐ์ฒด์ ๊ธฐ์ต๊ณต๊ฐ ํฌ๊ธฐ์ ๊ด๊ณ์์ด 1๊ฐ์ ์ฃผ์๋ง ์ ๋ฌํ๋ฉด ๋๋ค๋ ์ฅ์ ์ด ์์.
- ๊ตฌ์กฐ์ฒด์ ์ฉ๋์ด ํฐ ๊ฒฝ์ฐ ๊ตฌ์กฐ์ฒด ์ ์ฒด ๋ณต์ฌ์ ๋นํด ํจ์จ์ ์ผ๋ก ์๋ฃ๋ฅผ ์ ๋ฌ ํ ์ ์์ผ๋ฉฐ, ๊ธฐ์ต๊ณต๊ฐ๋ ํจ์จ์ ์ฌ์ฉํ ์ ์์.
- ์ฆ, ๊ฐ ์ ๋ฌ ๋ฐฉ์์ ๋ณต์ฌ๋ณธ์ ๋ง๋ค๊ธฐ ๋๋ฌธ์ ๊ตฌ์กฐ์ฒด ํ๋๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์งํ๊ฒ ๋์ง๋ง, ํฌ์ธํฐ ๋ฐฉ์์ ๊ตฌ์กฐ์ฒด์ ์ฃผ์๊ฐ์ ์ ์ฅ ํ ์ ์๋ ๋ณ์ ํ๋๋ง ์์ผ๋ฉด ๋จ. ํจ์จ์ ์.
#include <stdio.h>
struct num *calc(struct num *); // ํจ์ ์ ์ธ
struct num {
int x;
int y;
int sum;
int mul;
};
int main() {
struct num number1;
number1.x = 10;
number1.y = 20;
calc(&number1); // ํจ์ ํธ์ถ -> ์ฃผ์๊ฐ ์ ๋ฌ
printf("x:%d, y:%d, sum:%d, mul:%d\n",number1.x, number1.y, number1.sum, number1.mul);
getchar();
}
struct num *calc(struct num *number2) {
number2.sum = number2.x + number2.y;
number2.mul = number2.x * number2.y;
return(number2);
}
- main() ํจ์ ๋ด๋ถ์์ calc(&number1) ๋ก ์ฃผ์๊ฐ์ ์ ๋ฌํ๋ฉด์ ํจ์๋ฅผ ํธ์ถ ํ ์ ์์.
- calc ํจ์๋ ํฌ์ธํฐ ๋ณ์๋ก ์ฃผ์๊ฐ์ ๋ฐ์ ์ ์๋๋ฐ, ์ด๋ ํจ์๋ช ์๋ ํฌ์ธํฐ๋ฅผ ๋ถํ๊ฒ ๋จ.
โ 2. ๊ตฌ์กฐ์ฒด ๋นํธํ๋
(1) ๋นํธํ๋
[ ๋นํธํ๋ ๋? ]
- ๊ตฌ์กฐ์ฒด์ ๋ฉค๋ฒ๊ฐ ์๋ ๊ณณ์ ํ๋๋ผ ํ๋๋ฐ, ํด๋น ํ๋์์ ๋ฉค๋ฒ๋ค์ ์๋ฃํ์ ๊ฐ์ง๊ณ ์์.
- ์ด๋ฌํ ์๋ฃํ์ ๋นํธ ๋จ์๋ก ์ง์ ํ์ฌ ์์ฃ ๋ฅผ ์ ์ฅํ ์ ์๊ฒ ๋ฉค๋ฒ๋ฅผ ์ ์ํ ๊ฒ์ด ๋นํธํ๋์.
- ์ฝ๊ฒ๋งํด, ์๋ฃํ ๋ง๊ณ ๋นํธ ๋จ์๋ก ์ฌ์ฉ์ ์ ์ ์๋ฃํ์ผ๋ก ๋ณผ ์ ์์.
[ ๋นํธํ๋์ ์ฌ์ฉ ๋ชฉ์ ]
๐ ๋นํธ ๋จ์ ํ๋๊ทธ
**ํ๋๊ทธ(flag)**๋ ์ด๋ค ์ํ, ์กฐ๊ฑด, ์ต์
๋ฑ์ “์ผ์ง/๊บผ์ง(1/0)”์ผ๋ก ํํํ๋ ๊ฐ์ ์๋ฏธ
์์)
๊ณต๊ฒฉ ๊ฐ๋ฅ ์ฌ๋ถ: 1 ๋๋ 0
๋ฐฉ์ด ์ํ ์ฌ๋ถ: 1 ๋๋ 0
์ ํ ๊ฐ๋ฅ ์ฌ๋ถ: 1 ๋๋ 0
์ด๋ฐ “์ํ”๋ค์ 1๋นํธ๋ก ํํํ ์ ์์.
- ํ์ํ ๋งํผ์ ๋นํธ๋ฅผ ์ด์ฉํ์ฌ ์๋ฃ๋ฅผ ์ ์ฅํจ์ผ๋ก์จ ๊ธฐ์ต๊ณต๊ฐ ์ ์ฝ
- ๋นํธ ๋จ์๋ก ํน์ ์ํ๋ ์กฐ๊ฑด ๋ฑ์ ํํํ๋ ํ๋๊ทธ(flag)๋ฅผ ํํํ๋ ์ฉ๋์ ์๋ฃ
(2) ๋นํธํ๋ - ์ ์ ํ์

- ์ผ๋ฐ์ ์ผ๋ก๋ int ๋๋ unsigned int ๋ฅผ ํ์ฉํ์ง๋ง, ์ปดํ์ผ๋ฌ ๊ตฌํ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ ์ํ๋ ๊ฐ๋ฅํจ. ( ์ฆ, ์ผ๋จ ์ ์๋ง ๋จ. )
- ๋ํ, ์ค์ํ, ํฌ์ธํฐํ, ์ฌ์ฉ์ ์ ์ํ, ๋ฐฐ์ด ์๋ฃํ์ ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํจ.
- ๊ทธ๋ฆฌ๊ณ ํ๋์ ๋นํธํ๋์ ํฌ๊ธฐ๋ ์๋ฃํ ์ด๋ด์ฌ์ผ ํ๊ธฐ ๋๋ฌธ์ int(32bit) ๋ฅผ ๋์ด์๋ ๋นํธํฌ๊ธฐ๋ฅผ ์ง์ ํ๋ฉด ์ค๋ฅ๋จ.

- a,b,c ๊ฐ ๊ฐ๊ฐ์ ๋ฉค๋ฒ๋ณ๋ก ์ง์ ํ ๋นํธ ์ ๋งํผ์ ๊ณต๊ฐ๋ง ์ฌ์ฉํจ.
- ๋นํธํ๋๊ฐ์ ์๋ฃํ์ ๋ฐ๋ฅธ ๊ธฐ์ต๊ณต๊ฐ์ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์, a,b,c ๊ฐ๊ฐ์ 32bit ๋ด๋ถ์์ 1, 2, 1 bit ์ฉ ์ฐจ์ง๋ฅผ ํ๊ฒ ๋จ.
- ์ฆ, ๊ณต๊ฐ์ ๋ํ ํจ์จ์ฑ์ ์ฌ๋ฆด ์ ์์.
- sizeof(struct nibble) == sizeof(int) ์ ๊ฒฐ๊ณผ๋ true๊ฐ ๋์ด. ์ฆ, ํด๋น ๊ตฌ์กฐ์ฒด์ ํฌ๊ธฐ๊ฐ int(32bit) ๋์ผํ๋ค๋ ์๋ฏธ์.

- ์ปดํ์ผ๋ฌ ๊ตฌํ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ ์ํ๋ ๊ฐ๋ฅํ๋ฏ๋ก, short ์๋ฃํ ๋ํ ์ด์ฉ์ด ๊ฐ๋ฅ ํ ์๋ ์์.
(3) ๋นํธํ๋ - ์ฌ์ฉ ์์

- short(16bit) ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ ์๋ฃํ์ด๊ธฐ ๋๋ฌธ์, 16๊ฐ์ ๊ณต๊ฐ์ ๊ฐ์ง๊ณ ์์.
- ์ดํ, ๋นํธ ํ๋๋ก ํฌ๊ธฐ๋ฅผ ์ง์ ํ๋ฉด ํด๋น ํฌ๊ธฐ์์ ํํ์ด ๊ฐ๋ฅํ ๊ฐ๋ง ๋ฃ์ ์ ์์.
- ์๋ฅผ๋ค์ด, ๋นํธํ๋๋ฅผ 1bit ๋ฅผ ํ ๋น ํ๋๋ฐ, ๊ฑฐ๊ธฐ์ 2 or 3 or 4 .. ๋ฅผ ๋ฃ๋ ๊ฒฝ์ฐ๋ ์ค๋ฅ๊ฐ ๋ ์ ์์.
- ์ดํ, ๋ฉค๋ฒ๋ฅผ ์ฐธ์กฐํด์ ์์ ์ ํ ์, ๋นํธ์ ๊ฐ์ด ๋ณ๊ฒฝ์ด ๋๊ฒ ๋๋ฉฐ, ํฌ๊ธฐ์ ๋ง๋ ์๋ง ๋ฃ์ ์ ์์.

- unsigned ์ default ๋ int ์๋ฃํ์. ์ฆ, 32 bit ํฌ๊ธฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํจ.
(4) ๋นํธํ๋ - ์ ์ฅ

- ์์ ๊ฐ์ด short ์ 16bit ๋ฅผ ๊ฐ์ง๋ ์๋ฃํ์ธ๋ฐ 5, 6, 6, 4 = 21bit ๋ฅผ ์ฐจ์งํ๋ ๋นํธํ๋๊ฐ ์ ์ธ์ด ๋จ.
- ํฌ๊ธฐ๊ฐ ๋ง์ง ์๊ธฐ ๋๋ฌธ์ short(16bit) ๋ฅผ 2๊ฐ ์ฌ์ฉ์ ํ๊ฒ ๋จ. ( 32bit ํ ๋น )
- ํ์ง๋ง, ์ธ๋ถ์ ์ผ๋ก a, b ๋ ๋ค์ด๊ฐ๋๋ฐ c๊ฐ ๋ค์ด๊ฐ๊ธฐ ์๋ 1bit ๊ณต๊ฐ์ด ๋ถ์กฑํจ. ์ฆ, ์์ธ์ค ๊ฒฝ๊ณ์ ๊ฑธ์ณ์๋ ๊ฒฝ์ฐ์.
- ์ด๋ฌํ ๊ฒฝ์ฐ์๋ 2๋ฒ์ ๊ฑธ์ณ์ ๋นํธ๋ฅผ ์ฝ์ด์ผ ๋๊ณ , ๊ทธ ๋นํธ๋ฅผ ๋ ผ๋ฆฌ์ ์ผ๋ก ํฉ์น๋ ๊ณผ์ ์ ๊ฑฐ์ณ์ผํจ. ๋นํจ์จ์ ์.
- ๊ทธ๋์, c(6bit) ๋ฅผ ๋ค์ short ๊ณต๊ฐ์ ํ ๋นํ๊ณ ๊ทธ ๋ค์ d(4bit) ๋ฅผ ํ ๋นํ๊ณ ๋๋จธ์ง๋ ํจ๋ฉ์ผ๋ก ๋ฎ์ด์์ฐ๊ฒ ๋จ.
[ ๋ฉค๋ฒ ์ด๋ฆ์ด ์๋ ๋นํธํ๋ - ํจ๋ฉ ]

- unsigned short = 16bit ์ด๋ค.
- ์ฆ, 16bit ํฌ๊ธฐ์ ์๋ฃํ์ ํ ๋น ํ๊ณ , ๊ทธ๊ณณ์ ๋ฉค๋ฒ๋ค์ ๋นํธํ๋๋ก์จ ํฌ๊ธฐ๋ฅผ ์ง์ ํ์ฌ ๋ฃ๋ ๊ณผ์ ์ด๋ค.
- ์ด ๊ณผ์ ์์ ๋ฉค๋ฒ์ด๋ฆ์ด ์๋ ๋นํธํ๋๋ฅผ ์ ์ธํ๋ฉด, ๊ทธ๊ณณ์๋ ์ ์ธ ๋ ๋นํธํ๋์ ํฌ๊ธฐ ๋งํผ ํจ๋ฉ์ ๋ฐฐ์น ํ ์ ์์.
[ ๋ฉค๋ฒ ํฌ๊ธฐ๊ฐ 0์ธ ๋นํธํ๋ - ํจ๋ฉ ]

- ๋นํธํ๋์ ํฌ๊ธฐ๋ฅผ 0์ผ๋ก ์ ์ธํ ๊ฒฝ์ฐ, 16bit ๋ฅผ ์ฌ์ฉ ์ค์ธ a ํ๋๊ฐ ์๋ ๊ฒฝ์ฐ์ด๋ฏ๋ก, ์ ๊ทผ๋จ์๋ฅผ ๊ฑด๋๋ฐ์ด ๋ค์ ์ ๊ทผ๋จ์์ ๋ฐฐ์น๋๊ฒ ํจ. ์ฆ, ์๋ฃํ ํฌ๊ธฐ๋งํผ ๊ฑด๋๋ฐ๊ฒ ๋๋ ๊ฒ์. 10 bit ๋ฅผ ํจ๋ฉ์ผ๋ก ๋ฎ๊ณ ๊ฑด๋๋ฐ๋ ๊ฒ์.
[ ๋ค๋ฅธ ์๋ฃํ์ ๋นํธ ํ๋ ]

short a : 5 = short(16bit)
unsigned b : 6 = int(32bit)
signed c : 6 = int(32bit)
unsigned d : 4 = int(32bit)
- ๋ค์ํ ์๋ฃํ์ ๊ฐ์ง๋ ๋นํธํ๋๊ฐ ์กด์ฌํ๋ค๋ฉด, ๊ฐ ๋นํธํ๋๋ง๋ค ๊ณต๊ฐ์ ํ ๋น์ ํด์ ์ฌ์ฉ์ ํ๊ฒ ๋จ.
- ๋ํ, short ์ ์ ์ธํ ๋๋จธ์ง๋ int(32bit) ์ด๋ฏ๋ก, ์์ธ์คํ๊ธฐ ํธํ๊ฒ short ์ 2๊ฐ ์จ์ 32bit ํ ๋นํ ๋ค ๋๋จธ์ง ๋ถ๋ถ์ ๋ฏธ์ฌ์ฉ ๋ถ๋ถ์ผ๋ก ๋จ๊ธฐ๋ฉฐ ์ด 64bit ๊ณต๊ฐ์ ํ ๋นํด์ ์ฒ๋ฆฌ๋ฅผ ํ๊ฒ ๋จ.
- ์ฆ, ์ ๊ทผ ๋จ์๊ฐ 32bit ๊ธฐ์ค์ผ๋ก ๋์ด์ 4bit ๋จ์๋ก ์ ๊ทผ์ ํ๋ค? ๋ผ๋๊ฒ ๊ฐ์.
โ 3. ๊ณต์ฉ์ฒด
(1) ๊ณต์ฉ์ฒด - ๊ฐ๋
- ๊ตฌ์กฐ์ฒด์ ๋์ผํ๊ฒ ๋ค์์ ๋ฉค๋ฒ๋ก ๊ตฌ์ฑ๋๋ ์ฌ์ฉ์ ์ ์ ์๋ฃํ์ด๋ค.
- **๊ตฌ์กฐ์ฒด์ ๋ค๋ฅธ์ : ๊ตฌ์กฐ์ฒด๋ ๊ฐ๊ฐ์ ๋ฉค๋ฒ๊ฐ ๋ค๋ฅธ ๊ธฐ์ต๊ณต๊ฐ์ ๊ฐ์ง์ง๋ง, ๊ณต์ฉ์ฒด๋ ๊ฐ๊ฐ์ ๋ฉค๋ฒ๊ฐ ๊ธฐ์ต๊ณต๊ฐ์ ๊ณต์ ํจ.**
- ์ฆ, ๊ณต์ฉ์ฒด๋ ๋ค์์ ๋ฉค๋ฒ๊ฐ ํ๋์ ๊ธฐ์ต๊ณต๊ฐ์ ๊ณต์ ํ์ฌ ๊ฐ์์ ์๋ฃํ์ผ๋ก ๊ณต์ ๊ธฐ์ต๊ณต๊ฐ์ ์ฌ์ฉํ๋ค.
- ๋ํ, ๊ณต์ฉ์ฒด์ ๊ธฐ์ต๊ณต๊ฐ์ ๊ฐ ๋ฉค๋ฒ์ ๊ธฐ์ต๊ณต๊ฐ ํฌ๊ธฐ ์ค ๊ฐ์ฅ ํฐ ๊ฒ์ ์ ์ฅํ ์ ์๋ ํฌ๊ธฐ๋ฅผ ์ฐจ์งํจ.
(2) ๊ณต์ฉ์ฒด - ํ์ฉ ๋ฐ ์ ์

- ๊ตฌ์กฐ์ฒด์ ๋์ผํ ๊ตฌ์กฐ๋ก ์ ์๊ฐ ๋๋ฉฐ, ๊ฐ์ฅ ํฐ ํฌ๊ธฐ๋ฅผ ์ฐจ์งํ๋ double(8byte) ํฌ๊ธฐ๋ก ๊ณต๊ฐ์ด ๋ง๋ค์ด์ง๋ค.

(3) ๊ณต์ฉ์ฒด - ๋ณ์์ ์ ์ธ

- ๊ณต์ฉ์ฒด ๋ณ์๋ฅผ ์ ์ธํ๊ธฐ ์ํด์๋ ๊ตฌ์กฐ์ฒด์ struct ์ ๋์ผํ๊ฒ union ํค์๋๋ฅผ ์ฌ์ฉํด ์ ์ธ ํ ์ ์๋ค.
(4) ๊ณต์ฉ์ฒด - ๋ฉค๋ฒ ์ ๊ทผ

- ๊ตฌ์กฐ์ฒด์ ๋์ผํ๊ฒ ์ฐธ์กฐ ์ฐ์ฐ์๋ฅผ ํ์ฉํด์ ์ ๊ทผ ํ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ ์ ์์.
- ๋ฐ์ดํฐ๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ ์์ ๊ฐ์ด abc.a = 'A'; ๋ฅผ ๋ฃ๊ณ abc.b = 66; ๋ฅผ ๋ฃ๊ฒ ๋๋ฉด, abc.a ์ ๊ฐ๋ ๋ฐ๋๊ฒ ๋จ.
- ์ฆ, ๋ฐ์ดํฐ ๊ณต๊ฐ ์์ฒด๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ ํ๋์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๊พธ๋ฉด ์ ์ฒด ๋ค ๋ฐ๋๊ฒ ๋๋ ํ์์.
(5) ๊ณต์ฉ์ฒด - ํฌ์ธํฐ ๋ณ์ ๋ฉค๋ฒ ์ ๊ทผ

- ๊ตฌ์กฐ์ฒด์ ๋์ผํ๊ฒ "->" ์ฐ์ฐ์๋ฅผ ์ด์ฉ ํ ์ ์์. ์ฐธ๊ณ ๋ก (*p).a ๋ก๋ ์ ๊ทผ์ด ๊ฐ๋ฅํจ.
(6) ๊ณต์ฉ์ฒด - ์์
#include <stdio.h>
int main() {
union test {
short i; // 2byte
float f; // 4byte
double d; // 8byte
};
union test u; // union var ์ ์ธ
u.i = u.f = u.d = 0; // ์ฌ์ค์ d์๋ง 0์ ๋ฃ์ด๋ ์ด๊ธฐํ๋ ๋จ.
printf("%zd bytes\n", sizeof(u)); // %zd: sizeof ๋ฆฌํด ๋๋ byte ์๋ฅผ ๋ด๊ธฐ ์ํ ๊ทธ๋ฆ
u.i = 100;
printf("%d %f %f \n", u.i, u.f, u.d);
u.f = 0.5;
printf("%d %f %f \n", u.i, u.f, u.d);
u.d = 0.016667;
printf("%f\n", u.d);
}
// [ ์ถ๋ ฅ ]
// 8 bytes
// 100 0.000000 0.000000
// 0 0.500000 0.000000
// 0.016667
- ๊ณต์ฉ์ฒด test ๋ฅผ ์ ์ํ ๋ค, ๋ฉค๋ฒ๋ก๋ shhort, float, double ๊ฐ ์๊ธฐ ๋๋ฌธ์, 8byte ํฌ๊ธฐ๊ฐ ํ ๋น์ด ๋จ.
- ์ดํ, u.i = u.f = u.d = 0; ์ด๊ธฐํ๋ฅผ ํด์ฃผ์์ง๋ง, ์ฌ์ค์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ d์๋ง 0์ ๋ฃ์ด๋ ์ด๊ธฐํ๋ ๋จ.
- ์ดํ, i, f, d ๋ฅผ ์ถ๋ ฅ์ ํ๋ฉด 100, 0.000000, 0.000000 ์ด ์ถ๋ ฅ์ด ๋๋๋ฐ, ๋ชจ๋ ๋ฉค๋ฒ ๋ณ์๊ฐ ๋์ผํ๊ฒ 100์ ๊ฐ์ง์ง ์๋ ์ด์ ๋ u.f ์ u.d ๋ ๊ณต์ ํ๋ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ float, double ํ์์ผ๋ก ํด์ํ๊ธฐ ๋๋ฌธ์ ์ ์ฅ๋ raw ๋นํธ๊ฐ ์ ์ํ 100 ์ด๋ฏ๋ก float ์ด๋ double ํํ๋ก๋ ์ ์์ ์ธ ์ซ์๊ฐ ์๋๋ผ๊ณ ํ๋จํ๊ธฐ ๋๋ฌธ์ 0์ด ๋์ค๋ ๊ฒ์.
- ๋ง์ฐฌ๊ฐ์ง๋ก 0 0.500000 0.000000 ์ด ๋์ค๋ ๊ฒ๋ ๋์ผํ ์ด์ ์ด๋ค.
'๐ ๏ธBackend > โ๏ธC' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [C์ธ์ด] ๊ตฌ์กฐ์ฒด์ ๊ณต์ฉ์ฒด(1) (0) | 2025.11.27 |
|---|---|
| [C์ธ์ด] ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ(3) (0) | 2025.11.26 |
| [C์ธ์ด] ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ(2) (0) | 2025.10.17 |
| [C์ธ์ด] ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ(1) (0) | 2025.10.16 |
| [C์ธ์ด] ํจ์์ ๊ธฐ์ต ํด๋์ค(2) (0) | 2025.10.15 |