함수 템플릿

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

// 만약 float, long, short 등의 타입에 대해서도 같은 작업을 하고 싶다면?
// float add(float a, float b) { return a + b; }
// ... 계속해서 함수를 오버로딩해야 함

template <typename T> // 또는 template <class T>
반환타입 함수이름(T 매개변수1, T 매개변수2, ...) {
    // T 타입에 대해 동작하는 코드
}

// 여러 개의 타입 매개변수 사용 가능
template <typename T1, typename T2>
반환타입 함수이름(T1 매개변수1, T2 매개변수2, ...) {
    // T1, T2 타입에 대해 동작하는 코드
}

#include <iostream>
#include <string> // std::string을 위해

// 비교 연산과 값 복사를 지원하는 타입에 대해 동작하는 max 함수 템플릿 정의
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // 1. int 타입으로 max 함수 호출
    // 컴파일러가 T를 int로 추론하여 int max(int, int) 함수를 생성 (템플릿 인스턴스화)
    int i = max(10, 20);
    std::cout << "Max of 10 and 20: " << i << std::endl; // 출력: 20

    // 2. double 타입으로 max 함수 호출
    // 컴파일러가 T를 double로 추론하여 double max(double, double) 함수를 생성
    double d = max(3.14, 2.71);
    std::cout << "Max of 3.14 and 2.71: " << d << std::endl; // 출력: 3.14

    // 3. char 타입으로 max 함수 호출
    char c = max('A', 'Z');
    std::cout << "Max of 'A' and 'Z': " << c << std::endl; // 출력: Z

    // 4. std::string 타입으로 max 함수 호출
    std::string s = ::max(std::string("apple"), std::string("banana"));
    std::cout << "Max of \"apple\" and \"banana\": " << s << std::endl; // 출력: banana

    // 주의: 다른 타입끼리 호출 시 컴파일 오류 발생 (예: max(10, 3.14))
    // 이유: T가 int와 double 중 어떤 타입이 되어야 할지 컴파일러가 결정할 수 없기 때문.
    // template <typename T1, typename T2> T1 max(T1 a, T2 b) // 이렇게 타입을 분리하여 오버로딩 가능 (결과 타입 유의)
    // 또는 명시적 타입 지정: max<double>(10, 3.14)
    double mixed = max<double>(10, 3.14); // 명시적으로 T를 double로 지정
    std::cout << "Max of 10 and 3.14 (explicit double): " << mixed << std::endl; // 출력: 10

    return 0;
}

#include <iostream>

template <typename T>
T pick_max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    std::cout << pick_max<double>(2, 3.9) << '\n';
    std::cout << pick_max<int>(2, 3.9) << '\n';
}

함수이름<타입1, 타입2, ...>(인자1, 인자2, ...);

#include <iostream>

template <typename T>
T add_default(T a, T b, T default_value) {
    return a + b + default_value;
}

// 템플릿 매개변수 T를 함수의 반환 타입으로만 사용하고, 인자에는 사용하지 않는 경우
template <typename T>
T create_zero() {
    return static_cast<T>(0); // 0을 T 타입으로 변환
}

template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }

// 함수 템플릿은 블록 밖에 선언합니다. 반환 타입 추론은 C++14부터 지원됩니다.
template <typename T1, typename T2>
auto flexible_max(T1 a, T2 b) { return (a > b) ? a : b; }

int main() {
    // add_default 호출 시 T는 int로 추론됨
    std::cout << add_default(1, 2, 0) << std::endl; // 출력: 3

    // 컴파일러가 T를 추론할 수 없음: create_zero()
    // int zero_int = create_zero(); // 컴파일 오류! T를 추론할 수 없음.
    int zero_int = create_zero<int>(); // 명시적으로 <int> 지정
    std::cout << "Zero int: " << zero_int << std::endl; // 출력: 0

    double zero_double = create_zero<double>(); // 명시적으로 <double> 지정
    std::cout << "Zero double: " << zero_double << std::endl; // 출력: 0

    // 서로 다른 타입의 인자가 전달될 때
    // max 함수 템플릿 (예시 1의 코드와 동일)
    // template <typename T> T max(T a, T b) { return (a > b) ? a : b; }

    // double result = max(5, 3.14); // 컴파일 오류: T를 int로 할지 double로 할지 모호
    double result1 = max<double>(5, 3.14); // 명시적으로 double로 지정
    std::cout << "Max (5, 3.14): " << result1 << std::endl; // 출력: 5

    // 두 타입 매개변수는 각각 추론됩니다.
    double result2 = flexible_max(5, 3.14); // T1은 int, T2는 double로 추론. 반환 타입은 double로 추론
    std::cout << "Max (5, 3.14) with flexible_max: " << result2 << std::endl; // 출력: 5

    return 0;
}

#include <iostream>
#include <string>

// 1. 두 개의 T 타입 인자를 받는 max 함수 템플릿
template <typename T>
T max(T a, T b) {
    std::cout << "두 T 타입 인자를 받는 max 호출\n";
    return (a > b) ? a : b;
}

// 2. 세 개의 T 타입 인자를 받는 max 함수 템플릿 (오버로딩)
template <typename T>
T max(T a, T b, T c) {
    std::cout << "세 T 타입 인자를 받는 max 호출\n";
    return max(max(a, b), c); // 첫 번째 max 템플릿 호출
}

// 3. int를 받는 일반 함수 오버로드 (명시적 특수화가 아님)
// 인자 변환 등 다른 조건이 동등하면 일반 함수를 선호
int max(int a, int b) {
    std::cout << "int 타입에 대한 일반 max 함수 호출\n";
    return (a > b) ? a : b;
}

int main() {
    std::cout << max(10, 20) << std::endl;       // 출력: int 타입에 대한 일반 max 함수 호출, 20
    std::cout << max(3.14, 2.71) << std::endl;   // 출력: 두 T 타입 인자를 받는 max 호출, 3.14
    std::cout << max('A', 'Z') << std::endl;     // 출력: 두 T 타입 인자를 받는 max 호출, Z

    std::cout << max(10, 20, 30) << std::endl;   // 출력: 세 T 타입 인자를 받는 max 호출, 30
    std::cout << max(1.1, 2.2, 3.3) << std::endl; // 출력: 세 T 타입 인자를 받는 max 호출, 3.3

    // int 타입의 인자로 3개 전달 시
    std::cout << max<int>(10, 20, 30) << std::endl; // 출력: 세 T 타입 인자를 받는 max 호출, 30
                                                 // (명시적 템플릿 인수 지정; 일반 함수는 후보가 아님)

    return 0;
}

세 T 타입 인자를 받는 max 호출
두 T 타입 인자를 받는 max 호출
두 T 타입 인자를 받는 max 호출
30