HOWTO: сортировка массива структур по произвольному полю

struct myStruct{
    int m1;
    string m2;
    //etc...
};

vector<myStruct> v;
Compare fobj;
fobj.opt = 1;// <---???
sort(v.begin(),v.end(),fobj);

struct Compare:public binary_function<myStruct&,myStruct&, bool >{
        int opt;    
        bool operator()(const myStruct &a,const myStruct &b ) {
            switch(opt){
                case 1:{ return a.m1 < b.m1; break;}
                case 2:{ return a.m2 < b.m2; break;}
                //etc...
            }
        }
};

struct some
{
    int one;
    std::string two;
};
 
std::vector<some> v;
auto comp_by_one = [](const some &a, const some &b)-> bool {return a.one > b.one;};
auto comp_by_two = [](const some &a, const some &b)-> bool {return a.two > b.two;};
...
std::sort(v.begin(), v.end(), comp_by_one);
...
std::sort(v.begin(), v.end(), comp_by_two);
...

#include <string>
#include <iostream>
#include <algorithm>
 
struct st {
    int d;
    std::string s;
 
    st(const int _d, const std::string& _s) {
        d = _d;
        s = _s;
    }
 
    void print() const {
        std::cout << d << ":" << s << " ";
    }
};
 
bool intPriority(const st& v, const st& u) {
    if (v.d == u.d) {
        return (v.s < u.s);
    } else {
        return (v.d < u.d);
    }
}
 
bool stringPriority(const st& v, const st& u) {
    if (v.s == u.s) {
        return (v.d < u.d);
    } else {
        return (v.s < u.s);
    }
}
 
void printMassiv(const std::vector<st>& massiv) {
    for (auto &i: massiv) {
        i.print();
    }
    std::cout << "\n";
}
 
void sortMassivWithCriterion(std::vector<st>& massiv, const int cr) {
    switch(cr) {
        case 0: {
            std::sort(massiv.begin(), massiv.end(), intPriority);
            break;
        }
        case 1: {
            std::sort(massiv.begin(), massiv.end(), stringPriority);
            break;
        }
        default: return;
    }
    printMassiv(massiv);
}
 
int main() {
    std::vector<st> massiv;
    massiv.push_back(st(9, "a"));
    massiv.push_back(st(3, "g"));
    massiv.push_back(st(1, "i"));
    massiv.push_back(st(2, "h"));
    massiv.push_back(st(7, "c"));
    massiv.push_back(st(4, "f"));
    massiv.push_back(st(6, "d"));
    massiv.push_back(st(8, "b"));
    massiv.push_back(st(5, "e"));
    printMassiv(massiv);
 
    sortMassivWithCriterion(massiv, 0);
    sortMassivWithCriterion(massiv, 1);
 
    return 0;
}

#define MYCOMPARE(a, b, member) (a.##member<b.##member)
 
struct MYSTRUCT
{
 int kolichestvo;
 double kachestvo;
};
 
 
 
int _tmain(int argc, _TCHAR* argv[])
{
 MYSTRUCT st1, st2;
 st1.kachestvo =0.4; st2.kachestvo=0.75;
 st1.kolichestvo=15; st2.kolichestvo=1;
 
 printf("%d  ", MYCOMPARE(st2, st1, kolichestvo) );
 
 system ("pause");
 return 0;
}