์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐ŸŽฏ ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜ ๊ตฌํ˜„ํ•˜๊ธฐ

๐ŸŽฏ ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜ ๊ตฌํ˜„ํ•˜๊ธฐ

printf์ฒ˜๋Ÿผ ์ธ์ž ๊ฐœ์ˆ˜๊ฐ€ ์ž์œ ๋กœ์šด ํ•จ์ˆ˜, ์ง์ ‘ ๋งŒ๋“ค์–ด๋ณด์ž! ๐Ÿš€

์•ˆ๋…•! ์˜ค๋Š˜์€ C์–ธ์–ด์—์„œ ์ •๋ง ์‹ ๊ธฐํ•˜๊ณ  ์œ ์šฉํ•œ ๊ธฐ๋Šฅ ์ค‘ ํ•˜๋‚˜์ธ ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“œ๋Š” ๋ฐฉ๋ฒ•์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•ด๋ณผ๊ฒŒ. ๐Ÿ˜Š

ํ˜น์‹œ printf() ํ•จ์ˆ˜ ์จ๋ดค์ง€? ๋‹น์—ฐํžˆ ์จ๋ดค๊ฒ ์ง€! ๊ทธ๋Ÿฐ๋ฐ ์ด ํ•จ์ˆ˜๊ฐ€ ์™œ ์‹ ๊ธฐํ•œ์ง€ ์ƒ๊ฐํ•ด๋ณธ ์  ์žˆ์–ด? printf("%d", 10)์ฒ˜๋Ÿผ ์ธ์ž 2๊ฐœ๋ฅผ ๋„ฃ์„ ์ˆ˜๋„ ์žˆ๊ณ , printf("%d %s %f", 10, "hello", 3.14)์ฒ˜๋Ÿผ ์ธ์ž 4๊ฐœ๋ฅผ ๋„ฃ์„ ์ˆ˜๋„ ์žˆ์ž–์•„. ๐Ÿค”

์ผ๋ฐ˜์ ์ธ ํ•จ์ˆ˜๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜ ๊ฐœ์ˆ˜๊ฐ€ ์ •ํ•ด์ ธ ์žˆ๋Š”๋ฐ, ์–ด๋–ป๊ฒŒ ์ด๋Ÿฐ ๋งˆ๋ฒ• ๊ฐ™์€ ์ผ์ด ๊ฐ€๋Šฅํ• ๊นŒ? ๋ฐ”๋กœ ๊ฐ€๋ณ€ ์ธ์ž(Variable Arguments) ๊ธฐ๋Šฅ ๋•๋ถ„์ด์•ผ!

์ด ๊ธ€์—์„œ๋Š” ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜์˜ ์›๋ฆฌ๋ถ€ํ„ฐ ์‹ค์ œ ๊ตฌํ˜„ ๋ฐฉ๋ฒ•, ์ฃผ์˜์‚ฌํ•ญ, ๊ทธ๋ฆฌ๊ณ  ์‹ค๋ฌด์—์„œ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋‹ค์–‘ํ•œ ์˜ˆ์ œ๊นŒ์ง€ ์นœ๊ตฌ์ฒ˜๋Ÿผ ํŽธํ•˜๊ฒŒ ์„ค๋ช…ํ•ด์ค„๊ฒŒ. ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์‹ค๋ ฅ์„ ํ•œ ๋‹จ๊ณ„ ์—…๊ทธ๋ ˆ์ด๋“œํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด, ์žฌ๋Šฅ๋„ท์˜ ์ง€์‹์ธ์˜ ์ˆฒ์—์„œ ์ด๋Ÿฐ ๊นŠ์ด ์žˆ๋Š” ๋‚ด์šฉ๋“ค์„ ๊ณ„์† ํƒํ—˜ํ•ด๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์„ ๊ฑฐ์•ผ! ๐Ÿ’ช
๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜์˜ ์„ธ๊ณ„ ์ผ๋ฐ˜ ํ•จ์ˆ˜ func(a, b, c) ๊ณ ์ •๋œ ์ธ์ž ๊ฐœ์ˆ˜ ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜ func(a, ...) ์ž์œ ๋กœ์šด ์ธ์ž ๊ฐœ์ˆ˜ printf ์˜ˆ์‹œ printf("%d", 10) printf("%d %s", 10, "hi") printf("%d %s %f", ...) stdarg.h va_list va_start va_end ํ•ต์‹ฌ ๋งคํฌ๋กœ๋“ค๋กœ ๊ฐ€๋ณ€ ์ธ์ž๋ฅผ ์ž์œ ์ž์žฌ๋กœ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ์–ด์š”!

๐Ÿ“š ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜๋ž€ ๋ฌด์—‡์ธ๊ฐ€?

๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜๋Š” ๋ง ๊ทธ๋Œ€๋กœ ์ธ์ž์˜ ๊ฐœ์ˆ˜๊ฐ€ ๋ณ€ํ•  ์ˆ˜ ์žˆ๋Š” ํ•จ์ˆ˜๋ฅผ ๋งํ•ด. ์˜์–ด๋กœ๋Š” Variadic Function์ด๋ผ๊ณ  ๋ถ€๋ฅด์ง€. ๐ŸŽ“

์ผ๋ฐ˜์ ์ธ C ํ•จ์ˆ˜๋Š” ์ด๋ ‡๊ฒŒ ์ƒ๊ฒผ์–ด:

int add(int a, int b) {
    return a + b;
}

์ด ํ•จ์ˆ˜๋Š” ๋”ฑ 2๊ฐœ์˜ ์ •์ˆ˜๋งŒ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด. 3๊ฐœ๋ฅผ ๋„ฃ์œผ๋ ค๊ณ  ํ•˜๋ฉด? ์ปดํŒŒ์ผ ์—๋Ÿฌ๊ฐ€ ๋‚˜์ง€! ๐Ÿ˜ฑ

ํ•˜์ง€๋งŒ ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜๋Š” ๋‹ค๋ฅด๊ฒŒ ๋™์ž‘ํ•ด:

int sum(int count, ...) {
    // count ๊ฐœ์ˆ˜๋งŒํผ์˜ ์ธ์ž๋ฅผ ๋ฐ›์•„์„œ ์ฒ˜๋ฆฌ
}

์—ฌ๊ธฐ์„œ ... ์ด ๋ถ€๋ถ„์ด ๋ฐ”๋กœ ๊ฐ€๋ณ€ ์ธ์ž๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ํŠน๋ณ„ํ•œ ๋ฌธ๋ฒ•์ด์•ผ! ์ด ์  ์„ธ ๊ฐœ(ellipsis)๊ฐ€ "์—ฌ๊ธฐ์— ์ถ”๊ฐ€ ์ธ์ž๊ฐ€ ์˜ฌ ์ˆ˜ ์žˆ์–ด์š”"๋ผ๊ณ  ์ปดํŒŒ์ผ๋Ÿฌ์—๊ฒŒ ์•Œ๋ ค์ฃผ๋Š” ๊ฑฐ์ง€. โœจ
๐Ÿ’ก ํ•ต์‹ฌ ํฌ์ธํŠธ โ€ข ๊ฐ€๋ณ€ ์ธ์ž๋Š” ํ•จ์ˆ˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ๋ชฉ๋ก์˜ ๋งˆ์ง€๋ง‰์—๋งŒ ์˜ฌ ์ˆ˜ ์žˆ์–ด
โ€ข ์ตœ์†Œ ํ•˜๋‚˜ ์ด์ƒ์˜ ๊ณ ์ • ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ํ•„์š”ํ•ด
โ€ข ... ๊ธฐํ˜ธ๋กœ ํ‘œ์‹œํ•ด
โ€ข 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_list

va_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_copy

C99 ํ‘œ์ค€๋ถ€ํ„ฐ ์ถ”๊ฐ€๋œ 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: ํ‰๊ท  ๊ณ„์‚ฐ ํ•จ์ˆ˜

์ด๋ฒˆ์—” ํ‰๊ท ์„ ๊ตฌํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž:

#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;
}

์ด ์˜ˆ์ œ์—์„œ๋Š” ์ฒซ ๋ฒˆ์งธ ๊ฐ€๋ณ€ ์ธ์ž๋ฅผ ๋จผ์ € ์ฝ์–ด์„œ ์ดˆ๊ธฐ๊ฐ’์œผ๋กœ ์„ค์ •ํ•œ ๋‹ค์Œ, ๋‚˜๋จธ์ง€์™€ ๋น„๊ตํ•˜๋Š” ๋ฐฉ์‹์„ ์‚ฌ์šฉํ–ˆ์–ด. ์ด๋Ÿฐ ํŒจํ„ด๋„ ์ž์ฃผ ์“ฐ์ด๋‹ˆ๊นŒ ๊ธฐ์–ตํ•ด๋‘๋ฉด ์ข‹์•„! ๐Ÿ“
๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜ ์‹คํ–‰ ํ๋ฆ„ 1. ํ•จ์ˆ˜ ํ˜ธ์ถœ sum(3, 10, 20, 30) 2. va_list ์„ ์–ธ va_list args; 3. va_start ์ดˆ๊ธฐํ™” ๋ฐ ์‹œ์ž‘ 4. va_arg ๋ฐ˜๋ณต ์ธ์ž ํ•˜๋‚˜์”ฉ ์ฝ๊ธฐ 5. va_end ์ •๋ฆฌ ๋ฉ”๋ชจ๋ฆฌ ์Šคํƒ ๊ตฌ์กฐ count = 3 (๊ณ ์ • ์ธ์ž) arg1 = 10 (๊ฐ€๋ณ€ ์ธ์ž) arg2 = 20 (๊ฐ€๋ณ€ ์ธ์ž) arg3 = 30 (๊ฐ€๋ณ€ ์ธ์ž) va_arg ์ฒซ ํ˜ธ์ถœ

๐ŸŽจ ๋‹ค์–‘ํ•œ ํƒ€์ž… ์ฒ˜๋ฆฌํ•˜๊ธฐ

์ง€๊ธˆ๊นŒ์ง€๋Š” ๊ฐ™์€ ํƒ€์ž…์˜ ์ธ์ž๋“ค๋งŒ ๋‹ค๋ค˜๋Š”๋ฐ, ์‹ค์ œ๋กœ๋Š” ์—ฌ๋Ÿฌ ํƒ€์ž…์ด ์„ž์ธ ์ธ์ž๋ฅผ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•  ๋•Œ๊ฐ€ ๋งŽ์•„. ์ด๊ฒŒ ๋ฐ”๋กœ 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)๋กœ ์ฝ์–ด์•ผ ํ•ด!

๐Ÿ” ํƒ€์ž… ์Šน๊ฒฉ(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)
์ด๊ฑด ์ •๋ง ์ค‘์š”ํ•œ ํฌ์ธํŠธ์•ผ! float๋ฅผ ์ „๋‹ฌํ–ˆ๋‹ค๊ณ  va_arg(args, float)๋กœ ์ฝ์œผ๋ฉด ์•ˆ ๋ผ. ๋ฐ˜๋“œ์‹œ 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++์˜ ํ…œํ”Œ๋ฆฟ, ํ•จ์ˆ˜ ์˜ค๋ฒ„๋กœ๋”ฉ ๋“ฑ)

๐Ÿšจ ํ•จ์ • 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 - ํฌ๊ธฐ ์ œํ•œ์ด ์žˆ๋Š” ๋ฌธ์ž์—ด ๋ฒ„ํผ์— ์ถœ๋ ฅ

๐ŸŽฏ ์˜ˆ์ œ 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;
}

์ด๋Ÿฐ ์—๋Ÿฌ ํ•ธ๋“ค๋ง ์‹œ์Šคํ…œ์€ ๋Œ€๊ทœ๋ชจ ํ”„๋กœ์ ํŠธ์—์„œ ์ •๋ง ์œ ์šฉํ•ด! ๐ŸŽฏ
โš ๏ธ ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜ ์ฃผ์˜์‚ฌํ•ญ ์ด์ •๋ฆฌ โŒ ํ•˜์ง€ ๋ง์•„์•ผ ํ•  ๊ฒƒ โ€ข ๊ณ ์ • ๋งค๊ฐœ๋ณ€์ˆ˜ ์—†์ด ์‚ฌ์šฉ โ€ข va_end ํ˜ธ์ถœ ๋ˆ„๋ฝ โ€ข ์ž˜๋ชป๋œ ํƒ€์ž…์œผ๋กœ va_arg ํ˜ธ์ถœ โ€ข ์ธ์ž ๊ฐœ์ˆ˜ ์ดˆ๊ณผ ์ฝ๊ธฐ โ€ข float๋กœ va_arg ํ˜ธ์ถœ โœ… ๋ฐ˜๋“œ์‹œ ํ•ด์•ผ ํ•  ๊ฒƒ โ€ข ์ตœ์†Œ 1๊ฐœ ๊ณ ์ • ๋งค๊ฐœ๋ณ€์ˆ˜ ์„ ์–ธ โ€ข va_start์™€ va_end ์Œ์œผ๋กœ โ€ข ์˜ฌ๋ฐ”๋ฅธ ํƒ€์ž…์œผ๋กœ ์ฝ๊ธฐ โ€ข ์ธ์ž ๊ฐœ์ˆ˜ ์ถ”์  ๋ฉ”์ปค๋‹ˆ์ฆ˜ โ€ข double๋กœ ์‹ค์ˆ˜ ์ฝ๊ธฐ ๐Ÿ’ก ๊ถŒ์žฅ์‚ฌํ•ญ โ€ข ํƒ€์ž… ์•ˆ์ „์„ฑ ๊ณ ๋ ค โ€ข ๋ฌธ์„œํ™” ์ฒ ์ €ํžˆ โ€ข ์—๋Ÿฌ ์ฒ˜๋ฆฌ ๊ตฌํ˜„ โ€ข vprintf ๊ณ„์—ด ํ™œ์šฉ โ€ข ๋ฒ„ํผ ํฌ๊ธฐ ์ฒดํฌ ํƒ€์ž… ์Šน๊ฒฉ ๊ทœ์น™ (๋งค์šฐ ์ค‘์š”!) ์ „๋‹ฌ ์‹œ char โ†’ int short โ†’ int float โ†’ double (์ž๋™ ๋ณ€ํ™˜) ์ฃผ์˜! va_arg ์‚ฌ์šฉ va_arg(args, int) va_arg(args, int) va_arg(args, double) (์Šน๊ฒฉ๋œ ํƒ€์ž…) ์˜ˆ์ œ ์ฝ”๋“œ char c = 'A'; func(1, c); // char ์ „๋‹ฌ // โŒ va_arg(args, char) // โœ… va_arg(args, int)

๐Ÿš€ ๊ณ ๊ธ‰ ๊ธฐ๋ฒ•๊ณผ ํŒจํ„ด

์ด์ œ ์ข€ ๋” ๊ณ ๊ธ‰์Šค๋Ÿฌ์šด ๊ธฐ๋ฒ•๋“ค์„ ์•Œ์•„๋ณด์ž! ์ด๋Ÿฐ ํŒจํ„ด๋“ค์„ ์•Œ๋ฉด ์ •๋ง ํ”„๋กœํŽ˜์…”๋„ํ•œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿ˜Ž

๐ŸŽฏ ํŒจํ„ด 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);

๐ŸŽฏ ํŒจํ„ด 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์ฒ˜๋Ÿผ ๋‹ค์–‘ํ•œ ํƒ€์ž…์„ ๋ฐ›์•„์•ผ ํ•  ๋•Œ
โ€ข ํ˜ธ์ถœ ํŽธ์˜์„ฑ์ด ์ค‘์š”ํ•  ๋•Œ
โ€ข ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์Šคํƒ€์ผ์„ ๋”ฐ๋ฅผ ๋•Œ

๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•ด์•ผ ํ•  ๋•Œ:
โ€ข ๊ฐ™์€ ํƒ€์ž…์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๋งŽ์ด ์ฒ˜๋ฆฌํ•  ๋•Œ
โ€ข ํƒ€์ž… ์•ˆ์ „์„ฑ์ด ์ค‘์š”ํ•  ๋•Œ
โ€ข ๋ฐฐ์—ด์„ ์ด๋ฏธ ๊ฐ€์ง€๊ณ  ์žˆ์„ ๋•Œ

๊ตฌ์กฐ์ฒด๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•  ๋•Œ:
โ€ข ๋ณต์žกํ•œ ์˜ต์…˜์ด๋‚˜ ์„ค์ •์„ ์ „๋‹ฌํ•  ๋•Œ
โ€ข ๋ช…ํ™•ํ•œ ์ธํ„ฐํŽ˜์ด์Šค๊ฐ€ ํ•„์š”ํ•  ๋•Œ
โ€ข ํ™•์žฅ ๊ฐ€๋Šฅ์„ฑ์ด ์ค‘์š”ํ•  ๋•Œ

๐Ÿ› ๋””๋ฒ„๊น…๊ณผ ํ…Œ์ŠคํŠธ

๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜๋Š” ๋””๋ฒ„๊น…์ด ๊นŒ๋‹ค๋กœ์›Œ. ํšจ๊ณผ์ ์ธ ๋””๋ฒ„๊น… ๋ฐฉ๋ฒ•์„ ์•Œ์•„๋ณด์ž! ๐Ÿ”

๐ŸŽฏ ๋””๋ฒ„๊น… ๊ธฐ๋ฒ•

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. ์‹ค์ „ ํŒ
โ€ข ๋ช…ํ™•ํ•œ ๋ฌธ์„œํ™”
โ€ข ์—๋Ÿฌ ์ฒ˜๋ฆฌ ๊ตฌํ˜„
โ€ข ๋ž˜ํผ ํ•จ์ˆ˜ ์ œ๊ณต
โ€ข ๋Œ€์•ˆ ๊ธฐ์ˆ  ๊ณ ๋ ค
ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ๋ฐฐ์šฐ๋‹ค ๋ณด๋ฉด ์ด๋Ÿฐ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ๋“ค์ด ์ฒ˜์Œ์—” ์–ด๋ ต๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์–ด. ํ•˜์ง€๋งŒ ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ณ  ์‹คํ—˜ํ•ด๋ณด๋ฉด์„œ ์ต์ˆ™ํ•ด์ง€๋ฉด, ์ •๋ง ๊ฐ•๋ ฅํ•œ ๋„๊ตฌ๊ฐ€ ๋  ๊ฑฐ์•ผ! ๐Ÿ’ช

์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค๊ณผ ์ง€์‹์„ ๋‚˜๋ˆ„๊ณ , ์‹ค์ „ ํ”„๋กœ์ ํŠธ์— ์ฐธ์—ฌํ•˜๋ฉด์„œ ์‹ค๋ ฅ์„ ํ‚ค์›Œ๋‚˜๊ฐ€๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ํ•จ๊ป˜ ์„ฑ์žฅํ•˜๋Š” ๊ฐœ๋ฐœ์ž ์ปค๋ฎค๋‹ˆํ‹ฐ์—์„œ ๋งŽ์€ ๊ฒƒ์„ ๋ฐฐ์šธ ์ˆ˜ ์žˆ๊ฑฐ๋“ ! ๐ŸŒฑ

์ด ๊ธ€์ด ๊ฐ€๋ณ€ ์ธ์ž ํ•จ์ˆ˜๋ฅผ ์ดํ•ดํ•˜๋Š” ๋ฐ ๋„์›€์ด ๋˜์—ˆ๊ธธ ๋ฐ”๋ผ! ๊ถ๊ธˆํ•œ ์ ์ด ์žˆ๊ฑฐ๋‚˜ ๋” ์•Œ๊ณ  ์‹ถ์€ ๋‚ด์šฉ์ด ์žˆ๋‹ค๋ฉด, ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด๋ฉด์„œ ์‹คํ—˜ํ•ด๋ณด๋Š” ๊ฑธ ์ถ”์ฒœํ•ด. ๊ทธ๊ฒŒ ๊ฐ€์žฅ ๋น ๋ฅธ ํ•™์Šต ๋ฐฉ๋ฒ•์ด๋‹ˆ๊นŒ! ๐Ÿš€

ํ–‰๋ณตํ•œ ์ฝ”๋”ฉ ๋˜๊ธธ ๋ฐ”๋ž„๊ฒŒ! ํ™”์ดํŒ…! ๐Ÿ’ปโœจ

๐ŸŽ“ ์ด ๊ธ€์ด ๋„์›€์ด ๋˜์—ˆ๋‹ค๋ฉด, ์žฌ๋Šฅ๋„ท์—์„œ ๋” ๋งŽ์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ง€์‹์„ ํƒํ—˜ํ•ด๋ณด์„ธ์š”!
ํ•จ๊ป˜ ์„ฑ์žฅํ•˜๋Š” ๊ฐœ๋ฐœ์ž ์ปค๋ฎค๋‹ˆํ‹ฐ๊ฐ€ ์—ฌ๋Ÿฌ๋ถ„์„ ๊ธฐ๋‹ค๋ฆฌ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ๐Ÿ˜Š

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.