voidํ์ ๊ธฐ๋ณธ ๊ฐ๋
void๋ ๋ฐํ๊ฐ์ด ์๋ ํจ์์์ ์ฃผ๋ก ์ฌ์ฉ๋๋ ํค์๋์
๋๋ค. ๋ฐํํ ๊ฐ์ด ์์ผ๋ฏ๋ก, ํ์
์ญ์ ์๋ค๋ ๊ฐ๋
์
๋๋ค.
๋ค์ ์์ ์์ ๊ธฐ๋ณธ์ ์ธ void์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค:
int main(void)
{
void a;
return 0;
}
์ด ์ฝ๋๋ฅผ ์ปดํ์ผํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค:

์๋ฌ์ ์ด์ ๋ ๊ฐ๋จํฉ๋๋ค. void๋ ์๋ฃํ์ผ๋ก ์ฌ์ฉ๋ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
์ปดํ์ผ๋ฌ๋ ๋ณ์ ์ ์ธ ์ ํด๋น ๋ณ์์ ๋ช ๋ฐ์ดํธ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํด์ผ ํ ์ง ๊ณ์ฐํ๋๋ฐ, void๋ ํฌ๊ธฐ๊ฐ ์ ์๋์ง ์์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ์๊ฐ ์์ต๋๋ค.
1. voidํ๋ ์๋ฃํ์ผ๊น?
int, char ์ ๊ฐ์ ์๋ฃํ์ ํน์ ํฌ๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ์ ์์ง๋ง, void๋ ๊ทธ๋ ์ง์์ต๋๋ค.
๋ฐ๋ผ์, void ๋ ์๋ฃํ์ด๋ผ๊ธฐ๋ณด๋ค๋ "ํ์
์ด ์๋ค"๋ ์๋ฏธ๋ก ์ดํดํ๋ ๊ฒ์ด ๋ ์ ์ ํฉ๋๋ค.
๋ค์ ์ฝ๋๋ฅผ ํตํด void๊ฐ ๋ฐํ๊ฐ์ด ์๋ ํจ์์ ์ฌ์ฉ๋๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
#include <stdio.h>
void CoffeeMachine(int price)
{
if (price == 100)
{
printf("๋ธ๋์ปคํผ\n");
}
else if (price == 200)
{
printf("๋ฐํฌ์ปคํผ\n");
}
else
{
printf("์๋ชป ์
๋ ฅ\n");
}
}
void main()
{
int coin = 0;
printf("๋์ ์ ๋ฃ์ด์ฃผ์ธ์: ");
scanf("%d", &coin);
CoffeeMachine(coin);
return;
}
์ด ํจ์๋ void๋ฅผ ๋ฐํ ํ์
์ผ๋ก ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์ธ๋ถ๋ก ๋ฐํํ๋ ๊ฐ์ด ์์ต๋๋ค.
์ฆ, void๋ "๋ฐํํ ๊ฐ์ด ์๋ค"๋ ๊ฒ์ ์ปดํ์ผ๋ฌ์ ๋ช
์ํ๋ ์ญํ ์ ํฉ๋๋ค.
2. voidํ ํฌ์ธํฐ๋?
1. voidํ ํฌ์ธํฐ์ ์ ์ธ
void*๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ํฌ์ธํฐ ๋ณ์์
๋๋ค.
๋ค์ ์ฝ๋๋ฅผ ํ์ธํ๋ฉด
int main(void)
{
void* a; // voidํ ํฌ์ธํฐ ์ ์ธ
return 0;
}
์ ์ฝ๋๋ ์ปดํ์ผ ์๋ฌ ์์ด ์คํ๋ฉ๋๋ค.
ํฌ์ธํฐ ๋ณ์๋ ํญ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด 4๋ฐ์ดํธ(๋๋ 64๋นํธ ์์คํ
์์๋ 8๋ฐ์ดํธ)์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น๋ฐ์ต๋๋ค.
void* ์ญ์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ๋ง ์ ์ฅํ ์ ์์ต๋๋ค.
2. voidํ ํฌ์ธํฐ์ ํน์ง

void*๋ "์ฃผ์๊ฐ๋ง ์ ์ฅ"ํ ์ ์๊ณ , ๊ทธ ์ฃผ์์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐธ์กฐ ํ ์๋ ์์ต๋๋ค.
- ๋ณ์ a๋ 0x100์ด๋ผ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๊ณ ์์ต๋๋ค.
- ํ์ง๋ง ๋ณ์ a๊ฐ ์ด๋ค ๋ฐ์ดํฐ ํ์ ์ธ์ง ๋ช ์๋์ง ์์๊ธฐ ๋๋ฌธ์, ํด๋น ๊ฐ์ ์ง์ ์ฐธ์กฐํ ์ ์์ต๋๋ค.
3. voidํ ํฌ์ธํฐ์ ์ ํ์
๋ค์ ์ฝ๋๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
#include <stdio.h>
int main(void)
{
void* a;
int b = 1234;
a = &b; // b์ ์ฃผ์๊ฐ์ void ํฌ์ธํฐ a์ ์ ์ฅ
printf("%d\n", *a); // ๊ฐ ์ฐธ์กฐ ์๋
return 0;
}
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค:

์ด์ ๋ void*๋ ์ด๋ค ๋ฐ์ดํฐ ํ์
์ธ์ง ์ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
ํฌ์ธํฐ๋ ํด๋น ์ฃผ์์์ ๋ช ๋ฐ์ดํธ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์์ผ ํ๋์ง ์์์ผ ํ์ง๋ง, void*๋ ํ์
์ด ์์ผ๋ฏ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ฌ์ ์์ต๋๋ค.
4. voidํ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋?
๊ทธ๋ ๋ค๋ฉด, ๊ฐ์ ์ฐธ์กฐํ ์ ์๋ void*๋ ์ ์ฌ์ฉ๋ ๊น์?
void*๋ ์ฌ๋ฌ ๋ฐ์ดํฐ ํ์
์ ์ ์ฅํ๊ฑฐ๋, ๋ค์ํ ์ฉ๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํด์ผ ํ ๋ ์ ์ฉํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ํจ์ malloc์ ์ฌ์ฉํ ๋ ๋ฐํ๊ฐ์ ํญ์ void*ํํ์
๋๋ค.
#include <stdlib.h>
int* ptr = (int*)malloc(sizeof(int) * 10);
malloc์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ํ ํด๋น ์ฃผ์๋ฅผ ๋ฐํํ์ง๋ง, ๋ฐํ๊ฐ์ ๋ฐ์ดํฐ ํ์
์ ๋ช
์๋์ง ์์ต๋๋ค.
๊ทธ๋์ void*๋ก ๋ฐํ๋ ๊ฐ์ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ํ์
์ผ๋ก ์บ์คํ
ํด์ ์ฌ์ฉํด์ผํฉ๋๋ค.
๐งฉ๊ฒฐ๋ก : voidํ ํฌ์ธํฐ์ ํ์ฉ๊ณผ ์ดํด
- void๋ ํ์ ์ด ์ ํด์ง์ง ์์ ํฌ์ธํฐ ์ ๋๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์ง์ ์ฐธ์กฐํ ์ ์์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ ์ ์์ต๋๋ค.
- void*๋ฅผ ์ฌ์ฉํ๋ ๋ํ์ ์ธ ๊ฒฝ์ฐ๋ ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น, ๋ค์ํ ๋ฐ์ดํฐ ํ์ ์ฒ๋ฆฌ ๋ฑ์ด ์์ต๋๋ค.
'C์ธ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C์ธ์ด] ๊ตฌ์กฐ์ฒด๋ ๋ฌด์์ด๊ณ ์ ์ฌ์ฉํ๋ ๊ฑธ๊น? (0) | 2025.01.18 |
---|---|
[C์ธ์ด] ํจ์ ํฌ์ธํฐ ์ ์ธ๊ณผ ํ์ฉ (0) | 2025.01.12 |
[C์ธ์ด] *ํฌ์ธํฐ์ **ํฌ์ธํฐ ์ด์คํฌ์ธํฐ ๊ฐ๋ (0) | 2025.01.02 |
[C์ธ์ด] ๊ฐ ํธ์ถ ๋ฐฉ์(Call by Value)๊ณผ ์ฐธ์กฐ ํธ์ถ ๋ฐฉ์(Call by Reference) (0) | 2025.01.01 |
[C์ธ์ด] ๋ฐฐ์ดํ์ ์ธ์๋ ํฌ์ธํฐํ์ผ๋ก ๋ฐ๋๋ค. (0) | 2024.12.31 |