Функції: перевантаження та шаблони

void printInt(int value)    { cout << value; }
void printDouble(double value) { cout << value; }
void printChar(char value)  { cout << value; }

// Три функції з однаковим іменем, але різними параметрами
void print(int value)
{
    cout << "int: " << value << "\n";
}

void print(double value)
{
    cout << "double: " << value << "\n";
}

void print(const char text[])
{
    cout << "string: " << text << "\n";
}

int main()
{
    print(42);         // → print(int)    → "int: 42"
    print(3.14);       // → print(double) → "double: 3.14"
    print("Hello");    // → print(char[]) → "string: Hello"

    return 0;
}

// ✅ Різні сигнатури — коректне перевантаження
int add(int a, int b);
double add(double a, double b);
int add(int a, int b, int c);         // Три параметри
double add(int a, double b);          // Різні типи

// ❌ НЕ є перевантаженням — однакова сигнатура!
int multiply(int a, int b);
double multiply(int a, int b);  // Різниться лише тип повернення — ПОМИЛКА

void test(int x)    { cout << "int\n"; }
void test(double x) { cout << "double\n"; }
void test(float x)  { cout << "float\n"; }

test(5);     // → test(int)    — точний збіг
test(3.14);  // → test(double) — точний збіг (літерал double)
test(3.14f); // → test(float)  — точний збіг (суфікс f → float)
test('A');   // → test(int)    — char розширюється до int

void ambiguous(int a, double b)    { cout << "1\n"; }
void ambiguous(double a, int b)    { cout << "2\n"; }

ambiguous(1, 2);  // ❌ Помилка! Обидві вимагають однакових перетворень:
                  // 1→double + 2→int  vs  1→int + 2→double → рівнозначні

ambiguous(1, static_cast<double>(2));  // → ambiguous(int, double)

// Пошук максимуму серед 2, 3 або 4 чисел
int max(int a, int b)
{
    return (a > b) ? a : b;
}

int max(int a, int b, int c)
{
    return max(max(a, b), c);  // Перевикористовує двопараметровий max!
}

int max(int a, int b, int c, int d)
{
    return max(max(a, b), max(c, d));
}

int main()
{
    cout << max(3, 7)          << "\n";  // 7
    cout << max(3, 7, 5)       << "\n";  // 7
    cout << max(3, 7, 5, 9)    << "\n";  // 9
    return 0;
}

void greet(const char name[], int times = 1)
{
    for (int i = 0; i < times; i++) cout << "Hi, " << name << "\n";
}

void greet(const char name[])  // ❌ Конфліктує з попередньою!
{
    cout << "Hello, " << name << "\n";
}

greet("Alice");  // Яку функцію викликати? Обидві підходять!

int    absVal(int x)    { return (x < 0) ? -x : x; }
double absVal(double x) { return (x < 0) ? -x : x; }
float  absVal(float x)  { return (x < 0) ? -x : x; }
// Три функції. Одна логіка. Тричі.

template<typename T>
T absVal(T x)
{
    return (x < 0) ? -x : x;
}

template<typename T>
T absVal(T x)
{
    return (x < 0) ? -x : x;
}

int main()
{
    cout << absVal(-5)    << "\n";   // T = int    → компілятор генерує absVal<int>
    cout << absVal(-3.14) << "\n";   // T = double → компілятор генерує absVal<double>
    cout << absVal(-2.5f) << "\n";   // T = float  → компілятор генерує absVal<float>

    return 0;
}

cout << absVal<int>(-5)     << "\n";  // Явна інстанціація: T = int
cout << absVal<double>(-5)  << "\n";  // Явна: T = double (int → double)

template<typename T, typename U>
void printPair(T first, U second)
{
    cout << "(" << first << ", " << second << ")\n";
}

int main()
{
    printPair(1, 3.14);       // T=int, U=double
    printPair("age", 25);     // T=char[], U=int
    printPair(true, 'x');     // T=bool, U=char
    return 0;
}

template<typename T>
void swapValues(T& a, T& b)   // T& — посилання, щоб змінювати оригінали
{
    T temp = a;
    a = b;
    b = temp;
}

int main()
{
    int x = 5, y = 10;
    swapValues(x, y);
    cout << x << " " << y << "\n";  // 10 5

    double p = 1.1, q = 2.2;
    swapValues(p, q);
    cout << p << " " << q << "\n";  // 2.2 1.1

    return 0;
}

// N — розмір масиву, визначений на етапі компіляції
template<typename T, int N>
void printArray(T arr[N])
{
    for (int i = 0; i < N; i++)
    {
        cout << arr[i] << " ";
    }
    cout << "\n";
}

int main()
{
    int nums[5] = {1, 2, 3, 4, 5};
    printArray<int, 5>(nums);   // T=int, N=5

    return 0;
}

// Загальний шаблон
template<typename T>
T getMax(T a, T b)
{
    return (a > b) ? a : b;
}

// Спеціалізація для const char* (рядки порівнюємо не через >)
template<>
const char* getMax<const char*>(const char* a, const char* b)
{
    return (strcmp(a, b) > 0) ? a : b;
}

int main()
{
    cout << getMax(3, 7)              << "\n";  // 7 (загальний шаблон)
    cout << getMax("apple", "banana") << "\n";  // banana (спеціалізація)
    return 0;
}

// Overloading — різна логіка для різних типів
void serialize(int value)     { cout << value; }
void serialize(double value)  { cout << fixed << value; }
void serialize(bool value)    { cout << (value ? "true" : "false"); }

// Template — однакова логіка, будь-який тип
template<typename T>
T clamp(T value, T minVal, T maxVal)
{
    if (value < minVal) return minVal;
    if (value > maxVal) return maxVal;
    return value;
}

template<typename T>
void describe(T value)
{
    cout << "Generic: " << value << "\n";
}

// Явне перевантаження для bool
void describe(bool value)
{
    cout << "Bool: " << (value ? "true" : "false") << "\n";
}

int main()
{
    describe(42);      // → шаблон (Generic: 42)
    describe(3.14);    // → шаблон (Generic: 3.14)
    describe(true);    // → перевантаження! (Bool: true)
    return 0;
}

3
2.72
100
0
42
3.14