LV11 템플릿(template), 연산자 오버로딩

// variable template template <typename T> constexpr T pi = T(3.1415926535897932385L); int main() { float f = pi<float>; // float 버전의 pi double d = pi<double>; // double 버전의 pi int i = pi<int>; // int 버전의 pi (3) return 0; }

template <typename T> 반환타입 함수이름(T 매개변수) { // 함수 본체 }

// ❌ 기존 방식: 타입마다 별도 함수 필요 //int Add(int a, int b) { return a + b; } //float Add(float a, float b) { return a + b; } // ✅ 템플릿 방식: 하나의 함수로 모든 타입 처리 template <typename T> T Add(T a, T b) { return a + b; } int main() { int a = Add<int>(1, 2); // int 버전 호출 float b = Add<float>(1.0f, 2.0f); // float 버전 호출 return 0; }

Add<int>(1, 2) 호출 시: ├─ 컴파일러가 int 버전의 Add 함수 자동 생성 └─ int Add(int a, int b) { return a + b; }

template <typename T> void Swap(T& a, T& b) { T temp = a; a = b; b = temp; } // double 타입에 대한 특별한 처리 template <> void Swap<double>(double& a, double& b) { // double형은 값을 서로 바꾸지 않음 std::cout << "double은 교환하지 않습니다!" << std::endl; }

template <typename T> class Data { public: T GetData() { return mData; } void SetData(T data) { mData = data; } private: T mData; // T 타입의 데이터 저장 }; int main() { Data<int> intData; // int용 Data 클래스 Data<float> floatData; // float용 Data 클래스 intData.SetData(100); floatData.SetData(3.14f); return 0; }

template <typename... Args> // Args: 타입들의 집합 void function_name(Args... args) // args: 실제 값들의 집합 { // 함수 본체 }

#include <iostream> #include <print> #include <vector> // 재귀 종료 조건 void print() { std::cout << std::endl; } // 가변인자 템플릿 함수 template <typename T, typename... Args> void print(T first, Args... args) { std::cout << first << " "; print(args...); // 나머지 인자로 재귀 호출 } int main() { print(1, "Hello", 3.14, 'A'); // "1 Hello 3.14 A" 출력 return 0; }

#include <iostream> #include <print> #include <vector> template <typename... Args> auto sum(Args... args) { // print args... return (... + args); // 모든 인자를 더함 } template <typename... Args> void printAll(Args... args) { (std::print("{} ", args), ...); // 모든 인자를 출력 std::print("\n"); } int main() { int result = sum(1, 2, 3, 4, 5); // 15 반환 printAll(1, 2, 3, 4, 5); // "1 2 3 4 5" 출력 return 0; }

#include <iostream> #include <print> #include <vector> #include <list> namespace ya { template <typename T> class list { public: struct Node { T data; // 제네릭 데이터 Node* back; // 다음 노드 포인터 }; list() // 생성자 { mHead = nullptr; mTail = nullptr; } ~list() // 소멸자 { // 메모리 해제 코드 필요 } void push_back(T data) { if (mHead == nullptr) // 첫 번째 노드 { mHead = new Node(); mHead->data = data; mHead->back = nullptr; mTail = mHead; } else // 기존 노드가 있는 경우 { mTail->back = new Node(); mTail->back->data = data; mTail->back->back = nullptr; mTail = mTail->back; } } private: Node* mHead; // 첫 번째 노드 Node* mTail; // 마지막 노드 }; } int main() { ya::list<int> intList; // int용 리스트 intList.push_back(1); intList.push_back(2); std::list<int> stdList; // std::list 사용 예시 stdList.push_back(1); stdList.push_back(2); return 0; }

타입 operator연산자기호(매개변수) { // 연산자 동작 정의 }

struct Point { int x, y; // ➕ 덧셈 연산자 Point operator+(Point other) { Point result; result.x = x + other.x; result.y = y + other.y; return result; } // ➖ 뺄셈 연산자 (Point - Point) Point operator-(Point other) { Point result; result.x = x - other.x; result.y = y - other.y; return result; } // ➖ 뺄셈 연산자 (Point - int) Point operator-(int value) { Point result; result.x = x - value; result.y = y - value; return result; } // 🔍 비교 연산자 bool operator<(Point other) { return (x < other.x && y < other.y); } }; int main() { Point p1 = {1, 1}; Point p2 = {3, 2}; Point p3 = p1 + p2; // p1.operator+(p2) 호출 Point p4 = p1 - p2; // p1.operator-(p2) 호출 Point p5 = p1 - 5; // p1.operator-(5) 호출 if (p1 < p2) { // p1.operator<(p2) 호출 std::cout << "p1이 p2보다 작습니다" << std::endl; } return 0; }

struct Complex { double re, im; // 실수부, 허수부 Complex(double r, double i) : re(r), im(i) {} void Display() { std::cout << re << " + " << im << "i" << std::endl; } // 복소수 덧셈 Complex operator+(Complex& other) { return Complex(re + other.re, im + other.im); } }; int main() { Complex a(1.2, 3.4); // 1.2 + 3.4i Complex b(5.6, 7.8); // 5.6 + 7.8i Complex c = a + b; // (6.8, 11.2) c.Display(); // "6.8 + 11.2i" 출력 return 0; }

yaList.push_front(10); // 앞쪽에 추가하는 함수 int len = yaList.size(); // 크기 반환하는 함수

for (ya::list<int>::iterator iter = yaList.begin(); iter != yaList.end(); ++iter) { std::cout << *iter << std::endl; }

struct Vector2 { double x, y; explicit Vector2(double x_, double y_) : x(x_), y(y_) {} // 10가지 이상의 연산자 구현하기 // ==, !=, +, -, *, /, +=, -=, *=, /=, <, >, <= 등 };