Skip to content

Files

794 lines (601 loc) ยท 43.3 KB

File metadata and controls

794 lines (601 loc) ยท 43.3 KB

ํฌ์ธํ„ฐ์™€ ๋ฐฐ์—ด

ํฌ์ธํ„ฐ์™€ ๋ฐฐ์—ด์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๊ณ , ๋ณ€์ˆ˜๋ฅผ ์ž…๋ ฅ๋ฐ›๋Š” ๋ฐฉ๋ฒ•์— ๋Œ€ํ•ด ๋ฐฐ์›๋‹ˆ๋‹ค.

๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ(memory address)

2์žฅ์—์„œ ๋ฉ”๋ชจ๋ฆฌ๋Š” ์ฑ…์žฅ์ฒ˜๋Ÿผ ์ƒ๊ธด ์žฅ์น˜์ด๊ณ , ์ฑ…์žฅ์˜ ๊ฐ ๊ณต๊ฐ„์—” ๋ฐ‘์—์„œ๋ถ€ํ„ฐ ์ฐจ๋ก€๋Œ€๋กœ ๋ฒˆํ˜ธ๊ฐ€ ๋ถ™์–ด์žˆ๋‹ค๊ณ  ํ–ˆ์—ˆ์Šต๋‹ˆ๋‹ค. ์ด ๋ฒˆํ˜ธ๋ฅผ ์‹ค์ œ๋กœ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ(memory address)๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. C์—์„  ์ด ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ์— ๋Œ€ํ•ด ๋ง์…ˆ๊ณผ ๋บ„์…ˆ์„ ํ•  ์ˆ˜ ์žˆ๋Š” ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•˜๋Š”๋ฐ์š”, ์ด ๋•Œ ํฌ์ธํ„ฐ(pointer)๋ผ๊ณ  ํ•˜๋Š” ์ž๋ฃŒํ˜•์ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๋‹ด๊ณ  ์žˆ๋Š” ์ž๋ฃŒํ˜•์ž…๋‹ˆ๋‹ค. ์ฆ‰, ์ผ๋‹จ ์ˆ˜ํ•™์ ์œผ๋กœ ๋ดค์„ ๋•Œ ๋“ค์–ด์žˆ๋Š” ํ˜•ํƒœ๋Š” ์ •์ˆ˜์ž…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด int a๊ฐ€ ์ฃผ์†Œ 36~39๋ฅผ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๊ณ  ํ•ด๋ด…์‹œ๋‹ค. ๊ทธ๋Ÿผ ํฌ์ธํ„ฐ๋ฅผ ํ•˜๋‚˜ ๋งŒ๋“ค๊ณ , ๊ฑฐ๊ธฐ์— int a๋ฅผ ์ €์žฅํ•˜๋Š” ๊ณต๊ฐ„์˜ ๊ฐ€์žฅ ๋ฐ‘๋ถ€๋ถ„์ธ 36์„ ๊ทธ ํฌ์ธํ„ฐ์— ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ์— ์›ํ•˜๋Š” ์ •์ˆ˜๋ฅผ ๋”ํ•˜๊ฑฐ๋‚˜ ๋นผ๋Š” ๊ฒƒ๋„ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ ์„ ์–ธํ•˜๊ธฐ

ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๋Š” ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ๋•Œ, ๋ณ€์ˆ˜ ์•ž์— *๋ฅผ ๋ถ™์—ฌ์„œ ์„ ์–ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ณ„ํ‘œ*๋Š” ์• ์Šคํ„ฐ๋ฆฌ์Šคํฌ(asterisk)๋ผ๋Š” ์ด๋ฆ„์ด ์žˆ๋Š”๋ฐ์š”, ๋‹ค๋“ค ๋ณ„ํ‘œ๋‚˜ star๋ผ๊ณ  ๋ถ€๋ฆ…๋‹ˆ๋‹ค.

int main()
{
    int i = 5;
    int *p;
    p = &i;
}

๋ณ€์ˆ˜ i๋Š” ์ง€๊ธˆ๊นŒ์ง€ ์จ ์™”๋˜ ๋ณ€์ˆ˜์™€ ๋˜‘๊ฐ™์Šต๋‹ˆ๋‹ค. ๋ฐ˜๋ฉด์—, ๋ณ€์ˆ˜ p๋Š” ์„ ์–ธํ•  ๋•Œ ์•ž์— *์„ ๋ถ™์˜€๊ธฐ ๋•Œ๋ฌธ์— ํฌ์ธํ„ฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ์ด ์˜ˆ์ œ์—์„œ ์•Œ ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์€ ์—ฌ๋Ÿฌ๊ฐ€์ง€์ธ๋ฐ์š”,

  • p = &i๋ผ๋Š” ์‹์„ ํ†ตํ•ด &๊ฐ€ ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๋‹จํ•ญ ์—ฐ์‚ฐ์ž์ž„์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ํฌ์ธํ„ฐ๋ฅผ ์„ ์–ธํ•  ๋• ํ•ญ์ƒ ์–ด๋–ค ์ž๋ฃŒํ˜•์˜ ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋‹ด์„ ๊ฑด์ง€ ๋ช…์‹œํ•ด์•ผํ•จ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • *๊ฐ€ ๋ณ€์ˆ˜์˜ ์„ ์–ธ์—์„œ ๋ณ€์ˆ˜์˜ ์ด๋ฆ„ ์•ž์— ๋ถ™์œผ๋ฉด ํฌ์ธํ„ฐ์ž„์„ ๋‚˜ํƒ€๋‚ด๋Š” ํ‘œ์‹œ๊ฐ€ ๋œ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. *๊ฐ€ ๊ณฑํ•˜๊ธฐ ๋ง๊ณ ๋„ ์—ฌ๋Ÿฌ ์—ญํ• ์„ ํ•˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ, C์—์„  ๋ชจ์–‘์€ ๊ฐ™์ง€๋งŒ ์—ญํ• ์€ ๋‹ค๋ฅธ ๊ฒฝ์šฐ๊ฐ€ ์—ฌ๋Ÿฌ๊ฐ€์ง€ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด ๋•Œ ํฌ์ธํ„ฐ p์˜ ์ž๋ฃŒํ˜•์„ int *์ด๋ผ๊ณ  ํ•˜๋Š”๋ฐ์š”, ์ด ์ž๋ฃŒํ˜•์„ ํ’€์–ด์„œ int๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ(a pointer to an integer)๋ผ๊ณ ๋„ ํ•ฉ๋‹ˆ๋‹ค.

int์™€ *์€ ๋‹ค๋ฅธ ํ† ํฐ์œผ๋กœ ๋ถ„๋ฆฌ๋  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— int* p ๋ผ๊ณ  ์ ์–ด๋„ p๊ฐ€ ํฌ์ธํ„ฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

&๋Š” ์ฃผ์†Œ ์—ฐ์‚ฐ์ž(Address-of operator)๋ผ๊ณ  ๋ถˆ๋ฆฝ๋‹ˆ๋‹ค. ์ฃผ์†Œ ์—ฐ์‚ฐ์ž๋Š” ํ˜•๋ณ€ํ™˜ ์—ฐ์‚ฐ์ž์ฒ˜๋Ÿผ ์šฐ์„ ์ˆœ์œ„๊ฐ€ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž๋“ค๋ณด๋‹ค ๋†’๊ณ , ๊ฒฐํ•ฉ๋ฐฉํ–ฅ์ด ์˜ค๋ฅธ์ชฝ์—์„œ ์™ผ์ชฝ์ž…๋‹ˆ๋‹ค.

&๋ผ๋Š” ๊ธฐํ˜ธ ์ž์ฒด๋„ ์•ฐํผ์ƒŒ๋“œ(ampersand)๋ผ๋Š” ์ด๋ฆ„์ด ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ ์ด ์˜ˆ์ œ๋ฅผ ์‚ฌ๋žŒ๋“ค์ด ์“ฐ๋Š” ๋ง์— ๊ฐ€๊น๊ฒŒ ์“ฐ๋ฉด

ํ”„๋กœ๊ทธ๋žจ์ด ์‹œ์ž‘ํ–ˆ์„ ๋•Œ,
    ์ ๋‹นํ•œ ๊ณต๊ฐ„์„ i๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ  ์ •์ˆ˜ 5๋ฅผ ๋„ฃ์Šต๋‹ˆ๋‹ค.
    ์ ๋‹นํ•œ ๊ณต๊ฐ„์„ p๋ผ๊ณ  ์ด๋ฆ„ ์ง“์Šต๋‹ˆ๋‹ค.
    p๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— i์˜ ์ฃผ์†Œ๋ฅผ ๋‹ด์Šต๋‹ˆ๋‹ค.

๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ์ฆ‰, i๊ฐ€ 48~51๋ฒˆ์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๋ฉด p์—๋Š” 48์ด ๋“ค์–ด์žˆ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ์ž๋ฃŒํ˜•์ด float์ด๋‚˜ double์ด๋ผ๊ณ  ํ•˜๋”๋ผ๋„ ํฌ์ธํ„ฐ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๋‹ด๋Š” ์ž๋ฃŒํ˜•์ด๊ธฐ ๋•Œ๋ฌธ์— ํ•ญ์ƒ ์ •์ˆ˜๋ฅผ ๋‹ด์Šต๋‹ˆ๋‹ค. ์ด ๋•Œ๋ฌธ์— ํฌ์ธํ„ฐ๋Š” ์–ด๋–ค ์ž๋ฃŒํ˜•์„ ๊ฐ€๋ฆฌํ‚ค๋“ ๊ฐ„์— ํ•ญ์ƒ ๊ฐ™์€ ํฌ๊ธฐ๋ฅผ ๊ฐ€์ง€๋Š”๋ฐ์š”, ๋ณดํ†ต 4๋ฐ”์ดํŠธ ๋˜๋Š” 8๋ฐ”์ดํŠธ์˜ ํฌ๊ธฐ๋ฅผ ๊ฐ€์ง‘๋‹ˆ๋‹ค. ์ด๊ฒƒ์— ๋Œ€ํ•ด์„œ๋Š” ๋‚˜์ค‘์— ์ž์„ธํžˆ ๋‹ค๋ฃจ๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

๋ณ€์ˆ˜๋ฅผ ํ•œ ๋ฒˆ์— ์—ฌ๋Ÿฌ ๋ฒˆ ์„ ์–ธํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ, ํฌ์ธํ„ฐ๋„ ํ•œ ๋ฒˆ์— ์—ฌ๋Ÿฌ ๋ฒˆ ์„ ์–ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

int main()
{
    int *p, i = 5, *q = &i;
}

์—ฌ๊ธฐ์„œ p์™€ q๋Š” ํฌ์ธํ„ฐ์ด๊ณ , i๋Š” ๊ทธ๋ƒฅ ์ž๋ฃŒํ˜•์ด int์ธ ๋ณ€์ˆ˜์ž…๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ p๋Š” ์ดˆ๊ธฐ์‹์ด ์—†๊ธฐ ๋•Œ๋ฌธ์— ์–ด๋–ค ๊ฐ’์ด ๋“ค์–ด์žˆ๋Š”์ง€ ๋ชจ๋ฅด๊ณ , q๋Š” ์ดˆ๊ธฐ์‹ &i๊ฐ€ ์ฃผ์–ด์กŒ๊ธฐ ๋•Œ๋ฌธ์— i์˜ ์ฃผ์†Œ๊ฐ’์„ ๊ฐ–๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ๋ฅผ ์ด์šฉํ•œ ์ฐธ์กฐ

4์žฅ์—์„œ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋กœ๋งŒ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ํ•˜๋ฉด ํฐ ํ”„๋กœ๊ทธ๋žจ์„ ๊ฐœ๋ฐœํ•˜๊ธฐ ํž˜๋“ค์–ด์ง€๊ธฐ ๋•Œ๋ฌธ์— ๋ณ€์ˆ˜๋ผ๋Š” ๊ฒƒ์ด ์ƒ๊ฒผ๋‹ค๋Š” ์„ค๋ช…์„ ํ–ˆ์Šต๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ํŠน์ •ํ•œ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์— ๊ฐ’์„ ๋ถˆ๋Ÿฌ์˜ค๊ณ  ๊ณ„์‚ฐํ•œ ํ›„ ๋‹ค์‹œ ๋„ฃ๋Š” ๊ฒƒ์„ ๋ณ€์ˆ˜๋ผ๋Š” ๋„๊ตฌ๋กœ ์ถ”์ƒํ™”ํ•  ์ˆ˜ ์žˆ์Œ์„ ๋ฐฐ์› ์Šต๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์ง์ ‘์ ์œผ๋กœ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๋Š” ๋„๊ตฌ์ž…๋‹ˆ๋‹ค. ๋‹ค์‹œ ๋งํ•ด, ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ๋„ฃ๊ณ  ๋นผ๊ณ  ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ๋Š” ์ž‘์—…์„ ํฌ์ธํ„ฐ๋กœ๋„ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i = 5;
    int *p;
    p = &i;
    *p = 6;
    printf("%d ", i);
    printf("%d", *p + 7);
}
6 13

์—ฌ๊ธฐ์„œ int *p;์™€ p = &i;๋ฅผ ์ง€์šฐ๊ณ , *p๋ฅผ i๋กœ ๊ต์ฒดํ•ด๋„ ๊ฒฐ๊ณผ๋Š” ๊ฐ™์Šต๋‹ˆ๋‹ค. ์ฆ‰, *p๊ฐ€ i๋ฅผ ๋Œ€์ฒดํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ *์€ ๊ณฑ์…ˆ ์ดํ•ญ ์—ฐ์‚ฐ์ž๊ฐ€ ์•„๋‹ˆ๋ผ ๋‹จํ•ญ ์—ฐ์‚ฐ์ž๋กœ ์“ฐ์˜€์„ ๋•Œ, ํฌ์ธํ„ฐ๊ฐ€ ์›๋ž˜ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ๋Š” ๋ณ€์ˆ˜๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋Š” ์—ญํ• ์„ ํ•ฉ๋‹ˆ๋‹ค. ์ด ์˜ˆ์ œ๋ฅผ ์ปดํŒŒ์ผํ–ˆ์„ ๋•Œ i๊ฐ€ 64~67๋ฒˆ์„, p๊ฐ€ 68~71๋ฒˆ์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด๋ด…์‹œ๋‹ค. ๊ทธ๋Ÿผ ์ด ํ”„๋กœ๊ทธ๋žจ์„ ์‚ฌ๋žŒ์ด ํ•˜๋Š” ๋ง์— ๊ฐ€๊น๊ฒŒ ์˜ฎ๊ธฐ๋ฉด,

๋ฌธ์žฅ ์„ค๋ช… ์‹คํ–‰ ํ›„ ๋ฉ”๋ชจ๋ฆฌ ์ƒํƒœ
int i = 5; 64๋ฒˆ์„ i๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ , i๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— 5๋ฅผ ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 1"
int *p; 68๋ฒˆ์„ p๋ผ๊ณ  ์ด๋ฆ„ ์ง“์Šต๋‹ˆ๋‹ค. "Memory 2"
p = &i; p๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— i๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 3"
*p = 6; p๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๊ฐ€์ง€๋Š” ๊ณต๊ฐ„์— 6์„ ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 4"
printf("%d ", i); i๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. (6 ์ถœ๋ ฅ) "Memory 4"
printf("%d", *p + 7) p๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๊ฐ€์ง€๋Š” ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์— 7์„ ๋”ํ•œ ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. (13 ์ถœ๋ ฅ) "Memory 4"

์ด๋ ‡๊ฒŒ ํ•ด์„๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ ๋ฌธ์žฅ์˜ ์„ค๋ช…๊ณผ ์‹คํ–‰ ํ›„ ๋ฉ”๋ชจ๋ฆฌ ์ƒํƒœ๋ฅผ ์œ ์‹ฌํžˆ ๋ด์ฃผ์„ธ์š”.

*์€ ์ฐธ์กฐ ์—ฐ์‚ฐ์ž(indirection operator)๋ผ๊ณ  ๋ถˆ๋ฆฝ๋‹ˆ๋‹ค. ์ฐธ์กฐ ์—ฐ์‚ฐ์ž๋Š” ์ฃผ์†Œ ์—ฐ์‚ฐ์ž์ฒ˜๋Ÿผ ์šฐ์„ ์ˆœ์œ„๊ฐ€ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž๋“ค๋ณด๋‹ค ๋†’๊ณ , ๊ฒฐํ•ฉ๋ฐฉํ–ฅ์ด ์˜ค๋ฅธ์ชฝ์—์„œ ์™ผ์ชฝ์ž…๋‹ˆ๋‹ค.

int *p;๊ฐ™์ด ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ๋•Œ์˜ *๊ณผ *p = 6;๊ฐ™์ด ์‹์„ ์‚ฌ์šฉํ–ˆ์„ ๋•Œ์˜ *์€ ๋‹ค๋ฅธ ์˜๋ฏธ๋ฅผ ๊ฐ€์ง‘๋‹ˆ๋‹ค. ์ „์ž๋Š” ๊ทธ ๋ณ€์ˆ˜๊ฐ€ ํฌ์ธํ„ฐ๋ผ๋Š” ํ‘œ์‹œ์ด๊ณ , ํ›„์ž๋Š” ํฌ์ธํ„ฐ ์•ž์— ๋ถ™์–ด ๊ทธ ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ๋ณ€์ˆ˜๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ์—ฐ์‚ฐ์ž์ž…๋‹ˆ๋‹ค.

์ดˆ๊ธฐํ™”๋˜์ง€ ์•Š์•˜๊ฑฐ๋‚˜ ๋Œ€์ž…๋˜์ง€ ์•Š์€ ํฌ์ธํ„ฐ๋Š” ์•ˆ์— ์–ด๋–ค ์ฃผ์†Œ๊ฐ€ ๋“ค์–ด์žˆ๋Š”์ง€ ๋ชจ๋ฅด๊ธฐ ๋•Œ๋ฌธ์—, ๊ทธ๋Ÿฐ ํฌ์ธํ„ฐ๋“ค์— ์ฐธ์กฐ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ๋„ ์ •์˜๋˜์ง€ ์•Š์€ ํ–‰๋™์ž…๋‹ˆ๋‹ค. ์ด๊ฒƒ์— ๋Œ€ํ•œ ์ž์„ธํ•œ ์„ค๋ช…์€ ๋‚˜์ค‘์— ๋‹ค๋ฃจ๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

์ขŒ์ธก๊ฐ’(lvalue)์™€ ์šฐ์ธก๊ฐ’(rvalue)

์ง€๊ธˆ๊นŒ์ง€์˜ ์˜ˆ์ œ์—์„  ๋Œ€์ž… ์—ฐ์‚ฐ์ž์˜ ์ขŒํ•ญ์—” ํ•ญ์ƒ ๋ณ€์ˆ˜๊ฐ€ ๋“ค์–ด๊ฐ”์Šต๋‹ˆ๋‹ค. 5์žฅ์—์„œ ๋Œ€์ž… ์—ฐ์‚ฐ์ž์—์„œ ์ž์ฃผ ๋‚˜์˜ค๋Š” ์‹ค์ˆ˜๋“ค์— ๋Œ€ํ•ด ๋‹ค๋ค˜์„ ๋•Œ, a + 1 = 5์—์„œ a + 1์ด ์ฃผ์†Œ๋ฅผ ๊ฐ€์ง€๋Š” ๋ณ€์ˆ˜๊ฐ€ ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ๋Œ€์ž… ์—ฐ์‚ฐ์ž์˜ ์ขŒํ•ญ์— ๋‚˜์˜ค์ง€ ๋ชปํ•œ๋‹ค๊ณ  ์„ค๋ช…ํ–ˆ์ง€๋งŒ, ๋ฐฉ๊ธˆ ์œ„์˜ ์˜ˆ์ œ์—์„  ๋ณ€์ˆ˜๊ฐ€ ์•„๋‹Œ ์‹ *p๊ฐ€ ๋Œ€์ž… ์—ฐ์‚ฐ์ž์˜ ์™ผ์ชฝ์— ๋“ค์–ด๊ฐ”์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ, a, a + 1, *p ๋ชจ๋‘ ์ž๋ฃŒํ˜•์€ int๋กœ, ์ž๋ฃŒํ˜•์—๋Š” ์ฐจ์ด๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿผ C ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ๋Œ€์ž… ์—ฐ์‚ฐ์ž์˜ ์™ผ์ชฝ์— ์˜ฌ ์ˆ˜ ์žˆ๋Š” ์‹์„ ์–ด๋–ป๊ฒŒ ๊ตฌ๋ถ„ํ• ๊นŒ์š”?

C์—์„  ์‹์ด ๊ฐ€์งˆ ์ˆ˜ ์žˆ๋Š” ๊ฐ’์„ ์ขŒ์ธก๊ฐ’(lvalue)๊ณผ ์šฐ์ธก๊ฐ’(rvalue)๋กœ ๊ตฌ๋ถ„ํ•ฉ๋‹ˆ๋‹ค. ์ขŒ์ธก๊ฐ’์€ ๊ทธ ๊ฐ’์„ ๋‹ด๊ณ  ์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์•Œ ์ˆ˜ ์žˆ๋Š” ๊ฐ’์ž…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๋ณ€์ˆ˜ i๊ฐ€ 5๋ผ๋Š” ๊ฐ’์„ ๊ฐ€์ง€๊ณ  ์žˆ์„ ๋•Œ, ์‹ i๋Š” ๊ฒฐ๊ณผ๊ฐ’์ด 5์ธ ์ขŒ์ธก๊ฐ’์ž…๋‹ˆ๋‹ค. ์ฆ‰, 5๊ฐ€ ๋‹ด๊ฒจ์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ๋ณ€์ˆ˜ p๊ฐ€ i์˜ ์ฃผ์†Œ๊ฐ’์„ ๊ฐ€์ง€๋Š” ํฌ์ธํ„ฐ๋ผ๋ฉด, ์‹ *p๋Š” ๊ฒฐ๊ณผ๊ฐ’์ด 5์ธ ์ขŒ์ธก๊ฐ’์ž…๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ p๋Š” ๊ทธ ์ž์ฒด๋กœ๋„ ๋ณ€์ˆ˜์ด๊ธฐ ๋•Œ๋ฌธ์—, ์‹ p๋Š” ๊ฒฐ๊ณผ๊ฐ’์ด i์˜ ์ฃผ์†Œ์ธ ์ขŒ์ธก๊ฐ’์ž…๋‹ˆ๋‹ค. ๋ฐ˜๋Œ€๋กœ ์‹ i + 1์€ ๊ฒฐ๊ณผ๊ฐ’์ด 6์ด์ง€๋งŒ, ์ขŒ์ธก๊ฐ’์€ ์•„๋‹™๋‹ˆ๋‹ค. 6์ด ๋“ค์–ด์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์•Œ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ์‹ *p * 6์€ ๊ฒฐ๊ณผ๊ฐ’์ด 30์ด์ง€๋งŒ, ์ขŒ์ธก๊ฐ’์€ ์•„๋‹™๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ์ขŒ์ธก๊ฐ’์ด ์•„๋‹Œ ๊ฐ’๋“ค์„ ์šฐ์ธก๊ฐ’์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

๋Œ€์ž… ์—ฐ์‚ฐ์ž์˜ ์™ผ์ชฝ์— ๋“ค์–ด๊ฐˆ ์ˆ˜ ์žˆ๋Š” ๊ฐ’์€ ๋ฐ”๋กœ ์ขŒ์ธก๊ฐ’๋“ค์ž…๋‹ˆ๋‹ค. ์ขŒ์ธก๊ฐ’์ด๋ผ๋Š” ์ด๋ฆ„์€ ๋Œ€์ž… ์—ฐ์‚ฐ์ž์˜ ์™ผ์ชฝ์—์„œ ์˜ฌ ์ˆ˜ ์žˆ๋‹ค๋Š” ํŠน์ง•์—์„œ ์œ ๋ž˜ํ–ˆ์Šต๋‹ˆ๋‹ค. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋‹จํ•ญ ์—ฐ์‚ฐ์ž &๋ฅผ ์ ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์‹๋“ค์€ ๊ฒฐ๊ณผ๊ฐ’์ด ์ขŒ์ธก๊ฐ’์ด์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋‹ค์‹œ ๋งํ•ด, &(i + 1)์€ ์ž˜๋ชป๋œ ์‹์ด์ง€๋งŒ, &*p๋Š” ์˜ฌ๋ฐ”๋ฅธ ์‹์ž…๋‹ˆ๋‹ค.

์ดˆ๊ธฐํ™”๋˜์ง€ ์•Š์€ ํฌ์ธํ„ฐ์— ์ฐธ์กฐ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ด๋„ ๊ทธ ๊ฐ’์€ ์ขŒ์ธก๊ฐ’์ž…๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ๊ฐ€ ์–ด๋””๋ฅผ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ๋Š”์ง€๋Š” ๋ชจ๋ฅด๊ฒ ์ง€๋งŒ, ๊ฒฐ๊ณผ๊ฐ’์ด ๊ทธ ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ๋Š” ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์ด ๋˜๊ณ , ๊ฒฐ๊ณผ๊ฐ’์ด ๋“ค์–ด์žˆ๋Š” ์ฃผ์†Œ๋ฅผ ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ–๊ณ  ์žˆ๋Š” ์ฃผ์†Œ๋กœ ํŠน์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์„œ ~์˜ ๊ฒฐ๊ณผ๊ฐ’์€์ด๋ž€ ํ‘œํ˜„์€ ์ œ๊ฐ€ ~ is evaluated as๋ผ๋Š” ํ‘œํ˜„์„ ๋ฒˆ์—ญํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

C++ ํ‘œ์ค€์—์„  ์‹์ด ๊ฐ€์งˆ ์ˆ˜ ์žˆ๋Š” ๊ฐ’์„ lvalue, prvalue, xvalue, glvalue, rvalue ๋‹ค์„ฏ๊ฐ€์ง€๋กœ ๊ตฌ๋ถ„ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ๊ณผ ๊ด€๋ จ๋œ ์ •ํ™•ํ•œ ๊ตฌ๋ถ„์€ C++์— ๋Œ€ํ•ด ๋ฐฐ์šธ ๋•Œ ๋‹ค๋ฃจ๊ฒ ์Šต๋‹ˆ๋‹ค.

๋‹ค์Œ ์ฝ”๋“œ๋ฅผ Visual Studio ์—๋””ํ„ฐ์— ์ž…๋ ฅํ•ด์ฃผ์„ธ์š”.

int main()
{
    int a = 4;
    a + 1 = 5;
}

a์— ๋นจ๊ฐ„์ค„์ด ๋œจ๋ฉด์„œ ์—๋””ํ„ฐ์—์„œ ์—๋Ÿฌ ๋ฉ”์‹œ์ง€๋ฅผ ํ‘œ์‹œํ•˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

"lvalue-related error"

"expression must be a modifiable lvalue", ์ฆ‰ "ํ‘œํ˜„์‹์ด ์ˆ˜์ • ๊ฐ€๋Šฅํ•œ ์ขŒ์ธก๊ฐ’์ด์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค"์ž…๋‹ˆ๋‹ค. ์‹ค์ œ๋กœ Ctrl + F5๋ฅผ ๋ˆŒ๋Ÿฌ ์‹คํ–‰ํ•ด๋ณด๋ ค๊ณ  ํ•˜๋ฉด ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ๋น„์Šทํ•œ ๋ฉ”์‹œ์ง€์™€ ํ•จ๊ป˜ ์—๋Ÿฌ๋ฅผ ํ‘œ์‹œํ•˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ์˜ ํฌ์ธํ„ฐ(a pointer to a pointer)

ํฌ์ธํ„ฐ๋Š” ๋ณ€์ˆ˜์˜ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์ง์ ‘์ ์œผ๋กœ ๋‹ค๋ฃจ๊ธฐ ์œ„ํ•œ ์ž๋ฃŒํ˜•์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ, ํฌ์ธํ„ฐ ์ž์ฒด๋„ ๋ณ€์ˆ˜์ž…๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ C์—์„œ๋Š” ํฌ์ธํ„ฐ์˜ ํฌ์ธํ„ฐ๋„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i = 15, *p = &i, **pp = &p;
    printf("%d %d %d", i, *p, **pp);
}
15 15 15

๋ณ€์ˆ˜ p์˜ ์ž๋ฃŒํ˜•์ด int *์ธ ๊ฒƒ์ฒ˜๋Ÿผ, pp๋„ ์ž๋ฃŒํ˜•์ด int **์ด๊ณ , ํ’€์–ด์„œ int๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ(a pointer to a pointer to an integer)๋ผ๊ณ  ํ•˜๊ณ , ๊ฐ„๋‹จํ•˜๊ฒŒ ์ด์ค‘ ํฌ์ธํ„ฐ(double pointer)๋ผ๊ณ ๋„ ํ•ฉ๋‹ˆ๋‹ค.

์‹ **pp๋Š” ์ฐธ์กฐ ์—ฐ์‚ฐ์ž์˜ ๊ฒฐํ•ฉ๋ฐฉํ–ฅ์— ์˜ํ•ด *(*pp)๋กœ ํ•ด์„๋ฉ๋‹ˆ๋‹ค. *pp๋Š” ๊ฒฐ๊ณผ๊ฐ’์ด &i์ธ int * ์ขŒ์ธก๊ฐ’์œผ๋กœ, p์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ *(*pp)๋Š” *p์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์„œ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ int **pp;์—์„œ์˜ **๊ณผ printf("%d", **pp)์—์„œ์˜ **๊ฐ€ ๋‹ค๋ฅธ ์—ญํ• ์„ ํ•ฉ๋‹ˆ๋‹ค. ์ „์ž๋Š” pp๊ฐ€ ์ด์ค‘ํฌ์ธํ„ฐ๋ผ๋Š” ๊ฒƒ์„ ํ‘œ์‹œํ•˜๋Š” ๊ฒƒ์ด๊ณ , ํ›„์ž๋Š” pp๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ์ •์ˆ˜๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ๋„๋ก ์ฐธ์กฐ ์—ฐ์‚ฐ์ž *๊ฐ€ ๋‘ ๋ฒˆ ์“ฐ์ธ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

*์ด ์—ฌ๋Ÿฌ๊ฐœ ๋ถ™์–ด๋„ ๊ฐ ๊ธ€์ž๊ฐ€ ๋‹ค๋ฅธ ํ† ํฐ์œผ๋กœ ๋ถ„๋ฆฌ๋ฉ๋‹ˆ๋‹ค. ์ฆ‰, int **pp๋ผ๊ณ  ์“ฐ๋ฉด int, *, *, pp๋กœ ํ† ํฐํ™”๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ int * * pp๋ผ๊ณ  ์ ์–ด๋„, int** pp๋ผ๊ณ  ์ ์–ด๋„ pp๊ฐ€ ์ „๋ถ€ ์ด์ค‘ ํฌ์ธํ„ฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

์ด์ค‘ ํฌ์ธํ„ฐ๊ฐ€ ์žˆ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ์‚ผ์ค‘ ํฌ์ธํ„ฐ(triple pointer)๋„ ์žˆ๊ณ , ๊ทธ ์ด์ƒ๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

int main()
{
    int i = 15;
    int *p1 = &i;
    int **p2 = &p1;
    int ***p3 = &p2;
    int ****p4 = &p3;
}

์‚ผ์ค‘ ํฌ์ธํ„ฐ๋ถ€ํ„ฐ๋Š” ์ž˜ ์“ฐ์ด์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋ณ€์ˆ˜ ์ž…๋ ฅ๋ฐ›๊ธฐ

์ปดํ“จํ„ฐ์˜ ์ž‘๋™์€ ์ž…๋ ฅ/๊ณ„์‚ฐ/์ถœ๋ ฅ ์„ธ ๊ฐ€์ง€๋กœ ๋ถ„๋ฅ˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ง€๊ธˆ๊นŒ์ง€ ๊ณ„์‚ฐ๊ณผ ์ถœ๋ ฅ์€ ๋งŽ์ด ํ–ˆ์ง€๋งŒ, ์ž…๋ ฅ์€ ํ•œ ๋ฒˆ๋„ ํ•œ ์ ์ด ์—†๋Š”๋ฐ์š”, ๋“œ๋””์–ด ๋ณ€์ˆ˜๋ฅผ ์ž…๋ ฅ๋ฐ›๋Š” ๋ฐฉ๋ฒ•์„ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๊ฒŒ ๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์ถœ๋ ฅ์„ printf๋ผ๋Š” ๊ฑธ๋กœ ํ–ˆ๋˜ ๊ฒƒ ์ฒ˜๋Ÿผ, ์ž…๋ ฅ์€ scanf๋ผ๋Š” ๊ฑธ๋กœ ํ•ฉ๋‹ˆ๋‹ค. scanf๋ฅผ ์‚ฌ์šฉํ•˜๊ธฐ ์ „, ํ•„์š”ํ•œ ์‚ฌ์ „์ž‘์—…์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์†”๋ฃจ์…˜ ํƒ์ƒ‰๊ธฐ์—์„œ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งˆ์šฐ์Šค ์˜ค๋ฅธ์ชฝ ๋ฒ„ํŠผ์œผ๋กœ ํด๋ฆญํ•œ ํ›„, ์†์„ฑ์„ ๋ˆŒ๋Ÿฌ์ฃผ์„ธ์š”.

"Select properties"

๊ทธ๋Ÿผ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ”„๋กœ์ ํŠธ์˜ ์†์„ฑ ์„ค์ • ์ฐฝ์ด ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ์™ผ์ชฝ์˜ ๋ฉ”๋‰ด์—์„œ C/C++ > ์ „์ฒ˜๋ฆฌ๊ธฐ(Preprocessor) ๋ฉ”๋‰ด์— ๋“ค์–ด๊ฐ€์ฃผ์„ธ์š”.

"Project Property Pages"

์—ฌ๊ธฐ์„œ Configuration๊ณผ Platform์„ ๋ชจ๋‘ All Configurations๊ณผ All Platforms์œผ๋กœ ๋ฐ”๊พผ ํ›„, Preprocessor Definitions์— _CRT_SECURE_NO_WARNINGS;๋ฅผ ๋งจ ์•ž์— ๋„ฃ์–ด์ฃผ์„ธ์š”. _CRT_SECURE_NO_WARNINGS; ๊นŒ์ง€ ๋„ฃ์œผ์‹  ๊ฒƒ์„ ํ™•์ธํ•˜์…จ์œผ๋ฉด ํ™•์ธ์„ ๋ˆŒ๋Ÿฌ์ฃผ์„ธ์š”.

"Add _CRT_SECURE_NO_WARNINGS"

Visual Studio์˜ ์ปดํŒŒ์ผ๋Ÿฌ๋Š” scanf์— ๋ณด์•ˆ ๋ฌธ์ œ๊ฐ€ ์žˆ์–ด scanf ์‚ฌ์šฉ์„ ์›์น™์ ์œผ๋กœ ๊ธˆ์ง€ํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ €ํฌ๋Š” C ๋ฌธ๋ฒ•์„ ๋ฐฐ์šฐ๊ณ  ์žˆ๊ธฐ ๋•Œ๋ฌธ์—, scanf๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์€ ํฐ ๋ฌธ์ œ๊ฐ€ ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ด ์ž‘์—…์€ ๊ทธ ๊ธˆ์ง€ ๊ทœ์น™์„ ํ•ด์ œํ•˜๊ธฐ ์œ„ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•ด์ฃผ์„ธ์š”.

#include <stdio.h>

int main()
{
    int i;
    int *p = &i;
    scanf("%d", p);
    printf("%d", i * 2);
}

ํ”„๋กœ๊ทธ๋žจ์ด ์‹คํ–‰ํ•˜๋ฉด, ์ปค์„œ๊ฐ€ ๊นœ๋นก์ด๋ฉด์„œ ์•„๋ฌด๊ฒƒ๋„ ๋œจ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

"Console waiting for user input"

์ด ์ƒํƒœ๋กœ ๋ฌด์–ธ๊ฐ€ ์ž…๋ ฅํ•˜๋ฉด, ๊ธ€์”จ๊ฐ€ ๋œน๋‹ˆ๋‹ค. ๋ฐฑ์ŠคํŽ˜์ด์Šค๋„ ์ž‘๋™ํ•˜๊ณ ์š”.

"Sample input"

์ด ์ƒํƒœ๋กœ ์—”ํ„ฐ๋ฅผ ๋ˆŒ๋Ÿฌ์ฃผ์„ธ์š”.

"Sample output"

: 12
24

์•ž์œผ๋กœ :๋Š” ์‚ฌ์šฉ์ž์˜ ์ž…๋ ฅ ์˜ˆ์‹œ๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ํ‘œ์‹œ๋กœ ์‚ฌ์šฉํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

์ž…๋ ฅํ•œ ์ •์ˆ˜์˜ ๋‘ ๋ฐฐ๊ฐ€ ๋˜๋Š” ์ •์ˆ˜๊ฐ€ ์ถœ๋ ฅ๋œ ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ์˜ˆ์ œ์—์„œ i๊ฐ€ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„ 120~123์„, p๊ฐ€ 124~127์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•˜๊ณ , ๊ฐ ๋ฌธ์žฅ์„ ์ž์„ธํžˆ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

๋ฌธ์žฅ ์„ค๋ช… ์‹คํ–‰ ํ›„ ๋ฉ”๋ชจ๋ฆฌ ์ƒํƒœ
int i; 120๋ฒˆ์„ i๋ผ๊ณ  ์ด๋ฆ„ ์ง“์Šต๋‹ˆ๋‹ค. "Memory 1"
int *p = &i; 124๋ฒˆ์„ p๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ  i๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 2"
scanf("%d", p); p๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๊ฐ€์ง€๋Š” ๊ณต๊ฐ„์— ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ์ž…๋ ฅ๋ฐ›์€ ์ •์ˆ˜๋ฅผ ๋„ฃ์Šต๋‹ˆ๋‹ค. (12 ์ž…๋ ฅ) "Memory 3"
printf("%d", i * 2) i๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์— 2์„ ๊ณฑํ•œ ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. (24 ์ถœ๋ ฅ) "Memory 3"

์ด๋ ‡๊ฒŒ scanf๋Š” printf์™€ ๋‹ค๋ฅด๊ฒŒ ๊ทธ ๋ณ€์ˆ˜๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ๋ฅผ ์จ์•ผํ•ฉ๋‹ˆ๋‹ค. ์œ„ ์˜ˆ์ œ์—์„  ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ–ˆ์ง€๋งŒ, ๋ณ€์ˆ˜ ๋Œ€์‹ ์— ํ•ญ์ƒ ์‹์„ ์“ธ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์„ ์žŠ์ง€ ๋ง์•„์ฃผ์„ธ์š”.

#include <stdio.h>

int main()
{
    int i; scanf("%d", &i);
    printf("%d", i * 2);
}
: 12
24

scanf๋„ printf์ฒ˜๋Ÿผ ์—ฌ๋Ÿฌ ๊ฐ’์„ ๋ฐ›์„ ์ˆ˜ ์žˆ๊ณ , printf์™€ ๊ฐ™์€ ํ˜•์‹ ์ง€์ •์ž๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i;
    double j; scanf("%d %lf", &i, &j);
    printf("%lf", j / i);
}
: 1 0.5
0.500000

scanf๋Š” ๊ฐ’์„ ์ŠคํŽ˜์ด์Šค ๋ง๊ณ  ์—”ํ„ฐ๋กœ๋„ ๊ตฌ๋ถ„ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์œ„์˜ ์˜ˆ์ œ๋ฅผ ์‹คํ–‰ํ–ˆ์„ ๋•Œ,

: 1
: 0.5

๋กœ ์ž…๋ ฅํ•ด๋„ ์ถœ๋ ฅ์ด ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋ฐฐ์—ด(array)

4์žฅ ๋„์ž…๋ถ€์—์„œ ์†Œ๊ฐœํ•œ BMI ํ”„๋กœ๊ทธ๋žจ์„ ๋‹ค์‹œ ์˜ˆ์‹œ๋กœ ๋“ค๊ฒ ์Šต๋‹ˆ๋‹ค. ์ด์ œ ๋ณ€์ˆ˜๋„ ์“ธ ์ˆ˜ ์žˆ๊ฒ ๋‹ค, ์ž…๋ ฅ๋„ ๋ฐ›์„ ์ˆ˜ ์žˆ๊ฒ ๋‹ค, ์ด์ œ ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด์„œ ํŒ๋งคํ•œ ํ›„ ๋ถ€์ž๊ฐ€ ๋˜๋Š” ์ผ๋งŒ ๋‚จ์€ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. ๋นจ๋ฆฌ ๋ˆ์„ ๋ฒŒ๊ณ  ์‹ถ์œผ๋‹ˆ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

int main()
{
    int height_1, weight_1;
    int height_2, weight_2;
    int height_3, weight_3;
    ...
    int height_199, weight_199;
    int height_200, weight_200;
}

๊ทธ๋Ÿฐ๋ฐ ๋งˆ์นจ ํ”„๋กœ๊ทธ๋žจ์„ ํŒ๋งคํ•˜๋ ค๊ณ  ํ–ˆ๋˜ ์ฒด์œก๊ด€์— ์‚ฌ๋žŒ๋“ค์ด ๋ชฐ๋ ค ์‚ฌ์šฉ์ž 2000๋ช…์˜ BMI๋ฅผ ์ €์žฅํ•œ ํ›„ ๊ณ„์‚ฐํ•ด์•ผํ•œ๋‹ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ํšŒ์› ์ˆ˜๊ฐ€ ๊ธ‰์ฆํ•˜๋‹ˆ ์ฒด์œก๊ด€์ด ๋” ๋ฐœ์ „ํ•ด์„œ 10000๋ช…์˜ ํšŒ์›์ด ๋“ฑ๋กํ•˜๊ฒŒ ๋  ๊ฐ€๋Šฅ์„ฑ์ด ์ถฉ๋ถ„ํžˆ ์žˆ์–ด ๋ณด์ž…๋‹ˆ๋‹ค. ์œ„์—์„œ ํ–ˆ๋˜ ์ผ์„ ์ˆ˜์‹ญ๋ฒˆ ๋” ๋ฐ˜๋ณตํ•˜๋Š” ๊ฑด ์ข‹์€ ์ผ์ด ์•„๋‹Œ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

C์—์„  ์ด๋ ‡๊ฒŒ ๋น„์Šทํ•œ ๊ฐ’๋“ค์„ ๋งŽ์ด ๋ฐ›๊ฒŒ ๋˜๋Š” ๊ฒฝ์šฐ๋ฅผ ์œ„ํ•ด ๋ฐฐ์—ด(array)์ด๋ผ๋Š” ๊ฒƒ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐฐ์—ด์€ ๊ฐ™์€ ์ž๋ฃŒํ˜•์„ ๊ฐ€์ง€๋Š” ๊ฐ’ ์—ฌ๋Ÿฌ๊ฐœ๋ฅผ ์—ฐ์†์ ์ธ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์— ์ €์žฅํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด ๊ฐ’๋“ค์˜ ๊ฐœ์ˆ˜๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ์ž„์˜๋กœ ์กฐ์ ˆํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๊ฐœ์ˆ˜๋ฅผ ๋ฐฐ์—ด์˜ ๊ธธ์ด(length) ๋˜๋Š” ํฌ๊ธฐ(size)๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ฐ•์ขŒ์—์„  ํ˜ผ๋™์„ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•ด, ๊ธธ์ด๋ผ๋Š” ์šฉ์–ด๋ฅผ ์‚ฌ์šฉํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ๋ฐฐ์—ด์ด ๊ฐ–๊ณ  ์žˆ๋Š” ๊ฐ๊ฐ์˜ ๊ฐ’์„ ์›์†Œ(element)๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๋ฐฐ์—ด์€ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ๋•Œ, ๋ณ€์ˆ˜์˜ ์ด๋ฆ„ ๋’ค์— ๊ธธ์ด๋ฅผ ํ‘œ์‹œํ•˜๋Š” ๊ฒƒ์œผ๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค์Œ ์˜ˆ์‹œ๋ฅผ ๋ด์ฃผ์„ธ์š”.

int main()
{
    int i = 1;
    int arr[3];
    arr[0] = 2;
    arr[i] = 1 + arr[0];
    arr[i + 1] = 5;
    printf("%d %d %d", arr[0], arr[1], arr[2]);
}
2 3 5

์ด ์˜ˆ์ œ์—์„œ ์•Œ ์ˆ˜ ์žˆ๋Š” ์ ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

  • arr์ด๋ž€ ์ด๋ฆ„์— [3]์„ ๋ถ™์˜€๋”๋‹ˆ, arr[0], arr[1], arr[2]๋ผ๋Š” ๋ณ€์ˆ˜์ฒ˜๋Ÿผ ๋ณด์ด๋Š” ๊ฒƒ ์„ธ ๊ฐœ๊ฐ€ ๋งŒ๋“ค์–ด์กŒ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ N์œผ๋กœ ์„ ์–ธํ–ˆ์„ ๋•Œ, <๋ฐฐ์—ด์˜ ์ด๋ฆ„>[0] ๋ถ€ํ„ฐ <๋ฐฐ์—ด์˜ ์ด๋ฆ„>[N - 1]๊นŒ์ง€ N๊ฐœ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • []์•ˆ์—๋Š” ๋ฆฌํ„ฐ๋Ÿด๋งŒ ๋„ฃ์„ ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ ์‹์„ ๋„ฃ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, []๋Š” ๊ด„ํ˜ธ ์™ผ์ชฝ๊ณผ ์•ˆ์ชฝ์— ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ์ง‘์–ด๋„ฃ๋Š” ์ดํ•ญ ์—ฐ์‚ฐ์ž์ด๋ฉด์„œ, ์ฐธ์กฐ ์—ฐ์‚ฐ์ž *์ฒ˜๋Ÿผ ๊ฒฐ๊ณผ๊ฐ€ ์ขŒ์ธก๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.

[]๋Š” ์ฒจ์ž ์—ฐ์‚ฐ์ž(subscript operator)๋ผ๊ณ  ๋ถˆ๋ฆฝ๋‹ˆ๋‹ค. ์ฒจ์ž ์—ฐ์‚ฐ์ž์˜ [] ์•ˆ์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ์ฒจ์ž(index)๋ผ๊ณ ๋„ ๋ถ€๋ฆ…๋‹ˆ๋‹ค.

๋‹ค๋ฅธ ๋ณ€์ˆ˜ ์„ ์–ธ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ๋ฐฐ์—ด๋„ ํ•œ๋ฒˆ์— ์—ฌ๋Ÿฌ ๊ฐœ ์„ ์–ธํ•  ์ˆ˜ ์žˆ๊ณ , ์ดˆ๊ธฐ์‹๋„ ๋„ฃ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i = 1, arr[10], arr2[3] = { 7, 11, 13 }, *j;
    printf("%d %d %d", arr2[0], arr2[1], arr2[2]);
}
7 11 13

์—ฌ๊ธฐ์„œ {}๋„ ์—ฌ๋Ÿฌ ์—ญํ• ์„ ํ•˜๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. int main() { ... }์—์„œ๋„ ์“ฐ์ด๊ณ , ๋ฐฐ์—ด์„ ์ดˆ๊ธฐํ™”ํ•  ๋•Œ๋„ ์“ฐ์ด๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด ์˜ˆ์ œ์—์„  arr2์˜ ๊ธธ์ด๊ฐ€ 3์ด์—ˆ์ง€๋งŒ, arr2์˜ ๊ธธ์ด๊ฐ€ 10000์ด๋ผ๋ฉด ์ดˆ๊ธฐ์‹์— ์ˆซ์ž๋ฅผ 10000๊ฐœ ์จ์•ผํ• ๊นŒ์š”? ๋ณ€์ˆ˜๋ฅผ 10000๊ฐœ ๋งŒ๋“œ๋Š” ๊ฒƒ๋งŒํผ์ด๋‚˜ ๋ฒˆ๊ฑฐ๋กœ์›Œ๋ณด์ž…๋‹ˆ๋‹ค. ๋‹คํ–‰ํžˆ๋„ C๋ฅผ ๋งŒ๋“  ์‚ฌ๋žŒ๋“ค์€ ์ด๋Ÿฐ ๊ฒฝ์šฐ์—๋„ ๋Œ€์ฒ˜ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์„ ๋งŒ๋“ค์—ˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr1[1000] = { 2, 3, 5, 7, };
    int arr2[500] = { 1, 1, 2 };
    int arr3[20] = { 0 };
    printf("%d %d %d", arr1[4], arr2[3], arr3[1]);
}
0 0 0

arr1[3]์˜ ๊ฐ’์ด 7์ธ ๊ฑด ํ™•์‹คํ•œ๋ฐ, arr1[4]๋ถ€ํ„ฐ๋Š” ๊ฐ’์„ ๋ชจ๋ฅด๊ฒ ์Šต๋‹ˆ๋‹ค. arr2[3]๊ณผ arr3[1]๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๊ณ ์š”. ๊ทธ๋Ÿฐ๋ฐ ์‹คํ–‰ํ•ด๋ณด๋ฉด ์ „๋ถ€ ๊ฐ’์ด 0์ธ ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์™œ๋ƒํ•˜๋ฉด ๋ฐฐ์—ด์— ์ดˆ๊ธฐ์‹์ด ์ฃผ์–ด์ง€๋ฉด ์ˆซ์ž๋ฅผ ์“ฐ์ง€ ์•Š์€ ๋ถ€๋ถ„๋ถ€ํ„ฐ ์ „๋ถ€ 0์œผ๋กœ ์ดˆ๊ธฐํ™”๋˜๋„๋ก ์ •ํ•ด์ ธ์žˆ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ์ด ๊ธฐ๋Šฅ ๋•๋ถ„์— ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ์•„๋ฌด๋ฆฌ ๊ธธ์–ด๋„ ์ „๋ถ€ 0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•˜๋Š” ๊ฒƒ์ด ๊ฐ€๋Šฅํ•˜๊ณ , ์ •์˜๋˜์ง€ ์•Š๋Š” ํ–‰๋™์„ ๋ง‰์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

arr1์˜ ์ดˆ๊ธฐ์‹์—์„œ 7๋‹ค์Œ์˜ ,์— ์ฃผ๋ชฉํ•ด์ฃผ์„ธ์š”. ์˜คํƒ€๊ฐ€ ์•„๋‹ˆ๋ผ ์‹ค์ œ๋กœ ํ—ˆ์šฉ๋˜๋Š” ๋ฌธ๋ฒ•์ž…๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ์ดˆ๊ธฐ์‹์œผ๋กœ ์‚ฌ์šฉ๋˜๋Š” {} ์•ˆ์—์„  ,์„ ๊ณ„์† ์ด์–ด์„œ ์“ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

C๋ฅผ ๋งŒ๋“  ์‚ฌ๋žŒ๋“ค์€ ๋ฐฐ์—ด์„ ๋” ์‰ฝ๊ฒŒ ์“ธ ์ˆ˜ ์žˆ๋„๋ก ํ•˜๊ธฐ ์œ„ํ•ด ๋ฐฐ์—ด์˜ ์ดˆ๊ธฐ์‹์ด ์ฃผ์–ด์ง€๋ฉด ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ์ƒ๋žตํ•  ์ˆ˜๋„ ์žˆ๊ฒŒ ํ–ˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr1[] = { 2, 3, 5, 7, };
    double arr2[] = { 1, 1, 2 };
    printf("%d %lf", arr1[2], arr2[1]);
}
5 1.000000

์œ„ ์ฝ”๋“œ๋ฅผ Visual Studio ์—๋””ํ„ฐ์— ์ž…๋ ฅํ•˜์‹  ํ›„, arr1๊ณผ arr2 ์œ„์— ๋งˆ์šฐ์Šค๋ฅผ ์˜ฌ๋ ค์ฃผ์„ธ์š”. ๋ญ๊ฐ€ ํ‘œ์‹œ๋˜๋‚˜์š”?

"The length of an array can be omitted"

๋ฐ”๋กœ int arr1[4]๊ณผ double arr[3]๊ฐ€ ํ‘œ์‹œ๋˜๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ์ดˆ๊ธฐ์‹ ์•ˆ์— ๋“ค์–ด์žˆ๋Š” ์ˆซ์ž์˜ ๊ฐœ์ˆ˜์— ๋งž์ถ”์–ด ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ ์กฐ์ •ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•  ๋•Œ ๋ฉ”๋ชจ๋ฆฌ ์ƒํƒœ

๋ฐฐ์—ด์€ ๊ฐ™์€ ์ž๋ฃŒํ˜•์„ ๊ฐ€์ง€๋Š” ๊ฐ’์„ ๋ฉ”๋ชจ๋ฆฌ ์ƒ์˜ ์—ฐ์†์ ์ธ ๊ณต๊ฐ„์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋Š” ๊ฒƒ์ด๋ผ๊ณ  ํ–ˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, int arr[3]๊ฐ€ ์žˆ๋‹ค๋ฉด, int๊ฐ€ 3๊ฐœ ์—ฐ์†์ ์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ์— ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ฆ‰, arr[0]์ด 280~283์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๋ฉด, arr์€ 280~291, ์ด 12๋ฐ”์ดํŠธ๋ฅผ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ ์˜ˆ์ œ๋ฅผ ๋ด์ฃผ์„ธ์š”.

#include <stdio.h>

int main()
{
    int arr[3] = { 2, };
    scanf("%d", &arr[1]);
    int lhs = arr[0];
    int rhs = arr[1];
    int res = lhs * rhs;
    arr[2] = res;
    printf("%d ", arr[0]);
    printf("%d ", arr[1]);
    printf("%d", arr[2]);
}
: 5
2 5 10

lhs, rhs, res๊ฐ€ ๊ฐ๊ฐ 292~295, 296~299, 300~304์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

๋ฌธ์žฅ ์„ค๋ช… ์‹คํ–‰ ํ›„ ๋ฉ”๋ชจ๋ฆฌ ์ƒํƒœ
int arr[3] = { 2, }; 280๋ฒˆ์„ arr๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ , arr[0]๋ถ€ํ„ฐ 2, 0, 0์„ ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 1"
scanf("%d", &arr[1]); arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 1์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 4)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 284)์— ์‚ฌ์šฉ์ž๊ฐ€ ์ž…๋ ฅํ•œ ์ •์ˆ˜๋ฅผ ๋„ฃ์Šต๋‹ˆ๋‹ค. (5 ์ž…๋ ฅ) "Memory 2"
int lhs = arr[0]; 292๋ฒˆ์„ lhs๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ , arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 0์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 0)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 280)์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„, lhs๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 3"
int rhs = arr[1]; 296๋ฒˆ์„ rhs๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ , arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 1์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 4)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 284)์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„, rhs๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 4"
int res = lhs * rhs; 300๋ฒˆ์„ res๋ผ๊ณ  ์ด๋ฆ„ ์ง“๊ณ , lhs๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’๊ณผ rhs๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ๋ฅผ, res๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 5"
arr[2] = res; arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 2๋ฅผ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 8)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 288)์—, res๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ๋„ฃ์Šต๋‹ˆ๋‹ค. "Memory 6"
printf("%d ", arr[0]); arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 0์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 0)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 280)์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. (2 ์ถœ๋ ฅ) "Memory 6"
printf("%d ", arr[1]); arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 1์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 4)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 284)์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. (5 ์ถœ๋ ฅ) "Memory 6"
printf("%d", arr[2]); arr๋ผ๋Š” ์ด๋ฆ„์˜ ๊ณต๊ฐ„์˜ ์ฃผ์†Œ์—(= 280), int์˜ ํฌ๊ธฐ์— ์ฒจ์ž 2์„ ๊ณฑํ•œ ๊ฒฐ๊ณผ(= 8)๋ฅผ ๋”ํ•œ ์ฃผ์†Œ์˜ ๊ณต๊ฐ„(= 288)์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. (10 ์ถœ๋ ฅ) "Memory 6"

์—ฌ๊ธฐ์„œ arr[n]์€ ์ •ํ™•ํžˆ ์–ด๋–ค ์ผ์„ ํ•˜๋‚˜์š”? arr์˜ ์ฃผ์†Œ๋ฅผ p๋ผ๊ณ  ํ–ˆ์„ ๋•Œ, p+nร—4๋ฅผ ๊ณ„์‚ฐํ•œ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋งŒ์•ฝ arr์˜ ์›์†Œ๊ฐ€ int๊ฐ€ ์•„๋‹ˆ๋ผ double์ด์—ˆ๋‹ค๋ฉด arr[n]์€ int์˜ ํฌ๊ธฐ์ธ 4๊ฐ€ ์•„๋‹ˆ๋ผ 8์„ ์‚ฌ์šฉํ•˜์—ฌ p+nร—8์„ ๊ณ„์‚ฐํ•˜๋Š” ์‹์ด ๋˜์—ˆ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ฆ‰, ์ฒจ์ž ์—ฐ์‚ฐ์ž๋Š” ์‹ค์ œ๋กœ๋Š” ๋ฐฐ์—ด์ด ๋‹ด๋Š” ๊ฐ’๋“ค์˜ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ๋ฅผ ๊ณฑํ•œ ํ›„ ๋ฐฐ์—ด์ด ๊ฐ€์ง€๋Š” ์ฃผ์†Œ์— ๋”ํ•˜๋Š” ์—ฐ์‚ฐ์„ ํ•œ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

sizeof ์—ฐ์‚ฐ์ž

C์—์„  ์œ„ ์˜ˆ์ œ์ฒ˜๋Ÿผ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ ์ž์ฒด๊ฐ€ ์ค‘์š”ํ•ด์ง€๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋ช‡๋ช‡ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฒจ์ž ์—ฐ์‚ฐ์ž๋Š” ์•Œ์•„์„œ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ๋ฅผ ๊ณฑํ•ด์คฌ์ง€๋งŒ, ์ง์ ‘ ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ๋กœ ์‹์„ ๋งŒ๋“ค์–ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๋•Œ sizeof ๋‹จํ•ญ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. sizeof๋„ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž๋ณด๋‹ค ์šฐ์„ ์ˆœ์œ„๊ฐ€ ๋†’๊ณ , ๊ฒฐํ•ฉ ๋ฐฉํ–ฅ์ด ์˜ค๋ฅธ์ชฝ์—์„œ ์™ผ์ชฝ์ž…๋‹ˆ๋‹ค. sizeof์˜ ์‚ฌ์šฉ ๋ฐฉ๋ฒ•์€ ๋‘ ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค.

  1. ๊ฒฐ๊ณผ๊ฐ’์ด ์ฃผ์–ด์ง„ ์‹์˜ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
sizeof <์‹>
  1. ๊ฒฐ๊ณผ๊ฐ’์ด ์ฃผ์–ด์ง„ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
sizeof(<์ž๋ฃŒํ˜•>)

์‹ค์ œ ์‚ฌ์šฉ ์˜ˆ์‹œ๋ฅผ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i = sizeof(int), j = sizeof 2, k = sizeof(double);
    printf("%d %d %d", i, j, k);
}
4 4 8

๋จผ์ € ๋ฆฌํ„ฐ๋Ÿด 2์˜ ๊ฒฐ๊ณผ๋Š” int์ด๋ฏ€๋กœ, sizeof 2์˜ ๊ฒฐ๊ณผ๋Š” int์˜ ํฌ๊ธฐ์ธ 4๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. sizeof(int)์™€ sizeof(double)์˜ ๊ฒฐ๊ณผ๋Š” ๊ฐ ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ์ธ 4์™€ 8์ด ๋ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ, 4 4 8์ด ์ถœ๋ ฅ๋˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

sizeof ์—ฐ์‚ฐ์ž์˜ ๊ฒฐ๊ณผ๋Š” ์ž๋ฃŒํ˜•์ด int๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ, printf("%d", sizeof 2);๋Š” ์ •์˜๋˜์ง€ ์•Š๋Š” ํ–‰๋™์„ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค. ์œ„ ์˜ˆ์ œ์—์„  ์•”์‹œ์ ์ธ ์ถ•์†Œ ๋ณ€ํ™˜์ด ์ผ์–ด๋‚˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. sizeof์˜ ์ž๋ฃŒํ˜•์— ๋Œ€ํ•ด์„  ๋‚˜์ค‘์— ๋‹ค๋ฃจ๊ฒ ์Šต๋‹ˆ๋‹ค.

์ž๋ฃŒํ˜• ๋Œ€์‹  ์‹์„ ์‚ฌ์šฉํ–ˆ์„ ๋•Œ ๊ด„ํ˜ธ๊ฐ€ ์—†๋Š” ๊ฒƒ์— ์ฃผ๋ชฉํ•ด์ฃผ์„ธ์š”. (i + 1) + 2 ๋Œ€์‹ ์— i + 1 + 2๋ผ๊ณ  ์“ธ ์ˆ˜ ์žˆ๋Š” ๊ฒƒ ์ฒ˜๋Ÿผ, 2 ๋Œ€์‹ ์— (2)๋ผ๊ณ ๋„ ์“ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ sizeof 2 ๋Œ€์‹ ์— sizeof(2)๋ผ๊ณ ๋„ ์“ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. C๋ฅผ ์ด๋ฏธ ํ•ด๋ณด์…จ๋˜ ๋ถ„๋“ค์€ ๊ด„ํ˜ธ๊ฐ€ ์žˆ๋Š” ๊ฒƒ์— ์ต์ˆ™ํ•˜์‹ค ํ…๋ฐ, ์‹์˜ ๊ฒฝ์šฐ์—” ๊ด„ํ˜ธ๋ฅผ ์ƒ๋žตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ์—๋„ sizeof ์—ฐ์‚ฐ์ž๋ฅผ ์ ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int *p, i = sizeof p, j = sizeof(int *);
    printf("%d %d", i, j);
}
4 4

ํ”„๋กœ๊ทธ๋žจ์„ ์‹คํ–‰ํ•œ ์ปดํ“จํ„ฐ๋‚˜ ํ™˜๊ฒฝ์— ๋”ฐ๋ผ 8 8์ด ์ถœ๋ ฅ๋  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ ๋ฐฐ์—ด์— ์‚ฌ์šฉํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ์š”?

#include <stdio.h>

int main()
{
    double arr1[2];
    int arr2[3];
    int i = sizeof arr1, j = sizeof arr2;
    printf("%d %d", i, j);
}
16 12

sizeof์˜ ๊ฒฐ๊ณผ๊ฐ€ ๋ฐฐ์—ด์ด ๋‹ด๋Š” ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐ๊ฐ€ ์•„๋‹ˆ๋ผ, ์ž๋ฃŒํ˜•์˜ ํฌ๊ธฐร—๋ฐฐ์—ด์˜ ๊ธธ์ด์ž„์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฐ ํŠน์„ฑ์„ ํ™œ์šฉํ•˜๋ฉด ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ ์‰ฝ๊ฒŒ ๊ตฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ œ๊ฐ€ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ผ๊ณ  ๋งํ•œ ๊ฒƒ์— ์ฃผ๋ชฉํ•ด์ฃผ์„ธ์š”. ์•ž์œผ๋กœ ๋ณ€์ˆ˜์— ํฌ๊ธฐ๋ผ๋Š” ๋ง์„ ์‚ฌ์šฉํ•˜๋ฉด sizeof ์—ฐ์‚ฐ์ž๋ฅผ ์ ์šฉํ•œ ๊ฒฐ๊ณผ๋ผ๋Š” ๋œป์œผ๋กœ ๋ฐ›์•„๋“ค์—ฌ์ฃผ์„ธ์š”.

#include <stdio.h>

int main()
{
    int arr[] = { 2, 3, 5, 7, 11, };
    int len = sizeof arr / sizeof(int);
    printf("%d", len);
}
5

sizeof arr์˜ ๊ฒฐ๊ณผ๋Š” sizeof(int) * 5์ด๊ธฐ ๋•Œ๋ฌธ์— 20์ž…๋‹ˆ๋‹ค. ์ด ๊ฐ’์„ sizeof(int)๋กœ ๋‚˜๋ˆ„๋ฉด arr์˜ ๊ธธ์ด์ธ 5๋ฅผ ๊ตฌํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

sizeof๋Š” ๋‹ค๋ฅธ ์—ฐ์‚ฐ์ž์™€ ๊ตฌ๋ณ„๋˜๋Š” ํŠน๋ณ„ํ•˜๋Š” ํŠน์ง•์ด ํ•˜๋‚˜ ์žˆ๋Š”๋ฐ์š”, ๋‹ค์Œ ์˜ˆ์‹œ๋ฅผ ๋ด์ฃผ์„ธ์š”.

#include <stdio.h>

int main()
{
    int a = 2;
    int i = sizeof(a = 1);
    printf("%d %d", a, i);
}
2 4

a = 1์ด๋ผ๋Š” ์‹์—๋„ ๋ถˆ๊ตฌํ•˜๊ณ , a์—๋Š” 2๊ฐ€ ๋“ค์–ด๊ฐ€์žˆ์—ˆ์Šต๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ sizeof ์•ˆ์— ์‹์ด ๋“ค์–ด์žˆ์„ ๋•, ๊ทธ ์‹์˜ ์ž๋ฃŒํ˜•๋งŒ ๊ณ ๋ คํ•˜๊ณ  ์‹ค์ œ๋กœ ๊ทธ ์‹์„ ์‹คํ–‰ํ•˜์ง€๋Š” ์•Š๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ์ด ํŠน์„ฑ์„ ์ด์šฉํ•˜๋ฉด ์ฝ”๋“œ๋ฅผ ์ปดํŒŒ์ผํ•  ๋•Œ ๋‹ค์–‘ํ•œ ์ผ์„ ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋˜๋Š”๋ฐ์š”, ๊ทธ ๊ธฐ๋ฒ•์— ๋Œ€ํ•ด์„œ๋Š” ๋‚˜์ค‘์— ๋‹ค๋ฃจ๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•  ๋•Œ ์ฃผ์˜ํ•  ์ 

๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•  ๋•Œ ์ฃผ์˜ํ•  ์ ์— ๋Œ€ํ•ด ๋‹ค๋ฃจ๊ธฐ ์œ„ํ•ด์„  ๋จผ์ € ์ฒจ์ž ์—ฐ์‚ฐ์ž๊ฐ€ ๋ญ”์ง€ ์ž์„ธํžˆ ๋‹ค๋ฃฐ ํ•„์š”๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ํฌ์ธํ„ฐ๋ฅผ ์„ ์–ธํ•  ๋•Œ int *a๋ผ๊ณ  ํ•˜๋ฉด, ์—ฌ๊ธฐ์„œ *์€ ์ฐธ์กฐ ์—ฐ์‚ฐ์ž์ผ๊นŒ์š”? ์•„๋‹™๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ์˜ *์€ a๊ฐ€ ํฌ์ธํ„ฐ๋ฅผ ๋‚˜ํƒ€๋‚ด์ฃผ๋Š” ํ‘œ์‹œ์ผ ๋ฟ, ์—ฐ์‚ฐ์ž๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค. ๋ณ€์ˆ˜ ์„ ์–ธ ์ดํ›„ ์‹์œผ๋กœ์„œ *a๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด, ์—ฌ๊ธฐ์„œ๋Š” *๊ฐ€ ์—ฐ์‚ฐ์ž๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ๋ฐฐ์—ด์„ ์„ ์–ธํ•  ๋•Œ์˜ []๋Š” ์ฒจ์ž ์—ฐ์‚ฐ์ž๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค. ์ด๊ฑด ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ํ‘œ์‹œํ•˜๊ธฐ ์œ„ํ•œ ๊ธฐํ˜ธ์ž…๋‹ˆ๋‹ค.

๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ํ‘œ์‹œํ•  ๋•Œ๋Š”, ์ฒจ์ž ์—ฐ์‚ฐ์ž์™€ ๋‹ฌ๋ฆฌ [] ์•ˆ์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์ด ํ•ญ์ƒ ์ปดํŒŒ์ผํ•  ๋•Œ ๊ฒฐ๊ณผ๊ฐ’์„ ๋‚ผ ์ˆ˜ ์žˆ๊ณ , ๊ทธ ๊ฐ’์ด ์–‘์˜ ์ •์ˆ˜์ธ ์‹์ด์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

int main()
{
    int arr[1 + 2];
    int arr2[sizeof arr / sizeof(int)];
}

1 + 2๊ฐ€ 3์ด๊ณ , sizeof arr / sizeof(int)๊ฐ€ 3์ž„์„ ์ปดํŒŒ์ผํ•  ๋•Œ ์•Œ ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์ด ์˜ˆ์ œ๋Š” ์ž˜ ์ปดํŒŒ์ผ ๋ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ๋‹ค์Œ ์˜ˆ์ œ๋Š” ์ปดํŒŒ์ผ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i; scanf("%d", &i);
    int arr[i];
}

์ด๊ฒƒ์€ ๋ณ€์ˆ˜๋ฅผ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ์— ๋Œ€์‘์‹œํ‚ค๋Š” ์ž‘์—…์ด ์ปดํŒŒ์ผ ์‹œ์— ์ด๋ค„์ง€๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ []์•ˆ์— ์ปดํŒŒ์ผ ์‹œ ๊ฒฐ๊ณผ๊ฐ’์„ ์•Œ ์ˆ˜ ์—†๋Š” ์‹์ด ๋“ค์–ด๊ฐ„ ๊ฒฝ์šฐ, ๋ณ€์ˆ˜๋ฅผ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ์— ๋Œ€์‘์‹œํ‚ค๋Š” ์ž‘์—…์„ ํ•  ์ˆ˜ ์—†๊ธฐ ๋•Œ๋ฌธ์—, ์ปดํŒŒ์ผ ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

2020๋…„์— ์ตœ์‹  C++ ํ‘œ์ค€์ธ C++20์ด ๋‚˜์˜จ ๊ฒƒ ์ฒ˜๋Ÿผ, 2011๋…„์— C๋Š” C11์ด๋ผ๋Š” ํ‘œ์ค€์ด ๋‚˜์™”์Šต๋‹ˆ๋‹ค. C11 ํ‘œ์ค€์—์„  ๋ฐฐ์—ด์„ ์„ ์–ธํ•  ๋•Œ [] ์•ˆ์— ์ปดํŒŒ์ผ ์‹œ์— ๊ฒฐ์ •๋˜์ง€ ์•Š๋Š” ์‹์„ ๋„ฃ์„ ์ˆ˜ ์žˆ๋Š” ๊ฐ€๋ณ€ ๊ธธ์ด ๋ฐฐ์—ด(Variable-length array; VLA)๋ผ๋Š” ๊ธฐ๋Šฅ์„ ์†Œ๊ฐœํ–ˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ด ๊ธฐ๋Šฅ์€ ์ƒ๋žตํ•  ์ˆ˜ ์žˆ๋Š”(optional) ๊ธฐ๋Šฅ์ด๊ธฐ ๋•Œ๋ฌธ์—, Visual Studio ์ปดํŒŒ์ผ๋Ÿฌ๋ฅผ ํฌํ•จํ•œ ๋ช‡๋ช‡ ์ปดํŒŒ์ผ๋Ÿฌ๋Š” VLA๋ฅผ ์ง€์›ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. VLA๊ฐ€ ๋“ฑ์žฅํ•˜๊ธฐ ์ด์ „๋ถ€ํ„ฐ ๊ฐ€๋ณ€ ๊ธธ์ด์˜ ์ž๋ฃŒ๊ฐ€ ํ•„์š”ํ–ˆ์„ ๋• ๋™์  ํ• ๋‹น(dynamic allocation)์ด๋ผ๋Š” ๊ธฐ๋Šฅ์„ ์ด์šฉํ–ˆ์Šต๋‹ˆ๋‹ค. Visual Studio์˜ ์ปดํŒŒ์ผ๋Ÿฌ๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ๋„ ๊ฐ€๋ณ€ ๊ธธ์ด์˜ ์ž๋ฃŒ๊ฐ€ ํ•„์š”ํ•  ๋• ๋™์  ํ• ๋‹น์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋™์  ํ• ๋‹น์— ๋Œ€ํ•ด์„œ๋Š” ๋‚˜์ค‘์— ๋ฐฐ์šธ ์˜ˆ์ •์ž…๋‹ˆ๋‹ค.

๋ฐฐ์—ด์˜ ์•”์‹œ์  ๋ณ€ํ™˜

์ผ๋ฐ˜ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ๋•Œ๋Š”, ๋‹ค์Œ ๋‘ ์˜ˆ์ œ๊ฐ€ ๋™์ผํ•œ ํšจ๊ณผ๋ฅผ ๋ƒˆ์Šต๋‹ˆ๋‹ค.

int main() { int a; a = 5; }
int main() { int a = 5; }

ํ•˜์ง€๋งŒ ์ด๊ฑด ๋ฐฐ์—ด์—์„œ ํ†ตํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

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

์ง์ ‘ Visual Studio ์—๋””ํ„ฐ์— ์ž…๋ ฅํ•ด๋ณด๋ฉด, ์˜ค๋ฅ˜๊ฐ€ ํ‘œ์‹œ๋˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

"Array is not assignable"

๊ทธ๋Ÿฐ๋ฐ, "expression must be a modifiable lvalue", ์ฆ‰ ์ˆ˜์ • ๊ฐ€๋Šฅํ•œ ์ขŒ์ธก๊ฐ’์ด ์•„๋‹ˆ๋ผ๋Š” ์˜ค๋ฅ˜๊ฐ€ ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค. arr[0]์ด๋‚˜ arr[1]์€ ์ขŒ์ธก๊ฐ’์ธ๋ฐ, ์™œ arr์€ ์ขŒ์ธก๊ฐ’์ด ์•„๋‹๊นŒ์š”? ๋‚˜์ค‘์— ๋‹ค๋ฃจ๊ฒ ์ง€๋งŒ, arr์€ ์ขŒ์ธก๊ฐ’์ด ๋งž์Šต๋‹ˆ๋‹ค. arr์— ์ฃผ์†Œ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ &arr ์ฒ˜๋Ÿผ ์“ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ๋ฐฐ์—ด์ด ๋ฐฐ์—ด๋กœ์„œ ๋™์ž‘ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ๋Š”

  • ๋ฐฐ์—ด์ด ์ฃผ์†Œ ์—ฐ์‚ฐ์ž์™€ ์‚ฌ์šฉ๋˜๋Š” ๊ฒฝ์šฐ
  • ๋ฐฐ์—ด์ด sizeof ์—ฐ์‚ฐ์ž์™€ ์‚ฌ์šฉ๋˜๋Š” ๊ฒฝ์šฐ

๋กœ๋งŒ ํ•œ์ •๋˜์–ด์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๋‘ ๊ฐ€์ง€ ๊ฒฝ์šฐ๊ฐ€ ์•„๋‹ˆ๋ฉด ๋ฐฐ์—ด์€ ๊ทธ ๋ฐฐ์—ด์˜ ์ฒซ๋ฒˆ์งธ ์›์†Œ์˜ ์ฃผ์†Œ๊ฐ’์„ ๊ฐ€์ง€๋Š” ์šฐ์ธก๊ฐ’ ํฌ์ธํ„ฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ์ฆ‰, arr์ด 504~523๋ฒˆ์„ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ–ˆ์„ ๋•Œ, &arr์ด๋‚˜ sizeof arr์ฒ˜๋Ÿผ ์“ฐ์ง€ ์•Š์œผ๋ฉด, arr์€ ๊ฒฐ๊ณผ๊ฐ’์ด 504์ด๊ณ  ์ž๋ฃŒํ˜•์ด int *์ธ ์šฐ์ธก๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค. ์ด๋Ÿฐ ํŠน์„ฑ๋•Œ๋ฌธ์—, ๋ฐฐ์—ด์€ ์ดˆ๊ธฐํ™” ํ›„ ๋Œ€์ž…์ด ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

"์ฒซ๋ฒˆ์งธ ์›์†Œ์˜ ์ฃผ์†Œ๊ฐ’์„ ๊ฐ€์ง„๋‹ค"๋ผ๋Š” ๋ง์„ ์ž์„ธํžˆ ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ๋„ ์šฐ์ธก๊ฐ’์ด ๋  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ ์— ์ฃผ์˜ํ•ด์ฃผ์„ธ์š”. arr์ด ํฌ์ธํ„ฐ๋กœ ๋ณ€ํ™˜๋˜์—ˆ์„ ๋•Œ, ๊ทธ ๊ฒฐ๊ณผ๊ฐ’์ด 504๊ฐ€ ๋˜๋Š” ๊ฒƒ์€ ๋งž์ง€๋งŒ, 504๋ผ๋Š” ๊ฐ’์ด ๋“ค์–ด์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์€ ํŠน์ •ํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ์ฆ‰, ์ขŒ์ธก๊ฐ’์ด ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ์šฐ์ธก๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.

&arr์˜ ์ž๋ฃŒํ˜•์€ int *์ด ์•„๋‹ˆ๋ผ int (*)[5], ์ฆ‰ ๋ฐฐ์—ด์„ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ๋ผ๋Š” ๊ฒƒ์— ์ฃผ์˜ํ•ด์ฃผ์„ธ์š”. ์ด๊ฒƒ์— ๋Œ€ํ•ด์„  ๋‚˜์ค‘์— ๋ณต์žกํ•œ ํฌ์ธํ„ฐ์— ๋Œ€ํ•ด ๋ฐฐ์šธ ๋•Œ ๋‹ค๋ฃจ๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[3] = { 1, 2, 3 };
    int *p = arr;
    scanf("%d", p);
    printf("%d %d %d", arr[0], arr[1], arr[2]);
}
: 5
5 2 3

scanf์— ๋“ค์–ด๊ฐ€๋Š” ํฌ์ธํ„ฐ๋ฅผ ์‹ arr์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•˜๋‹ˆ ์ฒซ๋ฒˆ์งธ ์›์†Œ์˜ ๊ฐ’์ด ๋ฐ”๋€Œ์—ˆ์Šต๋‹ˆ๋‹ค. ์•„๊นŒ ์ฒจ์ž ์—ฐ์‚ฐ์ž๋Š” ๋ฐฐ์—ด์˜ ์ฃผ์†Œ + sizeof(์›์†Œ์˜ ์ž๋ฃŒํ˜•) ร— ์ฒจ์ž๋ฅผ ๊ณ„์‚ฐํ•œ๋‹ค๋Š” ๊ฒƒ์„ ๋ฐฐ์› ์Šต๋‹ˆ๋‹ค. arr[0]์—์„œ ์ฒจ์ž์˜ ๊ฐ’์€ 0์ด๋‹ˆ, arr[0]์˜ ์ฃผ์†Œ๋Š” ๋ฐฐ์—ด์˜ ์ฃผ์†Œ์™€ ๊ฐ™๋‹ค๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ํฌ์ธํ„ฐ์— arr์„ ๋Œ€์ž…ํ•œ ๊ฑด, &arr[0]๊ณผ ๊ฐ™์€ ํšจ๊ณผ๋ฅผ ๋ฐœํœ˜ํ•ฉ๋‹ˆ๋‹ค.

arr๊ณผ ๋‹ค๋ฅด๊ฒŒ *arr์€ ์ขŒ์ธก๊ฐ’์ด ๋งž์Šต๋‹ˆ๋‹ค. scanf๊ฐ€ ์ž‘๋™ํ•˜๊ธฐ ์ „, *arr์€ ๊ฒฐ๊ณผ๊ฐ’์ด 1์ด๊ณ , 1์ด 504๋ฒˆ ๊ณต๊ฐ„์— ๋“ค์–ด๊ฐ€์žˆ๋‹ค๋Š” ๊ฒƒ์„ ํŠน์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[3] = { 1, 2, 3 };
    scanf("%d", &arr[0]);
    printf("%d %d %d", arr[0], arr[1], arr[2]);
}
: 5
5 2 3

์ด๋ ‡๊ฒŒ ๋ฐฐ์—ด์ด ์ž๋™์ ์œผ๋กœ ํฌ์ธํ„ฐ๋กœ ๋ณ€ํ™˜๋˜๋Š” ๊ฒƒ์€ ์•”์‹œ์  ๋ณ€ํ™˜์˜ ์ผ์ข…์ž…๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ ์ถœ๋ ฅํ•˜๊ธฐ

ํฌ์ธํ„ฐ๋„ printf๋กœ ์ถœ๋ ฅํ•˜๋Š” ๊ฒƒ์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ๋ฅผ ์ถœ๋ ฅํ•  ๋• ํ˜•์‹ ์ง€์ •์ž %p๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int i;
    printf("%p", &i);
}
00F5FDDC

์ฃผ์†Œ๊ฐ€ 16์ง„์ˆ˜๋กœ ์ถœ๋ ฅ๋˜๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ง€๊ธˆ๊นŒ์ง€ ์ œ๊ฐ€ ์˜ˆ์‹œ๋ฅผ ๋“ค์—ˆ์„ ๋• 280, 120๋“ฑ ์ž‘์€ ๊ฐ’์„ ์‚ฌ์šฉํ–ˆ์ง€๋งŒ, ์‹ค์ œ ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋Š” ๊ฝค ํฐ ๊ฐ’์ž…๋‹ˆ๋‹ค.

๋ณ€์ˆ˜๊ฐ€ ๋Œ€์‘๋œ ์ฃผ์†Œ๋Š” ์—ฌ๋Ÿฌ ์š”์ธ์— ์˜ํ•ด ๋ฐ”๋€๋‹ˆ๋‹ค. ์œ„ ์ถœ๋ ฅ ๊ฒฐ๊ณผ๋Š” ์˜ˆ์‹œ ์ถœ๋ ฅ์œผ๋กœ, ํ”„๋กœ๊ทธ๋žจ์„ ์‹คํ–‰ํ•  ๋•Œ ๋งˆ๋‹ค ๋ฐ”๋€Œ๊ณ , ์‹คํ–‰ํ•˜๋Š” ์ปดํ“จํ„ฐ๋‚˜ ํ™˜๊ฒฝ์— ์˜ํ•ด์„œ๋„ ๋ณ€ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์ด ์–ด๋–ป๊ฒŒ ๋ฐ”๋€Œ๊ฒŒ ๋˜๋Š”์ง€๋Š” ๋‚˜์ค‘์— ๋‹ค๋ฃฐ ์˜ˆ์ •์ž…๋‹ˆ๋‹ค.

์•„๊นŒ ํฌ์ธํ„ฐ์˜ ํฌ๊ธฐ๋ฅผ ์ถœ๋ ฅํ•˜์…จ์„ ๋•Œ 8์ด ๋‚˜์™”์„ ๊ฒฝ์šฐ, ์œ„ ์˜ˆ์‹œ ์ถœ๋ ฅ์ฒ˜๋Ÿผ 8์ž๋ฆฌ 16์ง„์ˆ˜๊ฐ€ ์•„๋‹ˆ๋ผ 16์ž๋ฆฌ 16์ง„์ˆ˜๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.

printf๋กœ ํฌ์ธํ„ฐ๋ฅผ ์ถœ๋ ฅํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ scanf๋กœ ํฌ์ธํ„ฐ๋ฅผ ์ž…๋ ฅ๋ฐ›์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int *p;
    scanf("%p", &p);
}

๊ทธ๋Ÿฐ๋ฐ ์—ฌ๋Ÿฌ๋ถ„์ด ์ง€๊ธˆ๊นŒ์ง€ ์›Œ๋“œ๋‚˜ ํฌ๋กฌ๊ฐ™์€ ํ”„๋กœ๊ทธ๋žจ์„ ์‚ฌ์šฉํ•˜์‹œ๋ฉด์„œ ์ง์ ‘ ์ฃผ์†Œ๋ฅผ ์ž…๋ ฅํ•ด์•ผํ–ˆ๋˜ ์ ์ด ์žˆ๋‚˜์š”? ์ ์–ด๋„ ์ „ ๊ทธ๋Ÿฐ ๊ฒฝ์šฐ๋ฅผ ๋ณธ ์ ์ด ์—†์Šต๋‹ˆ๋‹ค. ์ด ๊ธฐ๋Šฅ์€ ์—ฌ๋Ÿฌ๋ถ„์ด ์•ž์œผ๋กœ ์“ธ ์ผ์ด ์—†์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ ์‚ฐ์ˆ  ์—ฐ์‚ฐ(pointer arithmetic)

์•„๊นŒ ๋ฐฐ์—ด์ด ํฌ์ธํ„ฐ๋กœ ์•”์‹œ์ ์œผ๋กœ ๋ณ€ํ™˜๋˜์ง€ ์•Š์„ ์กฐ๊ฑด์— ์ฒจ์ž ์—ฐ์‚ฐ์ž๊ฐ€ ์—†์—ˆ๋˜ ๊ฒƒ, ๊ธฐ์–ตํ•˜์‹œ๋‚˜์š”? ๋ฐ”๊ฟ” ๋งํ•˜์ž๋ฉด, arr[n]์—์„œ์˜ arr์€ ๋ฐฐ์—ด์ด ์•„๋‹ˆ๋ผ ํฌ์ธํ„ฐ ์šฐ์ธก๊ฐ’์ด๋ผ๋Š” ๋œป์ž…๋‹ˆ๋‹ค. ์•ž์—์„œ ์ด์•ผ๊ธฐํ•˜์ง€๋Š” ์•Š์•˜์ง€๋งŒ, ์ด๋ฏธ ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ–๊ณ  ์žˆ๋Š” ์ •์ˆ˜๋กœ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์„ ํ•˜๊ณ  ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[] = { 1, 2, 3 };
    int *p = arr;
    printf("%d %d %d", p[0], p[1], p[2]);
}
1 2 3

์—ฌ๊ธฐ์„œ p์ฒ˜๋Ÿผ 0๋ฒˆ์งธ ์›์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ๊ฐ€ ์•„๋‹ˆ๋ผ, 1๋ฒˆ์งธ, 2๋ฒˆ์งธ ์›์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ๋ฅผ ๊ฐ€์ ธ์˜ค๋ ค๋ฉด &p[1], &p[2]์ฒ˜๋Ÿผ ์“ฐ๋ฉด ๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ C์—์„  ์‚ฐ์ˆ  ์—ฐ์‚ฐ์„ ํ•  ๋•Œ ์ด๊ฒƒ๋ณด๋‹ค ๋” ์ข‹์€ ๋ฐฉ๋ฒ•์„ ์“ธ ์ˆ˜ ์žˆ๋Š”๋ฐ์š”, ๋ฐ”๋กœ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž๋“ค์ž…๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ๋Š” ๋ณธ์งˆ์ ์œผ๋กœ ์ •์ˆ˜๋ฅผ ์ €์žฅํ•˜๋Š” ์ž๋ฃŒํ˜•์ด๊ธฐ ๋•Œ๋ฌธ์—, ํฌ์ธํ„ฐ๋„ int๋‚˜ float๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋ง์…ˆ๊ณผ ๋บ„์…ˆ ์—ฐ์‚ฐ์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int *p = (int *)0x10;
    printf("%p %p %p", p, p + 1, p - 1);
}
00000010 00000014 0000000C

์œ„ ์˜ˆ์ œ์ฒ˜๋Ÿผ ์ž„์˜์˜ ์ •์ˆ˜๋ฅผ ์ฃผ์†Œ๊ฐ’์œผ๋กœ ์“ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์•„๊นŒ ํฌ์ธํ„ฐ๋ฅผ ์ถœ๋ ฅํ•ด๋ณด์…จ์œผ๋ฉด ์•Œ๊ฒ ์ง€๋งŒ, ์‹ค์ œ ๋ณ€์ˆ˜๋“ค์€ ๊ณ ์ •๋œ ์œ„์น˜์— ์žˆ์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์—, ํฌ์ธํ„ฐ์— ์ •์ˆ˜๋ฅผ ์ง์ ‘ ๋Œ€์ž…ํ•˜๋Š” ๊ฒฝ์šฐ๋Š” ๊ฑฐ์˜ ์—†์Šต๋‹ˆ๋‹ค.

์ถœ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ 10์ง„์ˆ˜๋กœ ๋ฐ”๊พธ๋ฉด ์–ด๋–ป๊ฒŒ ๋˜๋‚˜์š”? 16 20 12์ž…๋‹ˆ๋‹ค. 1์„ ๋”ํ•˜๊ณ  ๋บ๋”๋‹ˆ ์‹ค์ œ๋ก  4๊ฐ€ ๋”ํ•ด์ง€๊ณ  ๋นผ์กŒ์Šต๋‹ˆ๋‹ค. arr์ด ์–ด๋–ค ์ž๋ฃŒํ˜• T์˜ ๋ฐฐ์—ด์ด๋ผ๊ณ  ํ–ˆ์„ ๋•Œ, arr[0]๊ณผ arr[N]์€ ์‹ค์ œ๋กœ ์ฃผ์†Œ๊ฐ’์ด N * sizeof(T) ์ฐจ์ด๋‚œ ๊ฒƒ์ฒ˜๋Ÿผ, ์ž๋ฃŒํ˜•์ด T *์ธ ํฌ์ธํ„ฐ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ •์ˆ˜ N์„ ๋”ํ•˜๊ฑฐ๋‚˜ ๋บ์„ ๋•Œ ์‹ค์ œ๋กœ๋Š” N * sizeof(T)๊ฐ€ ๋”ํ•˜๊ฑฐ๋‚˜ ๋นผ์ง‘๋‹ˆ๋‹ค. ๊ทธ๋Ÿผ, ์ด ์„ฑ์งˆ์„ ์ฐธ์กฐ ์—ฐ์‚ฐ์ž์™€ ์ฃผ์†Œ ์—ฐ์‚ฐ์ž์™€ ์„ž์œผ๋ฉด, ํฌ์ธํ„ฐ์˜ ๋ง์…ˆ ์—ฐ์‚ฐ์ž์™€ ์ฒจ์ž ์—ฐ์‚ฐ์ž์˜ ์‹ ๊ธฐํ•œ ๊ด€๊ณ„๊ฐ€ ๋‚˜์˜ต๋‹ˆ๋‹ค. ๋ฐ”๋กœ p[n]์ด๋ผ๋Š” ์‹์ด *(p + n)๊ณผ ๋™์น˜๋ผ๋Š” ์ ์ž…๋‹ˆ๋‹ค. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ &p[n]์€ p + n๊ณผ ๋™์น˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

์–ด๋–ค ํฌ์ธํ„ฐ p์— ๋Œ€ํ•ด ์‹ &*p์˜ ๊ฒฐ๊ณผ๊ฐ’์€ ํ•ญ์ƒ p์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค. p[n]์ด *(p + n)๊ณผ ๊ฐ™์œผ๋‹ˆ, &p[n]์€ &*(p + n)์ด ๋˜๊ณ , ๋‹ค์‹œ p + n์ด ๋ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[] = { 1, 2, 3 };
    int *p = arr;
    printf("%d %d %d", *(p + 0), *(p + 1), *(p + 2));
}
1 2 3

์ˆ˜ํ•™์—์„œ์˜ ๋ง์…ˆ์€ ๋ณดํ†ต ๊ตํ™˜๋ฒ•์น™์ด ์„ฑ๋ฆฝํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์Šต๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ์˜ ๋ง์…ˆ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค. p + n๊ณผ n + p๋Š” ๊ฐ™์€ ๊ฒฐ๊ณผ๊ฐ’์„ ๋ƒ…๋‹ˆ๋‹ค. ์ฆ‰, ํ•œ ์ชฝ์€ ์ •์ˆ˜์ด๊ณ , ํ•œ ์ชฝ์€ ํฌ์ธํ„ฐ์ด๊ธฐ๋งŒ ํ•˜๋ฉด, ๋ฌด์—‡์ด ์ขŒ์šฐ ์–ด๋А์ชฝ์— ์žˆ๋“  ์ •์ˆ˜์ธ ์ชฝ์— sizeof(T)๋ฅผ ๊ณฑํ•ด์„œ ๋”ํ•ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int *p = (int *)0x10;
    printf("%p %p %p", p, 1 + p, 2 + p);
}
00000010 00000014 00000018

C์˜ ์ฒจ์ž ์—ฐ์‚ฐ์ž๋„ ์ด๋Ÿฌํ•œ ๋ง์…ˆ ์—ฐ์‚ฐ์ž์˜ ์œ ์—ฐ์„ฑ์„ ๋ฐ›์•„๋“ค์˜€์Šต๋‹ˆ๋‹ค. i[j]๊ฐ€ *(i + j)์™€ ๋™์น˜์ด๊ณ , *(j + i)๋ž‘ ๊ฐ™์œผ๋‹ˆ j[i]๋„ i[j]์™€ ๊ฐ™๋‹ค๊ณ  ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[] = { 1, 2, 3 };
    printf("%d %d %d", 0[arr], 1[arr], 2[arr]);
}
1 2 3

์ฝ”๋“œ๊ฐ€ ์•ฝ๊ฐ„ ์œ„ํ™”๊ฐ์ด ๋“ค์ง€๋งŒ, ์ž˜ ์ž‘๋™ํ•˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋˜ ํฌ์ธํ„ฐ์— ์ •์ˆ˜๋ฅผ ๋บ„ ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ, ์ฒจ์ž ์—ฐ์‚ฐ์ž์—์„œ๋„ ๋™์ผํ•œ ์ผ์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[] = { 1, 2, 3 };
    int* p = arr + 2;
    printf("%d %d %d", (-2)[p], p[-1], *p);
}
1 2 3

์—ฌ๊ธฐ์„œ ์‚ฌ์šฉ๋œ - ์—ฐ์‚ฐ์ž๋Š” ๋บ„์…ˆ ์—ฐ์‚ฐ์ž๊ฐ€ ์•„๋‹ˆ๋ผ, ์‹์˜ ์•ž์— ๋ถ™์–ด์„œ ๊ทธ ์‹์— -1์„ ๊ณฑํ•˜๋Š” ๋‹จํ•ญ ์—ฐ์‚ฐ์ž์ž„์— ์ฃผ์˜ํ•ด์ฃผ์„ธ์š”(-n -> (-1) * n). ์ฒจ์ž ์—ฐ์‚ฐ์ž๊ฐ€ ์ด ์—ฐ์‚ฐ์ž๋ณด๋‹ค ์šฐ์„ ์ˆœ์œ„๊ฐ€ ๋†’๊ธฐ ๋•Œ๋ฌธ์—, -2[p]๋ผ๊ณ  ์“ฐ๋ฉด -(2[p])๋กœ ํ•ด์„๋˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

๋‹ค์‹œ ์ˆ˜ํ•™์œผ๋กœ ๋Œ์•„๊ฐ€๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ํฌ์ธํ„ฐ1 + ์ •์ˆ˜ = ํฌ์ธํ„ฐ2์ž…๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ์–‘ ๋ณ€์— ํฌ์ธํ„ฐ1์„ ๋นผ๋ฉด, ์ •์ˆ˜ = ํฌ์ธํ„ฐ2 - ํฌ์ธํ„ฐ1๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. C์—์„œ๋„ ์ด๋ ‡๊ฒŒ ํฌ์ธํ„ฐ๋ผ๋ฆฌ ๋บ„์…ˆ์ด ๊ฐ€๋Šฅํ•˜๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋Š” ์ผ๋ฐ˜ ์ •์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    int arr[] = { 1, 2, 3 };
    int diff = &arr[2] - &arr[0];
    printf("%d", diff);
}
2

&arr[2]์™€ &arr[0]์€ ์‹ค์ œ๋กœ 8์ด ์ฐจ์ด๋‚˜์ง€๋งŒ, ํฌ์ธํ„ฐ ๋ง์…ˆ์—์„œ sizeof(int)๋ฅผ ๊ณฑํ–ˆ๋˜ ๊ฒƒ์ฒ˜๋Ÿผ ๋บ„์…ˆ์—์„  sizeof(int)๋ฅผ ๋‚˜๋ˆ ์ฃผ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ diff์—๋Š” 8รท4์˜ ๊ฒฐ๊ณผ์ธ 2๊ฐ€ ๋“ค์–ด๊ฐ€๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ ๋บ„์…ˆ์˜ ๊ฒฐ๊ณผ๋Š” int๊ฐ€ ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์—, ์ด ์˜ˆ์ œ์—์„œ๋„ ์ถ•์†Œ ๋ณ€ํ™˜์ด ์ผ์–ด๋‚˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค. ์œ„์—์„œ sizeof์˜ ๊ฒฐ๊ณผ๊ฐ€ int๊ฐ€ ์•„๋‹ˆ๋ผ๋Š” ๊ฒƒ์„ ๋‹ค๋ค˜๋Š”๋ฐ์š”, ์ด ๋บ„์…ˆ์˜ ๊ฒฐ๊ณผ ์ž๋ฃŒํ˜•๋„ sizeof์˜ ๊ฒฐ๊ณผ ์ž๋ฃŒํ˜•๊ณผ ํ•จ๊ป˜ ๋‹ค๋ฃจ๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

์„œ๋กœ ๋‹ค๋ฅธ ์ž๋ฃŒํ˜•์˜ ํฌ์ธํ„ฐ ๋‘ ๊ฐœ๋ฅผ ๋นผ๋Š” ์ฝ”๋“œ๋„ ์ปดํŒŒ์ผ์€ ๋ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ๊ทธ๊ฑด ๋ฌด์–ธ๊ฐ€ ์•”์‹œ์ ์ธ ํ˜•๋ณ€ํ™˜์ด ์ผ์–ด๋‚ฌ๊ธฐ ๋•Œ๋ฌธ์ด์ง€, ์œ ํšจํ•œ C ์ฝ”๋“œ์ด๊ธฐ ๋•Œ๋ฌธ์€ ์•„๋‹™๋‹ˆ๋‹ค. C๋Š” ์†Œ์œ„ ์•ฝํƒ€์ž…(weakly typed) ์–ธ์–ด๋ผ๊ณ  ๋ถˆ๋ฆฌ๋Š”๋ฐ์š”, ์•”์‹œ์ ์ธ ํ˜•๋ณ€ํ™˜์„ ํ—ˆ์šฉํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์•„์ฃผ ๋งŽ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. C++์€ C๋ณด๋‹ค ๊ฐ•ํƒ€์ž…(strongly typed)์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์™œ๋ƒํ•˜๋ฉด C++์—์„  C๋ณด๋‹ค ์•”์‹œ์ ์ธ ํ˜•๋ณ€ํ™˜์„ ํ—ˆ์šฉํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ์—์„œ๋„ C++์€ ์•”์‹œ์ ์ธ ํ˜•๋ณ€ํ™˜์„ ํ—ˆ์šฉํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์„œ๋กœ ๋‹ค๋ฅธ ์ข…๋ฅ˜์˜ ํฌ์ธํ„ฐ๋ฅผ ๋นผ๋Š” ๊ฒƒ์€ C++์—์„œ ์˜ค๋ฅ˜์ž…๋‹ˆ๋‹ค.

์ผ๋ฐ˜ ์ •์ˆ˜ ์ž๋ฃŒํ˜•์—์„œ์ฒ˜๋Ÿผ ํฌ์ธํ„ฐ์—์„œ๋„ ๋ณตํ•ฉ ๋Œ€์ž… ์—ฐ์‚ฐ์ž +=, -=์™€ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž ++, --๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <stdio.h>

int main()
{
    double arr[] = { 1, 2, 3 };
    double* p = arr;
    printf("%lf ", *(p++));
    printf("%lf ", *(++p));
    printf("%lf ", *p);
    p -= 2;
    printf("%lf ", *p);
    p += 2;
    printf("%lf ", *(p--));
    printf("%lf ", *(--p));
}
1.000000 3.000000 3.000000 1.000000 3.000000 1.000000

์ •์ˆ˜ ์ž๋ฃŒํ˜•์—์„œ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž๊ฐ€ 1์„ ๋”ํ•˜๊ณ  ๋นผ๋˜ ๊ฒƒ ์ฒ˜๋Ÿผ ํฌ์ธํ„ฐ์—์„  sizeof(T)๋ฅผ ๋”ํ•˜๊ณ  ๋นผ๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ์˜ ๋ง์…ˆ๊ณผ ๋บ„์…ˆ์—์„œ sizeof(T)๊ฐ€ ๊ณฑํ•ด์ง€๊ฑฐ๋‚˜ ๋‚˜๋ˆ ์ง€๋Š” ์ด์œ ๋Š” ๋ฌด์—‡์ผ๊นŒ์š”? C์—์„œ sizeof(T)๋ฅผ ์ž๋™์œผ๋กœ ๊ณฑํ•ด์ฃผ์ง€ ์•Š๋Š”๋‹ค๊ณ  ๊ฐ€์ •ํ•ด๋ด…์‹œ๋‹ค. ์ž๋ฃŒํ˜•์ด int์ธ ๋ณ€์ˆ˜ i๊ฐ€ 812~815๋ฅผ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ๋‹ค๊ณ  ํ–ˆ์„ ๋•Œ, &i + 1์€ 813์ด ๋ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ์ƒˆ ๋ณ€์ˆ˜ j๋ฅผ ๋งŒ๋“ค์–ด j = *(&i + 1)์ฒ˜๋Ÿผ ๋Œ€์ž…ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿผ j์—๋Š” 813~816์— ๋“ค์–ด์žˆ๋˜ ์ •์ˆ˜๊ฐ€ ๋Œ€์ž…๋˜๊ฒŒ ๋˜๋Š”๋ฐ, ์˜๋ฏธ์žˆ๋Š” ๊ฐ’์ด ๋“ค์–ด์žˆ์„ ๊ฒƒ์ด๋ผ๊ณ  ๋งํ•˜๊ธฐ ํž˜๋“ญ๋‹ˆ๋‹ค. ๋งŒ์•ฝ์— ์ด ์ƒํ™ฉ์—์„œ ๋ฐฐ์—ด์„ ์„ž์–ด์“ด๋‹ค๊ณ  ํ•˜๋ฉด, j = arr์ด๋ผ๊ณ  ํ–ˆ์„ ๋•Œ arr[n]์„ ์“ฐ๊ธฐ ์œ„ํ•ด์„  j + n * sizeof(int)๋ผ๊ณ  ์จ์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋•Œ ์–ด๋–ค ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” sizeof(int)๋ฅผ ๊ณฑํ•˜๋Š” ๊ฒƒ์„ ๊นŒ๋จน์„ ์ˆ˜๋„ ์žˆ๋Š”๋ฐ์š”, ์ด๋Ÿฌ๋ฉด ๋ฒ„๊ทธ์˜ ๊ฐ€๋Šฅ์„ฑ์ด ๋†’์•„์ง‘๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ ์ด๋Ÿฐ ์—ฌ๋Ÿฌ๊ฐ€์ง€ ์ƒํ™ฉ์„ ๊ณ ๋ คํ•˜์—ฌ, C์—์„  ํฌ์ธํ„ฐ์— ์ •์ˆ˜ N์„ ๋”ํ•˜๋ฉด sizeof(T)๊ฐ€ ์ž๋™์œผ๋กœ ๊ณฑํ•ด์ง€๋„๋ก ๋˜์–ด์žˆ์Šต๋‹ˆ๋‹ค.

์ด ๋ถ€๋ถ„์€ ๋ฉ”๋ชจ๋ฆฌ ์ •๋ ฌ(Memory alignment)์ด๋ผ๋Š” ๊ฒƒ๊ณผ๋„ ๋ฐ€์ ‘ํ•œ ์—ฐ๊ด€์„ ๋งบ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ง€๊ธˆ๊นŒ์ง€์˜ ์˜ˆ์ œ์—์„œ int ๋ณ€์ˆ˜์™€ ๋ฐฐ์—ด์˜ ์ฃผ์†Œ๊ฐ’์ด ๋ชจ๋‘ 4์˜ ๋ฐฐ์ˆ˜์˜€๋‹ค๋Š” ๊ฒƒ์„ ๋ˆˆ์น˜์ฑ„๊ณ  ๊ณ„์…จ๋‚˜์š”? ์‹ค์ œ ์ปดํ“จํ„ฐ์—์„  ๋ฉ”๋ชจ๋ฆฌ ๊ตฌ์กฐ์— ์˜ํ•ด, n๋ฐ”์ดํŠธ์˜ ์ •์ˆ˜/๋ถ€๋™์†Œ์ˆ˜์  ์ž๋ฃŒํ˜•์€ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๊ฐ€ n์˜ ๋ฐฐ์ˆ˜์ธ ๊ณต๊ฐ„์—์„œ๋ถ€ํ„ฐ n๋ฐ”์ดํŠธ๋ฅผ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰, int๊ฐ€ 8~11์„ ์ฐจ์ง€ํ•˜๋Š” ๊ฒƒ์€ 8์ด 4์˜ ๋ฐฐ์ˆ˜์ด๊ธฐ ๋•Œ๋ฌธ์— ๊ดœ์ฐฎ์ง€๋งŒ 6~9์€ 6์ด 4์˜ ๋ฐฐ์ˆ˜๊ฐ€ ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ๊ดœ์ฐฎ์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๊ทธ๋ƒฅ ๊ฐ’์„ ๋ถˆ๋Ÿฌ๋“ค์ด๋Š” ์†๋„๊ฐ€ ๋А๋ฆฐ ๊ฒฝ์šฐ๋„ ์žˆ์ง€๋งŒ, ์—ฐ์‚ฐ์žฅ์น˜์˜ ์ข…๋ฅ˜์— ๋”ฐ๋ผ ๋ฉ”๋ชจ๋ฆฌ ์ •๋ ฌ์ด ์˜ฌ๋ฐ”๋ฅด์ง€ ์•Š์œผ๋ฉด ์ž‘๋™์„ ๋ฉˆ์ถ”๋Š” ๊ฒฝ์šฐ๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฉ”๋ชจ๋ฆฌ ์ •๋ ฌ์— ๊ด€ํ•œ ๊ฒƒ๋„ ๋‚˜์ค‘์— ๋‹ค๋ฃฐ ์˜ˆ์ •์ž…๋‹ˆ๋‹ค.

๋‹ค์Œ: ์ œ์–ด ํ๋ฆ„