๐ ์ ์ฐจ์ ํ๋ก๊ทธ๋๋ฐ
์์ฐจ์ ์ธ ์คํ ํ๋ฆ ๊ฐ์กฐ
: ๊ฐ์ฅ ์ ํต์ ์ธ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์
ํ๋ก๊ทธ๋จ์ ์์ฐจ์ ์ผ๋ก ์คํ๋๋ ๋ช ๋ น์ด ์งํฉ๊ณผ ํจ์(๋๋ ์๋ธ๋ฃจํด)๋ค์ ์กฐํฉ์ผ๋ก ๊ตฌ์ฑ
โก๏ธ ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ๋ช ํํ๊ฒ ๊ธฐ์ , ๋ฌธ์ ๋ฅผ ๋จ๊ณ๋ณ๋ก ํด๊ฒฐํ๋๋ฐ ์ด์ ์ ๋ง์ถค
- Procedure(ํ๋ก์์ )๋ฅผ ์ด์ฉํ์ฌ ์์ฑํ๋ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ
- routine, subroutine, method, function ...
์ ์ฐจ์ ํ๋ก๊ทธ๋๋ฐ์ ์ฃผ์ ํน์ง
- ์์ฐจ์ ์คํ
- : ํ๋ก๊ทธ๋จ์ ์ -> ์๋๋ก, ๋๋ ์ง์ ๋ ํ๋ฆ์ ๋ฐ๋ผ ์์ฐจ์ ์ผ๋ก ์คํ๋จ. ๊ฐ ๋จ๊ณ๊ฐ ๋ช ํํ ์์๋ฅผ ๊ฐ์ง๋ฉฐ, ์กฐ๊ฑด๋ฌธ or ๋ฐ๋ณต๋ฌธ์ ํตํด ๋ถ๊ธฐ์ ๋ฐ๋ณต์ ์ ์ดํจ
- ํจ์์ ์๋ธ๋ฃจํด
- : ์ฝ๋์ ์ฌ์ฌ์ฉ๊ณผ ๋ชจ๋ํ๋ฅผ ์ํด ๊ธฐ๋ฅ๋ณ๋ก ํจ์ ์ ์. ๊ฐ ํจ์๋ ํน์ ์์ ์ ์ํ, ํ์์ ๋ฐ๋ผ ํธ์ถ๋จ
- ๋ฐ์ดํฐ์ ๋ณ์ : ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ ์ ์ญ ๋ณ์ ๋๋ ์ง์ญ ๋ณ์๋ก ๊ตฌ๋ถ๋๋ฉฐ, ํจ์ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๋ฐฉ์์ผ๋ก ํ๋ก๊ทธ๋จ์ด ๋์
์ ์ฐจ์ ํ๋ก๊ทธ๋๋ฐ์ ์ฅ๋จ์
์ฅ์ | ๋จ์ |
---|---|
๋จ์ํ๊ณ ์ง๊ด์ | ํ์ฅ์ฑ์ ํ๊ณ |
๋น ๋ฅธ ํ๋กํ ํ์ดํ | ์ฝ๋์ ์ฌ์ฌ์ฉ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ ์ ํ |
์ ์ฐจ์ ํ๋ก๊ทธ๋๋ฐ ์์
๋ํ์ ์ธ ์ ์ฐจ์ ์ธ์ด: C, Pascal, Fortran ...
#include <stdio.h>// ๋ ์์ ํฉ์ ๊ตฌํ๋ ํจ์int add(int a, int b) {
return a + b;
}
int main() {
int num1, num2, sum;
// ์ฌ์ฉ์๋ก๋ถํฐ ๋ ๊ฐ์ ์ซ์ ์
๋ ฅ ๋ฐ๊ธฐprintf("์ฒซ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &num1);
printf("๋ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &num2);
// ํจ์ ํธ์ถ์ ํตํด ํฉ ๊ณ์ฐ
sum = add(num1, num2);
// ๊ฒฐ๊ณผ ์ถ๋ ฅprintf("๋ ์์ ํฉ์ %d ์
๋๋ค.\n", sum);
return 0;
}
main()
: ํ๋ก๊ทธ๋จ์ ์์์ ์ด๋ฉฐ, ์์ฐจ์ ์ผ๋ก ์ฌ์ฉ์ ์
๋ ฅ, ํจ์ ํธ์ถ, ๊ฒฐ๊ณผ ์ถ๋ ฅ์ ๊ณผ์ ์ ๊ฑฐ์นจ. add()
: ์
๋ ฅ๋ ๋ ์์ ํฉ์ ๊ณ์ฐํ์ฌ ๋ฐํ
๐ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด ๋จ์๋ก ๋ฌถ์ด ๋ชจ๋ํ ๊ฐํ
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ๋ณธ ๊ฐ๋
- ๊ฐ์ฒด: ์ํ(์์ฑ, attributes)์ ํ๋(๋ฉ์๋, methods)๋ฅผ ํฌํจํ๋ ๋ ๋ฆฝ์ ์ธ ๋จ์ํ์ค ์ธ๊ณ์ ๊ฐ๋ ์ ์ํํธ์จ์ด์ ์ผ๋ก ๋ชจ๋ธ๋งํ์ฌ ์ง๊ด์ ์ธ ์ฝ๋ ์์ฑ์ด ๊ฐ๋ฅํจ
- ํด๋์ค: ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ธฐ ์ํ ํ ํ๋ฆฟ, ๊ฐ์ฒด์ ์์ฑ๊ณผ ๊ธฐ๋ฅ ์ ์
[OOP์ ์์น]
- ์บก์ํ
- ์์
- ๋คํ์ฑ
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ฃผ์ ํน์ง
- ํ์ค ์ธ๊ณ ๋ชจ๋ธ๋ง: ์ค์ ์ธ๊ณ์ ์ฌ๋ฌผ๊ณผ ๊ฐ๋ ์ ๊ฐ์ฒด๋ผ๋ ๋จ์๋ก ์ถ์ํํ์ฌ, ๋ฌธ์ ์์ญ์ ๋ณด๋ค ์ง๊ด์ ์ผ๋ก ํํ
- ๋ชจ๋ํ: ๊ธฐ๋ฅ๋ณ๋ก ํด๋์ค๋ฅผ ๋ถ๋ฆฌํจ์ผ๋ก์จ, ํ๋ก๊ทธ๋จ์ ์ฌ๋ฌ ๊ฐ์ ๋ ๋ฆฝ์ ์ธ ๋ชจ๋๋ก ๊ตฌ์ฑํ์ฌ ์ ์ง๋ณด์์ ํ์ฅ์ด ์ฉ์ด
- ์ฌ์ฌ์ฉ์ฑ: ์์๊ณผ ๋คํ์ฑ์ ํตํด ๊ธฐ์กด ์ฝ๋๋ฅผ ์ฌ์ฌ์ฉํ๊ณ , ์๋ก์ด ๊ธฐ๋ฅ์ ํ์ฅํ ์ ์์ด ๊ฐ๋ฐ ํจ์จ์ด ๋์
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ฅ๋จ์
์ฅ์ | ๋จ์ |
---|---|
์ ์ง๋ณด์ ์ฉ์ด | ์ด๊ธฐ ์ค๊ณ์ ๋ณต์ก์ฑ |
ํ์ฅ์ฑ | ์ฑ๋ฅ ์ค๋ฒํค๋ |
์ฝ๋ ์ฌ์ฌ์ฉ |
์์
๋ํ์ ์ธ ์ธ์ด: Java, Python, C++...
# ํด๋์ค ์ ์: Person
class Person:
def __init__(self, name, age):
self.name = name# ๊ฐ์ฒด์ ์ํ
self.age = age
# ๊ฐ์ฒด์ ํ๋์ ์ ์ํ๋ ๋ฉ์๋
def introduce(self):
print(f"์๋
ํ์ธ์, ์ ๋ {self.name}์ด๊ณ , {self.age}์ด์
๋๋ค.")
# ๊ฐ์ฒด ์์ฑ
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
# ๋ฉ์๋ ํธ์ถ
person1.introduce()# ์ถ๋ ฅ: ์๋
ํ์ธ์, ์ ๋ Alice์ด๊ณ , 30์ด์
๋๋ค.
person2.introduce()# ์ถ๋ ฅ: ์๋
ํ์ธ์, ์ ๋ Bob์ด๊ณ , 25์ด์
๋๋ค.
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ
: ์ํ ๋ณํ(๋ถ์ ํจ๊ณผ)๋ฅผ ์ต์ํํ๊ณ ์์ ํจ์๋ฅผ ์กฐํฉํ์ฌ ์์ธก ๊ฐ๋ฅํ ์ฝ๋ ์์ฑ
- ๋ถ์ ํจ๊ณผ: ์ธ๋ถ์ ์ํ๋ฅผ ๋ณ๊ฒฝํ๋ ๊ฒ
- ์์ ํจ์: ๋ถ์ํจ๊ณผ๊ฐ ์๋ ํจ์. ์ฆ, ์ด๋ค ํจ์์ ๋์ผํ ์ธ์๋ฅผ ์ฃผ์์ ๋ ํญ์ ๊ฐ์ ๊ฐ์ ๋ฆฌํดํ๋ ํจ์
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ํน์ง
- ์์์ฑ๊ณผ ๋ถ์ ํจ๊ณผ ์ต์ํ
- : ์ฝ๋์ ์ํ ๋ณํ์ ์ธ๋ถ ์์กด์ฑ์ ์ค์์ผ๋ก์จ, ํจ์์ ๋์์ ์ฝ๊ฒ ์์ธกํ๊ณ ํ ์คํธํ ์ ์์
- ๋ถ๋ณ์ฑ
- : ๋ฐ์ดํฐ ๋ณ๊ฒฝ ๋์ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์์ฑํ์ฌ, ํ๋ก๊ทธ๋จ์ ์์ ์ฑ์ ๋์
- ํจ์์ ์กฐํฉ๊ณผ ์ฌ์ฌ์ฉ
- : ์์ ๋จ์์ ์์ ํจ์๋ฅผ ์กฐํฉํ์ฌ ๋ณต์กํ ๋ก์ง์ ๊ตฌ์ฑํ ์ ์์ผ๋ฉฐ, ๋ชจ๋์ฑ๊ณผ ์ฌ์ฌ์ฉ์ฑ์ด ์ข์
- ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ์ ๋ฆฌ
- : ๋ถ๋ณ์ฑ๊ณผ ์์ ํจ์ ๋๋ถ์ ์ํ ๊ณต์ ์์ด ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋ฐ ๋น๋๊ธฐ ์์ ์ ๊ตฌํํ๊ธฐ์ ์ ํฉ
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์ฅ๋จ์
์ฅ์ | ๋จ์ |
---|---|
๋๋ฒ๊น ๊ณผ ํ ์คํธ ์ฉ์ด | ์ฑ๋ฅ์์ ์ค๋ฒํค๋ |
์ฝ๋์ ์์ธก ๊ฐ๋ฅ์ฑ | ํ์ต๊ณก์ |
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์์
๋ํ์ ์ธ ์ธ์ด: JavaScript, Python, Haskell...
// ์์ ํจ์: ์
๋ ฅ๊ฐ๋ง์ผ๋ก ๊ฒฐ๊ณผ ๊ฒฐ์ , ์ธ๋ถ ์ํ ๋ณ๊ฒฝ ์์
const add = (a, b) => a + b;
// ๋ถ์ ํจ๊ณผ๊ฐ ์๋ ํจ์ (Side Effect)
let count = 0;
const increase = () => count++;// ์ ์ญ ๋ณ์ count ๋ณ๊ฒฝ (๋ถ์ ํจ๊ณผ ๋ฐ์)
// ๊ณ ์ฐจ ํจ์: ํจ์๋ฅผ ์ธ์๋ก ๋ฐ๊ฑฐ๋ ๋ฐํํ๋ ํจ์
const applyOperation = (a, b, operation) => operation(a, b);
console.log(applyOperation(5, 3, add));// ์ถ๋ ฅ: 8
// ๋ถ๋ณ์ฑ์ ์ํ ์: ๋ฐฐ์ด์ map ํจ์ ์ฌ์ฉ
const numbers = [1, 2, 3, 4];
const doubled = numbers.map(num => num * 2);
console.log(doubled);// ์ถ๋ ฅ: [2, 4, 6, 8]
# ์์ ํจ์ ์์
def multiply(a, b):
return a * b
# ๊ณ ์ฐจ ํจ์ ์์ : ํจ์๋ฅผ ์ธ์๋ก ๋ฐ๋ ํจ์
def apply_operation(a, b, operation):
return operation(a, b)
print(apply_operation(4, 5, multiply)) # ์ถ๋ ฅ: 20
# ๋ถ๋ณ์ฑ ์ ์ง: map ํจ์๋ฅผ ์ฌ์ฉํ ์
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x ** 2, numbers))
print(squared) # ์ถ๋ ฅ: [1, 4, 9, 16]