Ver3.0
์ ์ฒด ์ด๋
Ver3.0 ๐ฏ ๊ฐ๋ณ ์ธ์ ํจ์ ๊ตฌํํ๊ธฐ

๐ฏ ๊ฐ๋ณ ์ธ์ ํจ์ ๊ตฌํํ๊ธฐ
printf์ฒ๋ผ ์ธ์ ๊ฐ์๊ฐ ์์ ๋ก์ด ํจ์, ์ง์ ๋ง๋ค์ด๋ณด์! ๐
ํน์ printf() ํจ์ ์จ๋ดค์ง? ๋น์ฐํ ์จ๋ดค๊ฒ ์ง! ๊ทธ๋ฐ๋ฐ ์ด ํจ์๊ฐ ์ ์ ๊ธฐํ์ง ์๊ฐํด๋ณธ ์ ์์ด? printf("%d", 10)์ฒ๋ผ ์ธ์ 2๊ฐ๋ฅผ ๋ฃ์ ์๋ ์๊ณ , printf("%d %s %f", 10, "hello", 3.14)์ฒ๋ผ ์ธ์ 4๊ฐ๋ฅผ ๋ฃ์ ์๋ ์์์. ๐ค
์ผ๋ฐ์ ์ธ ํจ์๋ ๋งค๊ฐ๋ณ์ ๊ฐ์๊ฐ ์ ํด์ ธ ์๋๋ฐ, ์ด๋ป๊ฒ ์ด๋ฐ ๋ง๋ฒ ๊ฐ์ ์ผ์ด ๊ฐ๋ฅํ ๊น? ๋ฐ๋ก ๊ฐ๋ณ ์ธ์(Variable Arguments) ๊ธฐ๋ฅ ๋๋ถ์ด์ผ!
์ด ๊ธ์์๋ ๊ฐ๋ณ ์ธ์ ํจ์์ ์๋ฆฌ๋ถํฐ ์ค์ ๊ตฌํ ๋ฐฉ๋ฒ, ์ฃผ์์ฌํญ, ๊ทธ๋ฆฌ๊ณ ์ค๋ฌด์์ ํ์ฉํ ์ ์๋ ๋ค์ํ ์์ ๊น์ง ์น๊ตฌ์ฒ๋ผ ํธํ๊ฒ ์ค๋ช ํด์ค๊ฒ. ํ๋ก๊ทธ๋๋ฐ ์ค๋ ฅ์ ํ ๋จ๊ณ ์ ๊ทธ๋ ์ด๋ํ๊ณ ์ถ๋ค๋ฉด, ์ฌ๋ฅ๋ท์ ์ง์์ธ์ ์ฒ์์ ์ด๋ฐ ๊น์ด ์๋ ๋ด์ฉ๋ค์ ๊ณ์ ํํํด๋ณด๋ ๊ฒ๋ ์ข์ ๊ฑฐ์ผ! ๐ช
๐ ๊ฐ๋ณ ์ธ์ ํจ์๋ ๋ฌด์์ธ๊ฐ?
๊ฐ๋ณ ์ธ์ ํจ์๋ ๋ง ๊ทธ๋๋ก ์ธ์์ ๊ฐ์๊ฐ ๋ณํ ์ ์๋ ํจ์๋ฅผ ๋งํด. ์์ด๋ก๋ Variadic Function์ด๋ผ๊ณ ๋ถ๋ฅด์ง. ๐์ผ๋ฐ์ ์ธ C ํจ์๋ ์ด๋ ๊ฒ ์๊ฒผ์ด:
int add(int a, int b) {
return a + b;
}์ด ํจ์๋ ๋ฑ 2๊ฐ์ ์ ์๋ง ๋ฐ์ ์ ์์ด. 3๊ฐ๋ฅผ ๋ฃ์ผ๋ ค๊ณ ํ๋ฉด? ์ปดํ์ผ ์๋ฌ๊ฐ ๋์ง! ๐ฑ
ํ์ง๋ง ๊ฐ๋ณ ์ธ์ ํจ์๋ ๋ค๋ฅด๊ฒ ๋์ํด:
int sum(int count, ...) {
// count ๊ฐ์๋งํผ์ ์ธ์๋ฅผ ๋ฐ์์ ์ฒ๋ฆฌ
}์ฌ๊ธฐ์ ... ์ด ๋ถ๋ถ์ด ๋ฐ๋ก ๊ฐ๋ณ ์ธ์๋ฅผ ๋ํ๋ด๋ ํน๋ณํ ๋ฌธ๋ฒ์ด์ผ! ์ด ์ ์ธ ๊ฐ(ellipsis)๊ฐ "์ฌ๊ธฐ์ ์ถ๊ฐ ์ธ์๊ฐ ์ฌ ์ ์์ด์"๋ผ๊ณ ์ปดํ์ผ๋ฌ์๊ฒ ์๋ ค์ฃผ๋ ๊ฑฐ์ง. โจ
๐ก ํต์ฌ ํฌ์ธํธ
โข ๊ฐ๋ณ ์ธ์๋ ํจ์ ๋งค๊ฐ๋ณ์ ๋ชฉ๋ก์ ๋ง์ง๋ง์๋ง ์ฌ ์ ์์ด
โข ์ต์ ํ๋ ์ด์์ ๊ณ ์ ๋งค๊ฐ๋ณ์๊ฐ ํ์ํด
โข ... ๊ธฐํธ๋ก ํ์ํด
โข stdarg.h ํค๋ ํ์ผ์ด ํ์์ผ
โข ์ต์ ํ๋ ์ด์์ ๊ณ ์ ๋งค๊ฐ๋ณ์๊ฐ ํ์ํด
โข ... ๊ธฐํธ๋ก ํ์ํด
โข stdarg.h ํค๋ ํ์ผ์ด ํ์์ผ
๐ ์ ๊ฐ๋ณ ์ธ์ ํจ์๊ฐ ํ์ํ ๊น?
์ค์ ํ๋ก๊ทธ๋๋ฐ์ ํ๋ค ๋ณด๋ฉด ์ด๋ฐ ์ํฉ๋ค์ด ์๊ฒจ:1๏ธโฃ ๋ก๊น ํจ์
๋๋ฒ๊น ํ ๋ ๋ค์ํ ํ์์ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๊ณ ์ถ์ ๋๊ฐ ๋ง์. ๋๋ก๋ ์ซ์๋ง, ๋๋ก๋ ๋ฌธ์์ด๊ณผ ์ซ์๋ฅผ ํจ๊ป ์ถ๋ ฅํ๊ณ ์ถ์์?
2๏ธโฃ ์ํ ์ฐ์ฐ ํจ์
์ฌ๋ฌ ๊ฐ์ ์ซ์๋ฅผ ๋ํ๊ฑฐ๋ ํ๊ท ์ ๊ตฌํ ๋, ๊ฐ์๊ฐ ๋งค๋ฒ ๋ค๋ฅผ ์ ์์ด. 2๊ฐ์ผ ์๋, 10๊ฐ์ผ ์๋ ์์ง.
3๏ธโฃ ๋ฌธ์์ด ํฌ๋งทํ
printf์ฒ๋ผ ๋ค์ํ ํ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฌธ์์ด๋ก ๋ง๋ค ๋ ์ ๋ง ์ ์ฉํด!
4๏ธโฃ ์ค์ ํจ์
์ต์ ์ด๋ ์ค์ ๊ฐ์ ๋ฐ๋ ํจ์์์, ํ์ํ ์ต์ ๋ง ์ ํ์ ์ผ๋ก ์ ๋ฌํ๊ณ ์ถ์ ๋ ํ์ฉํ ์ ์์ด.
์ด๋ฐ ์ํฉ๋ค์์ ๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋๊ฐ ํจ์ฌ ์ ์ฐํ๊ณ ๊น๋ํด์ ธ! ๐จ
๐ ๏ธ stdarg.h - ๊ฐ๋ณ ์ธ์์ ํต์ฌ ๋๊ตฌ
๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ๋ง๋ค๋ ค๋ฉด stdarg.h ํค๋ ํ์ผ์ ์ ์๋ ํน๋ณํ ๋งคํฌ๋ก๋ค์ ์ฌ์ฉํด์ผ ํด. ์ด ๋งคํฌ๋ก๋ค์ด ๋ง๋ฒ์ ์ด์ ์ผ! ๐| ๋งคํฌ๋ก | ์ญํ | ์ฌ์ฉ ์์ |
|---|---|---|
| va_list | ๊ฐ๋ณ ์ธ์ ๋ชฉ๋ก์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ํ์ | ๋ณ์ ์ ์ธ |
| va_start | ๊ฐ๋ณ ์ธ์ ๋ชฉ๋ก์ ์์ ์์น ์ด๊ธฐํ | ์ธ์ ์ ๊ทผ ์ |
| va_arg | ๋ค์ ์ธ์๋ฅผ ๊ฐ์ ธ์ค๊ณ ํฌ์ธํฐ ์ด๋ | ๊ฐ ์ธ์ ์ฝ๊ธฐ |
| va_end | ๊ฐ๋ณ ์ธ์ ์ฒ๋ฆฌ ์ข ๋ฃ ๋ฐ ์ ๋ฆฌ | ํจ์ ์ข ๋ฃ ์ |
| va_copy | va_list ๋ณต์ฌ (C99๋ถํฐ) | ๋ชฉ๋ก ์ฌ์ฌ์ฉ ์ |
๐ ๊ฐ ๋งคํฌ๋ก ์์ธ ์ค๋ช
๐น va_listva_list๋ ๊ฐ๋ณ ์ธ์๋ค์ ์ํํ๊ธฐ ์ํ ํน๋ณํ ํ์ ์ด์ผ. ๋ด๋ถ์ ์ผ๋ก๋ ํฌ์ธํฐ์ฒ๋ผ ๋์ํ์ง๋ง, ํ๋ซํผ๋ง๋ค ๊ตฌํ์ด ๋ค๋ฅผ ์ ์์ด์ ์ง์ ์กฐ์ํ๋ฉด ์ ๋ผ!
va_list args; // ๊ฐ๋ณ ์ธ์ ๋ชฉ๋ก์ ๊ฐ๋ฆฌํฌ ๋ณ์ ์ ์ธ๐น va_start
va_start๋ ๊ฐ๋ณ ์ธ์ ์ฒ๋ฆฌ๋ฅผ ์์ํ๊ธฐ ์ํด va_list๋ฅผ ์ด๊ธฐํํด. ๋ ๊ฐ์ ์ธ์๊ฐ ํ์ํด:
va_start(args, last_fixed_param);โข ์ฒซ ๋ฒ์งธ ์ธ์: va_list ๋ณ์
โข ๋ ๋ฒ์งธ ์ธ์: ๊ฐ๋ณ ์ธ์ ๋ฐ๋ก ์์ ๋ง์ง๋ง ๊ณ ์ ๋งค๊ฐ๋ณ์
์ด๋ ๊ฒ ํ๋ฉด args๊ฐ ์ฒซ ๋ฒ์งธ ๊ฐ๋ณ ์ธ์๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋ผ! ๐ฏ
๐น va_arg
va_arg๋ ํ์ฌ ๊ฐ๋ฆฌํค๊ณ ์๋ ์ธ์๋ฅผ ๊ฐ์ ธ์ค๊ณ , ๋ค์ ์ธ์๋ก ํฌ์ธํฐ๋ฅผ ์ด๋์์ผ:
int value = va_arg(args, int); // int ํ์
์ ๋ค์ ์ธ์ ๊ฐ์ ธ์ค๊ธฐ๋ ๋ฒ์งธ ์ธ์๋ก ๊ฐ์ ธ์ฌ ์ธ์์ ํ์ ์ ๋ช ์ํด์ผ ํด. ์ด๊ฒ ์ค์ํ ํฌ์ธํธ์ผ! ํ์ ์ ์๋ชป ์ง์ ํ๋ฉด ์๋ฑํ ๊ฐ์ ์ฝ๊ฒ ๋ผ. ๐ฐ
๐น va_end
va_end๋ ๊ฐ๋ณ ์ธ์ ์ฒ๋ฆฌ๋ฅผ ๋ง๋ฌด๋ฆฌํ๊ณ ๋ฆฌ์์ค๋ฅผ ์ ๋ฆฌํด:
va_end(args);์ด๊ฑธ ํธ์ถํ์ง ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋์๋ ์์์น ๋ชปํ ๋์์ด ๋ฐ์ํ ์ ์์ด. ๋ฐ๋์ ํธ์ถํด์ผ ํด! โ ๏ธ
โก ์ค์ํ ๊ท์น
va_start๋ฅผ ํธ์ถํ๋ค๋ฉด ๋ฐ๋์ ๊ฐ์ ํจ์ ๋ด์์ va_end๋ฅผ ํธ์ถํด์ผ ํด. ์ด๊ฑด ์ง์ ์ด๋ฃจ๋ ๊ฑฐ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ!
๐น va_copyC99 ํ์ค๋ถํฐ ์ถ๊ฐ๋ va_copy๋ va_list๋ฅผ ๋ณต์ฌํ ๋ ์ฌ์ฉํด:
va_list args_copy;
va_copy(args_copy, args); // args๋ฅผ args_copy๋ก ๋ณต์ฌ
// args_copy ์ฌ์ฉ...
va_end(args_copy); // ๋ณต์ฌ๋ณธ๋ ์ ๋ฆฌ ํ์!๊ฐ๋ณ ์ธ์๋ฅผ ๋ ๋ฒ ์ํํ๊ฑฐ๋, ๋ค๋ฅธ ํจ์์ ์ ๋ฌํ ๋ ์ ์ฉํด! ๐
๐ป ์ฒซ ๋ฒ์งธ ๊ฐ๋ณ ์ธ์ ํจ์ ๋ง๋ค๊ธฐ
์ด์ ์ค์ ๋ก ๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ๋ง๋ค์ด๋ณผ๊น? ๊ฐ์ฅ ๊ฐ๋จํ ์์ ๋ถํฐ ์์ํด๋ณด์! ๐๐ฏ ์์ 1: ์ ์ ํฉ๊ณ ๊ตฌํ๊ธฐ
์ฌ๋ฌ ๊ฐ์ ์ ์๋ฅผ ๋ฐ์์ ํฉ๊ณ๋ฅผ ๊ตฌํ๋ ํจ์๋ฅผ ๋ง๋ค์ด๋ณด์:#include <stdio.h>
#include <stdarg.h>
// count: ์ธ์ ๊ฐ์, ...: ๊ฐ๋ณ ์ธ์๋ค
int sum(int count, ...) {
va_list args; // ๊ฐ๋ณ ์ธ์ ๋ชฉ๋ก ๋ณ์
int total = 0;
va_start(args, count); // ๊ฐ๋ณ ์ธ์ ์ฒ๋ฆฌ ์์
for (int i = 0; i < count; i++) {
int value = va_arg(args, int); // ๋ค์ int ๊ฐ์ ธ์ค๊ธฐ
total += value;
}
va_end(args); // ๊ฐ๋ณ ์ธ์ ์ฒ๋ฆฌ ์ข
๋ฃ
return total;
}
int main() {
printf("2๊ฐ ํฉ: %d\n", sum(2, 10, 20)); // 30
printf("4๊ฐ ํฉ: %d\n", sum(4, 1, 2, 3, 4)); // 10
printf("6๊ฐ ํฉ: %d\n", sum(6, 5, 10, 15, 20, 25, 30)); // 105
return 0;
}
๐ ์ฝ๋ ๋ถ์
1๋จ๊ณ: va_list args๋ก ๊ฐ๋ณ ์ธ์๋ฅผ ๋ค๋ฃฐ ๋ณ์ ์ ์ธ
2๋จ๊ณ: va_start(args, count)๋ก ์ด๊ธฐํ (count ๋ค์๋ถํฐ๊ฐ ๊ฐ๋ณ ์ธ์)
3๋จ๊ณ: ๋ฐ๋ณต๋ฌธ์ผ๋ก va_arg(args, int)๋ฅผ count๋ฒ ํธ์ถํด์ ๊ฐ ์ธ์ ๊ฐ์ ธ์ค๊ธฐ
4๋จ๊ณ: va_end(args)๋ก ์ ๋ฆฌ
5๋จ๊ณ: ๊ฒฐ๊ณผ ๋ฐํ
์ด ํจ์์ ํต์ฌ์ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ๊ฐ์๋ฅผ ๋ฐ๋๋ค๋ ๊ฑฐ์ผ. ์ด๋ ๊ฒ ํ๋ฉด ๋ช ๊ฐ์ ์ธ์๊ฐ ๋ค์ด์ฌ์ง ์ ์ ์์ด์ ์์ ํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ง! ๐ก๏ธ2๋จ๊ณ: va_start(args, count)๋ก ์ด๊ธฐํ (count ๋ค์๋ถํฐ๊ฐ ๊ฐ๋ณ ์ธ์)
3๋จ๊ณ: ๋ฐ๋ณต๋ฌธ์ผ๋ก va_arg(args, int)๋ฅผ count๋ฒ ํธ์ถํด์ ๊ฐ ์ธ์ ๊ฐ์ ธ์ค๊ธฐ
4๋จ๊ณ: va_end(args)๋ก ์ ๋ฆฌ
5๋จ๊ณ: ๊ฒฐ๊ณผ ๋ฐํ
๐ฏ ์์ 2: ํ๊ท ๊ณ์ฐ ํจ์
์ด๋ฒ์ ํ๊ท ์ ๊ตฌํ๋ ํจ์๋ฅผ ๋ง๋ค์ด๋ณด์:#include <stdio.h>
#include <stdarg.h>
double average(int count, ...) {
if (count <= 0) {
return 0.0; // ์์ธ ์ฒ๋ฆฌ
}
va_list args;
double sum = 0.0;
va_start(args, count);
for (int i = 0; i < count; i++) {
// double๋ก ๋ฐ์์ผ ์์์ ๊ณ์ฐ ๊ฐ๋ฅ
sum += va_arg(args, double);
}
va_end(args);
return sum / count;
}
int main() {
printf("ํ๊ท : %.2f\n", average(3, 10.5, 20.3, 15.7)); // 15.50
printf("ํ๊ท : %.2f\n", average(5, 1.0, 2.0, 3.0, 4.0, 5.0)); // 3.00
return 0;
}
โ ๏ธ ์ฃผ์์ฌํญ
va_arg์์ ํ์
์ ์ง์ ํ ๋, ์ค์ ๋ก ์ ๋ฌ๋ ์ธ์์ ํ์
๊ณผ ์ผ์นํด์ผ ํด! ๋ง์ฝ int๋ฅผ ์ ๋ฌํ๋๋ฐ double๋ก ์ฝ์ผ๋ฉด ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์์ด.
๐ฏ ์์ 3: ์ต๋๊ฐ ์ฐพ๊ธฐ
์ฌ๋ฌ ์ซ์ ์ค์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ๋ ํจ์๋ ๋ง๋ค์ด๋ณด์:#include <stdio.h>
#include <stdarg.h>
#include <limits.h> // INT_MIN ์ฌ์ฉ
int max(int count, ...) {
if (count <= 0) {
return INT_MIN; // ์ ํจํ์ง ์์ ์
๋ ฅ
}
va_list args;
int maximum;
va_start(args, count);
// ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ด๊ธฐ ์ต๋๊ฐ์ผ๋ก ์ค์
maximum = va_arg(args, int);
// ๋๋จธ์ง ๊ฐ๋ค๊ณผ ๋น๊ต
for (int i = 1; i < count; i++) {
int value = va_arg(args, int);
if (value > maximum) {
maximum = value;
}
}
va_end(args);
return maximum;
}
int main() {
printf("์ต๋๊ฐ: %d\n", max(5, 3, 7, 2, 9, 1)); // 9
printf("์ต๋๊ฐ: %d\n", max(4, -5, -2, -8, -1)); // -1
printf("์ต๋๊ฐ: %d\n", max(3, 100, 50, 75)); // 100
return 0;
}์ด ์์ ์์๋ ์ฒซ ๋ฒ์งธ ๊ฐ๋ณ ์ธ์๋ฅผ ๋จผ์ ์ฝ์ด์ ์ด๊ธฐ๊ฐ์ผ๋ก ์ค์ ํ ๋ค์, ๋๋จธ์ง์ ๋น๊ตํ๋ ๋ฐฉ์์ ์ฌ์ฉํ์ด. ์ด๋ฐ ํจํด๋ ์์ฃผ ์ฐ์ด๋๊น ๊ธฐ์ตํด๋๋ฉด ์ข์! ๐
๐จ ๋ค์ํ ํ์ ์ฒ๋ฆฌํ๊ธฐ
์ง๊ธ๊น์ง๋ ๊ฐ์ ํ์ ์ ์ธ์๋ค๋ง ๋ค๋ค๋๋ฐ, ์ค์ ๋ก๋ ์ฌ๋ฌ ํ์ ์ด ์์ธ ์ธ์๋ฅผ ์ฒ๋ฆฌํด์ผ ํ ๋๊ฐ ๋ง์. ์ด๊ฒ ๋ฐ๋ก printf๊ฐ ํ๋ ์ผ์ด์ง! ๐๐ฏ ์์ 4: ๊ฐ๋จํ printf ๋ง๋ค๊ธฐ
ํฌ๋งท ๋ฌธ์์ด์ ํด์ํด์ ๋ค์ํ ํ์ ์ ์ถ๋ ฅํ๋ ํจ์๋ฅผ ๋ง๋ค์ด๋ณด์:#include <stdio.h>
#include <stdarg.h>
void my_printf(const char* format, ...) {
va_list args;
va_start(args, format);
for (const char* p = format; *p != '\0'; p++) {
if (*p == '%') {
p++; // % ๋ค์ ๋ฌธ์๋ก ์ด๋
switch (*p) {
case 'd': // ์ ์
printf("%d", va_arg(args, int));
break;
case 'f': // ์ค์
printf("%f", va_arg(args, double));
break;
case 's': // ๋ฌธ์์ด
printf("%s", va_arg(args, char*));
break;
case 'c': // ๋ฌธ์
printf("%c", va_arg(args, int)); // char๋ int๋ก ์ ๋ฌ๋จ
break;
case '%': // %% -> %
printf("%%");
break;
default:
printf("%%%c", *p); // ์ ์ ์๋ ํ์
break;
}
} else {
printf("%c", *p); // ์ผ๋ฐ ๋ฌธ์ ์ถ๋ ฅ
}
}
va_end(args);
}
int main() {
my_printf("์ ์: %d, ์ค์: %f\n", 42, 3.14);
my_printf("๋ฌธ์์ด: %s, ๋ฌธ์: %c\n", "Hello", 'A');
my_printf("์ฌ๋ฌ ๊ฐ: %d %s %f %c\n", 100, "test", 2.5, 'X');
return 0;
}
๐ก ํต์ฌ ๊ฐ๋
โข ํฌ๋งท ๋ฌธ์์ด์ ํ ๊ธ์์ฉ ์ํํ๋ฉด์ %๋ฅผ ๋ง๋๋ฉด ๋ค์ ๋ฌธ์๋ฅผ ํ์ธ
โข ๋ค์ ๋ฌธ์์ ๋ฐ๋ผ ์ ์ ํ ํ์ ์ผ๋ก va_arg ํธ์ถ
โข char ํ์ ์ ๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌ๋ ๋ int๋ก ์น๊ฒฉ๋๋ฏ๋ก va_arg(args, int)๋ก ์ฝ์ด์ผ ํด!
โข ๋ค์ ๋ฌธ์์ ๋ฐ๋ผ ์ ์ ํ ํ์ ์ผ๋ก va_arg ํธ์ถ
โข char ํ์ ์ ๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌ๋ ๋ int๋ก ์น๊ฒฉ๋๋ฏ๋ก va_arg(args, int)๋ก ์ฝ์ด์ผ ํด!
๐ ํ์ ์น๊ฒฉ(Type Promotion) ์ดํดํ๊ธฐ
๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌ๋ ๋ ์์ ํ์ ๋ค์ ์๋์ผ๋ก ํฐ ํ์ ์ผ๋ก ๋ณํ๋ผ. ์ด๊ฑธ ํ์ ์น๊ฒฉ์ด๋ผ๊ณ ํด:| ์๋ ํ์ | ์น๊ฒฉ๋ ํ์ | va_arg ์ฌ์ฉ๋ฒ |
|---|---|---|
| char | int | va_arg(args, int) |
| short | int | va_arg(args, int) |
| float | double | va_arg(args, double) |
| int | int (๋ณํ ์์) | va_arg(args, int) |
| double | double (๋ณํ ์์) | va_arg(args, double) |
๐ฏ ์์ 5: ๊ตฌ์กฐ์ฒด ์ฒ๋ฆฌํ๊ธฐ
๊ตฌ์กฐ์ฒด๋ ๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌํ ์ ์์ด:#include <stdio.h>
#include <stdarg.h>
typedef struct {
int x;
int y;
} Point;
void print_points(int count, ...) {
va_list args;
va_start(args, count);
printf("์ขํ๋ค:\n");
for (int i = 0; i < count; i++) {
Point p = va_arg(args, Point); // ๊ตฌ์กฐ์ฒด ์ ์ฒด๋ฅผ ์ฝ์
printf(" Point %d: (%d, %d)\n", i + 1, p.x, p.y);
}
va_end(args);
}
int main() {
Point p1 = {10, 20};
Point p2 = {30, 40};
Point p3 = {50, 60};
print_points(3, p1, p2, p3);
return 0;
}๊ตฌ์กฐ์ฒด๋ฅผ ๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌํ ๋๋ ๊ฐ ๋ณต์ฌ๊ฐ ์ผ์ด๋. ํฐ ๊ตฌ์กฐ์ฒด๋ผ๋ฉด ํฌ์ธํฐ๋ก ์ ๋ฌํ๋ ๊ฒ ๋ ํจ์จ์ ์ผ ์ ์์ด! ๐
โ ๏ธ ์ฃผ์์ฌํญ๊ณผ ํจ์ ๋ค
๊ฐ๋ณ ์ธ์ ํจ์๋ ๊ฐ๋ ฅํ์ง๋ง, ์กฐ์ฌํ์ง ์์ผ๋ฉด ์ฌ๊ฐํ ๋ฒ๊ทธ๋ฅผ ๋ง๋ค ์ ์์ด. ์ค์ ๋ก ๋ง์ ํ๋ก๊ทธ๋๋จธ๋ค์ด ์ฌ๊ธฐ์ ์ค์๋ฅผ ํ๊ฑฐ๋ ! ๐ฐ๐จ ํจ์ 1: ์ธ์ ๊ฐ์๋ฅผ ๋ชจ๋ฅผ ๋
๊ฐ์ฅ ํฐ ๋ฌธ์ ๋ ๋ช ๊ฐ์ ์ธ์๊ฐ ์ ๋ฌ๋์๋์ง ์ ์ ์๋ค๋ ๊ฑฐ์ผ. ์ปดํ์ผ๋ฌ๋ ๋ฐํ์๋ ์ด ์ ๋ณด๋ฅผ ์ ๊ณตํ์ง ์์!โ ์๋ชป๋ ์:
void bad_function(...) { // ๊ณ ์ ๋งค๊ฐ๋ณ์๊ฐ ์์!
// ์ด๋ป๊ฒ ์ธ์ ๊ฐ์๋ฅผ ์ ์ ์์๊น? ๋ถ๊ฐ๋ฅ!
}โ ์ฌ๋ฐ๋ฅธ ํด๊ฒฐ์ฑ ๋ค:
๋ฐฉ๋ฒ 1: ๊ฐ์๋ฅผ ๋ช ์์ ์ผ๋ก ์ ๋ฌ
void good_function(int count, ...) {
// count๋ก ๊ฐ์๋ฅผ ์ ์ ์์
}๋ฐฉ๋ฒ 2: ์ผํฐ๋ ๊ฐ ์ฌ์ฉ
void print_strings(...) {
va_list args;
va_start(args, ???); // ๋ฌธ์ : ๋ง์ง๋ง ๊ณ ์ ๋งค๊ฐ๋ณ์๊ฐ ์์!
// ์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉ ๋ถ๊ฐ!
}์ค์ ๋ก๋ ์ด๋ ๊ฒ ํด์ผ ํด:
void print_strings(const char* first, ...) {
va_list args;
va_start(args, first);
printf("%s\n", first); // ์ฒซ ๋ฒ์งธ ๋ฌธ์์ด ์ถ๋ ฅ
const char* str;
while ((str = va_arg(args, const char*)) != NULL) {
printf("%s\n", str);
}
va_end(args);
}
// ์ฌ์ฉ ์
print_strings("Hello", "World", "Test", NULL); // NULL๋ก ๋์ ํ์๋ฐฉ๋ฒ 3: ํฌ๋งท ๋ฌธ์์ด ๋ถ์
printf์ฒ๋ผ ํฌ๋งท ๋ฌธ์์ด์์ %์ ๊ฐ์๋ฅผ ์ธ์ ์ธ์ ๊ฐ์๋ฅผ ํ์ ํ๋ ๋ฐฉ๋ฒ๋ ์์ด!
๐จ ํจ์ 2: ํ์ ๋ถ์ผ์น
va_arg๋ ํ์ ๊ฒ์ฌ๋ฅผ ํ์ง ์์! ์๋ชป๋ ํ์ ์ผ๋ก ์ฝ์ผ๋ฉด ์ฐ๋ ๊ธฐ ๊ฐ์ ์ป๊ฒ ๋ผ:void dangerous(int count, ...) {
va_list args;
va_start(args, count);
int value = va_arg(args, int); // int๋ฅผ ๊ธฐ๋
va_end(args);
}
// ์๋ชป๋ ํธ์ถ
dangerous(1, 3.14); // double์ ์ ๋ฌํ๋๋ฐ int๋ก ์ฝ์! ๐ฅ
๐ก๏ธ ์์ ์์น
โข ํฌ๋งท ๋ฌธ์์ด์ด๋ ํ์
์ ๋ณด๋ฅผ ํจ๊ป ์ ๋ฌํด์ ํ์
์ ํ์ธํ ์ ์๊ฒ ๋ง๋ค๊ธฐ
โข ๋ฌธ์ํ๋ฅผ ์ฒ ์ ํ ํด์ ์ฌ์ฉ์๊ฐ ์ฌ๋ฐ๋ฅธ ํ์ ์ ์ ๋ฌํ๋๋ก ์ ๋
โข ๊ฐ๋ฅํ๋ฉด ํ์ ์์ ์ฑ์ด ๋ณด์ฅ๋๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ ๊ณ ๋ ค (C++์ ํ ํ๋ฆฟ, ํจ์ ์ค๋ฒ๋ก๋ฉ ๋ฑ)
โข ๋ฌธ์ํ๋ฅผ ์ฒ ์ ํ ํด์ ์ฌ์ฉ์๊ฐ ์ฌ๋ฐ๋ฅธ ํ์ ์ ์ ๋ฌํ๋๋ก ์ ๋
โข ๊ฐ๋ฅํ๋ฉด ํ์ ์์ ์ฑ์ด ๋ณด์ฅ๋๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ ๊ณ ๋ ค (C++์ ํ ํ๋ฆฟ, ํจ์ ์ค๋ฒ๋ก๋ฉ ๋ฑ)
๐จ ํจ์ 3: va_end ๋๋ฝ
va_end๋ฅผ ํธ์ถํ์ง ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋์๋ ์คํ ์์์ด ๋ฐ์ํ ์ ์์ด:void leak_example(int count, ...) {
va_list args;
va_start(args, count);
// ์์
์ํ...
// va_end(args); ๋ฅผ ๊น๋นกํจ! โ
return; // ์ํ!
}ํนํ ํจ์ ์ค๊ฐ์ returnํ๋ ๊ฒฝ์ฐ ์ฃผ์ํด์ผ ํด:
void safe_example(int count, ...) {
va_list args;
va_start(args, count);
if (count <= 0) {
va_end(args); // ์ฌ๊ธฐ์๋ ์ ๋ฆฌ!
return;
}
// ์์
์ํ...
va_end(args); // ์ ์ ์ข
๋ฃ ์์๋ ์ ๋ฆฌ!
}๐จ ํจ์ 4: ๋ฐฐ์ด ์ ๋ฌ์ ํจ์
๋ฐฐ์ด์ ๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌํ๋ ค๊ณ ํ ๋ ์กฐ์ฌํด์ผ ํด:void process_arrays(int count, ...) {
va_list args;
va_start(args, count);
for (int i = 0; i < count; i++) {
int* arr = va_arg(args, int*); // ํฌ์ธํฐ๋ก ๋ฐ์์ผ ํจ!
// arr ์ฌ์ฉ...
}
va_end(args);
}
int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {4, 5, 6};
process_arrays(2, arr1, arr2); // ๋ฐฐ์ด์ ํฌ์ธํฐ๋ก decay๋จ
return 0;
}๋ฐฐ์ด์ ์๋์ผ๋ก ํฌ์ธํฐ๋ก ๋ณํ๋๋ฏ๋ก, int*๋ก ๋ฐ์์ผ ํด!
๐ง ์ค์ ํ์ฉ ์์
์ด์ ์ค๋ฌด์์ ์ ๋ง ์ ์ฉํ๊ฒ ์ธ ์ ์๋ ์์ ๋ค์ ์ดํด๋ณด์! ์ฌ๋ฅ๋ท์์ ํ๋ก๊ทธ๋๋ฐ ์ฌ๋ฅ์ ๊ณต์ ํ ๋๋ ์ด๋ฐ ์ค์ฉ์ ์ธ ์์ ๋ค์ด ํฐ ๋์์ด ๋ ๊ฑฐ์ผ. ๐ผ๐ฏ ์์ 6: ๋ก๊น ์์คํ
๋๋ฒ๊น ํ ๋ ์ ๋ง ์ ์ฉํ ๋ก๊น ํจ์๋ฅผ ๋ง๋ค์ด๋ณด์:#include <stdio.h>
#include <stdarg.h>
#include <time.h>
typedef enum {
LOG_DEBUG,
LOG_INFO,
LOG_WARNING,
LOG_ERROR
} LogLevel;
const char* level_strings[] = {
"DEBUG",
"INFO",
"WARNING",
"ERROR"
};
void log_message(LogLevel level, const char* format, ...) {
// ํ์ฌ ์๊ฐ ๊ฐ์ ธ์ค๊ธฐ
time_t now = time(NULL);
char time_str[26];
ctime_r(&now, time_str);
time_str[24] = '\0'; // ๊ฐํ ๋ฌธ์ ์ ๊ฑฐ
// ๋ก๊ทธ ๋ ๋ฒจ ์ถ๋ ฅ
printf("[%s] [%s] ", time_str, level_strings[level]);
// ๊ฐ๋ณ ์ธ์ ์ฒ๋ฆฌ
va_list args;
va_start(args, format);
vprintf(format, args); // vprintf ์ฌ์ฉ!
va_end(args);
printf("\n");
}
int main() {
log_message(LOG_INFO, "ํ๋ก๊ทธ๋จ ์์");
log_message(LOG_DEBUG, "๋ณ์ x = %d, y = %d", 10, 20);
log_message(LOG_WARNING, "๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋: %.2f MB", 45.67);
log_message(LOG_ERROR, "ํ์ผ ์ด๊ธฐ ์คํจ: %s", "data.txt");
return 0;
}
๐ ์๋ก์ด ๊ฐ๋
: vprintf
vprintf๋ va_list๋ฅผ ์ง์ ๋ฐ๋ printf ๋ฒ์ ์ด์ผ! ๊ฐ๋ณ ์ธ์ ํจ์ ์์์ ๋ค๋ฅธ ๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ํธ์ถํ ๋ ์ ๋ง ์ ์ฉํด.
๋น์ทํ ํจ์๋ค:
โข vprintf - ํ์ค ์ถ๋ ฅ
โข vfprintf - ํ์ผ ์ถ๋ ฅ
โข vsprintf - ๋ฌธ์์ด ๋ฒํผ์ ์ถ๋ ฅ
โข vsnprintf - ํฌ๊ธฐ ์ ํ์ด ์๋ ๋ฌธ์์ด ๋ฒํผ์ ์ถ๋ ฅ
๋น์ทํ ํจ์๋ค:
โข vprintf - ํ์ค ์ถ๋ ฅ
โข vfprintf - ํ์ผ ์ถ๋ ฅ
โข vsprintf - ๋ฌธ์์ด ๋ฒํผ์ ์ถ๋ ฅ
โข vsnprintf - ํฌ๊ธฐ ์ ํ์ด ์๋ ๋ฌธ์์ด ๋ฒํผ์ ์ถ๋ ฅ
๐ฏ ์์ 7: ์์ ํ ๋ฌธ์์ด ํฌ๋งทํ
๋ฒํผ ์ค๋ฒํ๋ก์ฐ๋ฅผ ๋ฐฉ์งํ๋ ์์ ํ ๋ฌธ์์ด ํฌ๋งทํ ํจ์:#include <stdio.h>
#include <stdarg.h>
#include <string.h>
int safe_sprintf(char* buffer, size_t size, const char* format, ...) {
if (buffer == NULL || size == 0) {
return -1;
}
va_list args;
va_start(args, format);
// vsnprintf๋ ๋ฒํผ ํฌ๊ธฐ๋ฅผ ์ฒดํฌํด์ค
int result = vsnprintf(buffer, size, format, args);
va_end(args);
// ๋ฒํผ๊ฐ ์ถฉ๋ถํ๋์ง ํ์ธ
if (result < 0 || (size_t)result >= size) {
buffer[size - 1] = '\0'; // null ์ข
๋ฃ ๋ณด์ฅ
return -1; // ๋ฒํผ ๋ถ์กฑ
}
return result;
}
int main() {
char buffer[50];
int len = safe_sprintf(buffer, sizeof(buffer),
"์ด๋ฆ: %s, ๋์ด: %d", "ํ๊ธธ๋", 25);
if (len >= 0) {
printf("์ฑ๊ณต: %s (๊ธธ์ด: %d)\n", buffer, len);
} else {
printf("์คํจ: ๋ฒํผ๊ฐ ๋ถ์กฑํฉ๋๋ค\n");
}
// ๋ฒํผ ์ค๋ฒํ๋ก์ฐ ํ
์คํธ
len = safe_sprintf(buffer, sizeof(buffer),
"์์ฃผ ๊ธด ๋ฌธ์์ด์
๋๋ค. %s %s %s %s",
"ํ
์คํธ", "ํ
์คํธ", "ํ
์คํธ", "ํ
์คํธํ
์คํธํ
์คํธ");
if (len < 0) {
printf("๋ฒํผ ๋ถ์กฑ ๊ฐ์ง๋จ! ์์ ํ๊ฒ ์ฒ๋ฆฌ๋จ\n");
}
return 0;
}์ด ํจ์๋ ๋ฒํผ ํฌ๊ธฐ๋ฅผ ์ฒดํฌํด์ ์ค๋ฒํ๋ก์ฐ๋ฅผ ๋ฐฉ์งํด. ์ค๋ฌด์์ ์ ๋ง ์ค์ํ ํจํด์ด์ผ! ๐ก๏ธ
๐ฏ ์์ 8: ๋์ SQL ์ฟผ๋ฆฌ ๋น๋
๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฟผ๋ฆฌ๋ฅผ ๋์ ์ผ๋ก ๋ง๋๋ ํจ์ (๊ฐ๋ ์ ์์ ):#include <stdio.h>
#include <stdarg.h>
#include <string.h>
typedef enum {
TYPE_INT,
TYPE_STRING,
TYPE_DOUBLE
} ParamType;
void build_query(char* buffer, size_t size, const char* table,
int param_count, ...) {
va_list args;
va_start(args, param_count);
// ์ฟผ๋ฆฌ ์์
int offset = snprintf(buffer, size, "SELECT * FROM %s WHERE ", table);
for (int i = 0; i < param_count; i++) {
if (i > 0) {
offset += snprintf(buffer + offset, size - offset, " AND ");
}
const char* column = va_arg(args, const char*);
ParamType type = va_arg(args, ParamType);
switch (type) {
case TYPE_INT: {
int value = va_arg(args, int);
offset += snprintf(buffer + offset, size - offset,
"%s = %d", column, value);
break;
}
case TYPE_STRING: {
const char* value = va_arg(args, const char*);
offset += snprintf(buffer + offset, size - offset,
"%s = '%s'", column, value);
break;
}
case TYPE_DOUBLE: {
double value = va_arg(args, double);
offset += snprintf(buffer + offset, size - offset,
"%s = %.2f", column, value);
break;
}
}
}
va_end(args);
}
int main() {
char query[256];
// WHERE age = 25 AND name = 'ํ๊ธธ๋'
build_query(query, sizeof(query), "users", 2,
"age", TYPE_INT, 25,
"name", TYPE_STRING, "ํ๊ธธ๋");
printf("์์ฑ๋ ์ฟผ๋ฆฌ: %s\n", query);
// WHERE price = 99.99 AND category = 'book' AND stock = 10
build_query(query, sizeof(query), "products", 3,
"price", TYPE_DOUBLE, 99.99,
"category", TYPE_STRING, "book",
"stock", TYPE_INT, 10);
printf("์์ฑ๋ ์ฟผ๋ฆฌ: %s\n", query);
return 0;
}์ด ์์ ๋ ํ์ ์ ๋ณด๋ฅผ ํจ๊ป ์ ๋ฌํด์ ์์ ํ๊ฒ ์ฒ๋ฆฌํ๋ ํจํด์ ๋ณด์ฌ์ค. ์ค๋ฌด์์ ์ด๋ฐ ๋ฐฉ์์ ๋ง์ด ์ฌ์ฉํด! ๐
๐ฏ ์์ 9: ์๋ฌ ํธ๋ค๋ง ์์คํ
์๋ฌ ์ฝ๋์ ๋ฉ์์ง๋ฅผ ํจ๊ป ์ฒ๋ฆฌํ๋ ์์คํ :#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
typedef enum {
ERR_NONE = 0,
ERR_FILE_NOT_FOUND,
ERR_INVALID_PARAM,
ERR_OUT_OF_MEMORY,
ERR_NETWORK
} ErrorCode;
typedef struct {
ErrorCode code;
char message[256];
} Error;
Error last_error = {ERR_NONE, ""};
void set_error(ErrorCode code, const char* format, ...) {
last_error.code = code;
va_list args;
va_start(args, format);
vsnprintf(last_error.message, sizeof(last_error.message), format, args);
va_end(args);
}
void print_error() {
if (last_error.code != ERR_NONE) {
printf("์๋ฌ [%d]: %s\n", last_error.code, last_error.message);
}
}
int open_file(const char* filename) {
if (filename == NULL) {
set_error(ERR_INVALID_PARAM, "ํ์ผ๋ช
์ด NULL์
๋๋ค");
return -1;
}
// ํ์ผ ์ด๊ธฐ ์๋ (์๋ฎฌ๋ ์ด์
)
if (filename[0] == '\0') {
set_error(ERR_FILE_NOT_FOUND, "ํ์ผ์ ์ฐพ์ ์ ์์ต๋๋ค: '%s'", filename);
return -1;
}
return 0; // ์ฑ๊ณต
}
void* allocate_memory(size_t size) {
void* ptr = malloc(size);
if (ptr == NULL) {
set_error(ERR_OUT_OF_MEMORY,
"๋ฉ๋ชจ๋ฆฌ ํ ๋น ์คํจ: %zu ๋ฐ์ดํธ ์์ฒญ", size);
}
return ptr;
}
int main() {
// ์๋ฌ ํ
์คํธ 1
if (open_file(NULL) < 0) {
print_error();
}
// ์๋ฌ ํ
์คํธ 2
if (open_file("") < 0) {
print_error();
}
// ์๋ฌ ํ
์คํธ 3
void* ptr = allocate_memory(999999999999UL); // ์์ฒญ ํฐ ํฌ๊ธฐ
if (ptr == NULL) {
print_error();
}
return 0;
}์ด๋ฐ ์๋ฌ ํธ๋ค๋ง ์์คํ ์ ๋๊ท๋ชจ ํ๋ก์ ํธ์์ ์ ๋ง ์ ์ฉํด! ๐ฏ
๐ ๊ณ ๊ธ ๊ธฐ๋ฒ๊ณผ ํจํด
์ด์ ์ข ๋ ๊ณ ๊ธ์ค๋ฌ์ด ๊ธฐ๋ฒ๋ค์ ์์๋ณด์! ์ด๋ฐ ํจํด๋ค์ ์๋ฉด ์ ๋ง ํ๋กํ์ ๋ํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด. ๐๐ฏ ํจํด 1: va_list ์ ๋ฌํ๊ธฐ
๊ฐ๋ณ ์ธ์ ํจ์์์ ๋ค๋ฅธ ๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ํธ์ถํ ๋ va_list๋ฅผ ์ ๋ฌํ ์ ์์ด:#include <stdio.h>
#include <stdarg.h>
// ์ค์ ์์
์ ์ํํ๋ ํจ์
void log_impl(const char* prefix, const char* format, va_list args) {
printf("[%s] ", prefix);
vprintf(format, args);
printf("\n");
}
// ๋ํผ ํจ์๋ค
void log_info(const char* format, ...) {
va_list args;
va_start(args, format);
log_impl("INFO", format, args);
va_end(args);
}
void log_error(const char* format, ...) {
va_list args;
va_start(args, format);
log_impl("ERROR", format, args);
va_end(args);
}
void log_debug(const char* format, ...) {
va_list args;
va_start(args, format);
log_impl("DEBUG", format, args);
va_end(args);
}
int main() {
log_info("์๋ฒ ์์๋จ, ํฌํธ: %d", 8080);
log_error("์ฐ๊ฒฐ ์คํจ: %s", "ํ์์์");
log_debug("๋ณ์ ๊ฐ: x=%d, y=%d", 10, 20);
return 0;
}์ด ํจํด์ ์ฝ๋ ์ค๋ณต์ ์ค์ด๊ณ ์ ์ง๋ณด์๋ฅผ ์ฝ๊ฒ ๋ง๋ค์ด์ค! ๐จ
๐ฏ ํจํด 2: va_copy ํ์ฉํ๊ธฐ
va_list๋ฅผ ๋ ๋ฒ ์ํํด์ผ ํ ๋ va_copy๋ฅผ ์ฌ์ฉํด:#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
char* format_string(const char* format, ...) {
va_list args, args_copy;
va_start(args, format);
// 1๋จ๊ณ: ํ์ํ ๋ฒํผ ํฌ๊ธฐ ๊ณ์ฐ
va_copy(args_copy, args);
int size = vsnprintf(NULL, 0, format, args_copy);
va_end(args_copy);
if (size < 0) {
va_end(args);
return NULL;
}
// 2๋จ๊ณ: ๋ฉ๋ชจ๋ฆฌ ํ ๋น
char* buffer = (char*)malloc(size + 1);
if (buffer == NULL) {
va_end(args);
return NULL;
}
// 3๋จ๊ณ: ์ค์ ํฌ๋งทํ
vsnprintf(buffer, size + 1, format, args);
va_end(args);
return buffer;
}
int main() {
char* str = format_string("์ด๋ฆ: %s, ๋์ด: %d, ์ ์: %.2f",
"๊น์ฒ ์", 25, 95.5);
if (str != NULL) {
printf("์์ฑ๋ ๋ฌธ์์ด: %s\n", str);
free(str);
}
return 0;
}
๐ก ์ va_copy๊ฐ ํ์ํ ๊น?
va_list๋ ํ ๋ฒ ์ํํ๋ฉด ๋๊น์ง ์ด๋ํด๋ฒ๋ ค. ๋ค์ ์ฒ์๋ถํฐ ์ฝ์ผ๋ ค๋ฉด ์๋ก์ด va_list๊ฐ ํ์ํ๋ฐ, ๊ทธ๋ฅ ๋์
ํ๋ฉด ์ ๋๊ณ va_copy๋ฅผ ์ฌ์ฉํด์ผ ํด!
โ ์๋ชป๋ ๋ฐฉ๋ฒ: va_list args2 = args;
โ ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ: va_copy(args2, args);
โ ์๋ชป๋ ๋ฐฉ๋ฒ: va_list args2 = args;
โ ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ: va_copy(args2, args);
๐ฏ ํจํด 3: ํ์ ์์ ์ฑ ํฅ์
ํ์ ์ ๋ณด๋ฅผ ๋ช ์์ ์ผ๋ก ์ ๋ฌํด์ ์์ ์ฑ์ ๋์ด๋ ๋ฐฉ๋ฒ:#include <stdio.h>
#include <stdarg.h>
#include <string.h>
typedef enum {
FMT_END = 0, // ์ข
๋ฃ ํ์
FMT_INT,
FMT_DOUBLE,
FMT_STRING
} FormatType;
void safe_print(const char* prefix, ...) {
va_list args;
va_start(args, prefix);
printf("%s: ", prefix);
FormatType type;
while ((type = va_arg(args, FormatType)) != FMT_END) {
switch (type) {
case FMT_INT: {
int value = va_arg(args, int);
printf("%d ", value);
break;
}
case FMT_DOUBLE: {
double value = va_arg(args, double);
printf("%.2f ", value);
break;
}
case FMT_STRING: {
const char* value = va_arg(args, const char*);
printf("%s ", value);
break;
}
default:
printf("[์ ์ ์๋ ํ์
] ");
break;
}
}
printf("\n");
va_end(args);
}
int main() {
safe_print("๋ฐ์ดํฐ",
FMT_STRING, "์ด๋ฆ:",
FMT_STRING, "ํ๊ธธ๋",
FMT_STRING, "๋์ด:",
FMT_INT, 30,
FMT_STRING, "ํค:",
FMT_DOUBLE, 175.5,
FMT_END); // ์ข
๋ฃ ํ์
safe_print("์ ์",
FMT_INT, 95,
FMT_INT, 87,
FMT_INT, 92,
FMT_END);
return 0;
}์ด ๋ฐฉ๋ฒ์ ํ์ ์ ๋ณด๋ฅผ ํจ๊ป ์ ๋ฌํด์ ์ค์๋ฅผ ์ค์ฌ์ค! ์ข ๋ ์ฅํฉํ์ง๋ง ์์ ํด. ๐
๐ฏ ํจํด 4: ์ฝ๋ฐฑ ํจ์์ ๊ฒฐํฉ
๊ฐ๋ณ ์ธ์์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๊ฒฐํฉํ๋ฉด ์ ๋ง ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ๋ง๋ค ์ ์์ด:#include <stdio.h>
#include <stdarg.h>
typedef void (*Callback)(int value);
void for_each_int(Callback callback, int count, ...) {
va_list args;
va_start(args, count);
for (int i = 0; i < count; i++) {
int value = va_arg(args, int);
callback(value); // ์ฝ๋ฐฑ ํธ์ถ
}
va_end(args);
}
// ์ฝ๋ฐฑ ํจ์๋ค
void print_value(int value) {
printf("%d ", value);
}
void print_square(int value) {
printf("%d ", value * value);
}
void print_double(int value) {
printf("%d ", value * 2);
}
int main() {
printf("์๋ณธ ๊ฐ: ");
for_each_int(print_value, 5, 1, 2, 3, 4, 5);
printf("\n");
printf("์ ๊ณฑ ๊ฐ: ");
for_each_int(print_square, 5, 1, 2, 3, 4, 5);
printf("\n");
printf("2๋ฐฐ ๊ฐ: ");
for_each_int(print_double, 5, 1, 2, 3, 4, 5);
printf("\n");
return 0;
}์ฝ๋ฐฑ๊ณผ ๊ฐ๋ณ ์ธ์๋ฅผ ์กฐํฉํ๋ฉด ์ ๋ง ์ ์ฐํ API๋ฅผ ๋ง๋ค ์ ์์ด! ๐ช
๐ฌ ๋ด๋ถ ๋์ ์๋ฆฌ ์ดํดํ๊ธฐ
๊ฐ๋ณ ์ธ์ ํจ์๊ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง ๋ด๋ถ๋ฅผ ๋ค์ฌ๋ค๋ณด๋ฉด ๋ ๊น์ด ์ดํดํ ์ ์์ด. ๐ง๐ ์คํ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
ํจ์๊ฐ ํธ์ถ๋ ๋ ์ธ์๋ค์ ์คํ์ ์์ฌ. ๊ฐ๋ณ ์ธ์๋ ๋ง์ฐฌ๊ฐ์ง์ผ:// ํจ์ ํธ์ถ: sum(3, 10, 20, 30)
์คํ ๊ตฌ์กฐ (์์์ ์๋๋ก):
โโโโโโโโโโโโโโโ
โ 30 โ โ ์ธ ๋ฒ์งธ ๊ฐ๋ณ ์ธ์
โโโโโโโโโโโโโโโค
โ 20 โ โ ๋ ๋ฒ์งธ ๊ฐ๋ณ ์ธ์
โโโโโโโโโโโโโโโค
โ 10 โ โ ์ฒซ ๋ฒ์งธ ๊ฐ๋ณ ์ธ์
โโโโโโโโโโโโโโโค
โ 3 โ โ count (๊ณ ์ ๋งค๊ฐ๋ณ์)
โโโโโโโโโโโโโโโค
โ ๋ฐํ ์ฃผ์ โ
โโโโโโโโโโโโโโโva_start๋ ๊ณ ์ ๋งค๊ฐ๋ณ์์ ์ฃผ์๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ฐ๋ณ ์ธ์์ ์์ ์์น๋ฅผ ๊ณ์ฐํด. ๊ทธ๋์ ์ต์ ํ๋์ ๊ณ ์ ๋งค๊ฐ๋ณ์๊ฐ ํ์ํ ๊ฑฐ์ผ! ๐ฏ
๐ ๋งคํฌ๋ก์ ์ค์ ๊ตฌํ (๊ฐ๋ ์ )
์ค์ ๊ตฌํ์ ํ๋ซํผ๋ง๋ค ๋ค๋ฅด์ง๋ง, ๊ฐ๋ ์ ์ผ๋ก๋ ์ด๋ ๊ฒ ๋์ํด:// ๊ฐ๋
์ ๊ตฌํ (์ค์ ์ ๋ค๋ฅผ ์ ์์)
typedef char* va_list;
#define va_start(ap, last) \
(ap = (va_list)&last + sizeof(last))
#define va_arg(ap, type) \
(*(type*)((ap += sizeof(type)) - sizeof(type)))
#define va_end(ap) \
(ap = NULL)
โ ๏ธ ์ฃผ์
์ด๊ฑด ๋จ์ํ๋ ๊ฐ๋
์ ์ค๋ช
์ด์ผ! ์ค์ ๊ตฌํ์ ํจ์ฌ ๋ณต์กํ๊ณ ํ๋ซํผ ์์กด์ ์ด์ผ. ์ ๋๋ก ์ง์ ๊ตฌํํ๋ ค๊ณ ํ์ง ๋ง! ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํด์ผ ํด.
๐ฏ ์ ํ์ ์ ๋ณด๊ฐ ์์๊น?
C์ธ์ด์ ๊ฐ๋ณ ์ธ์ ์์คํ ์ ํ์ ์ ๋ณด๋ฅผ ์ ์ฅํ์ง ์์. ์ด๊ฒ ์ฅ์ ์ด์ ๋จ์ ์ด์ผ:์ฅ์ :
โข ์ค๋ฒํค๋๊ฐ ์ ์ (๋ฉ๋ชจ๋ฆฌ, ์ฑ๋ฅ)
โข ๋จ์ํ๊ณ ๋น ๋ฆ
โข ์ ์ฐ์ฑ์ด ๋์
๋จ์ :
โข ํ์ ์์ ์ฑ์ด ์์
โข ๋ฐํ์ ์๋ฌ ๊ฐ๋ฅ์ฑ
โข ๋๋ฒ๊น ์ด ์ด๋ ค์
๊ทธ๋์ C++์์๋ ํ ํ๋ฆฟ๊ณผ ๊ฐ๋ณ ํ ํ๋ฆฟ(variadic templates)์ ๋์ ํด์ ํ์ ์์ ์ฑ์ ์ ๊ณตํ์ง! ๐
๐ ์ค๋ฌด ํ์ฉ ํ๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค
์ค์ ํ๋ก์ ํธ์์ ๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ์ฌ์ฉํ ๋ ์์๋๋ฉด ์ข์ ํ๋ค์ ์ ๋ฆฌํด๋ณผ๊ฒ! ๐ผโ ๋ฒ ์คํธ ํ๋ํฐ์ค
1๏ธโฃ ๋ช ํํ ์ธํฐํ์ด์ค ์ค๊ณ// โ ๋์ ์: ๋ถ๋ช
ํํจ
void process(...);
// โ
์ข์ ์: ๋ช
ํํ ์๋
void log_message(LogLevel level, const char* format, ...);
void sum_integers(int count, ...);
void format_string(char* buffer, size_t size, const char* format, ...);2๏ธโฃ ๋ฌธ์ํ ์ฒ ์ ํ
/**
* ์ฌ๋ฌ ์ ์์ ํฉ์ ๊ณ์ฐํฉ๋๋ค.
*
* @param count ์ธ์์ ๊ฐ์
* @param ... int ํ์
์ ๊ฐ๋ณ ์ธ์๋ค
* @return ๋ชจ๋ ์ธ์์ ํฉ
*
* ์์ :
* int result = sum(3, 10, 20, 30); // result = 60
*
* ์ฃผ์:
* - count๋ ์ค์ ์ ๋ฌ๋ ์ธ์ ๊ฐ์์ ์ผ์นํด์ผ ํจ
* - ๋ชจ๋ ๊ฐ๋ณ ์ธ์๋ int ํ์
์ด์ด์ผ ํจ
*/
int sum(int count, ...);3๏ธโฃ ์๋ฌ ์ฒ๋ฆฌ ๊ตฌํ
int safe_sum(int count, ...) {
if (count < 0) {
fprintf(stderr, "์๋ฌ: count๋ 0 ์ด์์ด์ด์ผ ํฉ๋๋ค\n");
return 0;
}
if (count > 100) {
fprintf(stderr, "๊ฒฝ๊ณ : ๋๋ฌด ๋ง์ ์ธ์ (%d๊ฐ)\n", count);
}
va_list args;
va_start(args, count);
int sum = 0;
for (int i = 0; i < count; i++) {
sum += va_arg(args, int);
}
va_end(args);
return sum;
}4๏ธโฃ ๋ํผ ํจ์ ์ ๊ณต
์ฌ์ฉ์ ํธ์๋ฅผ ์ํด ํ์ ๋ณ ๋ํผ ํจ์๋ฅผ ์ ๊ณตํ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ:
// ๋ด๋ถ ๊ตฌํ
void log_impl(const char* level, const char* format, va_list args);
// ์ฌ์ฉ์์ฉ ๋ํผ๋ค
void log_info(const char* format, ...) {
va_list args;
va_start(args, format);
log_impl("INFO", format, args);
va_end(args);
}
void log_error(const char* format, ...) {
va_list args;
va_start(args, format);
log_impl("ERROR", format, args);
va_end(args);
}5๏ธโฃ ๋งคํฌ๋ก ํ์ฉ
๋ฐ๋ณต์ ์ธ ํจํด์ ๋งคํฌ๋ก๋ก ๋จ์ํํ ์ ์์ด:
#define LOG_FUNCTION(name, level) \
void log_##name(const char* format, ...) { \
va_list args; \
va_start(args, format); \
log_impl(level, format, args); \
va_end(args); \
}
LOG_FUNCTION(info, "INFO")
LOG_FUNCTION(warning, "WARNING")
LOG_FUNCTION(error, "ERROR")
LOG_FUNCTION(debug, "DEBUG")โก ์ฑ๋ฅ ์ต์ ํ ํ
1๏ธโฃ ๋ถํ์ํ va_copy ํผํ๊ธฐva_copy๋ ์ค๋ฒํค๋๊ฐ ์์ผ๋ ๊ผญ ํ์ํ ๋๋ง ์ฌ์ฉํด:
// โ ๋ถํ์ํ ๋ณต์ฌ
void func(int count, ...) {
va_list args, args_copy;
va_start(args, count);
va_copy(args_copy, args); // ํ ๋ฒ๋ง ์ํํ ๊ฑฐ๋ฉด ๋ถํ์
// args_copy ์ฌ์ฉ...
va_end(args_copy);
va_end(args);
}
// โ
ํ์ํ ๋๋ง
void func(int count, ...) {
va_list args;
va_start(args, count);
// args ์ง์ ์ฌ์ฉ
va_end(args);
}2๏ธโฃ ์คํ ๋ฒํผ ํ์ฉ
์์ ๋ฌธ์์ด์ ์คํ ๋ฒํผ๋ฅผ ์ฌ์ฉํด์ ๋์ ํ ๋น์ ํผํด:
void format_message(const char* format, ...) {
char buffer[256]; // ์คํ ๋ฒํผ
va_list args;
va_start(args, format);
int size = vsnprintf(buffer, sizeof(buffer), format, args);
if (size >= sizeof(buffer)) {
// ๋ฒํผ๊ฐ ๋ถ์กฑํ๋ฉด ๋์ ํ ๋น
char* large_buffer = malloc(size + 1);
if (large_buffer) {
va_list args_copy;
va_copy(args_copy, args);
vsnprintf(large_buffer, size + 1, format, args_copy);
va_end(args_copy);
// large_buffer ์ฌ์ฉ...
free(large_buffer);
}
} else {
// buffer ์ฌ์ฉ...
}
va_end(args);
}3๏ธโฃ ์ธ๋ผ์ธ ํจ์ ๊ณ ๋ ค
์๊ณ ์์ฃผ ํธ์ถ๋๋ ๊ฐ๋ณ ์ธ์ ํจ์๋ ์ธ๋ผ์ธ์ผ๋ก ๋ง๋ค ์ ์์ด:
static inline void debug_print(const char* format, ...) {
#ifdef DEBUG
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
#endif
}
๐ ๋์ ๊ธฐ์ ๋น๊ต
๊ฐ๋ณ ์ธ์ ํจ์ ๋ง๊ณ ๋ ๋น์ทํ ๊ธฐ๋ฅ์ ๊ตฌํํ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ค์ด ์์ด. ๊ฐ๊ฐ์ ์ฅ๋จ์ ์ ๋น๊ตํด๋ณด์! ๐ค๐ ๋ฐฉ๋ฒ ๋น๊ต
| ๋ฐฉ๋ฒ | ์ฅ์ | ๋จ์ | ์ฌ์ฉ ์๊ธฐ |
|---|---|---|---|
| ๊ฐ๋ณ ์ธ์ | โข ์ ์ฐํจ โข ํ์ค ๊ธฐ๋ฅ โข ๊ฐ๊ฒฐํ ํธ์ถ |
โข ํ์
์์ ์ฑ ์์ โข ๋๋ฒ๊น ์ด๋ ค์ โข ์๋ฌ ๊ฐ๋ฅ์ฑ |
printf ๊ฐ์ ๋ฒ์ฉ ํจ์ |
| ๋ฐฐ์ด ์ ๋ฌ | โข ํ์
์์ โข ๋ช ํํจ โข ๋๋ฒ๊น ์ฌ์ |
โข ๋ฐฐ์ด ์์ฑ ํ์ โข ํธ์ถ์ด ์ฅํฉํจ |
๊ฐ์ ํ์ ๋ค์ ์ฒ๋ฆฌ |
| ๊ตฌ์กฐ์ฒด | โข ํ์
์์ โข ๋ช ํํ ์๋ฏธ โข ํ์ฅ ์ฉ์ด |
โข ๊ตฌ์กฐ์ฒด ์ ์ ํ์ โข ๋ฉ๋ชจ๋ฆฌ ์ค๋ฒํค๋ |
๋ณต์กํ ์ต์ ์ ๋ฌ |
| ํจ์ ์ค๋ฒ๋ก๋ฉ (C++) |
โข ํ์
์์ โข ์ปดํ์ผ ํ์ ์ฒดํฌ |
โข C์์ ๋ถ๊ฐ โข ํจ์ ๊ฐ์ ์ฆ๊ฐ |
C++ ํ๋ก์ ํธ |
| ๊ฐ๋ณ ํ
ํ๋ฆฟ (C++11) |
โข ์๋ฒฝํ ํ์
์์ โข ์ฑ๋ฅ ์ต์ ํ |
โข C์์ ๋ถ๊ฐ โข ๋ณต์กํ ๋ฌธ๋ฒ |
ํ๋ C++ ํ๋ก์ ํธ |
๐ฏ ์์ ๋ก ๋น๊ตํ๊ธฐ
๊ฐ์ ๊ธฐ๋ฅ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํด๋ณด์:๋ฐฉ๋ฒ 1: ๊ฐ๋ณ ์ธ์
int sum(int count, ...) {
va_list args;
va_start(args, count);
int total = 0;
for (int i = 0; i < count; i++) {
total += va_arg(args, int);
}
va_end(args);
return total;
}
// ์ฌ์ฉ
int result = sum(3, 10, 20, 30);๋ฐฉ๋ฒ 2: ๋ฐฐ์ด ์ ๋ฌ
int sum_array(const int* values, int count) {
int total = 0;
for (int i = 0; i < count; i++) {
total += values[i];
}
return total;
}
// ์ฌ์ฉ
int values[] = {10, 20, 30};
int result = sum_array(values, 3);๋ฐฉ๋ฒ 3: ๊ตฌ์กฐ์ฒด
typedef struct {
int* values;
int count;
} IntArray;
int sum_struct(IntArray arr) {
int total = 0;
for (int i = 0; i < arr.count; i++) {
total += arr.values[i];
}
return total;
}
// ์ฌ์ฉ
int values[] = {10, 20, 30};
IntArray arr = {values, 3};
int result = sum_struct(arr);
๐ฏ ์ ํ ๊ฐ์ด๋
๊ฐ๋ณ ์ธ์๋ฅผ ์ฌ์ฉํด์ผ ํ ๋:
โข printf์ฒ๋ผ ๋ค์ํ ํ์ ์ ๋ฐ์์ผ ํ ๋
โข ํธ์ถ ํธ์์ฑ์ด ์ค์ํ ๋
โข ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์คํ์ผ์ ๋ฐ๋ฅผ ๋
๋ฐฐ์ด์ ์ฌ์ฉํด์ผ ํ ๋:
โข ๊ฐ์ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๋ง์ด ์ฒ๋ฆฌํ ๋
โข ํ์ ์์ ์ฑ์ด ์ค์ํ ๋
โข ๋ฐฐ์ด์ ์ด๋ฏธ ๊ฐ์ง๊ณ ์์ ๋
๊ตฌ์กฐ์ฒด๋ฅผ ์ฌ์ฉํด์ผ ํ ๋:
โข ๋ณต์กํ ์ต์ ์ด๋ ์ค์ ์ ์ ๋ฌํ ๋
โข ๋ช ํํ ์ธํฐํ์ด์ค๊ฐ ํ์ํ ๋
โข ํ์ฅ ๊ฐ๋ฅ์ฑ์ด ์ค์ํ ๋
โข printf์ฒ๋ผ ๋ค์ํ ํ์ ์ ๋ฐ์์ผ ํ ๋
โข ํธ์ถ ํธ์์ฑ์ด ์ค์ํ ๋
โข ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์คํ์ผ์ ๋ฐ๋ฅผ ๋
๋ฐฐ์ด์ ์ฌ์ฉํด์ผ ํ ๋:
โข ๊ฐ์ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๋ง์ด ์ฒ๋ฆฌํ ๋
โข ํ์ ์์ ์ฑ์ด ์ค์ํ ๋
โข ๋ฐฐ์ด์ ์ด๋ฏธ ๊ฐ์ง๊ณ ์์ ๋
๊ตฌ์กฐ์ฒด๋ฅผ ์ฌ์ฉํด์ผ ํ ๋:
โข ๋ณต์กํ ์ต์ ์ด๋ ์ค์ ์ ์ ๋ฌํ ๋
โข ๋ช ํํ ์ธํฐํ์ด์ค๊ฐ ํ์ํ ๋
โข ํ์ฅ ๊ฐ๋ฅ์ฑ์ด ์ค์ํ ๋
๐ ๋๋ฒ๊น ๊ณผ ํ ์คํธ
๊ฐ๋ณ ์ธ์ ํจ์๋ ๋๋ฒ๊น ์ด ๊น๋ค๋ก์. ํจ๊ณผ์ ์ธ ๋๋ฒ๊น ๋ฐฉ๋ฒ์ ์์๋ณด์! ๐๐ฏ ๋๋ฒ๊น ๊ธฐ๋ฒ
1๏ธโฃ ๋ก๊น ์ถ๊ฐ#include <stdio.h>
#include <stdarg.h>
#define DEBUG_VARARGS 1
int sum_debug(int count, ...) {
#if DEBUG_VARARGS
printf("[DEBUG] sum_debug ํธ์ถ: count=%d\n", count);
#endif
va_list args;
va_start(args, count);
int total = 0;
for (int i = 0; i < count; i++) {
int value = va_arg(args, int);
#if DEBUG_VARARGS
printf("[DEBUG] arg[%d] = %d\n", i, value);
#endif
total += value;
}
va_end(args);
#if DEBUG_VARARGS
printf("[DEBUG] ๊ฒฐ๊ณผ: %d\n", total);
#endif
return total;
}2๏ธโฃ ์ธ์ ๊ฒ์ฆ
void validate_and_print(const char* format, ...) {
if (format == NULL) {
fprintf(stderr, "์๋ฌ: format์ด NULL์
๋๋ค\n");
return;
}
// ํฌ๋งท ๋ฌธ์์ด ๊ฒ์ฆ
int percent_count = 0;
for (const char* p = format; *p; p++) {
if (*p == '%' && *(p+1) != '%') {
percent_count++;
}
}
printf("ํฌ๋งท ์ง์ ์ ๊ฐ์: %d\n", percent_count);
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
}3๏ธโฃ ๋จ์ ํ ์คํธ
#include <assert.h>
void test_sum() {
// ๊ธฐ๋ณธ ํ
์คํธ
assert(sum(2, 10, 20) == 30);
assert(sum(3, 1, 2, 3) == 6);
// ๊ฒฝ๊ณ ์กฐ๊ฑด
assert(sum(0) == 0);
assert(sum(1, 100) == 100);
// ์์ ํ
์คํธ
assert(sum(2, -10, 10) == 0);
assert(sum(3, -5, -10, -15) == -30);
printf("๋ชจ๋ ํ
์คํธ ํต๊ณผ!\n");
}
int main() {
test_sum();
return 0;
}๐ ์ผ๋ฐ์ ์ธ ๋ฒ๊ทธ์ ํด๊ฒฐ์ฑ
๋ฒ๊ทธ 1: ์ธ์ ๊ฐ์ ๋ถ์ผ์น// โ ๋ฒ๊ทธ
sum(3, 10, 20); // 3๊ฐ๋ผ๊ณ ํ๋๋ฐ 2๊ฐ๋ง ์ ๋ฌ!
// ํด๊ฒฐ์ฑ
: ๋งคํฌ๋ก๋ก ์๋ ๊ณ์ฐ
#define SUM(...) sum(COUNT_ARGS(__VA_ARGS__), __VA_ARGS__)
#define COUNT_ARGS(...) (sizeof((int[]){__VA_ARGS__})/sizeof(int))๋ฒ๊ทธ 2: ํ์ ๋ถ์ผ์น
// โ ๋ฒ๊ทธ
sum(2, 10.5, 20.3); // double์ int๋ก ์ฝ์!
// ํด๊ฒฐ์ฑ
: ํ์
๋ณ ํจ์ ์ ๊ณต
int sum_int(int count, ...);
double sum_double(int count, ...);๋ฒ๊ทธ 3: va_end ๋๋ฝ
// โ ๋ฒ๊ทธ
int buggy_sum(int count, ...) {
va_list args;
va_start(args, count);
if (count <= 0) {
return 0; // va_end ๋๋ฝ!
}
// ...
va_end(args);
return total;
}
// โ
์์
int fixed_sum(int count, ...) {
va_list args;
va_start(args, count);
if (count <= 0) {
va_end(args); // ์ถ๊ฐ!
return 0;
}
// ...
va_end(args);
return total;
}
๐ ์ค์ ํ๋ก์ ํธ ์์
์ด์ ๋ฐฐ์ด ๋ด์ฉ์ ์ข ํฉํด์ ์ค์ ์์ ์ฌ์ฉํ ์ ์๋ ์์ ํ ์์ ๋ฅผ ๋ง๋ค์ด๋ณด์! ๐จ๐ฏ ํ๋ก์ ํธ: ๊ฐ๋จํ ํ ์คํธ ํ๋ ์์ํฌ
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdbool.h>
// ํ
์คํธ ํต๊ณ
typedef struct {
int total;
int passed;
int failed;
} TestStats;
static TestStats stats = {0, 0, 0};
// ํ
์คํธ ๊ฒฐ๊ณผ ์ถ๋ ฅ
void test_result(bool passed, const char* format, ...) {
stats.total++;
if (passed) {
stats.passed++;
printf("โ
PASS: ");
} else {
stats.failed++;
printf("โ FAIL: ");
}
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
printf("\n");
}
// ์ ์ ๋น๊ต ํ
์คํธ
void assert_int_equals(int expected, int actual, const char* format, ...) {
bool passed = (expected == actual);
printf(" ");
if (passed) {
printf("โ
");
} else {
printf("โ ");
}
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
if (!passed) {
printf(" (๊ธฐ๋๊ฐ: %d, ์ค์ ๊ฐ: %d)", expected, actual);
}
printf("\n");
stats.total++;
if (passed) {
stats.passed++;
} else {
stats.failed++;
}
}
// ๋ฌธ์์ด ๋น๊ต ํ
์คํธ
void assert_string_equals(const char* expected, const char* actual,
const char* format, ...) {
bool passed = (strcmp(expected, actual) == 0);
printf(" ");
if (passed) {
printf("โ
");
} else {
printf("โ ");
}
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
if (!passed) {
printf(" (๊ธฐ๋๊ฐ: \"%s\", ์ค์ ๊ฐ: \"%s\")", expected, actual);
}
printf("\n");
stats.total++;
if (passed) {
stats.passed++;
} else {
stats.failed++;
}
}
// ํ
์คํธ ๊ทธ๋ฃน ์์
void test_group(const char* format, ...) {
printf("\n");
printf("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n");
printf("๐ ");
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
printf("\n");
printf("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n");
}
// ์ต์ข
๊ฒฐ๊ณผ ์ถ๋ ฅ
void test_summary() {
printf("\n");
printf("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n");
printf("๐ ํ
์คํธ ๊ฒฐ๊ณผ ์์ฝ\n");
printf("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n");
printf("์ ์ฒด: %d๊ฐ\n", stats.total);
printf("์ฑ๊ณต: %d๊ฐ โ
\n", stats.passed);
printf("์คํจ: %d๊ฐ โ\n", stats.failed);
if (stats.failed == 0) {
printf("\n๐ ๋ชจ๋ ํ
์คํธ ํต๊ณผ!\n");
} else {
printf("\nโ ๏ธ %d๊ฐ์ ํ
์คํธ ์คํจ\n", stats.failed);
}
printf("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n");
}
// ํ
์คํธํ ํจ์๋ค
int add(int a, int b) {
return a + b;
}
int multiply(int a, int b) {
return a * b;
}
// ๋ฉ์ธ ํ
์คํธ
int main() {
printf("๐ ํ
์คํธ ํ๋ ์์ํฌ ์์\n");
// ๋ง์
ํ
์คํธ
test_group("๋ง์
ํจ์ ํ
์คํธ");
assert_int_equals(30, add(10, 20), "10 + 20 = 30");
assert_int_equals(0, add(-5, 5), "-5 + 5 = 0");
assert_int_equals(-10, add(-5, -5), "-5 + -5 = -10");
// ๊ณฑ์
ํ
์คํธ
test_group("๊ณฑ์
ํจ์ ํ
์คํธ");
assert_int_equals(200, multiply(10, 20), "10 ร 20 = 200");
assert_int_equals(0, multiply(0, 100), "0 ร 100 = 0");
assert_int_equals(-50, multiply(-5, 10), "-5 ร 10 = -50");
// ๋ฌธ์์ด ํ
์คํธ
test_group("๋ฌธ์์ด ํ
์คํธ");
assert_string_equals("hello", "hello", "๋ฌธ์์ด ๋์ผ์ฑ");
assert_string_equals("test", "test", "๋ฌธ์์ด ๋น๊ต");
// ์ต์ข
๊ฒฐ๊ณผ
test_summary();
return (stats.failed == 0) ? 0 : 1;
}์ด ํ ์คํธ ํ๋ ์์ํฌ๋ ๊ฐ๋ณ ์ธ์๋ฅผ ํ์ฉํด์ ์ ์ฐํ๊ณ ์ฌ์ฉํ๊ธฐ ํธํ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํด! ์ค์ ํ๋ก์ ํธ์์ ์ด๋ฐ ํจํด์ ๋ง์ด ์ฌ์ฉํ๊ฑฐ๋ . ๐
๐ก ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง ๊ฐ๋ณ ์ธ์ ํจ์์ ๋ํด ์ ๋ง ๊น์ด ์๊ฒ ์์๋ดค์ด! ๐๊ฐ๋ณ ์ธ์ ํจ์๋ C์ธ์ด์ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ด์ง๋ง, ์กฐ์ฌํด์ ์ฌ์ฉํด์ผ ํด. ํ์ ์์ ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ ์ค์ํ๊ธฐ ์ฝ๊ฑฐ๋ . ํ์ง๋ง ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ฉด ์ ๋ง ์ ์ฐํ๊ณ ํธ๋ฆฌํ API๋ฅผ ๋ง๋ค ์ ์์ด!
๐ฏ ํต์ฌ ์์ฝ
1. ๊ธฐ๋ณธ ๊ฐ๋
โข ... ๋ฌธ๋ฒ์ผ๋ก ๊ฐ๋ณ ์ธ์ ์ ์ธ
โข stdarg.h ํค๋ ํ์
โข ์ต์ ํ๋์ ๊ณ ์ ๋งค๊ฐ๋ณ์ ํ์
2. ํต์ฌ ๋งคํฌ๋ก
โข va_list: ๊ฐ๋ณ ์ธ์ ๋ชฉ๋ก ํ์
โข va_start: ์ด๊ธฐํ
โข va_arg: ์ธ์ ์ฝ๊ธฐ
โข va_end: ์ ๋ฆฌ
โข va_copy: ๋ณต์ฌ
3. ์ฃผ์์ฌํญ
โข ํ์ ์น๊ฒฉ ๊ท์น ์ดํด
โข ์ธ์ ๊ฐ์ ์ถ์ ๋ฉ์ปค๋์ฆ ํ์
โข va_end ๋ฐ๋์ ํธ์ถ
โข ํ์ ๋ถ์ผ์น ์ฃผ์
4. ์ค์ ํ
โข ๋ช ํํ ๋ฌธ์ํ
โข ์๋ฌ ์ฒ๋ฆฌ ๊ตฌํ
โข ๋ํผ ํจ์ ์ ๊ณต
โข ๋์ ๊ธฐ์ ๊ณ ๋ ค
ํ๋ก๊ทธ๋๋ฐ์ ๋ฐฐ์ฐ๋ค ๋ณด๋ฉด ์ด๋ฐ ๊ณ ๊ธ ๊ธฐ๋ฅ๋ค์ด ์ฒ์์ ์ด๋ ต๊ฒ ๋๊ปด์ง ์ ์์ด. ํ์ง๋ง ์ง์ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์คํํด๋ณด๋ฉด์ ์ต์ํด์ง๋ฉด, ์ ๋ง ๊ฐ๋ ฅํ ๋๊ตฌ๊ฐ ๋ ๊ฑฐ์ผ! ๐ชโข ... ๋ฌธ๋ฒ์ผ๋ก ๊ฐ๋ณ ์ธ์ ์ ์ธ
โข stdarg.h ํค๋ ํ์
โข ์ต์ ํ๋์ ๊ณ ์ ๋งค๊ฐ๋ณ์ ํ์
2. ํต์ฌ ๋งคํฌ๋ก
โข va_list: ๊ฐ๋ณ ์ธ์ ๋ชฉ๋ก ํ์
โข va_start: ์ด๊ธฐํ
โข va_arg: ์ธ์ ์ฝ๊ธฐ
โข va_end: ์ ๋ฆฌ
โข va_copy: ๋ณต์ฌ
3. ์ฃผ์์ฌํญ
โข ํ์ ์น๊ฒฉ ๊ท์น ์ดํด
โข ์ธ์ ๊ฐ์ ์ถ์ ๋ฉ์ปค๋์ฆ ํ์
โข va_end ๋ฐ๋์ ํธ์ถ
โข ํ์ ๋ถ์ผ์น ์ฃผ์
4. ์ค์ ํ
โข ๋ช ํํ ๋ฌธ์ํ
โข ์๋ฌ ์ฒ๋ฆฌ ๊ตฌํ
โข ๋ํผ ํจ์ ์ ๊ณต
โข ๋์ ๊ธฐ์ ๊ณ ๋ ค
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์ง์์ ๋๋๊ณ , ์ค์ ํ๋ก์ ํธ์ ์ฐธ์ฌํ๋ฉด์ ์ค๋ ฅ์ ํค์๋๊ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ. ํจ๊ป ์ฑ์ฅํ๋ ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์์ ๋ง์ ๊ฒ์ ๋ฐฐ์ธ ์ ์๊ฑฐ๋ ! ๐ฑ
์ด ๊ธ์ด ๊ฐ๋ณ ์ธ์ ํจ์๋ฅผ ์ดํดํ๋ ๋ฐ ๋์์ด ๋์๊ธธ ๋ฐ๋ผ! ๊ถ๊ธํ ์ ์ด ์๊ฑฐ๋ ๋ ์๊ณ ์ถ์ ๋ด์ฉ์ด ์๋ค๋ฉด, ์ง์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด๋ฉด์ ์คํํด๋ณด๋ ๊ฑธ ์ถ์ฒํด. ๊ทธ๊ฒ ๊ฐ์ฅ ๋น ๋ฅธ ํ์ต ๋ฐฉ๋ฒ์ด๋๊น! ๐
ํ๋ณตํ ์ฝ๋ฉ ๋๊ธธ ๋ฐ๋๊ฒ! ํ์ดํ ! ๐ปโจ
๐ ์ด ๊ธ์ด ๋์์ด ๋์๋ค๋ฉด, ์ฌ๋ฅ๋ท์์ ๋ ๋ง์ ํ๋ก๊ทธ๋๋ฐ ์ง์์ ํํํด๋ณด์ธ์!
ํจ๊ป ์ฑ์ฅํ๋ ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ๊ฐ ์ฌ๋ฌ๋ถ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ต๋๋ค. ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
๋๊ธ์ ๋ถ๋ฌ์ค๋ ์ค์
๋๋ค.
๋๊ธ์ ๋ถ๋ฌ์ค์ง ๋ชปํ์ต๋๋ค. ์ฐ๊ฒฐ ์ํ๋ฅผ ํ์ธํ๊ณ ๋ค์ ์๋ํด ์ฃผ์ธ์.
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.