Глава 5. Продвинутые концепции #

// Шаблонная функция для обмена значений
template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;
    swap(x, y);  // Работает с int
    
    double a = 3.14, b = 2.71;
    swap(a, b);  // Работает с double
    
    return 0;
}

template <typename T1, typename T2>
void printPair(T1 first, T2 second) {
    std::cout << "First: " << first 
              << ", Second: " << second << std::endl;
}

int main() {
    printPair(42, "Hello");      // int и const char*
    printPair(3.14, std::string("Pi")); // double и string
    return 0;
}

template <typename T>
class Stack {
private:
    std::vector<T> elements;

public:
    void push(const T& item) {
        elements.push_back(item);
    }

    T pop() {
        if (!elements.empty()) {
            T top = elements.back();
            elements.pop_back();
            return top;
        }
        throw std::out_of_range("Стек пуст");
    }

    bool isEmpty() const {
        return elements.empty();
    }
};

int main() {
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);

    Stack<std::string> stringStack;
    stringStack.push("Привет");
    stringStack.push("Мир");

    return 0;
}

template <typename T = int>
class Container {
private:
    T value;

public:
    Container(T val = T()) : value(val) {}
};

int main() {
    Container<>  defaultContainer;     // int по умолчанию
    Container<double> doubleContainer; // double
    return 0;
}

template <typename K, typename V>
class Map {
private:
    std::vector<std::pair<K, V>> data;

public:
    void insert(const K& key, const V& value) {
        data.push_back({key, value});
    }

    V& operator[](const K& key) {
        for (auto& item : data) {
            if (item.first == key) {
                return item.second;
            }
        }
        // Вставка нового элемента, если ключ не найден
        data.push_back({key, V()});
        return data.back().second;
    }
};

int main() {
    Map<std::string, int> ages;
    ages.insert("Алиса", 30);
    ages["Боб"] = 25;

    Map<int, std::string> names;
    names.insert(1, "Первый");
    names[2] = "Второй";

    return 0;
}

// Шаблонная функция с ограничением на копируемость
template <typename T>
requires std::copyable<T>
T duplicateValue(const T& value) {
    return value;
}

// Общий шаблон
template <typename T>
class Printer {
public:
    void print(const T& value) {
        std::cout << "Общий шаблон: " << value << std::endl;
    }
};

// Полная специализация для bool
template <>
class Printer<bool> {
public:
    void print(bool value) {
        std::cout << "Специализация для bool: " 
                  << (value ? "true" : "false") << std::endl;
    }
};

int main() {
    Printer<int> intPrinter;
    intPrinter.print(42);  // Общий шаблон

    Printer<bool> boolPrinter;
    boolPrinter.print(true);  // Специализация для bool

    return 0;
}

// Общий шаблон для указателей
template <typename T>
class Pointer {
public:
    static void print(T* ptr) {
        std::cout << "Указатель: " << ptr << std::endl;
    }
};

// Частичная специализация для указателей на char
template <typename T>
class Pointer<T*> {
public:
    static void print(T* ptr) {
        std::cout << "Указатель на объект: " 
                  << *ptr << std::endl;
    }
};

int main() {
    int x = 42;
    int* ptr = &x;
    
    Pointer<int*>::print(ptr);  // Вызовет специализированную версию

    return 0;
}