Доступ к атрибуту класса по его порядковому номеру

#include "stdafx.h"
#include <windows.h>
#include <iostream>
 
struct One{
    int Two;
    double Three;
    char Four;
};
 
int _tmain(int argc, _TCHAR* argv[]){
    One one_example;
    one_example.Two = 2;
    one_example.Three = 3;
    one_example.Four = '4';
    void *first_field = &one_example;
    void *second_field = (double*)first_field + 1;      //ширина полей равна ширине наибольшего поля - double
    void *third_field = (double*)first_field + 2;
 
    std::cout << "Field Two: " << *static_cast<int *>(first_field) << std::endl;
    std::cout << "Field Three: " << *static_cast<double *>(second_field) << std::endl;
    std::cout << "Field Four: " << *static_cast<char *>(third_field) << std::endl;
    system("pause");
    return 0;
}

#include <functional>
#include <algorithm>
#include <iostream>
#include <utility>
#include <string>
#include <vector>
 
template <class type>
using compare     = std::function<bool(const type&, const type&)>;
template<
        class classT
        >
struct field_comparer  {
    using type        = classT;
    bool operator() (const type& a, const type& b) {
        return functor (a, b);
    }
    field_comparer():functor(nullptr) {}
    field_comparer(const compare<type>& f):functor(f) {}
    field_comparer(const compare<type>&& f):functor(std::move(f)) {}
    //field_comparer(const field_comparer<type>& f):functor(f.functor) {}
    //field_comparer(const field_comparer<type>&& f):functor(std::move(f.functor)) {}
 
    template<class T>
    field_comparer<T> operator=(const field_comparer<T>& f) { functor.assign(f.functor); }
    template<class T>
    field_comparer<T> operator=(const field_comparer<T>&& f){ functor.assign(std::move(f.functor)); }
    compare<type> functor;
};
 
template<
        class classT,
        class memberT
        >
struct some:public field_comparer<classT> {
    using type        = classT;
    using member_type = memberT;
    using member_ptr  = member_type type::*;
    using compare     = std::function<bool(const member_type&, const member_type&)>;
    some(member_ptr mem, compare func)
        :member(mem), comp(func){
        this->field_comparer<type>::functor = std::bind(&some<type, member_type>::call, this,
                  std::placeholders::_1, std::placeholders::_2);
    }
    some(some<classT, memberT> const& l)
        :field_comparer<type>(l.functor),
          member(l.member), comp(l.comp){}
    some(some<classT, memberT> const&& l)
        :field_comparer<type>(l.functor),
          member(std::move(l.member)), comp(std::move(l.comp)){}
    bool call(const type& a, const type& b) {
        return comp(a.*member, b.*member);
    }
private:
    member_ptr member;
    compare    comp;
};
template<
        class classT,
        class memberT,
        class cmpT = std::less<memberT>
        >
field_comparer<classT> make_comparer(
        memberT classT::*member,
        cmpT cmp = cmpT()
        ) {
    return std::move(some<classT, memberT>(member, cmp));
}
 
struct test_idx {
    char one;
    int two;
    std::string three;
    test_idx* four;
};
int main() {
    using namespace std;
    vector<test_idx> a{
        {'a',  100500, "hello", nullptr},
        {'z', 42, "a hell", (test_idx*)(0xdead)}
    };
 
    auto print = [&a]() ->void
    {
             for(auto& i: a)
                 cout << '{'
                      << i.one << ", "
                      << i.two << ", "
                      << i.three << ", "
                      << i.four << "} ";
             cout << endl;
    };
    vector<field_comparer<test_idx>>
            one_idx{
                make_comparer(&test_idx::one),
                make_comparer(&test_idx::two),
                make_comparer(&test_idx::three),
                make_comparer(&test_idx::four)
    };
    print();
    for(auto& cmp: one_idx) {
        std::sort(a.begin(), a.end(), cmp);
        print();
    }
    return 0;
}

#include <functional>
#include <algorithm>
#include <iostream>
#include <utility>
#include <string>
#include <vector>
 
template <class type>
using compare     = std::function<bool(const type&, const type&)>;
 
template<
        class classT,
        class memberT,
        class cmpT = compare<memberT>
        >
compare<classT> make_cmp(
        memberT classT::*member,
        cmpT cmp = std::less<memberT>()
        ) {
    return  [cmp, member](const classT& a, const classT& b) -> bool {
            return cmp(a.*member, b.*member);
    };
}
 
struct test_idx {
    char one;
    int two;
    std::string three;
    test_idx* four;
};
int main() {
    using namespace std;
    vector<test_idx> a{
        {'a',  100500, "hello", nullptr},
        {'z', 42, "a hell", (test_idx*)(0xdead)}
    };
 
    auto print = [&a]() ->void
    {
             for(auto& i: a)
                 cout << '{'
                      << i.one << ", "
                      << i.two << ", "
                      << i.three << ", "
                      << i.four << "} ";
             cout << endl;
    };
    vector<compare<test_idx>>
        idx_two{
        make_cmp(&test_idx::one),
        make_cmp(&test_idx::two),
        make_cmp(&test_idx::three),
        make_cmp(&test_idx::four)
    };
    for (auto& cmp : idx_two) {
        std::sort(a.begin(), a.end(), cmp);
        print();
    }
    return 0;
}