๋์ ํ ๋น: Dynamic Memory Allocation ์ฐ๋ฆฌ๋ ๊ทธ๋์ ์ ์ ํ ๋น์ ํตํด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ ์์์ต๋๋ค. ์ ์ ํ ๋น์ ํตํ๋ฉด, ์ปดํ์ผ์ ํ ๋์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋๊ณ , ์ด๋ ํ๋ก๊ทธ๋จ ์ข
๋ฃ์๊น์ง ๋ณ๋๋์ง ์์ต๋๋ค. ์๋ฅผ๋ค์ด, ํ๋ก๊ทธ๋จ ๋ด๋ถ์์ ์ด๋ ํ ์ ์ x๋ฅผ ์ ์ธํ์๋ค๋ฉด, ๊ทธ ๋ณ์์ ๊ฐ์ ๋ณํ ์ ์์ผ๋ ๋ณ์์๊ฒ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋๊น์ง ๋ณํ์ง ์์ต๋๋ค. ๊ทธ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ๋ sizeof ํจ์๋ก ์ ์ ์์์ต๋๋ค. ๊ทธ์ ๋ฐํด ๋์ ํ ๋น์ ์ปดํ์ผ์ ํ ๋๊ฐ ์๋, ๋ฐํ์ ๋์ค์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ์ ์๊ฒ ํด์ค๋๋ค. ๋์ ํ ๋น์ ํตํด Heap ์์ญ์ ๋ฐ์ดํฐ๋ฅผ ํ ๋นํ ์ ์์ต๋๋ค. ์ฆ, ๋์ ํ ๋น์ ํ ์์ญ์์ ๋ฐ์ํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ํ ๋น๋ ๊ฐ์ ๋ํ ์ ๊ทผ์ ํฌ์ธํฐ๋ฅผ ํตํด์๋ง ๊ฐ๋ฅํฉ๋๋ค. C++ ..
C++
์ญ์ฐธ์กฐ (Dereferencing) ๋ชจ๋ ์๋ค์ํผ ํฌ์ธํฐ๋ ๋ค๋ฅธ ๋ฐ์ดํฐ์ ์ฃผ์๊ฐ์ ์ ์ฅํด๋๋ ๋ณ์์
๋๋ค. ์ฐ๋ฆฌ๋ ์ฃผ์๋ฅผ ํตํด์ ์ํ๋ ์์น์ ๋ฐฉ๋ฌธํฉ๋๋ค. C++์์๋ ๋์ผํฉ๋๋ค. ๋น์ฐํ ํฌ์ธํฐ์ ๊ฐ์ผ๋ก ์ํ๋ ๋ฐ์ดํฐ์ ์ฃผ์๋ฅผ ์๋ค๋ฉด, ๊ทธ ์ฃผ์๋ฅผ ํตํด ํด๋น ์์น์ ์๋ ๋ฐ์ดํฐ์ ์ ๊ทผํ ์๋ ์๊ฒ ์ฃ ? ์ด๊ฒ์ ์ฐ๋ฆฌ๋ ์ญ์ฐธ์กฐ (Dereferencing) ๋ผ๊ณ ๋ถ๋ฆ
๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ฐฉ๋ฒ์ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ํฌ์ธํฐ๋ฅผ ์ ์ธํ ๋, ๋ณ์์ ๋ค๋ฅธ ๋ถ๋ถ์ด ์ด๋ค ๊ฒ์ด์๋์ง ๊ธฐ์ต์ด ๋์๋์? ๋ณ์์๋ ๋ค๋ฅด๊ฒ ํฌ์ธํฐ์ ์ด๋ฆ ์์ asterisk(*) ๋งํฌ๋ฅผ ๋ถ์์ต๋๋ค. ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ(์ฃผ์)๋ฅผ ๋ฐ๋ผ๊ฐ์ ์๋ ์์น์ ์ ์ฅ๋ ๊ฐ์ ์กฐํํ ๋๋ ๋์ผํฉ๋๋ค. ๋ณ์๋ช
์์ *๋ฅผ ๋ถ์ด๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค. ์ ์ธํ ๋์ ๋์ผํ synta..
C++์์๋ & ๊ธฐํธ๋ฅผ ํตํด ๋ฐ์ดํฐ์ ์ฃผ์์ ์ ๊ทผํ ์ ์์ต๋๋ค. ๊ฐ์ 16์ง์ ์ซ์๋ก ๋ฐํ๋ฉ๋๋ค. ์์๋ฅผ ๋ณด์ฌ๋๋ฆฌ๊ฒ ์ต๋๋ค. #include using namespace std; int main() { int num{10}; cout
ํฌ์ธํฐ์ ์ ์ธ์ ๋ค์๊ณผ ๊ฐ์ ๊ตฌ์กฐ๋ก ์งํ๋ฉ๋๋ค. variable_type *pointer_name; asterisk(*)๋ง ์์ด์ง๋ฉด ๋ณ์์ ๋์ผํฉ๋๋ค. ์์ int *int_ptr; double *double_ptr; char *char_ptr; string *string_ptr; ํ์ง๋ง, ์ค์ํ ๊ฒ์ ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ๋ฅผ ํด ์ฃผ์ด์ผ ํฉ๋๋ค. ์ด๊ธฐํ๋ฅผ ํ์ง ์์ผ๋ฉด ํฌ์ธํฐ์ ์ฐ๋ ๊ธฐ ์ฃผ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์๊ฒ ๋ฉ๋๋ค. ์ด๊ธฐํ๊น์ง ํ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๋ฉ๋๋ค. variable_type *pointer_name {nullptr}; ์์ int *int_ptr {}; double *double_ptr {nullptr}; char *char_ptr {nullptr}; string *string_ptr {nullptr};