Sort vector, сортировка по двум полям структуры

struct DATA{
    string fir;
    string sec;
    double sm;
};
vector <DATA> vec;
vector <DATA>::iterator itv;
bool myfunction (DATA i,DATA j) { return (atoi(i.fir.c_str()) < atoi(j.fir.c_str()) && (atoi(i.sec.c_str()) < atoi(j.sec.c_str()))); }
sort(vec.begin(),vec.end(),myfunction);

bool myfunction (DATA i,DATA j) 
{
    if(  atoi(i.fir.c_str()) < atoi(j.fir.c_str()) )
               return true;
    else
    {
         if (  atoi(i.fir.c_str()) == atoi(j.fir.c_str())  &&   atoi( i.sec.c_str() ) < atoi(j.sec.c_str()  )
                     return true;
    } 
    return false; 
 }

/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_data
{
    //-----------------------------------------------------------------------------------
    T_str   first_;
    T_str   second_;
    double  d_;
    //-----------------------------------------------------------------------------------
    bool    operator<   ( T_data    const   &   data )
    {
        return      std::make_pair( first_,         second_         )
                <   std::make_pair( data.first_,    data.second_    );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////

#pragma once
 
#include <functional>
#include <vector>
 
    template <typename T>
    class chain_comparer {
        typedef std::function<bool( const T&, const T& )> comparer;
 
    public:
        
        //comparer.chain<std::greater>( boost::bind( &person::name, _1 ) );
        template <template <typename> class Comparer, typename Getter>
        chain_comparer& chain( const Getter& getter ) {
            typedef std::remove_reference<std::result_of<Getter(T)>::type>::type result_type;
            return chain( Comparer<result_type>(), getter );
        }
 
        //comparer.chain( std::greater<std::string>(), boost::bind( &person::name, _1 ) );
        template <typename Comparer, typename Getter>
        chain_comparer& chain( const Comparer& comparer, const Getter& getter ) {
            i_comparers.push_back( std::bind( comparer, std::bind( getter, std::placeholders::_1 ), std::bind( getter, std::placeholders::_2 ) ) );
            return *this;
        }
 
        //cmp.chain<std::greater>( &person::name );
        template <template <typename> class Comparer, typename ValType>
        chain_comparer& chain( ValType T::* member ) {
            return chain( Comparer<ValType>(), member );
        }
 
        //comparer.chain( std::greater<std::string>(), &person::name );
        template <typename Comparer, typename ValType>
        chain_comparer& chain( const Comparer& comparer, ValType T::* member ) {
            i_comparers.push_back( std::bind( comparer, std::bind( member, std::placeholders::_1 ), std::bind( member, std::placeholders::_2 ) ) );
            return *this;
        }
 
        bool operator()( const T& lhs, const T& rhs ) {
            for( const auto& comparer : i_comparers ) {
                if( comparer( lhs, rhs ) ) return true;
                if( comparer( rhs, lhs ) ) return false;
            }
 
            return false;
        }
 
    private:
        std::vector<comparer> i_comparers;
    };

    chain_comparer<DATA> comparer;
    comparer.chain<std::less>( &DATA::fir );
    comparer.chain<std::less>( &DATA::sec );
    std::sort( vec.begin(), vec.end(), comparer );

#include <algorithm>
#include <iostream>
#include <vector>
 
struct S
{
    int x, y, z;
};
 
int main()
{
    using vec_S = std::vector<S>;
    vec_S v = {{1, 9, 1000}, {3, 1, 1000}, {2, 1, 1000}, {1, 8, 1000}};
    auto print_v = [](const vec_S &vec)
    {
        for (auto el: vec)
            std::cout << "(" << el.x << ", " << el.y << ", " << el.z << ") ";
        std::cout << std::endl;
    };
 
    std::cout << "Before: ";
    print_v(v);
    std::sort(v.begin(), v.end(), [](const S &lhs, const S &rhs) { return lhs.x != rhs.x ? lhs.x < rhs.x : lhs.y < rhs.y; });
    std::cout << "After: ";
    print_v(v);
}