Класс ATC, реализовать сортировку и поиск по заданному ключу

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
 
namespace cf{
    
    class Abonent{
        private:
            std::string name;
            int phone;
            float tariff;
        public:
            Abonent(){
                name = std::string();
                phone = 0;
                tariff = .0f;
            }
            Abonent(std::string m_name, int m_phone, float m_tariff){
                name = m_name;
                phone = m_phone;
                tariff = m_tariff;
            }
            Abonent(const Abonent & abonent){
                name = abonent.getName();
                phone = abonent.getPhone();
                tariff = abonent.getTariff();
            }
            void setName(const std::string m_name){
                name = m_name;
            }
            void setPhone(const int m_phone){
                phone = m_phone;
            }
            void setTariff(const float m_tariff){
                tariff = m_tariff;
            }
            std::string getName() const{
                return name;
            }
            int getPhone() const{
                return phone;
            }
            float getTariff() const{
                return tariff;
            }
    };
    
    class Connect{
        private:
            Abonent a1;
            Abonent a2;
            float timeConnect;
        public:
            Connect(){}
            Connect(Abonent & m_a1, Abonent & m_a2){
                a1 = m_a1;
                a2 = m_a2;
            }
            void setConnect(Abonent & m_a1, Abonent & m_a2){
                if(m_a1.getPhone() == m_a2.getPhone()){
                    std::cout << "Incorrected connection." << std::endl;
                    return;
                }
                a1 = m_a1;
                a2 = m_a2;
            }
            Abonent getLeftAbonent() const{
                return a1;
            }
            Abonent getRightAbonent() const{
                return a2;
            }
            void print() const{
                if(a1.getPhone() && a2.getPhone()){
                        std::cout << "Name : " << a1.getName() << " phone : "
                                        << a1.getPhone() << " tariff : " << a1.getTariff() 
                                        << " --- " << "Name : " << a2.getName() << " phone : "
                                        << a2.getPhone() << " tariff : " << a2.getTariff() << std::endl;
                }
            }
            void setTimeConnect(float m_timeConnect){
                timeConnect = m_timeConnect;
            }
            float getTimeConnect() const{
                return timeConnect;
            }
            
    };
    
    typedef void (*SORT)(std::vector<Abonent> &);
    typedef void (*FIND)(std::vector<Abonent> &, size_t & idx);
    
    void margeSort(std::vector<Abonent> & abonents){
        std::cout << "Sorting an array of merger." << std::endl;
        // TO DO
    }
    
    void shakerSort(std::vector<Abonent> & abonents){
        std::cout << "Shake sorting an array." << std::endl;
        // TO DO
    }
    
    void fullSearch(std::vector<Abonent> & abonents, size_t & idx){
        std::cout << "Full searching  in array." << std::endl;
        // TO DO
    }
    
    void interpolationSearch(std::vector<Abonent> & abonents, size_t & idx){
        std::cout << "Interpolation searching  in array." << std::endl;
        // TO DO
    }
    
    class ATM{
        private:
            SORT _sort;
            std::vector<Abonent> abonents;
            std::vector<Connect> connects;
        public:
            void setSort(SORT m_sort){
                _sort = m_sort;
            }
            void find(FIND m_find, size_t & idx){
                m_find(abonents, idx);
            }
            void sort(){
                if(_sort)
                    _sort(abonents);
                else
                    std::cout << "Set the sorting method." << std::endl;    
            }
            void addAbonent(Abonent a){
                abonents.push_back(a);
            }
            void addConnect(Connect c){
                /* Need verification abonents
                    if(false){
                        std::cout << "Unknow abonent" << std::endl;
                        return;
                    }
                */
                
                connects.push_back(c);
            }
            void printConnects() const{
                for(size_t i = 0; i < connects.size(); ++i){
                    connects[i].print();
                }
            }
            void printAbonents() const{
                for(size_t i = 0; i < abonents.size(); ++i){
                    std::cout << "Name : " << abonents[i].getName() << " phone : "
                                        << abonents[i].getPhone() << " tariff : " << abonents[i].getTariff() 
                                        << std::endl; 
                }
            }
            
            void save(char * fileName){
                if(fileName == 0 || fileName == '\0'){
                    std::cout << "Invalid input file name.";
                    return ;
                }
 
                std::ofstream out(fileName);
                for(size_t i = 0; i < abonents.size(); ++i){
                    out << abonents[i].getName() << ' ' << abonents[i].getPhone()
                          << abonents[i].getPhone() << ' ' << abonents[i].getTariff() << std::endl;
                }
                
                out.close();
            }
            
            void load(){
                // TO DO
            }
    };
    
}
 
int main() {
 
    cf::ATM atm;
    cf::Abonent a1(std::string("Name1"), 111111, 1.48);
    cf::Abonent a2(std::string("Name2"), 222222, 2.48);
    cf::Abonent a3(std::string("Name3"), 333333, 3.48);
    
    atm.addAbonent(a1);
    atm.addAbonent(a2);
    atm.addAbonent(a3);
    
    cf::Connect c1(a1, a2); c1.setTimeConnect(0.28);
    cf::Connect c2(a1, a3); c2.setTimeConnect(5.39);
    cf::Connect c3(a2, a3); c3.setTimeConnect(10.01);
    
    atm.addConnect(c1);
    atm.addConnect(c2);
    atm.addConnect(c3);
    
    atm.printConnects();
    
    return 0;
}