Функции с переменным числом параметров

void Find_MinElement(int k, ...)
{
    
    int *p = &k;
    int min = 0;
    int temp = 0;
    for (; k != 0; k--)
    {
        if ((k % 2 == 0) && (*p < *(++p)))
        {
            cout << "yes";
            temp = *p;
            *p = *(++p);
            *(++p) = *p;
            p++;
        }
        cout << *p;
    }
 
}
 
int main()
{
 
setlocale(LC_ALL, "Russian");
cout << "Минимальный в элемент: ";  Find_MinElement(5, 4, 3, 2,4,6);
 
system("pause");
    return 0;
}

//General definition of the helper class
template <typename ...Args> struct FromVariadic;
 
//This specialization does the actual job: it splits the whole pack
//into 2 parts: one single type T and the rest of types Args...
//As soon as it is done T is added to an mpl::vector.
//"bottom--up" recursion is used to fetch all types
template <class T, typename ...Args>
struct FromVariadic<T, Args...>
{
    typedef typename boost::mpl::push_front<typename FromVariadic<Args...>::type, T>::type type;
};
 
//This is a specialization for the case when only one type is passed
//and also finishes recursive descent
template <class T>
struct FromVariadic<T>
{
    typedef boost::mpl::vector<T> type;
};
 
//This one handles the case when no types where passed at all
template <>
struct FromVariadic<>
{
    typedef boost::mpl::vector<> type;
};

template<typename T, T...t>
constexpr T minEven() {
    typedef boost::mpl::vector_c<T, t...> vec;
        typedef typename boost::mpl::min_element<
              vec
            >::type iter;
    return boost::mpl::deref<iter>::type::value;
}
 
static_assert(std::is_same<boost::mpl::int_<minEven<int,1,7,0,-2,5,-1>()>,boost::mpl::int_<-2>>::value,"");

template<typename T, typename...Args>
constexpr T minEven(Args&&...args) {
    typedef typename FromVariadic<Args...>::type vec;
        typedef typename boost::mpl::min_element<
              vec
            >::type iter;
    return boost::mpl::deref<iter>::value;
}

#include <boost/hana.hpp>
#include <iostream>
 
using namespace boost::hana;
using namespace boost::hana::literals;
 
template <typename... Args>
constexpr auto minEven(Args...args) {
  auto values = make_tuple(args...);
  auto indexes = to_tuple(make_range(0_c, length(values)));
  auto indexedValues = zip(values, indexes);
 
  auto filteredIndexedValues = remove_if(indexedValues, [](const auto& v) {
      return int_c<v[1_c]> % 2_c == 0_c;
  });
 
  auto filteredValues = transform(filteredIndexedValues, front);
 
  return minimum(filteredValues);
}
 
int main() {
  constexpr auto x = minEven(5,4,3,2,4,6);
  std::cout << x << std::endl;
}

template<class T>
void min_elem(std::initializer_list<T>&& lst)
{
    std::vector<T> vec;
    std::copy(std::make_move_iterator(lst.begin()), std::make_move_iterator(lst.end()), std::back_inserter(vec));
    std::sort(vec.begin(), vec.end());
    std::cout << vec[1];
}

template<class T>
void min_element(std::initializer_list<T>&& lst)
{
    std::vector<T> vec;
    std::copy(std::make_move_iterator(lst.begin()), std::make_move_iterator(lst.end()), std::back_inserter(vec));
    auto max = std::numeric_limits<T>::max();
    for (auto i{ 0u }; i != vec.size(); ++i)
    {
        if (!(i % 2) && vec[i] < max)
            max = vec[i];
    }
    std::cout << max;
}

template<class T>
void min_element(std::initializer_list<T>&& lst)
{
    std::vector<T> vec;
    std::copy(std::make_move_iterator(lst.begin()), std::make_move_iterator(lst.end()), std::back_inserter(vec));
    auto cur{ 0u };
    auto max = std::numeric_limits<T>::max();
    std::for_each(vec.begin(), vec.end(), [&cur, &max](T value) 
    {
        if (!(cur++ % 2) && value < max)
            max = value;
    });
    std::cout << max;
}

template<class T>
void min_element(std::initializer_list<T>&& lst)
{
    std::vector<T> vec;
    std::copy(std::make_move_iterator(lst.begin()), std::make_move_iterator(lst.end()), std::back_inserter(vec));
    static auto cur{ 0u };
    static auto max = std::numeric_limits<T>::max();
    std::for_each(vec.begin(), vec.end(), [](T value) 
    {
        if (!(cur++ % 2) && value < max)
            max = value;
    });
    std::cout << max;
}

#include <iostream>
using namespace std;
 
int Find_MinElement(int k, ...)
{
    
    int *p = &k;
    int min = -1;
 
    if (p[0] > 0)
    {
        min = p[1];
 
        for (int i=3; i<p[0]; i+=2)
        {
            if (p[i] < min)
                min = p[i];
        }
    }
    return min;
 }
 
int main()
{
 
    setlocale(LC_ALL, "Russian");
    cout << "Минимальный в элемент: " <<  Find_MinElement(5, 4, 3, 2,4,6) << endl;
 
    system("pause");
    return 0;
}