ํฌ์ธํฐ์ ๋ฐฐ์ด์ ๋ํด ์์๋ณด๊ณ , ๋ณ์๋ฅผ ์ ๋ ฅ๋ฐ๋ ๋ฐฉ๋ฒ์ ๋ํด ๋ฐฐ์๋๋ค.
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๋ฒ์ ์ฐจ์งํ๊ณ ์๋ค๊ณ ๊ฐ์ ํด๋ด
์๋ค. ๊ทธ๋ผ ์ด ํ๋ก๊ทธ๋จ์ ์ฌ๋์ด ํ๋ ๋ง์ ๊ฐ๊น๊ฒ ์ฎ๊ธฐ๋ฉด,
์ด๋ ๊ฒ ํด์๋ ์ ์์ต๋๋ค. ๊ฐ ๋ฌธ์ฅ์ ์ค๋ช ๊ณผ ์คํ ํ ๋ฉ๋ชจ๋ฆฌ ์ํ๋ฅผ ์ ์ฌํ ๋ด์ฃผ์ธ์.
*
์์ฐธ์กฐ ์ฐ์ฐ์(indirection operator)
๋ผ๊ณ ๋ถ๋ฆฝ๋๋ค. ์ฐธ์กฐ ์ฐ์ฐ์๋ ์ฃผ์ ์ฐ์ฐ์์ฒ๋ผ ์ฐ์ ์์๊ฐ ์ฐ์ ์ฐ์ฐ์๋ค๋ณด๋ค ๋๊ณ , ๊ฒฐํฉ๋ฐฉํฅ์ด ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ ๋๋ค.
int *p;
๊ฐ์ด ๋ณ์๋ฅผ ์ ์ธํ ๋์*
๊ณผ*p = 6;
๊ฐ์ด ์์ ์ฌ์ฉํ์ ๋์*
์ ๋ค๋ฅธ ์๋ฏธ๋ฅผ ๊ฐ์ง๋๋ค. ์ ์๋ ๊ทธ ๋ณ์๊ฐ ํฌ์ธํฐ๋ผ๋ ํ์์ด๊ณ , ํ์๋ ํฌ์ธํฐ ์์ ๋ถ์ด ๊ทธ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ณ์๋ฅผ ๊ฐ์ ธ์ค๋ ์ฐ์ฐ์์ ๋๋ค.
์ด๊ธฐํ๋์ง ์์๊ฑฐ๋ ๋์ ๋์ง ์์ ํฌ์ธํฐ๋ ์์ ์ด๋ค ์ฃผ์๊ฐ ๋ค์ด์๋์ง ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์, ๊ทธ๋ฐ ํฌ์ธํฐ๋ค์ ์ฐธ์กฐ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ ์ ์๋์ง ์์ ํ๋์ ๋๋ค. ์ด๊ฒ์ ๋ํ ์์ธํ ์ค๋ช ์ ๋์ค์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ์ต๋๋ค.
์ง๊ธ๊น์ง์ ์์ ์์ ๋์
์ฐ์ฐ์์ ์ขํญ์ ํญ์ ๋ณ์๊ฐ ๋ค์ด๊ฐ์ต๋๋ค. 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
์ ๋นจ๊ฐ์ค์ด ๋จ๋ฉด์ ์๋ํฐ์์ ์๋ฌ ๋ฉ์์ง๋ฅผ ํ์ํ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
"expression must be a modifiable lvalue", ์ฆ "ํํ์์ด ์์ ๊ฐ๋ฅํ ์ข์ธก๊ฐ์ด์ด์ผ ํฉ๋๋ค"์
๋๋ค. ์ค์ ๋ก Ctrl + F5
๋ฅผ ๋๋ฌ ์คํํด๋ณด๋ ค๊ณ ํ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ๋น์ทํ ๋ฉ์์ง์ ํจ๊ป ์๋ฌ๋ฅผ ํ์ํ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
ํฌ์ธํฐ๋ ๋ณ์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ง์ ์ ์ผ๋ก ๋ค๋ฃจ๊ธฐ ์ํ ์๋ฃํ์ ๋๋ค. ๊ทธ๋ฐ๋ฐ, ํฌ์ธํฐ ์์ฒด๋ ๋ณ์์ ๋๋ค. ๊ทธ๋์ 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
๋ฅผ ์ฌ์ฉํ๊ธฐ ์ , ํ์ํ ์ฌ์ ์์
์ด ์์ต๋๋ค. ์๋ฃจ์
ํ์๊ธฐ์์ ํ๋ก์ ํธ๋ฅผ ๋ง์ฐ์ค ์ค๋ฅธ์ชฝ ๋ฒํผ์ผ๋ก ํด๋ฆญํ ํ, ์์ฑ
์ ๋๋ฌ์ฃผ์ธ์.
๊ทธ๋ผ ๋ค์๊ณผ ๊ฐ์ด ํ๋ก์ ํธ์ ์์ฑ ์ค์ ์ฐฝ์ด ํ์๋ฉ๋๋ค. ์ฌ๊ธฐ์ ์ผ์ชฝ์ ๋ฉ๋ด์์ C/C++
> ์ ์ฒ๋ฆฌ๊ธฐ(Preprocessor)
๋ฉ๋ด์ ๋ค์ด๊ฐ์ฃผ์ธ์.
์ฌ๊ธฐ์ Configuration
๊ณผ Platform
์ ๋ชจ๋ All Configurations
๊ณผ All Platforms
์ผ๋ก ๋ฐ๊พผ ํ, Preprocessor Definitions
์ _CRT_SECURE_NO_WARNINGS;
๋ฅผ ๋งจ ์์ ๋ฃ์ด์ฃผ์ธ์. _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);
}
ํ๋ก๊ทธ๋จ์ด ์คํํ๋ฉด, ์ปค์๊ฐ ๊น๋นก์ด๋ฉด์ ์๋ฌด๊ฒ๋ ๋จ์ง ์์ต๋๋ค.
์ด ์ํ๋ก ๋ฌด์ธ๊ฐ ์ ๋ ฅํ๋ฉด, ๊ธ์จ๊ฐ ๋น๋๋ค. ๋ฐฑ์คํ์ด์ค๋ ์๋ํ๊ณ ์.
์ด ์ํ๋ก ์ํฐ๋ฅผ ๋๋ฌ์ฃผ์ธ์.
: 12
24
์์ผ๋ก
:
๋ ์ฌ์ฉ์์ ์ ๋ ฅ ์์๋ฅผ ๋ํ๋ด๋ ํ์๋ก ์ฌ์ฉํ๊ฒ ์ต๋๋ค.
์
๋ ฅํ ์ ์์ ๋ ๋ฐฐ๊ฐ ๋๋ ์ ์๊ฐ ์ถ๋ ฅ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ์ด ์์ ์์ i
๊ฐ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ 120~123์, p
๊ฐ 124~127์ ์ฐจ์งํ๊ณ ์๋ค๊ณ ๊ฐ์ ํ๊ณ , ๊ฐ ๋ฌธ์ฅ์ ์์ธํ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์ด๋ ๊ฒ 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
๋ก ์ ๋ ฅํด๋ ์ถ๋ ฅ์ด ๊ฐ์ต๋๋ค.
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
์์ ๋ง์ฐ์ค๋ฅผ ์ฌ๋ ค์ฃผ์ธ์. ๋ญ๊ฐ ํ์๋๋์?
๋ฐ๋ก 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์ ์ฐจ์งํ๊ณ ์๋ค๊ณ ๊ฐ์ ํ๊ฒ ์ต๋๋ค.
์ฌ๊ธฐ์ arr[n]
์ ์ ํํ ์ด๋ค ์ผ์ ํ๋์? arr
์ ์ฃผ์๋ฅผ p
๋ผ๊ณ ํ์ ๋, p+nร4
๋ฅผ ๊ณ์ฐํ๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค. ๋ง์ฝ arr
์ ์์๊ฐ int
๊ฐ ์๋๋ผ double
์ด์๋ค๋ฉด arr[n]
์ int
์ ํฌ๊ธฐ์ธ 4
๊ฐ ์๋๋ผ 8
์ ์ฌ์ฉํ์ฌ p+nร8
์ ๊ณ์ฐํ๋ ์์ด ๋์์ ๊ฒ์
๋๋ค. ์ฆ, ์ฒจ์ ์ฐ์ฐ์๋ ์ค์ ๋ก๋ ๋ฐฐ์ด์ด ๋ด๋ ๊ฐ๋ค์ ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ๊ณฑํ ํ ๋ฐฐ์ด์ด ๊ฐ์ง๋ ์ฃผ์์ ๋ํ๋ ์ฐ์ฐ์ ํ๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
C์์ ์ ์์ ์ฒ๋ผ ์๋ฃํ์ ํฌ๊ธฐ ์์ฒด๊ฐ ์ค์ํด์ง๋ ๊ฒฝ์ฐ๊ฐ ๋ช๋ช ์์ต๋๋ค. ์ฒจ์ ์ฐ์ฐ์๋ ์์์ ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ๊ณฑํด์คฌ์ง๋ง, ์ง์ ํ๋ก๊ทธ๋๋จธ๊ฐ ์๋ฃํ์ ํฌ๊ธฐ๋ก ์์ ๋ง๋ค์ด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค. ์ด ๋ sizeof
๋จํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. sizeof
๋ ์ฐ์ ์ฐ์ฐ์๋ณด๋ค ์ฐ์ ์์๊ฐ ๋๊ณ , ๊ฒฐํฉ ๋ฐฉํฅ์ด ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์
๋๋ค. sizeof
์ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ๋ ๊ฐ์ง์
๋๋ค.
- ๊ฒฐ๊ณผ๊ฐ์ด ์ฃผ์ด์ง ์์ ์๋ฃํ์ ํฌ๊ธฐ๊ฐ ๋ฉ๋๋ค.
sizeof <์>
- ๊ฒฐ๊ณผ๊ฐ์ด ์ฃผ์ด์ง ์๋ฃํ์ ํฌ๊ธฐ๊ฐ ๋ฉ๋๋ค.
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 ์๋ํฐ์ ์ ๋ ฅํด๋ณด๋ฉด, ์ค๋ฅ๊ฐ ํ์๋๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ, "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);
}
๊ทธ๋ฐ๋ฐ ์ฌ๋ฌ๋ถ์ด ์ง๊ธ๊น์ง ์๋๋ ํฌ๋กฌ๊ฐ์ ํ๋ก๊ทธ๋จ์ ์ฌ์ฉํ์๋ฉด์ ์ง์ ์ฃผ์๋ฅผ ์ ๋ ฅํด์ผํ๋ ์ ์ด ์๋์? ์ ์ด๋ ์ ๊ทธ๋ฐ ๊ฒฝ์ฐ๋ฅผ ๋ณธ ์ ์ด ์์ต๋๋ค. ์ด ๊ธฐ๋ฅ์ ์ฌ๋ฌ๋ถ์ด ์์ผ๋ก ์ธ ์ผ์ด ์์ ๊ฒ์ ๋๋ค.
์๊น ๋ฐฐ์ด์ด ํฌ์ธํฐ๋ก ์์์ ์ผ๋ก ๋ณํ๋์ง ์์ ์กฐ๊ฑด์ ์ฒจ์ ์ฐ์ฐ์๊ฐ ์์๋ ๊ฒ, ๊ธฐ์ตํ์๋์? ๋ฐ๊ฟ ๋งํ์๋ฉด, 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์ ๋ฐฐ์๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ๊ด์ฐฎ์ง ์์ต๋๋ค. ๊ทธ๋ฅ ๊ฐ์ ๋ถ๋ฌ๋ค์ด๋ ์๋๊ฐ ๋๋ฆฐ ๊ฒฝ์ฐ๋ ์์ง๋ง, ์ฐ์ฐ์ฅ์น์ ์ข ๋ฅ์ ๋ฐ๋ผ ๋ฉ๋ชจ๋ฆฌ ์ ๋ ฌ์ด ์ฌ๋ฐ๋ฅด์ง ์์ผ๋ฉด ์๋์ ๋ฉ์ถ๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ๋ฉ๋ชจ๋ฆฌ ์ ๋ ฌ์ ๊ดํ ๊ฒ๋ ๋์ค์ ๋ค๋ฃฐ ์์ ์ ๋๋ค.