LV11 템플릿(template), 리스트(list), 연산자 오버로딩

// int용 더하기 int Add(int a, int b) { return a + b; } // float용 더하기 float Add(float a, float b) { return a + b; } // double용 더하기 double Add(double a, double b) { return a + b; } // ... 타입마다 계속 만들어야 함!

template <typename T> T Add(T a, T b) { return a + b; } // 이것 하나면 끝!

// 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; } int main() { int x = 10, y = 20; Swap(x, y); // 일반 템플릿 사용: 값이 교환됨 double a = 1.5, b = 2.5; Swap(a, b); // 특수화된 버전 사용: 교환 안 됨! return 0; }

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) // first: 첫 번째, args: 나머지 { std::cout << first << " "; // 첫 번째 출력 print(args...); // 나머지로 다시 호출 (재귀) } int main() { print(1, "Hello", 3.14, 'A'); // 실행 순서: // 1. print(1, "Hello", 3.14, 'A') // → 1 출력, print("Hello", 3.14, 'A') 호출 // 2. print("Hello", 3.14, 'A') // → Hello 출력, print(3.14, 'A') 호출 // 3. print(3.14, 'A') // → 3.14 출력, print('A') 호출 // 4. print('A') // → A 출력, print() 호출 // 5. print() // → 줄바꿈하고 종료 return 0; }

#include <iostream> #include <print> #include <vector> template <typename... Args> auto sum(Args... args) { return (... + args); // 왼쪽부터 차례로: ((1+2)+3)+4+5 // (... + args) 는 다음과 같이 전개됨: // sum(1,2,3,4,5) → ((((1 + 2) + 3) + 4) + 5) } template <typename... Args> void printAll(Args... args) { (std::print("{} ", args), ...); // 각 인자마다 print 호출 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; }

struct Point { int x, y; }; Point p1 = {1, 2}; Point p2 = {3, 4}; Point p3 = p1 + p2; // ❌ 에러! + 연산자를 사용할 수 없음

struct Point { int x, y; Point operator+(Point other) { // + 연산자 정의 return {x + other.x, y + other.y}; } }; Point p3 = p1 + p2; // ✅ 작동! 직관적!

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

struct Point { int x, y; // ➕ 덧셈 연산자 오버로딩 // p1 + p2 를 호출하면 p1.operator+(p2) 가 실행됨 Point operator+(Point other) { Point result; result.x = x + other.x; // 이 객체의 x + 상대방의 x result.y = y + other.y; // 이 객체의 y + 상대방의 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; // 실수부(real), 허수부(imaginary) Complex(double r, double i) : re(r), im(i) {} void Display() { std::cout << re << " + " << im << "i" << std::endl; } // 복소수 덧셈: (a + bi) + (c + di) = (a+c) + (b+d)i 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; // ✨ 수학 공식처럼 사용! // (1.2+3.4i) + (5.6+7.8i) = 6.8 + 11.2i c.Display(); // "6.8 + 11.2i" 출력 return 0; }

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

template <typename T> class list { public: struct Node { T data; // 제네릭 데이터 Node* back; // 다음 노드 포인터 }; class iterator { Node* p; bool operator!=(const iterator& other) const { } void operator++() // 전위 증가 연산자 { } }; ...... }; // main for (ya::list<int>::iterator iter = yaList.begin(); iter != yaList.end(); ++iter) { std::cout << *iter << std::endl; }

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

// ❌ 템플릿 없이 (코드 중복) int Add(int a, int b) { return a + b; } double Add(double a, double 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; } // 모든 타입에 대해 작동!