Повна (явна) спеціалізація шаблонів

#include <iostream>

// ═════════════════════════════════════════════════════════════
// ПЕРВИННИЙ ШАБЛОН: оголошення класу
// ═════════════════════════════════════════════════════════════
template <typename T>
class Printer
{
public:
    void print(const T& value);  // Оголошення методу
};

// Визначення методу первинного шаблону поза класом
template <typename T>
void Printer<T>::print(const T& value)
{
    std::cout << "[Printer<T>] Значення: " << value << "\n";
}

// ═════════════════════════════════════════════════════════════
// ПОВНА СПЕЦІАЛІЗАЦІЯ для bool
// ═════════════════════════════════════════════════════════════
template <>
class Printer<bool>
{
public:
    void print(const bool& value);
};

// Визначення методу спеціалізації
template <>
void Printer<bool>::print(const bool& value)
{
    std::cout << "[Printer<bool>] Булеве значення: "
              << (value ? "true" : "false") << "\n";
}

int main()
{
    Printer<int> intPrinter;
    intPrinter.print(42);

    Printer<bool> boolPrinter;
    boolPrinter.print(true);

    return 0;
}

#include <iostream>

// ═════════════════════════════════════════════════════════════
// 1. ПЕРВИННИЙ ШАБЛОН
// ═════════════════════════════════════════════════════════════
template <typename T>
void process(T value)
{
    std::cout << "[1] Первинний шаблон: T\n";
}

// ═════════════════════════════════════════════════════════════
// 2. СПЕЦІАЛІЗАЦІЯ для int
// ═════════════════════════════════════════════════════════════
template <>
void process<int>(int value)
{
    std::cout << "[2] Спеціалізація шаблону: int\n";
}

// ═════════════════════════════════════════════════════════════
// 3. ПЕРЕВАНТАЖЕНА НЕШАБЛОННА ФУНКЦІЯ для int
// ═════════════════════════════════════════════════════════════
void process(int value)
{
    std::cout << "[3] Нешаблонна перевантажена функція: int\n";
}

int main()
{
    process(3.14);    // Випадок A: double
    process(42);      // Випадок B: int
    process<int>(42); // Випадок C: явна специфікація шаблону

    return 0;
}

#include <iostream>

// ═════════════════════════════════════════════════════════════
// ПЕРВИННИЙ ШАБЛОН: за замовчуванням всі типи НЕ примітивні
// ═════════════════════════════════════════════════════════════
template <typename T>
struct IsFundamental
{
    static constexpr bool value = false;
};

// ═════════════════════════════════════════════════════════════
// СПЕЦІАЛІЗАЦІЇ для примітивних типів
// ═════════════════════════════════════════════════════════════
template <>
struct IsFundamental<int>
{
    static constexpr bool value = true;
};

template <>
struct IsFundamental<double>
{
    static constexpr bool value = true;
};

template <>
struct IsFundamental<char>
{
    static constexpr bool value = true;
};

template <>
struct IsFundamental<bool>
{
    static constexpr bool value = true;
};

// Допоміжна функція для зручного виведення
template <typename T>
void checkType()
{
    if constexpr (IsFundamental<T>::value)
        std::cout << "Тип є примітивним\n";
    else
        std::cout << "Тип НЕ є примітивним\n";
}

// Власний клас для тестування
class MyClass {};

int main()
{
    std::cout << "int: ";
    checkType<int>();  // Примітивний

    std::cout << "double: ";
    checkType<double>();  // Примітивний

    std::cout << "MyClass: ";
    checkType<MyClass>();  // Не примітивний

    std::cout << "int*: ";
    checkType<int*>();  // Не примітивний (покажчик)

    return 0;
}

#include <iostream>

// ═════════════════════════════════════════════════════════════
// FIRST POLICY: звільнення одиночного об'єкта
// ═════════════════════════════════════════════════════════════
template <typename T>
struct SingleObjectPolicy
{
    static void destroy(T* ptr)
    {
        std::cout << "[SingleObjectPolicy] delete ptr\n";
        delete ptr;
    }
};

// ═════════════════════════════════════════════════════════════
// SECOND POLICY: звільнення масиву
// ═════════════════════════════════════════════════════════════
template <typename T>
struct ArrayPolicy
{
    static void destroy(T* ptr)
    {
        std::cout << "[ArrayPolicy] delete[] ptr\n";
        delete[] ptr;
    }
};

// ═════════════════════════════════════════════════════════════
// Клас SmartPointer із налаштовуваною політикою
// ═════════════════════════════════════════════════════════════
template <typename T, typename Policy = SingleObjectPolicy<T>>
class SmartPointer
{
private:
    T* m_ptr;

public:
    explicit SmartPointer(T* ptr = nullptr) : m_ptr(ptr) {}

    ~SmartPointer()
    {
        Policy::destroy(m_ptr);
    }

    T& operator*() { return *m_ptr; }
    T* operator->() { return m_ptr; }

    // Заборона копіювання (для спрощення прикладу)
    SmartPointer(const SmartPointer&) = delete;
    SmartPointer& operator=(const SmartPointer&) = delete;
};

int main()
{
    // Одиночний об'єкт: використовуємо SingleObjectPolicy (за замовчуванням)
    SmartPointer<int> ptr1(new int(42));

    // Масив: явно вказуємо ArrayPolicy
    SmartPointer<int, ArrayPolicy<int>> ptr2(new int[10]);

    // Деструктори викличуться автоматично при виході зі scope

    return 0;
}

#include <iostream>
#include <vector>
#include <list>

// ═════════════════════════════════════════════════════════════
// ТЕГИ ДЛЯ КАТЕГОРІЙ ІТЕРАТОРІВ
// ═════════════════════════════════════════════════════════════
struct RandomAccessIteratorTag {};
struct BidirectionalIteratorTag {};

// ═════════════════════════════════════════════════════════════
// TRAIT: визначення категорії ітератора
// ═════════════════════════════════════════════════════════════
template <typename Iterator>
struct IteratorTraits;

// Спеціалізація для покажчиків (random access)
template <typename T>
struct IteratorTraits<T*>
{
    using category = RandomAccessIteratorTag;
};

// Спеціалізація для std::list::iterator (bidirectional)
template <typename T>
struct IteratorTraits<typename std::list<T>::iterator>
{
    using category = BidirectionalIteratorTag;
};

// ═════════════════════════════════════════════════════════════
// РЕАЛІЗАЦІЇ для різних категорій
// ═════════════════════════════════════════════════════════════

// Random Access: O(1) — пряме додавання
template <typename Iterator>
void advanceImpl(Iterator& it, int n, RandomAccessIteratorTag)
{
    std::cout << "[Random Access] it += n (O(1))\n";
    it += n;
}

// Bidirectional: O(n) — послідовна інкрементація
template <typename Iterator>
void advanceImpl(Iterator& it, int n, BidirectionalIteratorTag)
{
    std::cout << "[Bidirectional] Цикл ++it (O(n))\n";
    for (int i = 0; i < n; ++i)
        ++it;
}

// ═════════════════════════════════════════════════════════════
// ПУБЛІЧНИЙ ІНТЕРФЕЙС: автоматичний вибір реалізації
// ═════════════════════════════════════════════════════════════
template <typename Iterator>
void advance(Iterator& it, int n)
{
    using Category = typename IteratorTraits<Iterator>::category;
    advanceImpl(it, n, Category{});  // Створюємо тимчасовий об'єкт-тег
}

int main()
{
    // Random Access ітератор (покажчик)
    int arr[] = {1, 2, 3, 4, 5};
    int* ptr = arr;
    advance(ptr, 3);
    std::cout << "Значення після advance: " << *ptr << "\n\n";

    // Bidirectional ітератор (std::list)
    std::list<int> lst = {10, 20, 30, 40, 50};
    auto it = lst.begin();
    advance(it, 2);
    std::cout << "Значення після advance: " << *it << "\n";

    return 0;
}

#include <iostream>

// Первинний шаблон
template <typename T>
void func(T value)
{
    std::cout << "[1] Шаблон T\n";
}

// Спеціалізація для int*
template <>
void func<int*>(int* value)
{
    std::cout << "[2] Спеціалізація int*\n";
}

// Перевантажена шаблонна функція для всіх покажчиків
template <typename T>
void func(T* value)
{
    std::cout << "[3] Шаблон T* (перевантаження)\n";
}

int main()
{
    int x = 42;
    int* px = &x;

    func(px);  // Що викличеться: [2] чи [3]?

    return 0;
}

#include <iostream>

// Первинний шаблон
template <typename T>
void print(T value)
{
    std::cout << "[Primary] " << value << "\n";
}

// ═════════════════════════════════════════════════════════════
// ТОЧКА ІНСТАНЦІЮВАННЯ 1: компілятор бачить лише первинний шаблон
// ═════════════════════════════════════════════════════════════
void earlyCall()
{
    print(42);  // Інстанціює print<int> із первинного шаблону
}

// ═════════════════════════════════════════════════════════════
// Спеціалізація оголошена ПІСЛЯ першого виклику
// ═════════════════════════════════════════════════════════════
template <>
void print<int>(int value)
{
    std::cout << "[Specialization] " << value << "\n";
}

// ═════════════════════════════════════════════════════════════
// ТОЧКА ІНСТАНЦІЮВАННЯ 2: тепер спеціалізація видима
// ═════════════════════════════════════════════════════════════
void lateCall()
{
    print(42);  // Використовує спеціалізацію
}

int main()
{
    std::cout << "Ранній виклик:\n";
    earlyCall();

    std::cout << "\nПізній виклик:\n";
    lateCall();

    return 0;
}