Примеры для второй части лекции про шаблоны C++

templates_part2.cpp

/***

SFINAE: Substitution failure is not an error

*/

// В основном базируется на std::enable_if
// https://en.cppreference.com/w/cpp/types/enable_if

#include <type_traits>

int main() {
    using T1 = std::enable_if<8 == sizeof(void*), long>::type;
    using T2 = std::enable_if<4 == sizeof(int)>::type;

    static_assert(std::is_same_v<long, T1>);
    static_assert(std::is_same_v<void, T2>);
}

// Обычно вместо std::enable_if<C, T>::type пишут std::enable_if_t<C, T>.

#include <iostream>
#include <cmath>

template<typename T>
std::enable_if_t<std::is_floating_point_v<T>, bool>
is_equal(T a, T b)
{
    return std::abs(std::abs(a) - std::abs(b)) < 0.0001;
}

template<typename T>
std::enable_if_t<std::is_integral_v<T>, bool>
is_equal(T a, T b)
{
    return a == b;
}

int main()
{
    std::cout << "   int: " << is_equal(1, 1) << std::endl;
    std::cout << "double: " << is_equal(0.0, 0.0000002) << std::endl;
}

/***

Может иметь несколько форм:

enable_if для возвращаемого значения;
enable_if для параметра шаблона по умолчанию;
enable_if для аргумента функции/метода по умолчанию.

*/

// Пример использования enable_if в параметре шаблона.
// Чтобы можно было написать auto в качестве типа возвращаемого значения.

#include <iostream>
#include <type_traits>

template<typename A, typename B,
    typename D = std::enable_if_t<std::is_integral_v<A> && std::is_integral_v<B>> >
auto
add(A a, B b) { return a+b; }

template<typename A, typename B,
    typename D = std::enable_if_t<std::is_floating_point_v<A> && std::is_floating_point_v<B>> >
float
add(A a, B b) { return static_cast<float>(a +b); }

int main() {
    auto r1 = add(1, 2l);
    static_assert(std::is_same_v<long, decltype(r1)>);

    auto r2 = add(2.0, 3.0f);
    static_assert(std::is_same_v<float, decltype(r2)>);
}

// При определении шаблонного конструктора.

// Пример простого шаблонного конструктора.

#include <iostream>
#include <type_traits>
#include <string>

template<typename T>
class ValueHolder
{
    T _value;

public:
    template<typename U>
    ValueHolder(U && v) : _value{std::forward<U>(v)}
    {
        std::cout << "template constructor" << std::endl;
    }

    [[nodiscard]] const T &
    value() const { return _value; }
};

int main() {
    ValueHolder<std::string> v1{"Hello"};
    std::cout << "v1: " << v1.value() << std::endl;

    ValueHolder<std::string> v2{std::string{"World"}};
    std::cout << "v2: " << v2.value() << std::endl;
}

// Ведет к ошибке компиляции вот в таком случае:
//
// ValueHolder<std::string> v3{v2};
//
// Версия с SFINAE

#include <iostream>
#include <type_traits>
#include <string>

template<typename T>
class ValueHolder
{
    T _value;

public:
    template<typename U,
        typename Guard = std::enable_if_t<
                !std::is_same_v<std::decay_t<U>, ValueHolder>
            >
        >
    ValueHolder(U && v) : _value{std::forward<U>(v)}
    {
        std::cout << "template constructor" << std::endl;
    }

    [[nodiscard]] const T &
    value() const { return _value; }
};

int main() {
    ValueHolder<std::string> v1{"Hello"};
    std::cout << "v1: " << v1.value() << std::endl;

    ValueHolder<std::string> v2{std::string{"World"}};
    std::cout << "v2: " << v2.value() << std::endl;

    ValueHolder<std::string> v3{v2};
    std::cout << "v3: " << v3.value() << std::endl;
}

// Используется std::decay: https://en.cppreference.com/w/cpp/types/decay
//
// Performs the type conversions equivalent to the ones performed when passing
// function arguments by value.
//
// В частности, для нашего случая: Otherwise, the member typedef type is
// std::remove_cv<std::remove_reference<T>::type>::type.


//
// SFINAE посредством параметра по умолчанию
//

#include <iostream>
#include <type_traits>

template<typename A, typename B>
auto
add(A a, B b,
    std::enable_if_t<std::is_integral_v<A> && std::is_integral_v<B>> * = nullptr)
{ return a+b; }

template<typename A, typename B>
float
add(A a, B b,
    std::enable_if_t<std::is_floating_point_v<A> && std::is_floating_point_v<B>> * = nullptr )
{ return static_cast<float>(a+b); }

int main() {
    auto r1 = add(1, 2l);
    static_assert(std::is_same_v<long, decltype(r1)>);

    auto r2 = add(2.0, 3.0f);
    static_assert(std::is_same_v<float, decltype(r2)>);
}

/////////////////////////////////////////////////////

/***

Случай, когда приходится использовать нотацию this->member.

*/

#include <iostream>

template<typename T>
struct Base {
    T _x;
};

template<typename T>
struct Derived : public Base<T> {
    void print() const {
        std::cout << _x << std::endl;
    }
};

int main() {
    Derived<int> v{10};
    v.print();
}

// Ошибка компиляции, т.к. в Derived<T>::print имя _x неизвестно.
// Возможные исправления:

// Вариант №1

    void print() const {
        std::cout << this->_x << std::endl;
    }

// Вариант №2

template<typename T>
struct Derived : public Base<T> {
    using Base<T>::_x;
    void print() const {
        std::cout << _x << std::endl;
    }
};

/////////////////////////////////////////////////////

/***

Лямбда-функции и шаблоны

Если нам нужно куда-то передать лямбду в качестве параметра, то либо std::function,
либо шаблон. Но std::function -- это аналог std::shared_ptr, за std::function может
скрываться невидимая пользователю аллокация памяти.

*/

#include <iostream>

template<typename L>
auto CallLambda(L && lambda) { return lambda(); }

struct Demo {
    Demo() = default;
    Demo(const Demo &) { std::cout << "Demo copy ctor" << std::endl; }
    Demo & operator=(const Demo &) {
        std::cout << "Demo copy operator" << std::endl;
        return *this;
    }
};

template<typename L>
decltype(auto) CallLambda2(L && lambda) { return lambda(); }

int main()
{
    Demo a;
    const auto & b1 = CallLambda([&a]() -> Demo & { return a;});
    (void) b1;

    const auto & b2 = CallLambda2([&a]() -> Demo & { return a;});
    if(&a == &b2) std::cout << "same object" << std::endl;
}

// Отдельная история происходит когда нам нужно сохранить лямбду как поле
// какого-то класса. Простой вариант -- std::function, но если не подходит, то...

// Проблемный вариант:

#include <iostream>
#include <type_traits>

template<typename Lambda>
class LambdaHolder
{
    Lambda _lambda;

public:
    LambdaHolder(Lambda && lambda) : _lambda{std::move(lambda)} {}

    decltype(auto) Call(int v) { return _lambda(v); }
};

template<typename Lambda>
[[nodiscard]] auto
MakeHolder(Lambda && lambda)
{
    using LambdaType = std::decay_t<Lambda>;
    return LambdaHolder<LambdaType>{std::move(lambda)};
}

void Func(int v) { std::cout << "func: " << v << std::endl; }

int main() {
    const auto first = [](int v) { std::cout << "first: " << v << std::endl; };
    auto second = [](int v) {
        std::cout << "second: " << v << std::endl;
        return v+1;
    };

    MakeHolder(Func).Call(0);
//    MakeHolder(first).Call(1);
    MakeHolder(second).Call(2);
    MakeHolder([&first](int v) { first(v+10); }).Call(3);
}

// Проблема в том, что first -- это const.
// Решение:

template<typename Lambda>
class LambdaHolder
{
    Lambda _lambda;

public:
    template<typename ActualLambda>
    LambdaHolder(ActualLambda && lambda) : _lambda{std::forward<ActualLambda>(lambda)} {}

    decltype(auto) Call(int v) { return _lambda(v); }
};

/////////////////////////////////////////////////////

/***

Variadic templates

*/

template<typename... TArgs>
void f(TArgs ...args) {}

// Разница между TArgs... args и TArgs && ...args:

#include <iostream>

template<typename... Args>
void Handle(Args... /*args*/) {}

struct Demo {
    Demo() = default;
    Demo(const Demo &) { std::cout << "Demo copy ctor" << std::endl; }
    Demo & operator=(const Demo &) {
        std::cout << "Demo copy operator" << std::endl;
        return *this;
    }
};

int main() {
    Demo d1, d2, d3;
    Handle(d1, d2, d3);
}

// Второй вариант:

#include <iostream>

template<typename... Args>
void Handle(Args && .../*args*/) {}

struct Demo {
    Demo() = default;
    Demo(const Demo &) { std::cout << "Demo copy ctor" << std::endl; }
    Demo & operator=(const Demo &) {
        std::cout << "Demo copy operator" << std::endl;
        return *this;
    }
};

int main() {
    Demo d1, d2, d3;
    Handle(d1, d2, d3);
}

// Для того, чтобы развернуть parameter pack нужно записать pack...

#include <iostream>

template<typename... Args>
void Handle(Args && ...args) {
    int values[]{args...};
    for(int v : values) std::cout << v << std::endl;
}

int main() {
    Handle(5, 6, 7, 8);
}

// Узнать размер pack-а можно посредством sizeof...(pack):

#include <iostream>
#include <array>

template<typename... Args>
void Handle(Args && ...args) {
    std::array<int, sizeof...(args)> values{args...};
    for(int v : values) std::cout << v << std::endl;
}

int main() {
    Handle(5, 6, 7, 8);
}

// При распаковке pack-а можно делать и вызов функции:

#include <iostream>
#include <array>

int square(int v) { return v * v; }

template<typename... Args>
void Handle(Args && ...args) {
    std::array<int, sizeof...(args)> values{square(args)...};
    for(int v : values) std::cout << v << std::endl;
}

int main() {
    Handle(5, 6, 7, 8);
}

// Можно завершать рекурсию посредством терминальных функций и
// посредством if constexpr.

// Терминальная функция:

#include <iostream>
#include <array>

namespace min_impl {

template<typename T>
T GetMinElement(T currentMin) {
    return currentMin;
}

template<typename T, typename... Tail>
T GetMinElement(T currentMin, T toCompare, Tail ...tail) {
    return GetMinElement(currentMin < toCompare ? currentMin : toCompare, tail...);
}

} /* namespace min_impl */

template<typename T, typename... Tail>
T MinElement(T head, Tail ...tail) {
    return min_impl::GetMinElement(head, tail...);
}

int main() {
    std::cout << MinElement(10) << std::endl;
    std::cout << MinElement(10, 0) << std::endl;
    std::cout << MinElement(-1, 0) << std::endl;
    std::cout << MinElement(-1, 0, -2) << std::endl;
    std::cout << MinElement(10, 20, 30, 5, 0, -1, 100, 50) << std::endl;
    std::cout << MinElement(10, 20, 30, 40, 50) << std::endl;
    std::cout << MinElement(50, 40, 30, 20, 10) << std::endl;
}

// Использование if constexpr:

#include <iostream>
#include <array>

namespace min_impl {

template<typename T, typename... Tail>
T GetMinElement(T currentMin, T toCompare, Tail ...tail) {
    if constexpr(0 == sizeof...(tail))
        return toCompare < currentMin ? toCompare : currentMin;
    else
        return GetMinElement(GetMinElement(currentMin, toCompare), tail...);
}

} /* namespace min_impl */

template<typename T, typename... Tail>
T MinElement(T head, Tail ...tail) {
    if constexpr(0 == sizeof...(tail))
        return head;
    else
        return min_impl::GetMinElement(head, tail...);
}

int main() {
    std::cout << MinElement(10) << std::endl;
    std::cout << MinElement(10, 0) << std::endl;
    std::cout << MinElement(-1, 0) << std::endl;
    std::cout << MinElement(-1, 0, -2) << std::endl;
    std::cout << MinElement(10, 20, 30, 5, 0, -1, 100, 50) << std::endl;
    std::cout << MinElement(10, 20, 30, 40, 50) << std::endl;
    std::cout << MinElement(50, 40, 30, 20, 10) << std::endl;
}

// Использование variadic templates для perfect forwarding.

#include <iostream>
#include <memory>
#include <string>

template<typename T, typename... Args>
std::unique_ptr<T> MyMakeUnique(Args && ...args) {
    return std::unique_ptr<T>{ new T(std::forward<Args>(args)...) };
}

int main() {
    auto s1 = MyMakeUnique<std::string>(std::size_t{20}, 'A');
    std::cout << *s1 << std::endl;
    auto s2 = MyMakeUnique<std::string>(*s1 + "-tail");
    std::cout << *s2 << std::endl;
}

// Можно обратить внимание на использование круглых скобок при вызове
// конструктора T внутри MyMakeUnique.

/////////////////////////////////////////////////////

/***

Fold expression -- https://en.cppreference.com/w/cpp/language/fold

( pack op ... )         (1) -> Unary right fold.
( ... op pack )         (2) -> Unary left fold
( pack op ... op init ) (3) -> Binary right fold
( init op ... op pack ) (4)	 -> Binary left fold

Раскрывается в:

1) Unary right fold (E op ...) -> (E1 op (... op (EN-1 op EN)))
2) Unary left fold (... op E) -> (((E1 op E2) op ...) op EN)
3) Binary right fold (E op ... op I) -> (E1 op (... op (EN−1 op (EN op I))))
4) Binary left fold (I op ... op E) -> ((((I op E1) op E2) op ...) op EN)

*/

#include <iostream>

template<typename... Args>
auto sum(Args ...args) {
    return (... + args);
}

template<typename T>
T square(T v) { return v * v; }

template<typename... Args>
auto sum_squares(Args ...args) {
    return (... + square(args));
}

int main() {
    std::cout << sum(1, 2, 3, 4.3) << std::endl;
    std::cout << sum_squares(1, 2, 3, 4.3) << std::endl;
}

// Нужно учитывать приоритеты операций если в fold expression есть начальное значение:

template<typename... Args>
int sum(Args&&... args)
{
//  return (args + ... + 1 * 2);   // Error: operator with precedence below cast
    return (args + ... + (1 * 2)); // OK
}