Pointer Pointer๋ ๋ณ์์
๋๋ค. ๋ณ์์ ๊ตฌ์ฑ ์์๋ ๋ฉ๋ชจ๋ฆฌ์ ์์น, ๋ณ์ ํ์
, ๊ทธ๋ฆฌ๊ณ ๊ฐ์ ๊ฐ์ง๋๋ค. ํฌ์ธํฐ๋ ๋ค๋ฅธ ๋ณ์๋ ํจ์์ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์์
๋๋ค. ์ด๊ฒ ๋ฌด์จ ๋ป์ด๋๋ฉด, ๋ณ์์ '๊ฐ' ์ ํด๋นํ๋ ๋ถ๋ถ์ด ๋ค๋ฅธ ๋์์ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๋ผ๋ ๊ฒ ์
๋๋ค. ์๋ฅผ ๋ค์ด int x {10}; ์ผ๋ก ์ ์ ๋ณ์ x๋ฅผ ์ ์ธํ๊ณ 10์ ํ ๋นํ๋ค๋ฉด, ๋ณ์ x๋ฅผ ๊ฐ๋ฅดํค๋ ๋ค๋ฅธ ํฌ์ธํฐ๋ฅผ ์ ์ธํ ์ ์์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด, ํฌ์ธํฐ๋ ์ ์ฌ์ฉํ ๊น์? ํฌ์ธํฐ๊ฐ ์ด๋ฏธ ์กด์ฌํ๋ ๋ณ์๋ฅผ ๊ฐ๋ฅดํค๋ ๋ณ์๋ผ๋ฉด, ๊ทธ๋ฅ ์๋์ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋๊ฑฐ ์๋๊น์? ํฌ์ธํฐ ์ฌ์ฉ์ ์ด์ ์์ ์ง๋ฌธ์ ์ด์ด์ ์ด์ ๋ฅผ ์ค๋ช
ํ๊ฒ ์ต๋๋ค. ๋ง์ต๋๋ค. ์๋์ ๋ณ์๋ฅผ ์ง์ ์ฌ์ฉํ๋ฉด ๋ฌธ์ ๊ฐ ์์ต๋๋ค. ํ์ง๋ง, ์ฐ๋ฆฌ๋ ์ข
์ข
ํ๋ก๊ทธ๋จ ์์์ ๋ณต์กํ ๊ตฌ์กฐ๋ก ..
C++
'๋ฐ๋ณต๋ฌธ ์์ฉ ํ๋ก๊ทธ๋จ' ํฌ์คํธ์์ ๊ตฌํํ๋ ํ๋ก๊ทธ๋จ์ ํจ์๋ฅผ ์ ๊ทน์ ์ผ๋ก ์ด์ฉํ์ฌ ๋์ผํ๊ฒ ๊ตฌํํด ๋ณด์์ต๋๋ค. ๊ธฐ์กด์ ํ๋ก๊ทธ๋จ์ ํจ์์ ํ์ฉ์ด ์์์ง๋ง, ์ด๋ฒ ํ๋ก๊ทธ๋จ์ ํจ์๋ก ๋ณ๊ฒฝํ๊ณ ๊ธฐ๋ฅ๋ ๋ช ๊ฐ ์ถ๊ฐํ์์ต๋๋ค. ํจ์ ์์ด ๋ฐ๋ณต๋ฌธ๋ค๋ก๋ง ๊ตฌํ๋ ๊ธฐ์กด์ ํ๋ก๊ทธ๋จ์ ๋ค์ ํฌ์คํธ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค. [C++] ๋ฐ๋ณต๋ฌธ ์์ฉ ํ๋ก๊ทธ๋จ ์ฝ๋ ์ค๋ช
switch๋ฌธ, for๋ฌธ, do-while๋ฌธ์ ๋ชจ๋ ํ์ฉํ ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์
๋๋ค. ์ฌ๋ฌ๊ฐ์ง ๊ธฐ๋ฅ์ ์ํํ๊ธฐ ์ํด ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ์ ๋ฐ๊ณ , ๊ทธ ์
๋ ฅ์ ํด๋นํ๋ ๊ธฐ๋ฅ์ ์ํํฉ๋๋ค. ์ฝ๋ #include using na code-studies.tistory.com ๊ฐ๋ตํ๊ฒ ์ค๋ช
ํ์๋ฉด, ์ฌ์ฉ์๋ก๋ถํฐ ๋ฌธ์๋ฅผ ํตํด ์ต์
์ ์ ํ ๋ฐ๊ณ ๊ทธ์ ๋ฐ๋ฅธ ๋์์ ํํ๋ ํ๋ก๊ทธ๋จ์
๋๋ค. ๋ชจ๋ ..
ํ์ตํ ์ฌ๊ท ํจ์ ๋ด์ฉ์ ํ์ฉํ์ฌ ์
๋ ฅ๋ ์ ์์ ๋ชจ๋ ์๋ฆฟ์๋ฅผ ๋ง์
ํ ๊ฐ์ ๋ฐํํ๋ ํจ์๋ฅผ ์์ฑํด ๋ด
์๋ค. Test cases) '1234' → (1 + 2 + 3 + 4) = 10 '99999' → (9 + 9 + 9 + 9 + 9) = 45 '1000000000' → (1 + 0 + 0 + ... + 0) = 1 ์ฝ๋ #include using namespace std; int sum_of_digits(int); int main() { cout
Recursive function, ์ฌ๊ทํจ์๋ '์ค์ค๋ก๋ฅผ ํธ์ถํ๋ ํจ์' ์
๋๋ค. ์ค์ค๋ก๋ฅผ ํธ์ถํ๋ ๋ฐฉ๋ฒ์ ์ง์ ํธ์ถํ ์๋ ์๊ณ , ๋ค๋ฅธ ํจ์๋ฅผ ํตํด ๊ฐ์ ํธ์ถํ ์๋ ์์ต๋๋ค. ์ฌ๊ทํจ์๋ ์ด์งํ์, ํฉํ ๋ฆฌ์ผ ์ฐ์ฐ, ํผ๋ณด๋์น ์์ด ๋ฑ ์ํ์ด๋ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋ถ์ผ์์ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค. ์ฒซ๋ฒ์งธ๋ก ํฉํ ๋ฆฌ์ผ(!)์ ์์๋ฅผ ๋ค์ด๋ณด๊ฒ ์ต๋๋ค. ์ฐ์ ํฉํ ๋ฆฌ์ผ์ด๋, '๊ทธ ์๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋ชจ๋ ์์ ์ ์์ ๊ณฑ' ์
๋๋ค. 0! = 1 ์ด๊ณ , n! = n * (n - 1)! ์ด๋ผ๊ณ ์ดํดํ๋ฉด ๋ฉ๋๋ค. ๊ทธ ํจ์๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ๊ทํจ์๋ฅผ ํ์ฉํ์ฌ ๊ตฌํํ ์ ์์ต๋๋ค. // factorial function unsigned long long factorial(unsigned long long n) { if (n == 0) re..