hse seminar: common editor

#include <vector>

printf("Hello, world!\n");
pentagon.hack();
t
std::vector<T> get_even_numbers(std::vector<int>::iterator begin, It end) {


template<class T, class It>
It get_even_numbers(It begin, It end, It dest) {
    return copy_if(begin, end, dest, [](T x) {return x % 2 == 0; });
}



get_even_values<uint64_t>(values.begin(), values.end())


    std::set<uint64_t> values = { 1,2,3,4 };
    std::vector<uint64_t> result = get_even_values(
        values.cbegin(),
        values.cend()
    );




auto it = get_even_values2(
        values.cbegin(),
        values.cend(),
        std::back_inserter(result)
    );


template<class It, class outputIt>
It get_even_values2(It begin, It end, outputIt dest) {
    for (; begin != end; begin++) {
        if ((*begin) % 2 == 0) {
            (*dest) = (*begin);
            dest++;
        }
    }
    return dest;
}


    auto result = sum(1, 5);
    auto result2 = sum(1.0, 6.0);

template <typename T>
T sum(const T& x, const T& y) {
    return x + y;t
}

template <>
MyNumber sum(const MyNumber& x, const MyNumber& y) {
    MyNumber result;
    result.value = x.value + y.value;
    return result;
}


struct MyNumber {
    int value;
};

MyNumber a, b;
MyNumber c = sum(a, b)





create_set<std::set<int>>(100);


template <typename T, class Z = typename T::value_type>
T create_set(Z upTo) {
    T t;
    for (Z i = 1; i <= upTo; i++) {
        t.insert(i);
    }
    return t;
}

#include <chrono>
using namespace std::chrono;

template<typename T>
void timedFunc(typename T::value_type count) {
    auto startTime = steady_clock::now();
    create_set(count);
    auto endTime = steady_clock::now();
    auto elapsed_ms = duration_cast<milliseconds>(endTime - startTime);
    std::cout << "The time: " << elapsed_ms.count() << " ms\n";

}