๋ชฉ๋ก์ ์ฒด ๊ธ (1096)
KoreanFoodie's Study
์๋ฒ์ง๋ ๋์๊ฒ ์ด๋ฅด์ จ๋ค. ๋ถ์๋ฅผ ๋ณด๋ฉด ๊พน ์ฐธ๊ณ ์ง๋๊ฐ๋ผ๊ณ . ์ ๊น๋ง. ๋์๊ฒ ๊ฐ์ ๊ต์ก์ ์ค์์ฑ์ ์คํํ๋ค๊ฑฐ๋, ๋ด ์๋ฒ์ง์ ์ธ๊ฐ์ฑ์ ์๋จํ์ง๋ ์์์ผ๋ฉด ์ข๊ฒ ๋ค. ํ๊ตญ๋ง์ ๋๊น์ง ๋ค์ด๋ณผ ํ์๊ฐ ์๋ ๋ฒ์ด๋ค. ๊ทธ๋ฌ๋ ๋ง์ง๋ง์ ๋ง์ง๋ง๊น์ง ์ ์๋ง ํธํก์ ๊ฐ๋ค๋ฌ์ด ๋ณด์. ๋๊ตฐ๊ฐ๊ฐ ๋์๊ฒ ์ ์ผ ์กด๊ฒฝํ๋ ์ฌ๋์ด ๋๊ตฌ๋๊ณ ๋ฌป๋๋ค๋ฉด, ๋๋ ์๋ ์๋, 5๋ ์ ์๋ ๊ทธ๋ฌ๋ฏ ์๋ฒ์ง๋ฅผ ์ธ๊ธํ ๊ฒ์ด๋ค. ์ ์๋ฒ์ง๋ฅผ ์ ์ผ ์กด๊ฒฝํ๋ ์ธ๋ฌผ๋ก ๊ผฝ๋๊ณ ? ๋น์ฐํ๊ฒ๋, ์๋ฒ์ง๊ฐ ์ธ์์์ ์ ์ผ ๋ฉ์๋ ์ฌ๋์ด๊ธฐ์, ๋ฅ๋ ฅ์ด ์ ๋ง ์ถ์คํ์๊ธฐ์... ๊ฐ์ ํผ์์ ์ธ ์กฐ๊ฑด ๋๋ฌธ์ ์๋ ๊ฒ์ด๋ค. ๋ค๋ง, ๋์๊ฒ ์์ด ๋๋ฌด๋ ๊ณ ๋ง์ฐ์ ๋ถ์ด๊ธฐ ๋๋ฌธ์. ๋์๊ฒ ์ข์ผ์ ๋ถ์ด๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๊ฒ ์ด์ผ๊ธฐํ ์๋ฐ์ ์๋๊ฒ ์๋๊น. ๋ฐ๋ฉด ํ ๋ฒ๋ ๋ง๋๋ณธ ์ ์๋, ์ด์ฉ๋ฉด ์ฃผ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! C++ ์คํ์ผ์ ์บ์คํ ๊ธฐ์กด์ C ์ธ์ด์์๋ ์ปดํ์ผ๋ฌ๊ฐ ์์์ ์บ์คํ ํ๋ ์์์ (implicit) ์บ์คํ ๊ณผ, ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ์บ์คํ ํ๋ผ๊ณ ์ง์ ํ๋ ๋ช ์์ (explicit) ์บ์คํ ์ด ์์๋ค. ํ์ง๋ง C++์์๋ ๋ค์๊ณผ ๊ฐ์ 4๊ฐ์ง์ ์บ์คํ ์ ์ ๊ณตํ๊ณ ์๋ค. 1. static_cast : ์ฐ๋ฆฌ๊ฐ ํํ ์๊ฐํ๋, ์ธ์ด์ ์ฐจ์์์ ์ง์ํ๋ ์ผ๋ฐ์ ์ธ ํ์ ๋ณํ 2. const_cast : ๊ฐ์ฒด์ ์์์ฑ(const)๋ฅผ ์์ ๋ ํ์ ๋ณํ. ์ฝ๊ฒ ๋งํด const int๊ฐ int๋ก ๋ฐ๋๋ค. 3. dynamic_cast : ํ์ ํด๋์ค ์ฌ์ด์์์ ๋ค์ด์บ์คํ 4. reinterpret_cast : ์..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! friend ํค์๋ ํด๋์ค ๋ด๋ถ์์ ๋ค๋ฅธ ํด๋์ค๋ ํจ์๋ค์ friend๋ก ์ ์ํ ์ ์๋๋ฐ, friend๋ก ์ ์๋ ํด๋์ค๋ ํจ์๋ค์ ์๋ ํด๋์ค์ private๋ก ์ ์๋ ๋ณ์๋ ํจ์๋ค์ ์ ๊ทผํ ์ ์๋ค. class A { private: void DoSth() {}; int a; friend class B; friend void func(); } class B { public: void b() { A a; a.DoSth(); a.a = 1; } } void func() { A aa; aa.a= 2; a.DoSth(); } ์์์ friend๋ก ์ง์ ๋ ํด๋์ค B์ ํจ์ func( )๋..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! MyString์ '==' ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ ์ด๋ฏธ MyString class์์ compareํจ์๋ฅผ ๋ง๋ค์๋ค๋ฉด, ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ์ ๊ฐ๋จํ ๊ตฌํํ ์ ์๋ค. bool MyString::operator==(const MyString& str) { return !compare(str); } ๋์ ์ฐ์ฐ์ ํจ์ ๋ณต์์๋ฅผ ๊ตฌํํ Complex ํด๋์ค์์ '=' ์ฐ์ฐ์ ํจ์๋ฅผ ๊ตฌํํ๋ค๊ณ ํด ๋ณด์. Complex& Complex::operator=(const Complex& c) { real = c.real; img = c.img; return *this; } ์ ์ฐธ์กฐ์(Complex &)๋ก ๊ฐ์ ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! explicit ํค์๋ explicit ํค์๋๋, ๊ฐ๋จํ ๋งํด ์์์ ํ ๋ณํ์ ํ์ฉํ์ง ์์ ๋ ๋ถ์ฌ์ฃผ๋ ํค์๋์ด๋ค. ์๋ฅผ ๋ค์ด, ์ด์ ์ ๋ง๋ค์๋ MyString ํด๋์ค์ ๋ค์๊ณผ ๊ฐ์ ์์ฑ์์ ํจ์๋ฅผ ์ถ๊ฐํ๋ค๊ณ ๊ฐ์ ํด ๋ณด์. MyString::MyString(int capacity) { string_length = 0; string_content = new char[capacity]; memory_capacity = capacity; } void MyString::DoSomething(MyString s) {}; ๋ง์ฝ, explicit์ด ์๋ค๋ฉด, ๋ค์๊ณผ ๊ฐ์ ํธ์ถ์ ์ ์์ ์ผ๋ก ์๋..
๋ค์ด๋ด. ๋ด๊ฐ ๋ ธ๋๋ฅผ ๋ค์ผ๋ฉฐ ์์ค์ปฌ๋ ์ดํฐ๋ฅผ ์ฒ์ฒํ ๋ด๋ ค๊ฐ๊ณ ์์๋๋ฐ ๋ง์ผ. ๋ด๋ ค๊ฐ๋ค ๋ณด๋ ์ค์ณ ์ง๋์น๋ ์ฌ๋๋ค๋ ์ญ์ ๋์ ๊ฐ์ ์์ดํ ํ๋ก๋ฅผ ๊ฐ๊ณ ์๋๋ผ๊ณ . ๊ทผ๋ฐ ๊ทธ ์ค ํ ๋ถ์ด ์์ดํ ํ๋ก๋ฅผ ๋จ์ด๋จ๋ฆฐ๊ฑฐ์ผ. ์ผ์ด์ค๋ฅผ ๋ซ๋ค๊ฐ. ์ด์ฉ๊ธด ์ด์งธ, ์น์ ํจ์ด ๋ชจํ ์ธ ๋ด๊ฐ ๋ชป ๋ณธ์ฒ ํ ์ ์์์ง. ๊ทธ๋์ ๋ง์น ์นด๋ ๋ง์ ์ ํ๋ฏ ๊ณผ์ฅ๋ ์์ง์ผ๋ก ํ๊ฒจ ๋๊ฐ๋ ์์ด ํ์ ํ๋, ๋ ์ง์ด ๊ทธ๋ถ์๊ฒ ๊ฑด๋ด์ฃผ์์ด. ๊น์ง ๋๋ผ ์ฒญ์ค๋ชจ์ฒ๋ผ ๋์ ๋ฅ๊ทธ๋๊ฒ ๋ฌ ๊ทธ๋ถ์ ์์ดํ ํ์ชฝ์ ์ด์ํ๊ฒ ๋ค๊ณ ์์์ง. ๋ง์นจ ๋๋ ์์ดํ์ ๋ผ๊ณ ์์๊ธฐ์, ์ผ์ชฝ ์ฝฉ๋๋ฌผ์ ์ ์ ๋นผ์ด๋ค๊ณ ๊ทธ๋ถ์ ์์ดํ์ ๊ฐ๋ณ๊ฒ ๋ถ๋ชํ์ด. Cheers. ์์ดํ ๊ฑด๋ฐฐ์ ํจ๊ป ๋๋ ๋์ง๋ง์ด ๊ทธ๋ฐ ๋ฌธ๊ตฌ๋ฅผ ๋ด๋ฑ๊ณ ์ ์ ํ ๊ทธ ์๋ฆฌ๋ฅผ ๋น ์ ธ๋์์ด. ์๋ง ๋ชจ๋ฅด๊ธด ๋ชฐ๋ผ๋, ๊ทธ ๋ถ์๊ฒ๋ ํ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ 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..