๋ชฉ๋ก์ ์ฒด ๊ธ (1110)
KoreanFoodie's Study
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ๋ฌธ์์ด ํด๋์ค ๊ธฐ์กด C์ธ์ด์์๋ ๋ฌธ์์ด์ ๋ง์ง๋ง์ ๋ ๊ฐ('\0')์ ์ฝ์ ํ๋ค. C++์์๋ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก string ํด๋์ค๋ฅผ ์ ๊ณตํ๊ณ ์์ผ๋ฏ๋ก, char* ๋์ string์ ์ฌ์ฉํ์! ์ง์ String Class๋ฅผ ๋ง๋ค์ด ๋ณด๋ ๊ฒ์ ์ข์ ์ฐ์ต์ด ๋๋ค. ํ์ ๋ช ์ธ๋ ๋ค์๊ณผ ๊ฐ๋ค. ๋ณ์ : ๋ฌธ์์ด ๊ธธ์ด, ๋ฌธ์์ด ๋ด์ฉ, ์ฌ์ฉํ๋ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ ๋ฉ์๋ : ์์ฑ์, ์๋ฉธ์, insert, erase, find, reserve, assign, compare ๋๋ณด๊ธฐ์ ์์ ์ฝ๋๋ฅผ ๋ฃ์ด ๋์๋ค. ๋๋ณด๊ธฐ ๋ชจ๋์ ์ฝ๋์์ ์ ์ํ MyString ํด๋์ค ์ฝ๋ ์์ : #include // str..
์ฌ๋๋ค์ ์ ๋ถ ์กฐ๊ธ์ฉ ๋ค๋ฅธ ์ท์ ์ ๊ณ ์๋ค. ์ค๋๋ ์๋ง์ ํ์๋ค์ ๋จ๋ค๊ณผ ๋ค๋ฅธ ์ฒ์ชผ๊ฐ๋ฆฌ๋ฅผ ๊ฐ๊ธฐ ์ํด ๋ฐฑํ์ ์ ๊ฑท๊ณ ๋ ๊ฑท๋๋ค. ๋ค์ ๊ฑฐ๋ฆฐ๋ค. ์ฌ๋ง์์ ๋ฐ๋์ ์ฐพ๋ฏ์ด, ๋์๋ ํ๊ตฌ์ฌ์ ๋ฉ์ถ ์ค์ ๋ชจ๋ฅธ๋ค. ์ง์น์ง๋ ์๋ ๋ณด๋ค. ์ ๋ชจ๋ ์ฌ๋๋ค์ ๋จ๋ค๊ณผ ๋ค๋ฅด๊ฒ ์ ์ผ๋ ค ํ๋ ๊ฑธ๊น. ๊ฐ์ผ๋ฉด์๋ ์กฐ๊ธ ๋ค๋ฅด๊ฒ. ๋น์ทํ๋ฉด์๋ ํน์์๊ฒ. ์์ผ๊น. ๋ชจ๋๊ฐ ๊ฟ๊พธ๋ ๋๊ฐ์ ์ผ๊ตด์ ๊ฐ๊ธฐ ์ํด ๋ถ์ฃผํ๋ฉด์, ์ท์๋ ์. ๊ฐ๋จ์ธ๋๊ฐ ๋๊ธฐ ์ํด ๋ฐ๋ผ์์ด๋ผ๋ ์ค๋ช ๋ ๊ฐ์ํ๋ฉด์ ์. ๋๊ฐ์ ๋, ๋๊ฐ์ ์ฝ, ๋๊ฐ์ ์ ์ ๊ฐ๊ธธ ๋ฐ๋ผ๋ ์ฌ๋๋ค. ํ์ง๋ง ์ ๋ ์ท์๋ ๋๊ทธ๋ฝ์ง ๋ชปํ ์ฌ๋๋ค. ๊ด๋ํจ์ ๊ฒฝํํ์ง ๋ชปํ, ๋ถ์ํ ์ท๋ค์๊ฒ ์ฌ์ฌํ ์๋ก๋ฅผ ๊ฑด๋ด๊ณ ์ถ์ ๋ ์ด๋ค. ์ ํ๋ฐ์ง ๋ชปํ ํผ์กฐ๋ฌผ์๊ฒ ์ถ๋ณต์. ๋ค์ ์์๋ ๋๊ตฐ๊ฐ์ ์ท์ฅ์ ๊ฑธ๋ ค ์๊ธฐ๋ฅผ.
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ์์ฑ์์ ์ด๊ธฐํ ๋ฆฌ์คํธ(initializer list) ๊ฐ๋จํ ์์ ์ฝ๋๋ฅผ ๋ณด์. class Test { int a; int b; Test(); } Test::Test() : a(1), b(2) {} ์์ ์์์์, (์์ฑ์ ์ด๋ฆ) : var1(arg1), var2(arg2) ... ๊ฐ์ ํ์์ ์จ ์ฃผ๋ฉด, ์์ฑ์ ํธ์ถ๊ณผ ๋์์ ๋ฉค๋ฒ ๋ณ์๋ค์ ์ด๊ธฐํํด์ค ์ ์๋ค. "๋์์"๋ผ๋ ๊ฐ๋ ์ด ์ค์ํ๋ค. ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฉด ์์ฑ์ ๋จผ์ ํ๊ณ ๊ทธ ๋ค์์ ๋์ ์ ์ํํ๊ฒ ๋๋ค. ๋ฐ๋ผ์, ์ด๊ธฐํ ๋ฆฌ์คํธ๋ int a = 10; ์ ๊ฐ๊ณ , ์ผ๋ฐ ๋ฒ์ ์ ์์ฑ์๋ int a; a = 10; ์ฒ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ์๋ฉธ์ ํด๋์ค ์์ฑ์์์ ๋ง๋ค์ด ์ค ์์์ ๊ฐ์ฒด๊ฐ ์๋ฉธํ ๋ ๋ฐ๋์ ํด์ ๋์ด์ผ ๋ฉ๋ชจ๋ฆฌ ๋์(memory leak)์ด ์ผ์ด๋์ง ์๋๋ค. #include class Marine { char* name; public: Marine(); Marine(const char* marine_name); ~Marine(); }; Marine::Marine() { name = NULL; } Marine::Marine(const char* marine_name) { name = new char[strlen(marine_name) + 1]; strcpy(name, marine_name); } Marine..
ํจ์์ ์ค๋ฒ๋ก๋ฉ (function overloading) ํจ์์ ์ค๋ฒ๋ก๋ฉ์, ์ธ์๋ก ๋ค์ด์ค๋ ๋ณ์์ ํ์ ์ ๋ฐ๋ผ ์ด๋ฆ์ด ๊ฐ์ ํจ์๋ค ์ค ์ ํฉํ ํจ์๋ฅผ ํธ์ถํด ์ฃผ๋ ๊ฒ์ ์๋ฏธํ๋ค. ์ด๋, ์ธ์๋ฅผ ์ฐพ๋ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค. 1 ๋จ๊ณ : ์์ ๊ณผ ํ์ ์ด ์ผ์นํ๋ ํจ์๋ฅผ ์ฐพ๋๋ค. 2๋จ๊ณ : ์ ํํ ์ผ์นํ๋ ํ์ ์ด ์๋ ๊ฒฝ์ฐ, ์๋์ ๊ฐ์ ํ๋ณํ์ ํตํด ์ผ์นํ๋ ํจ์๋ฅผ ์ฐพ๋๋ค. Char, unsigned char, short ๋ int๋ก ๋ณํ๋๋ค. Unsinged Short๋ int์ ํฌ๊ธฐ์ ๋ฐ๋ผ int ํน์ unsigned int๋ก ๋ณํ๋๋ค. Float๋ double๋ก ๋ณํ๋๋ค. Enum์ int๋ก ๋ณํ๋๋ค. 3๋จ๊ณ : ์์ ๊ฐ์ด ๋ณํํด๋ ์ผ์นํ๋ ๊ฒ์ด ์๋ค๋ฉด ์๋์ ์ข ๋ ํฌ๊ด์ ์ธ ํ๋ณํ์ด ์ผ์ด๋๋ค. ์์์ ์ซ..
๊ฐ์ฒด๋? ๊ฐ์ฒด๋ ์ธ์คํด์ค ๋ณ์(instance variable)๊ณผ ์ธ์คํด์ค ๋ฉ์๋(instance method)๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ํด๋์ค ํด๋์ค๋ ๊ฐ์ฒด๋ฅผ ์ฐ์ด๋ด๋ '์ค๊ณ๋'์ด๋ค. ํด๋์ค ๋ด๋ถ์ ๋ณ์์ ํจ์๋ฅผ ๊ฐ๊ฐ ๋ฉค๋ฒ ๋ณ์(member variable)๊ณผ ๋ฉค๋ฒ ํจ์(member function)์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ๋ฉค๋ฒ ๋ณ์์ ํจ์๋ ์ ๊ทผ ์ง์ ์๋ฅผ ์ค์ ํ ์ ์๋ค. public : ์ธ๋ถ์์ ์ ๊ทผ ๊ฐ๋ฅ protected : ์์๋ ํด๋์ค๋ง ์ ๊ทผ ๊ฐ๋ฅ private : ์ธ๋ถ์์ ์ ๊ทผ ๋ถ๊ฐ๋ฅ ์ฌ์ค C++์์ ํด๋์ค์ ๊ตฌ์กฐ์ฒด์ ์ ์ผํ ์ฐจ์ด๋ ๋ฐ๋ก ์ ๊ทผ ์ง์ ์์ ์๋ค!
new์ delete c์ malloc๊ณผ calloc์ด ์๋ค๋ฉด, C++์๋ new์ delete๊ฐ ์๋ค. int* p = new int; *p = 10; delete p; ๋ง์ฝ ์ง์ญ๋ณ์๋ฅผ delete๋ก ํด์ ํ๋ ค ํ๋ค๋ฉด Heap์ด ์๋ ๊ณต๊ฐ์ ํด์ ํ๋ ค ํ๋ค๋ ๊ฒฝ๊ณ ๋ฉ์์ง๊ฐ ๋ํ๋๋ค. ์ปดํ์ผ๋ฌ๋ ๋ณ์๋ฅผ ๊ฐ๊น์ด ๊ณณ์์ ์ฐพ๋๋ค. int a = 4; { std::cout
์ฐธ์กฐ์ (๋ ํผ๋ฐ์ค) ๋ ํผ๋ฐ์ค(reference)๋ & ๊ธฐํธ๋ฅผ ์ด์ฉํด์ ํ๊ธฐํ๋ค. #include int main() { int a = 3; int& another_a = a; } ์ฐธ์กฐ์๋ ๋ณ๋ช , ์ฆ ๋๋ค๋ฅธ ์ด๋ฆ์ด๋ค. ๋ ํผ๋ฐ์ค๋ ๋ฐ๋์ ์ ์ ์ ๋๊ตฌ์ ๋ณ๋ช ์ด ๋ ๊ฒ์ธ์ง ์ง์ ํด์ผ ํ๋ค. ๋ํ, ๋ ํผ๋ฐ์ค๊ฐ ํ ๋ฒ ๋ณ๋ช ์ด ๋๋ฉด ์ ๋๋ก ๋ค๋ฅธ ์ด์ ๋ณ๋ช ์ด ๋ ์ ์๋ค! int a = 10; int& another_a = a; int b = 3; another_a = b; ์ ์ผ ๋ง์ง๋ง ์ค์, ์ค์ ๋ก "a=b"์ ๊ฐ์ ์๋ฏธ๋ฅผ ์ง๋๋ค. ๋ํ, ๋ ํผ๋ฐ์ค๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ์์ ์กด์ฌํ์ง ์์ ์๋ ์๋ค. ์ด๋ ๋ ํผ๋ฐ์ค๋ฅผ ์ํด ์๋ก์ด ๊ณต๊ฐ์ ํ ๋นํ ํ์๊ฐ ์์ ์๋ ์๋ค๋ ๊ฒ์ด๋ค. ์ฐธ์กฐ์์ ์ฐธ์กฐ์? int a = 1; int& ..
์ด๋ฆ ๊ณต๊ฐ (namespace) namespace๋ ์ ์๋ ๊ฐ์ฒด๊ฐ ์ด๋ ์์์ธ์ง๋ฅผ ์ง์ ํด์ค๋ค. #include "header1.h" #include "header2.h" int main() { header1::foo(); header2::foo(); } ์์ ์์์ฒ๋ผ, header1๊ณผ header2์ ๊ฐ์ ์ด๋ฆ์ ํจ์ foo( )๊ฐ ์ ์๋์ด ์๋๋ผ๋ namespace๋ฅผ ์ฌ์ฉํ๋ฉด ๊ตฌ๋ถํด์ ์ฌ์ฉํ ์ ์๋ค. ๋ํ, "using namespace std;"์ ๊ฐ์ ๋ฐฉ์์ ์ถ์ฒํ์ง ์๋๋ค. std์๋ ์๋ง์ ํจ์๋ค์ด ํฌํจ๋์ด ์๊ธฐ ๋๋ฌธ์, ์ถฉ๋์ด ์ผ์ด๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฆ ์๋ ์ด๋ฆ ๊ณต๊ฐ ์ด๋ฆ ์๋ ์ด๋ฆ ๊ณต๊ฐ์ ์ค์ ํ ๊ฒฝ์ฐ, ์ ์๋ ๊ฒ๋ค์ ํด๋น ํ์ผ ์์์๋ง ์ ๊ทผํ ์ ์๊ฒ ๋๋ค. ์ด ๊ฒฝ์ฐ ๋ง์น stati..
๊ฐ์น๋ ๋ฌด์์ธ๊ฐ. ๋ฌด์์ ๊ฐ์น์๋ค๊ณ ์ ์ํ ์ ์์๊น. ๋นํธ์ฝ์ธ์ด ์ฒ์ ์ดํ์ด ๋ถ์์ ๋๋ฅผ ์์ํ ๊ธฐ์ตํ๋ค. ๋ฌด์์ด ๊ฐ์น ์๊ธธ๋ ์ฌ๋๋ค์ ๋ฐ์ดํฐ ์ชผ๊ฐ๋ฆฌ์ ๊ทธ๋ฆฌ๋ ์ด๊ดํ๋ ๊ฒ์ธ๊ฐ. ๋ ๋ํ ๋นํธ์ฝ์ธ ๊ธฐ์ ์์ ์ ์ฝ์ผ๋ฉฐ, ์ค์ ํฌ์๋ ํ๊ณ ๊ธ๋ ์ฐ๋ฉฐ ์คํํธ์ ์๋ ๊ธฐ์๊ฑฐ๋ ธ๋ค. ๋๋ฌด๋๋ ๊ถ๊ธํ๊ธฐ์. ๋น์ท ๊ทธ๊ฒ ๋ฌด์์ด๊ธธ๋ ๊ทธ๋ฆฌ๋ ๊ฐ์น๊ฐ ์๋ค๊ณ ํ๋์ง ์์์ผ๊ฒ ๋ค๊ณ ์๊ฐํ์๋ค. ํ์ง๋ง ์๋ฌด๋ฆฌ ๊ธฐ์ ์ด ํ๋ฅญํ๋ค ํ๋ค, ๊ฒฐ๊ตญ ๊ฐ์น๋ ์ธ๊ฐ์ด ์ ํ๋ ๊ฒ์ด์๋ค. ์ํธ๊ฐ์ ํฉ์, '์ด๊ฒ์ ๊ฐ์น๊ฐ ์๋ ๊ฒ์ด๋ค'๋ผ๋ ๊ณตํต์ ์ ๋ขฐ๊ฐ ๋ฌด์์ ์ ๋ฅผ ์ฐฝ์ถํด๋ด๊ณ ์์๋ค. ์ถํด๊ทผ๊ธธ์ ์ฑ ์์ง๋ ๋ฒ์ค ์ ๋ฆฌ์ฐฝ์๋, ์ค๋๋ ๋ช ํ ์ธ์ผ์ ํ๋ณดํ๋ ์คํฐ์ปค๊ฐ ๋์ง๋์ง ๋ถ์ด์๋ค. ๋ช ํ์ ์ ๋ง๋ก ๊ฐ์น๊ฐ ์๋ ๊ฒ์ผ๊น. ์ต ์๋ฆฌ๊ฐ ๋๋ ๋์ ์ง๋ถํ ์ ๋์ ๊ฐ์ด์น๊ฐ..