Computer Science
Generic Programming
8/1/2024

Generic Programming ์ด๋?
Generic programming centers around the idea of abstracting from concrete, efficient algorithms to obtain generic algorithms that can be combined with different data representations to produce a wide variety of useful software.
์ ๋๋ฆญ ํ๋ก๊ทธ๋๋ฐ์ด๋ ๊ตฌ์ฒด์ ์ธ ์๊ณ ๋ฆฌ์ฆ, ๋ก์ง, ํน์ ํ๋์ ์๋ก ๋ค๋ฅธ ๋ฐ์ดํฐ ํ์ ์ ๋ํด ์ ์ฉํ๊ธฐ ์ํด ํ๋์ ์ผ๋ฐํ๋ ์๊ณ ๋ฆฌ์ฆ, ๋ก์ง, ํน์ ํ๋์ผ๋ก ์ถ์ํํ๋ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ๋ฒ์ ๋๋ค.

์ด๋ ์ถ์ํ์ ํ ๋ฐฉ๋ฒ์ด๊ธฐ์, ์ํํธ์จ์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ์ถ์ํํ๊ณ ์ ํ๋๊ฐ์ ๋ฐ๋ผ ๊ฐ์ ์ฝ๋๋ผ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์ฑํ๋ ์ ์์ต๋๋ค. ๋ง์ฝ Student, Lecturer, Faculty๋ผ๋ ๊ฐ๋ ์ด ์๊ณ , ์ด๋ค์ด ๋ชจ๋ ๋ฑ๋ก๋ ์ ์์ด์ผ ํ๋ค๋ฉด, ์ด๋ฅผ ๊ฐ์ฒด๋ค์ด ๊ฐ์ ธ์ผํ ์ผ์ข ์ ๊ณ์ฝ์ผ๋ก ๋ณด๊ณ ๊ตฌํ์ ๊ฐ์ ํ์๋ ์ธก๋ฉด์์๋ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ ์ ์์ ๊ฒ์ด๋ฉฐ, ๋ฑ๋ก ๋ก์ง์ ๋์ผํ๋ ์ฌ๋ฌ ํ์ ์ ๋ฐ๋๋ก ํ์๋ ์ธก๋ฉด์์๋ ์ ๋๋ฆญ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ ๊ฒ์ ๋๋ค.
Build process remind

์ฐ๋ฆฌ๊ฐ ์์ฑํ ์์ค์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์ณ ์ํ๋ฉ๋๋ค.
- ์ปดํ์ผ - ์ฌ๋์ด ์ฝ์ ์ ์๋ ์์ค์ฝ๋๋ฅผ ๊ธฐ๊ณ์ด๋ก ๋ณํํ๋ ๊ณผ์ ์ ๋๋ค.
- ๋งํน - ์ปดํ์ผ๋ ํ์ผ๋ค์ ์ฎ์ด ํ๋์ ์คํ๊ฐ๋ฅํ ํ์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ ๋๋ค.
- ๋ก๋ฉ - ๋งํน์ด ์๋ฃ๋ ์คํ๊ฐ๋ฅํ ํ์ผ์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฌํ๋ ๊ณผ์ ์ ๋๋ค.
์ด ๋์ ์ปดํ์ผ๊ณผ ๋งํน ๊ณผ์ , ์ฆ ํ๋์ ์คํ๊ฐ๋ฅํ ํ์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ ๋น๋๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํฉ๋๋ค. ๋น๋ ์๊ธฐ๋ ํ๋ก๊ทธ๋จ์ด ์ํ์ค์ด ์๋๋ฏ๋ก ์ปดํ์ผ ํ์์ด๋ผ ๋ถ๋ฅด๋ฉฐ, ๋ก๋ฉ ์ดํ ํ๋ก๊ทธ๋จ์ด ์คํ์ค์ธ ์๊ธฐ๋ฅผ ๋ฐํ์์ด๋ผ ๋ถ๋ฆ ๋๋ค.
c++ template
C++์์ ์ ๋๋ฆญ ํ๋ก๊ทธ๋๋ฐ์ template์ด๋ผ๋ ๊ฐ๋ ์ผ๋ก ๋์ ๋์์ต๋๋ค. ํํ c++๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ ์ฌ์ฉํ๋ STL์ Standard Template Library์ ์ฝ์๋ก, ์ด๋ฌํ ์ ๋๋ฆญ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ ์ด ์ฌ์ฉ๋์์์ ์ ์ ์์ต๋๋ค. STL์ ์ฌ๋ฌ ์ ๋ง๋ค์ด์ง ์๋ฃ๊ตฌ์กฐ ํด๋์ค๋ฅผ ์ ๊ณตํ๊ณ , ์ด๋ค์ ์ฌ์ฉํ๋ ์์ ์ ํ์ ์ ์ง์ ํ์ฌ ์ด๋ ํ ํ์ ์ด๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์ ์๋๋ก ํฉ๋๋ค.
// [์ฝ๋ 1] c++ template ์์
template <class T>
class Calculator
{
private:
T num1;
T num2;
public:
Calculator(T num1, T num2) {
this->num1 = num1;
this->num2 = num2;
}
T GetAdd() {
return num1 + num2;
}
};
int main()
{
// ์๋๋ ์๋ฐ์์๋ ๋ณผ ์ ์๋ C++๋ง์ ์์ฑ์์
๋๋ค.
Calculator<int> calcu1(10, 20);
cout << calcu1.GetAdd() << endl;
Calculator<double> calcu2(10.52, 20.24);
cout << calcu2.GetAdd() << endl;
}C++์์๋ ํ ํ๋ฆฟ์ ์์ ๊ฐ์ด ์ฌ์ฉํฉ๋๋ค. template <class T>๋ผ๋ ์ฝ๋๋ฅผ ํตํด ์ด ํด๋์ค๊ฐ ์ ๋๋ฆญ ํด๋์ค์์ ํํํ๋ฉฐ, T ์ ๋๋ฆญ ํ์ ์ ํตํด ํด๋์ค ๋ด๋ถ์์ ์ผ๋ฐํ๋ ํ์ ์ ์ฌ์ฉํฉ๋๋ค.
ํด๋์ค ํ ํ๋ฆฟ์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ Calculator<int> calcu; ์ ๊ฐ์ด ํด๋์ค๋ฅผ ์์ฑํ๋ ์์ ์ ํ์ ์ ์ง์ ํด์ค์ผ ํฉ๋๋ค. ์ดํ ํด๋น ํด๋์ค๋ ํด๋น ํ์ ๋ง์ ๋ฐ๊ณ ๋ก์ง์ ์ํํ๊ฒ ๋ฉ๋๋ค.
Compile-time Type generalization

C++ ์ template์ ๋ค์๊ณผ ๊ฐ์ ํน์ง์ ๊ฐ์ต๋๋ค.
1. ์ ์ธ๊ณผ ์ ์๋ ๋ญ๋ฑ๊ทธ๋ ค์ ํ์ง๋ง, ์ฌ์ฉ๋ ๋๋ ํ์ ์ ์ ์ํ์ฌ ์ฌ์ฉํด์ผ ํ๋ค.
๋ก์ง์ ์ถ์ํํ๊ธฐ ์ํ์ฌ T๋ผ๋ ์ ๋๋ฆญ ํ์ ์ ์ฌ์ฉํ์ง๋ง, ์ด ํด๋์ค๊ฐ ์ค์ ๋ก ์ฌ์ฉ๋๋ ์์ ์์๋ ํ์ ์ด ์ง์ ๋์ด์ผ ํฉ๋๋ค.
2. ์ปดํ์ผ ํ์ ํจ์ํ
C++ ์ปดํ์ผ๋ฌ๋ ์ปดํ์ผํ๋ ๋์ค ์ ๋๋ฆญ ํด๋์ค๊ฐ ์ฌ์ฉ๋ ๊ณณ์ ๊ธฐ๊ณ์ด๋ก ๋ฒ์ญํ ๋ ๊ธฐ์ ๋ ํ์ ์ ์ฒ๋ฆฌํ ์ ์๋ ์คํ๊ฐ๋ฅํ ๋ช ๋ น์ด ๋ฌถ์์ ์์ฑํฉ๋๋ค. ์ด ์คํ๊ฐ๋ฅํ ๋ช ๋ น์ด ๋ฌถ์์ ์ ๋๋ฆญ ํด๋์ค์ ๋ก์ง์ ๊ธฐ์ ๋ ๋ฐ์ดํฐ ํ์ ์ด ์ ์ฉ๋์ด์๋ ๋ชจ์ต์ ๋๋ค. [์ฝ๋ 2]์ด์ ๋ ์ปดํ์ผ๋ฌ๋ฅผ ํตํด ํด๋น ํ์ ์ ์ฒ๋ฆฌํ ์ ์๋ ํด๋์ค๊ฐ ๋ง๋ค์ด์ก์ผ๋ฏ๋ก ์๋์ ์ ๋๋ฆญ ์ฝ๋๊ฐ ์๋ ๊ณณ์ ์ด ์ฝ๋๋ฅผ ํธ์ถํ๋๋ก ์ปดํ์ผ๋ฉ๋๋ค. ์ด๋ฌํ ๋ถํSpecialization์ ์ปดํ์ผ ํ์์ ๋ฐ์ํฉ๋๋ค.
3. ํ ํ๋ฆฟ์ ์ฌ์ฉ์ ํ๋ก๊ทธ๋จ์ ๋๋ ค์ง๊ฒ ๋ง๋ค์ง ์๋๋ค.
๋ถํ๋๋ ์์ ์ ์ปดํ์ผ ํ์์ด๋ฏ๋ก ๋ฐํ์์ ์๊ฐ๋ณต์ก๋์๋ ์๊ด์ด ์์ต๋๋ค. ์ปดํ์ผ ์ดํ ๋ฐํ์์๋ T๋ผ๋ ์ผ๋ฐํ๋ ํ์ ์ ๋ณด๋ ํ๋ก๊ทธ๋จ์ ๊ทธ ์ด๋์๋ ๋จ์ง ์๊ณ ์ค์ง ๊ตฌ์ฒด์ ์ธ ํ์ ์ ๋ฐ๋ ํด๋์ค๋ง์ด ๋จ์ต๋๋ค.
4. Code Explosion
๋ง์ฝ Calculator<int> ๋ฟ๋ง ์๋๋ผ Calculator<double>, Calculator<MyClass> ๋ ํ๋ก๊ทธ๋จ ๋ด์์ ์ฌ์ฉ๋๋ค๋ฉด ๊ฐ๊ฐ์ ํ์ ์ ์ฒ๋ฆฌํ๋ ์ฝ๋๊ฐ ์์ฑ๋ฉ๋๋ค. ๋ง์ฝ type T์ ๋์ํ๋ ํ์ ์ด ๋ง์ ๊ฒฝ์ฐ ๊ทธ๊ฒ ๊ฐ๊ฐ์ ๋ํ ํด๋์ค ์ฝ๋๊ฐ ์์ฑ๋ ๊ฒ์ ๋๋ค. ์ด๋ ๋น๋๋ ํ์ผ์ ํฌ๊ธฐ๋ฅผ ํฌ๊ฒ ๋ง๋ค ์ ์์ผ๋ฉฐ, ์ปดํ์ผ ํ์์ด ๊ธธ์ด์ง๊ฒ ๋ง๋ฆ๋๋ค. ์ด๋ฌํ ํ์์ Code Explosion์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
// [์ฝ๋ 2] ์ปดํ์ผํ์์ ์์ฑ๋๋ ์คํ๊ฐ๋ฅํ ์ฝ๋ ์์
// ์ปดํ์ผ๋ฌ๋ ๋๋ต ์ด๋ ๊ฒ ์๊ธด ์ฝ๋๋ฅผ ์์ฑํ๋ค. ์ด๋๋ ์ผ๋ฐํ๋ ํ์
์ ๋ณด๋
// ๋จ์ง ์๊ณ , ์ค์ง ๊ตฌ์ฒด์ ์ธ ํ์
์ ์ฒ๋ฆฌํ๋ ์ฝ๋๋ง์ด ๋จ๋๋ค.
class Calculator.int
{
private:
int num1;
int num2;
public:
Calculator(int num1, int num2) {
this->num1 = num1;
this->num2 = num2;
}
int GetAdd() {
return num1 + num2;
}
};๊ฒฐ๊ตญ C++์ template์ ํ๋์ ๋ก์ง์ ์ฌ๋ฌ ํ์ ์ผ๋ก ์ ๊ณตํ๊ธฐ ์ํด ๊ฐ๊ฐ์ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํ๋์์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด Java๋ ์ด๋จ๊น์?
Java Generics
// [์ฝ๋ 3] Java Generics ์์
class Calculator<T>
{
private T num1;
private T num2;
public Calculator(T num1, T num2) {
this.num1 = num1;
this.num2 = num2;
}
public T getAdd() {
return num1 + num2;
}
};
class Main {
public static void main(String[] args) {
Calculator<Integer> calcuInt = new Calcu<>();
System.out.println(calcu.getAdd());
Calculator<Long> calcuDouble = new Calcu<>();
System.out.println(calcu.getAdd());
}
}Java์์ Generic Programming์ Generic์ด๋ผ๋ ๊ฐ๋ ์ผ๋ก ๋์ ๋์์ต๋๋ค. C++ ์ง์์ STL์ด ์๋ค๋ฉด Java ์ง์์๋ Collection์ด ์์ด์, ์ฌ๋ฌ๊ฐ์ง Collection ํด๋์ค๋ฅผ ํตํด ์๋ก ๋ค๋ฅธ ํ์ ์ ๋ํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
Type Erasure
Java์ Generic์ ๋ค์๊ณผ ๊ฐ์ ํน์ง์ ๊ฐ์ต๋๋ค.
1. ํ์ ์๊ฑฐ
Calculator<Integer> ์ ๊ด๋ จ๋ ์ฝ๋๋ ์ปดํ์ผํ์์ ๊ฑฐ์น๊ณ ๋ ์ดํ์ ๋ฐ์ด๋๋ฆฌ ์ฝ๋์์๋ Integer์ ๊ด๋ จ๋ ์ ๋ณด๋ ๋ชจ๋ ์ญ์ ๋๊ณ , ๋ด๋ถ์ ์ผ๋ก๋ Object๋ฅผ ๋ค๋ฃจ๋ ๋ฐ์ด๋๋ฆฌ ์ฝ๋๋ก ๋ณ๊ฒฝ๋ฉ๋๋ค. ๋ชจ๋ ๊ฐ์ฒด์ ์กฐ์์ธ Object๋ก ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ๋ฐ์ดํฐ ํ์ ์ ํ๋์ ํด๋์ค๋ฅผ ํตํด ๋ค๋ฃฐ ์ ์์ต๋๋ค.
2. ์๋ ํ๋ณํ
ํ์ง๋ง ๋ชจ๋ ํ์ ์ Object๋ก ๋ฐ๊พธ๊ฒ ๋๋ค๋ฉด ํ์ ์ ์จ์ ํ๊ฒ ์ฌ์ฉํ ์ ์์ ๊ฒ์ ๋๋ค. ๋ฐ๋ผ์ ์๋ฐ ์ปดํ์ผ๋ฌ๋ ์ ๋๋ฆญ ์์๋ฅผ ๊บผ๋ด๋ ์ฝ๋์ ํ์ ์บ์คํ ํ๋ ์ฝ๋๋ฅผ ๋ฃ์ต๋๋ค. ์ด๋ฅผ ํตํด ๊ฐ๋ฐ์๋ ๋ช ์์ ์ผ๋ก ์บ์คํ ์ ์์ฑํ์ง ์์๋ ๋๋ฉฐ, ํ์ ์์ ์ฑ์ ๋ณด์ฅ๋ฐ์ ์ ์์ต๋๋ค.
Java์ Generic๋ c++์ template๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ํ๋์ ๋ก์ง๋ง ์์ฑํ๋ฉด ์ฌ๋ฌ๊ฐ์ ๋ฐ์ดํฐ ํ์ ์ ์ฒ๋ฆฌํ ์ ์๋๋ก ๋ง๋ค ์ ์์ต๋๋ค. ํ์ง๋ง Java์ generic์ ์ฌ์ฉ๋๋ ํ์ ์ ์ฒ๋ฆฌํ ์ ์๋ ์ฝ๋๋ฅผ ๊ฐ๊ฐ ์์ฑํด๋ด๋ ๋ฐฉ์์ด ์๋๋๋ค. Object, ํน์ ํน์ ํด๋์ค์ ํด๋นํ๋ ์ฝ๋๋ก ์นํํ์ฌ ๋์ํ ๋ฟ์ ๋๋ค.
๋ฐ๋ผ์ Java์์๋ Code Explosion์ด ๋ฐ์ํ์ง ์์ต๋๋ค. Java์์๋ ํ๋์ ์ฝ๋(๋ช ๋ น์ด ๋ฌถ์)๋ฅผ ์ฌํ์ฉํฉ๋๋ค. ์ด๋ ๋ถ๋ช ํ ์ฅ์ ์ด์ง๋ง ๋จ์ ์ญ์ ์กด์ฌํฉ๋๋ค. c++ ํ๋ก๊ทธ๋จ์ ๋ฐํ์์๋ ๊ฐ๊ฐ์ ์ ๋๋ฆญ ํด๋์ค๋ ๊ทธ๊ฒ์ ์ฒ๋ฆฌํ๋ ํ์ ์ ๋ณด๋ฅผ ๊ฐ๊ณ ์์ด์ ์ด๋ฅผ ํตํด ๋ฆฌํ๋ ์ ์ ์ฌ์ฉํ์ฌ ํน์ํ ์ฒ๋ฆฌ๋ฅผ ํ ์ ์์ต๋๋ค. ํ์ง๋ง Java์ ๊ฒฝ์ฐ ๋ฐํ์์ ์ ๋๋ฆญ ํ์ ์ ๋ณด๋ ์๋ฉธ๋์ด ์ ์ ์๋ค๋ ๋จ์ ์ ๊ฐ๊ณ ์์ต๋๋ค.
Compile-time Polymorphism vs Run-time Polymorphism

Polymorphism โ providing a single interface to entities of different types. Virtual functions provide dynamic (run-time) polymorphism through an interface provided by a base class. Overloaded functions and templates provide static (compile-time) polymorphism
๋คํ์ฑ์ ํ๋์ ์ด๋ฆ์ ๊ฐ์ง ๋ฉ์๋๋ก๋ถํฐ ์ฌ๋ฌ ๋์์ด ์ํ๋ ์ ์๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ๋คํ์ฑ์ ๋ ๊ฐ๋๋ก ๋๋ฉ๋๋ค.
Dynamic Polymorphism, ํน์ Run-time Polymorphism์ผ๋ก ๋ถ๋ฆฌ๋ ๊ฒ์ผ๋ก ์ค๋ฒ๋ผ์ด๋ฉ์ ์ํด ํ๋์ ๋ฉ์๋๊ฐ ์ค์ ์ฐธ์กฐ ๊ฐ์ฒด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ฌ ์๋ก ๋ค๋ฅธ ๋์์ ํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์ด ๋ ๋์์ด ๊ฒฐ์ ๋๋ ์์ ์ ๋ฐํ์์ด๋ฏ๋ก, ์ด๋ฌํ ๋คํ์ฑ์ ๋ฐํ์ ๋คํ์ฑ์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
ํ ํธ, ํ๋์ ์ด๋ฆ์ ๊ฐ์ง ๋ฉ์๋์ ๋์์ด ์ปดํ์ผ ํ์์ ์๋ก ๋ค๋ฅธ ๋์์ผ๋ก ๊ฒฐ์ ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ์ค๋ฒ๋ก๋ฉ๊ณผ ์ด ๊ธ์ ์ฃผ์ ์ธ Generic ๋ฉ์๋๊ฐ ๊ทธ ์์์ ๋๋ค. ์ด๋ฌํ ๋คํ์ฑ์ Static Polymorphism, ํน์ Compile-time Polymorphism์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
์ค๋ฒ๋ก๋ฉ์ ์๋ก ๋ค๋ฅธ ํ๋ผ๋ฏธํฐ๋ฅผ ํตํด ํ๋์ ์ด๋ฆ์ ๊ฐ์ง ๋ฉ์๋๊ฐ ์๋ก ๋ค๋ฅธ ๋ช ๋ น์ ์ํํ๊ฒ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋๋ค. ์ ๋๋ฆญ์ ์ผ๋ฐํ๋ ํ์ ์ผ๋ก ๋ค์ํ ์ธ์๋ฅผ ์ฒ๋ฆฌํ ์ ์๊ฒ ํ๋ ๊ฒ์ ๋๋ค. ์ด๋ค์ ๋ชจ๋ ํ๋์ ๋ฉ์๋ ์ด๋ฆ์ผ๋ก ์ฌ๋ฌ๊ฐ์ง ๋์์ ํ ์ ์๊ฒ ๋ง๋ค๋ฉด์, ์ด๋ค ๋์์ ์ํํ ์ง์ ๋ํด ์ปดํ์ผ ํ์์ ๊ฒฐ์ ๋๋ค๋ ํน์ง์ด ์์ต๋๋ค.