[Practice & Tips] Practice 5 : ํฌ์ธํฐ์ ๋ณ์, ๋ฐฐ์ด๊ณผ ์ฐธ์กฐ
1. ํฌ์ธํฐ์ ๋ณ์
A) ๋ณ์์ ํฌ์ธํธ ๋ณ์
a) ๋ณ์
: ๋ฐ์ดํฐ ์ ์ฅ์ ๋ชฉ์ ์ผ๋ก ํ๋ก๊ทธ๋จ์ ์ํด ํ ๋น๋์ด์ง ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ช ์นญ์ผ๋ก, ๋ณ์๋ฅผ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ์ ์ธ๊ณผ ์ ์ ๊ณผ์ ์ ๊ฑฐ์ณ์ผ ํ๋ค.
ex) int o;
o = 10;
b) ํฌ์ธํฐ ๋ณ์
: ํน์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ๋ฅดํค๋ ๋ณ์
# ์ง์ ๋ฐฉ๋ฒ : ์๋ฃํ์ ๋ค์ชฝ์ '*'๋ฅผ ์ฒจ๊ฐํจ์ผ๋ก์จ ํฌ์ธํฐ ๋ณ์๋ฅผ ๋ง๋ค ์ ์๋ค.
ex) int* p;, int** r;
# ํฌ์ธํฐ ๋ณ์์ ๋ค๋ฅธ ์ด๋ฆ
: ์๋ฃํ์ ๋คํธ์ 1๊ฐ์ '*'๊ฐ ์ฒจ๊ฐ๋ ํฌ์ธํฐ ๋ณ์๋ ์ผ์ค ํฌ์ธํฐ ๋ณ์๋ผ๊ณ ๋ ๋ถ๋ฅด๋ฉฐ, ํ๋ฌธ์์ ์๋ฏธ๋ ์ผ๋ฐ ํฌ์ธํฐ ๋ณ์์ ๋์ผํ๋ค.
B) ํฌ์ธํฐ ์ ์ธ ๋ฐ ์ด๊ธฐํ
a) ๋ถ๋ฆฌํ ์ ์ธ
# int *p; ๋ฑ ๊ณผ ๊ฐ์ด ํฌ์ธํฐ ๋ณ์ p๋ฅผ ์ ์ ์ง์ ๋ฉ๋ชจ๋ฆฌ์ ๋ํด ์ ์ธ
์ดํ p = &n; ๊ณผ ๊ฐ์ด๋ณ์ p ๋ฅผ &๊ธฐํธ๋ฅผ ์ฌ์ฉํ์ฌ n์ ์ฃผ์๋ฅผ p์ ์ ์ฅํ๋ค. ์ด๋ฌํ ์์ฉ์ ์ด๊ธฐํ๋ผ๊ณ ํ๋ค.
์ด๋ ๋ณ์์ ์ฃผ์๋ฅผ ๋ถ๋ฌ์ค๋ ๊ธฐํธ์ธ '&'์ ๋ฉ๋ชจ๋ฆฌ ์ ํฌ์ธํฐ๊ฐ ์ง์ ํ๋ ๊ฐ์ ์ถ์ถํ๋ ๊ธฐํธ์ธ '*'์ ์ฌ์ฉํ๋ค.
b) ํตํฉํ ์ ์ธ
# ๋ถ๋ฆฌํ ์ ์ธ๊ณผ๋ ๋ฌ๋ฆฌ n๊ณผ์ ๋งค์นญ ์์ ๊ณผ ํฌ์ธํฐ ์ ์ธ์ ๋์์ ์งํํ๋ ์ ์ธ ๋ฐฉ์์ด๋ค.
'int *p = &n '์ฒ๋ผ ํฌ์ธํฐ p๋ฅผ ์ ์ธํ๋ฉฐ ์ด๋ฅผ &์ ์ฌ์ฉํ์ฌ n๊ณผ ๋งค์นํ๋ค.
c) ์๋ฃํ์ ํฌ๊ธฐ
# ์ ์ํ ์๋ฃํ
- char : 1
- short : 2
- long : 4
- long long : 8
- int : 4
# ์ค์ํ ์๋ฃํ
- float : 4
- double : 8
C) ํฌ์ธํฐ, ๋ณ์์ ๊ด๋ จ๋ ํฌ๊ธฐ
a) ํฌ์ธํฐ๊ฐ ์ง์ํ๋ ๋ณ์ ํฌ๊ธฐ
- int ํ -> 4byte์ ํฌ๊ธฐ ๋งํผ ์ฝ์ด๋ค์
- char ํ -> 1byte ์ ํฌ๊ธฐ๋งํผ ์ฝ์ด๋ค์
- doubleํ -> 8byte์ ํฌ๊ธฐ๋งํผ ์ฝ์ด๋ค์
b) ํฌ์ธํฐ ๋ณ์ ๊ทธ ์์ฒด์ ํฌ๊ธฐ
- ํฌ์ธํฐ ๋ณ์๋ ๊ทธ ์์ฒด๋ก 4byte์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ค.
ex) sizeof (๋ชจ๋ ํฌ์ธํธ ๋ณ์) = 4
2. ํฌ์ธํฐ์ ๋ฐฐ์ด
A) ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ ๋ณ์
# ๋ฐฐ์ด : ์๋ฃ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๋์ดํ ๊ตฌ์กฐ๋ฅผ ์๋ฏธํ๋ฉฐ, ๋ฐ์ดํฐ ํ์์ ํฌ๊ธฐ๋งํผ ๊ฐ ์์๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์งํ๋ค. ๋ฐฐ์ด์ [์๋ฃํ] [์๋ณ์] [๋ฐฐ์ด ํฌ๊ธฐ] ์ ํ์์ผ๋ก ์ ์ธ์ด ๊ฐ๋ฅํ๋ค.
๋ฐฐ์ด์ ๊ฐ ์์๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์ด์ด ๋์ด๊ณ , ๋ฐฐ์ด์ ๊ทธ ๋ค์ ์์น์ ์์๋ก ์ ๊ธ ์ *(ํฌ์ธํฐ ๋ณ์ +1)๋ก ํํํ๋ค. ๊ทธ ๋ค์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฒ์ผ๋ก๋ถํฐ m๋งํผ ๋จ์ฌ์ ธ ์๋ ์์์๋ *(ํฌ์ธํฐ ๋ณ์ +m)์ ํํ์ ์ฌ์ฉํ๋ค.
ex) int n[5] = { 1, 2, 3, 4, 5 };
ex) int n[4] = { 1, 2, 3, 4 };
int *p = NULL;
p = n; or p = &n[0];
# ํฌ์ธํฐ ๋ณ์ : ๋ฉ๋ชจ๋ฆฌ ์ ํน์ ์ฃผ์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ณ์์ด๋ค.
ex) int *p = NULL; -> ํน์ ๋ฐฐ์ด์ ๋ํ์ฌ ํฌ์ธํฐ ๋ณ์๋ฅผ ์ด๊ธฐํํ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ์ฃผ์๋ก ์ง์ ํ๋ค.
p = n; or p= &n[0];
3. ์ฐธ์กฐ
A) ์ฐธ์กฐ์ ์ฐธ์กฐ์ ์ ์ธ
# ์ฐธ์กฐ
: ์ด๋ฏธ ์กด์ฌํ๋ ๋ณ์์ ๋ ๋ค๋ฅธ ์ด๋ฆ์ธ ๋ณ๋ช ์ ๋ถ์ด๋ ๊ฒ์ผ๋ก, ๋ง๋ค์ด์ง ๋ณ๋ช ์ ํตํด ๋ณ์์ ๊ณ ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ผ๋ก ๋ค์ด๊ฐ ์ ์๋ค. ํ์ง๋ง ๋ณ๋ช ์ ์ง๋ ๊ฒ์ผ ๋ฟ ๋ฉ๋ชจ๋ฆฌ์ ์๋ก์ด ๊ณต๊ฐ์ ์ฃผ๋ ๊ฒ์ ์๋๋ฉฐ, ๊ธฐ์กด์ ๋ณ์๋ฅผ ๋์ ํ์ฌ ์ฐ์ผ ๋ฟ์ด๋ค. ๋ง์ ์ปดํจํฐ ์ธ์ด ์ค์์๋ C++ ์์ ์ฒ์์ผ๋ก ์ฐ์ธ ๊ฐ๋ ์ผ๋ก, ํจ์๋ฅผ ๋ถ๋ฌ๋ผ ๋ ์์ฃผ ์ฐ์ธ๋ค.
# ์ฐธ์กฐ์ ์ ์ธ
: ์ปดํ์ผ๋ฌ์๊ฒ ์ง๊ธ ์ฐธ์กฐํ ๋ด์ฉ์ด ๋ ๋ค๋ฅธ ์ด๋ฆ์์ ์๋ฆฌ๋ ์ญํ ์ด๋ฉฐ, ์ ์ธ ๋ฐฉ๋ฒ์ ์ง์ ํ๊ณ ์ ํ๋ ํ์ ๋ค์ '&'์ ๋ถ์ด๋ ๋ฐฉ์์ผ๋ก ์งํ๋๋ค.
ex) int n = 2;
int &ref = n;
B) ์ฐธ์กฐ์ ํฌ์ธํฐ์ ์ฐจ์ด
# ํฌ์ธํฐ ๋ณ์๋ ์๋ก์ด ๋ณ์๋ฅผ ๋ง๋๋ ์์ ์ ์ํํ๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ณ๋ ๊ณต๊ฐ์ ๋ถ์ฌํ ์ ์๋ค. ํ์ง๋ง ์ฐธ์กฐ์์ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ์ ๊ณต๊ฐ์ ๋ถ์ฌํ๋ ๋ฅ๋ ฅ์ ๊ฐ์ง๊ณ ์์ง ์๋ค.
# ํฌ์ธํฐ ๋ณ์์ ๊ฒฝ์ฐ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ๋ฐฐ์ด ๊ตฌ์กฐ ์ ๋ค๋ฅธ ์ธ๋ฑ์ค ์์ ๋ฉ๋ชจ๋ฆฌ์ ์ ๊ทผํ ์ ์์ผ๋, ์ฐธ์กฐ์์ ๊ฒฝ์ฐ ํฌ์ธํฐ์ ๋ฌ๋ฆฌ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ์ ๊ทผํ ์ ์์ผ๋ฉฐ, ์ด์ ๋ฐ๋ผ ์์ ์ฑ์ด ํฌ์ธํฐ์ ๋นํด ๋๋ค.
# ํฌ์ธํฐ ๋ณ์๋ ์ฃผ์์ ๊ฐ์ ์ด์ฉํ์ฌ ํด๋น ๋ฐ์ดํฐ์ ์ ๊ทผํ๋ค. ๋ฐ๋ผ์ ๊ทธ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ด ํน์ ๋์์ ์ธ๋ฑ์ค ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฌ๋ ์ฐธ์กฐ์๋ ๋ณ์ ๋ด๋ถ์ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ ๊ถํ์ด ์๋ ๊ทธ์ ๋ณ๋ช ์ ๋ถ๊ณผํ๋ค๋ ํน์ง์ด ์๋ค.
4. ํจ์์ ์ธ์ ์ ๋ฌ ๋ฐฉ์
A) ํจ์ ํธ์ถ๊ณผ ์ธ์ ์ ๋ฌ
# ํจ์ ํธ์ถ
: ํน์ ํ๋ก๊ทธ๋จ์์ ๊ธฐ๋ฅ์ ๊ตฌํํ๋ ์ํฉ์์ ์ฌ์ฉ์ ์ ์ ํจ์๋ฅผ ํ๋ฒ ๋ง๋ค์ด ๋๊ณ ํ์ํ ๋๋ง๋ค ๋ค์ ๋ง๋๋ ๊ณผ์ ์์ด ๋ถ๋ฌ์ ํธ๋ฆฌํ๊ฒ ์ฐ๋ ๊ฒ์ ๋งํ๋ค. ํจ์๊ฐ ํธ์ถ๋๋ฉด ํจ์ ์์ ์กด์ฌํ๋ ๋ฌธ์ฅ๋ค์ด ์์๋๋ก ์คํ๋๊ณ , ์ด ๋ฌธ์ฅ๋ค์ด ๋ชจ๋ ์คํ๋๋ฉด ํธ์ถ๋์ด์ง ์์น๋ก ๋ค์ ๋๋์๊ฐ๋ค.
B) Call by X ์ธ์ ์ ๋ฌ ๋ฐฉ์
a) Call by value
: ์ธ์์ ๊ฐ์ ํจ์์ ์ ๋ฌํ๋ ๋ฐฉ์์ผ๋ก, ์ธ์์ ๊ฐ์ด ๋งค๊ฐ๋ณ์๋ก ๋ณต์ฌ๋๋ ๊ณผ์ ์ ๊ฑฐ์ณ์ผ ํ๋ค. ์ด๋ ๋ง๋ค์ด์ง ๋งค๊ฐ๋ณ์๋ค์ ๊ทธ๊ฒ๋ค์ ๊ฐ์ด ๋ฐ๋์ด๋ ์๋ณธ ๋ณ์๋ค์๊ฒ ์ํฅ์ด ์๊ธฐ ๋๋ฌธ์ ์์ ์ฑ์ด ์๋ ์ ๋ฌ ๋ฐฉ๋ฒ์ด๋ค.
์๋์ ์ฌ์ง์ฒ๋ผ swap ํจ์๋ฅผ ํธ์ถํด์ผ ํ๋ ์ํฉ์์ s ,n ๊ฐ์ ์ธ์์ ๊ฐ์ ๋งค๊ฐ ๋ณ์ k, m ์ผ๋ก ๋ณต์ฌ๋์ด ์ ๋ฌ๋๋ค. ์ดํ์ swap ํจ์์ ๊ณผ์ ์ด ์ํ๋๋ฉฐ ํจ์์ ํฌํจ๋ ์ง์ญ๋ณ์๋ค์ ๊ฐ์ด ์๋ก ๋ฐ๋๋ค. ์ ํ ์ดํ ๋ค์ main ํจ์๋ก ๋๋์์ค๊ณ , ํจ์ ํธ์ถ ์ดํ์ ๊ณผ์ ์ด ์คํ๋๋ค.
b) Call by address
: ํจ์๋ฅผ ํธ์ถํ ์์ญ ์ ์ค์ธ์๋ฅผ ์ธ๋ถ ํจ์์์ ์ ์ด ๊ฐ๋ฅํ๋๋ก ํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ฐฉ์์ผ๋ก, ํธ์ถ ๋งค๊ฐ์ฒด๊ฐ ์ฃผ์์ธ ๋ฐฉ๋ฒ์ด๋ค. ์ฃผ์๋ฅผ ์ ๋ฌ๋ฐ๋ ๊ณผ์ ์ด ์กด์ฌํ๊ธฐ์ ์์ฉํ๋ ์ชฝ์ ํฌ์ธํฐ์ฌ์ผ๋ง ํ๋ฉฐ, ๋์ฒด์ ์ผ๋ก ๋์ ๋ฐฉ์์ด ๊ฐ์ ์ํ ํธ์ถ ๋ฐฉ์๊ณผ ์ ์ฌํ๋ค๋ ํน์ง์ด ์๋ค.
์๋์ ์ฌ์ง์์ ๋ณผ ์ ์๋ฏ p, z์ ์ฃผ์๊ฐ ๊ฐ๊ฐ ๋งค๊ฐ๋ณ์์ธ r, k์ ํ ๋น๋๋ฉฐ r, k๊ฐ ํฌ์ธํฐ ๋ณ์๋ก์จ ์ ์ธ๋๋ค.
c) Call by reference
: ํจ์ ์์์ ์ธ๋ถ ๋ณ์๋ฅผ ๋ณ๊ฒฝํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ ๋ฐฉ์์ผ๋ก, ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฉด์๋ ํจ์ ํธ์ถ์ ๊ตฌํํ ์ ์๋ ๋ฐฉ๋ฒ์ด๋ค. ์ฒ์๋ถํฐ ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฐฉ๋ฒ์ ์๋๊ณ , C++์ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋๋ฉฐ ๊ฐ๋ฅํด์ง ๋ฐฉ์์ด๋ค. ์ ๋ณด๋ฅผ ๋ฐ์ ๋ & ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํจ์ผ๋ก์จ ์ค์ธ์์ ์ฐธ์กฐ ์ ๋ณด๋ฅผ ์ ๋ฌ๋ฐ๋ ๊ณผ์ ์ ๊ฑฐ์น๋ค. ๋ค๋ฅธ ํธ์ถ ๋ฐฉ์๊ณผ ๊ฒฐ๊ณผ๋ ๋น์ทํ์ง๋ง, ๋ค์ ์๋ฌ ๋ฐ์์ ๊ฐ๋ฅ์ฑ์ด ์ ๊ณ ๊ฐ๋ ์ฑ์ด ์ข๋ค๋ ํน์ง์ด ์๋ค.
์๋ ์ฌ์ง์์ ๋ณผ ์ ์๋ฏ p, z์ ๊ฐ์ด swap ํจ์์ ์์ผ๋ก ๋ค์ด๊ฐ๊ณ , ์ดํ int %w = z, int %l = p ์ ๊ณผ์ ์ ๊ฑฐ์ณ w์ ใ ฃ๊ฐ ๊ฐ๊ฐ z, p์ ์ฐธ์กฐ์๋ก ๋ฐ๋์๋ค.
5. inline ํจ์
: ํจ์์ ํธ์ถ ์ค๋ฒํค๋๋ฅผ ์์ ๊ธฐ ์ํด ์ฌ์ฉํ๋ ํจ์์ด๋ค.
ํจ์๋ฅผ ํธ์ถํ๋ ๊ฒฝ์ฐ์ ๊ฐํน '์ค๋ฒํค๋'๋ผ๋ ํ์์ด ๋ฐ์ํ์ฌ ํจ์ ํธ์ถ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๊ธธ์ด์ง๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ๋ค. C++์๋ ์ค๋ฒํค๋ ํ์์ ๋ง๊ธฐ ์ํ ํค์๋์ธ 'inline'์ด ์กด์ฌํ๊ณ , ํจ์๋ช ์์ ๋ถ์์ผ๋ก์จ ์ธ๋ผ์ธ ํจ์๋ฅผ ๋ง๋ค ์ ์๋ค.
ํจ์์ ์ด๋ฆ ์์ชฝ์ inline ํค์๋๊ฐ ๋ค์ด๊ฐ๊ฒ ๋๋ฉด ์ปดํ์ผ๋ฌ๋ ํจ์๋ฅผ ์์ฑํ๋ ๊ณผ์ ์์ด ํจ์์ ์ฝ๋๋ฅผ ํธ์ถํ ๊ณณ์ ์ง์ ๋ถ์ด๋ ์์ ์ ์ค์ํ๋ค.
ex) inline double square(double i){ return i*i;}