OOP ์ ๋ํ ์๋ชป๋ ์ดํด
OOP ๋ ๊ธฐ์กด C์ ๊ฐ์ ์ ์ฐจ์งํฅ์ ์ธ ์ธ์ด์ ๋นํด ์บก์ํ, ๋คํ์ฑ, ๋ญ ๊ธฐํ ๋ฑ๋ฑ ๋๊ฒ ํ๊ธฐ ์ ์ธ
์ถ์ํ (abstraction)
ํ๋ก๊ทธ๋๋ฐ์์ ๊ฐ์ฅ์ค์ํ ๊ฒ , ๊ทธ๋ฆฌ๊ณ ๋ชจ๋ ๊ฒ, ์ฆ ์ถ์ํ์
๊ฐ๋จํ ๊ฒ์ ๊ฐ๋จํ๊ฒ ์์ฑํจ
๋ณต์กํ๊ฒ์ ์ถ์ํํด์ ๊ฐ๋จํ๊ฒ ์์ฑํจ.(์ํ์์ ๊ธฐํธ๊ฐ ์ค์ํ๊ฑด ๋ณต์กํ ๊ฐ๋ ์ ์ต๋ํ ๋จ์ํ๊ฒ (์ถ์ํ) ํํํ๊ธฐ ์ํจ)
ex. player ์ enemy ๊ฐ ์กด์ฌ
player posX, posY, hp(์ฒด๋ ฅ๋ฐ), player_property_a (๊ทธ์ธ player ์์ฑ์ค์ ํ๋)
enemy posX, posY, hp(์ฒด๋ ฅ๋ฐ), enemy_property_a (๊ทธ์ธ enemy ์์ฑ์ค์ ํ๋)
Player์ enumey ๋ฅผ ๊ทธ๋ ค์ผํจ์ผ๋ก ๋ค์ ๋๊ฐ์ ํจ์์ ๋ชฉ๋ก์ด ๋ฐ์ดํฐ ๋ฆฌ์คํธ๊ฐ ํ์ํจ
Player player Enemy enemys[1024]
draw_player(Player player) draw_enemy (Emeny enemy)
์ฝ๋๊ฐ ๋ณต์กํด์ง
์ถ์ํ
C , pascal , assembly ํน์ ์์ ์ ์ฐจ์งํฅ ์ธ์ด ๋ฒ์
struct GameObject { int object_type ; 0 = Player, 1 = Enemy int posX int posY int hp(์ฒด๋ ฅ๋ฐ); }
struct Player { GameObject game_object_property; player_property_a property_a; // (๊ทธ์ธ player ์์ฑ์ค์ ํ๋) }
struct Enemy { GameObject game_object_property; enemy_property_a property_a; // (๊ทธ์ธ enemy ์์ฑ์ค์ ํ๋) }
//game_object.object_type์ ๋ฐ๋ผ ์ ์ ํ๊ฒ Player๋ฅผ ๊ทธ๋ฆฌ๊ฑฐ๋ Enemy๋ฅผ ๊ทธ๋ ค์ค
Player์ Enemy์ ๊ณตํต์ ์์ฑ์ GameObject๋ก ํํํ์์์ผ๋ก ๋์ค์ ๋ณ๊ฒฝ์ด ์๊ธฐ๋ฉด GameObject ๊ตฌ์กฐ์ฒด๋ง ์์ ํ๋ฉด ๋จ type ์ฌํ์ฉ์. type ์ด๋๊ฒ์ ์ด๋ ๊ฒ ๋๋ฒ์ด์ ๊ณตํต์ผ๋ก ์ ์๋๋ ๊ฒ๋ค์ ๋ค๋ฅธ๊ณณ์์ ๋ ์ฌ์ฉํ๊ธฐ ์ํ ์ข์ ๋๊ตฌ์
C++ ํน์ C#, python ํน์ ๊ฐ์ฒด์งํฅ ์ธ์ด ๋ฒ์
class GameObject { int posX int posY int hp(์ฒด๋ ฅ๋ฐ);
void draw() ; }
class Player : GameObject { player_property_a property_a; // (๊ทธ์ธ player ์์ฑ์ค์ ํ๋) void draw() ; }
class Enemy : GameObject { enemy_property_a property_a; // (๊ทธ์ธ enemy ์์ฑ์ค์ ํ๋) void draw() ; }
์์ ์ ์ฐจ์งํฅ ์ธ์ด ๋ฒ์ ๊ณผ ๋์์ธ์์ ๋์ผํจ, ํ์ง๋ง ํจ์ฌ ํธ๋ฆฌํจ ๋์์ธ ๋ฐฉ์์ ๋์ผํด๋ ๊ทธ ๋์์ธ์ ๊ตฌํํ๋ ๊ณผ์ ์ด ํธํ๋ค๋ ๊ฒ๋ ๋ฌด์ฒ ์ค์ํจ.
์ ์ฐจ์งํฅ์ ์ธ์ด ํน์ ์ ์ฐจ์งํฅ์ ํ๋ก๊ทธ๋๋ฐ
์ ์ฐจ์งํฅ์ ์ด๋ผ๋ ์ฉ์ด๋ ๋ฒ์ญ์ ์ค๋ฅ์.
procedural programming , ์ฆ ์ถ์ํ๋ฅผ procedure (ํจ์) ๋ผ๋ ๊ฒ์ผ๋ก ํ๋ ๊ฒ์. ์ด๊ฒ์ด ์คํ๊ฒํฐ ์ฝ๋์ ๋์ผํ๋ค๋ ์๋ฏธ๋ก ๋ฐ์ ๋ค์ด๋ ์ฑ ์ด ๋ง์๋ฐ OOP ์ธ์ด์ ์ฌ์ค ๋ณ๋ค๋ฅผ๊ฒ ์์. ์กฐ๊ธ๋ ๋ถํธํ๋ค๋ ๊ฒ๋ฟ์.
๊ทธ๋์ ๊ฐ์ฒด๋?
OOP ์ธ์ด์์ ๊ฐ์ฒด
class ๋ผ๋ ๊ฒ์ ํตํด ๋ฐ์ดํฐ์ ํจ์๋ฅผ ๋ฌถ์ด ๋ ผ ๊ฒ์ ์๊ธฐํจ. ์ฌ์ค ๋งค์ฐ ๋จ์ํ ๊ฐ๋ . ๋จ์ง ์ด๋ฌํ ๋ฐฉ๋ฒ์ด ์๋์ฑ์ด๋ ๋คํ์ฑ๋ฑ์ ์ฝ๊ฒ ํํํ ์ ์์ด ๋ง์ด ์ฌ์ฉ๋๋ ๊ฒ.
reference
https://wiki.haskell.org/Why_Haskell_matters
The great benefit of Object-Oriented Programming is rarely that you group your data with the functions that act upon it together into an object - it's that it allows for great data encapsulation (separating the interface from implementation) and polymorphism (letting a whole set of data types behave the same way).
OOP์ ๊ฐ์ฅ ๊ฐ์ฅ ํฐ ์ฅ์ ์ผ๋ก๋ ์ผ๋ถ์ ๊ฒฝ์ฐ ๋ฐ์ดํฐ์ ํจ์๋ฅผ ๊ฐ์ด ๋ฌถ์ํ ํจ๊ป ๋์ํ๊ฒ ํ๋ ๊ฒ์ด๋ค. ์ด๊ฒ์ ๋งค์ฐ ์ข์ ์๋์ฑ๊ณผ ๋คํ์ฑ์ ์ ๊ณตํ๋ค.
ํ๋ก๊ทธ๋๋ฐ ์ด๋?
- ํ๋ก๊ทธ๋๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฒ - ๋ฐ์ดํฐ์ ๊ทธ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ์ฐ์ฐ ํน์ ํจ์๊ฐ ์กด์ฌํจ. - ๋ฐ๋ผ์ ํ๋ก๊ทธ๋๋ฐ์ด๋ "๋ฐ์ดํฐ๋ฅผ ์ ์ํ๊ณ ๊ทธ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ํจ์๋ฅผ ์ ์ํด์ ์ํ๋ ๋์์ ๊ตฌํํ๋ฉด๋จ"
๊ทธ๋์ ๋ค์ ๊ฐ์ฒด๋?
- ์ ์ํ๊ธฐ ๋๋ฆ์ด๊ณ ์ด๊ฒ์ ๋๋ฉ์ธ์ ๋ฐ๋ผ ๋ค๋ฆ.
์๋์ง๋ฌธ. ํน์ ๊ทธ๋ผ ๊ฒ์๋ด UI์ ์ํด ์๋ HP๋ฐ, MP๋ฐ ๊ฐ์ ๊ฒ๋ ๊ฐ์ฒด์ ํด๋น๋๋์?
- ์์ ์๊ธฐํ๊ฒ ์ฒ๋ผ ๋ฌด์ธ๊ฐ๋ฅผ ํํํ๊ธฐ ์ํด ๋ฐ์ดํฐ๋ฅผ ์ ์ํ๊ณ ํ์ํ๋ฉด ์ถ์ํ๋ฅผ ํจ.ย
case 1.ย
case 1.
1.5 ํ๊ท๋ชจ์ ์์ ์์ ์ฑ ์ ๋ถ๋ฅํ ๋ ์ด๋ป๊ฒ ๋ถ๋ฅํ ๊ฑด๊ฐ?
case 2.
๊ดํ๋ฌธ ๊ต๋ณด๋ฌธ๊ณ ์์ ์ฑ ์ ๋ถ๋ฅํ ๋ ์ด๋ป๊ฒ ๋ถ๋ฅํ ๊ฑด๊ฐ?
์ด๋ฌธ์ ์ ํต์ฌ์ ์ฑ
์ ๊ฐฏ์์. 1.5 ํ ๊ท๋ชจ์์ ์์ค์ฑ
๋ถ๋ฅ์ sf, ๊ณผํ, ์ฐ์ , ํํ์ง.. ์ด๋ ๊ฒ ๋๋๊ฑฐ์? ์์ค์ฑ
๋ ๊ณต๊ฐ์ ์ฝ 50 ๊ถ์ ๋ณด ๋ฐ์ ์๋๋ฐ ๊ฑฐ๊ธฐ์ ์ด๋ ๊ฒ ๋๋๋๊ฒ ์๋ฏธ๊ฐ ์์? ๊ทธ๋ฅ "์์ค์ฝ๋" ์ด๋ ๊ฒ ํ๋ฉด๋จ ๋ฐ๋ฉด ๊ต๋ณด๋ฌธ๊ณ ์ ๊ฒฝ์ฐ๋ ์์ค์ฑ
๋ง ๋ช์ฒ๊ถ์. ๋ฐ๋ผ์ ์ถฉ๋ถํ ์ธ๋ถ์ ์ผ๋ก ๋ถ๋ฅํด์ผํจ
๊ฒฐ๋ก . ์์๋งํ๋ ๊ฐ์ฒด๋ก ์ ์ํ ์ง ๋ง์ง๋ ํ๋ก๊ทธ๋จ ์ ์ฒด ๊ท๋ชจ์ ๋ณต์ก์ฑ, ๊ทธ๋ฆฌ๊ณ ๊ทธ๋ ๊ฒ ๋ถ๋ฅํ ๊ฒฐ๊ณผ์ ๋ํด ๊ฐ๋ฐ ๋ฐ ๋ถ์์ ๊ทธ ์ฉ์ดํจ์ ์์ธกํด ๋ณด๊ณ ํ๋จํด์ผํจ. ํ์ง๋ง ์ด๋ฐ๋ฌธ์ ๋ ๋์์ธ์ ์ธ ๋ฌธ์ ์์ผ๋ก ๊ทธ๋ฅ ๋๋์ผ๋ก ํ๋ ๊ฒฝ์ฐ๊ฐ ์๋๋ฐ, ๊ทธ๋ฌ๋ฉด ์ด๋ณด์. ๋ง์ฝ ๋์์ธ์ ํ๋ค๋ฉด ๊ทธ์ ๋ํด์ ๋ถ๋ช
ํ ์ค๋ช
ํ ์ ์์ด์ผ ํจ.
๋๊ธ 0