Класс данных, класс сортировок

#include <stdexcept>
#include <iostream>
#include <fstream>
#include <Windows.h>
#include <iomanip.h>
 
using namespace std;
 
char   NEWT[256];
char*  RUS(char*TEXT){
    CharToOem(TEXT,NEWT);
    return NEWT;
}
 
static const char * const FILE_NAME = "irons.txt";                              //Глобальная статическая переменная
 
class Iron{
     public:
          typedef bool (*predicate_t) (const Iron &, const Iron &);
          Iron ():
          m_price (0),
          m_modes_count (0),
          m_power (0)
      
          { m_producer[0] = '\0'; }
 
          Iron (const char *producer, unsigned power, unsigned modes_count, unsigned price): 
          m_price (price),
          m_modes_count (modes_count),
          m_power (power)
 
          { strcpy (m_producer, producer); }
 
          const char  *producer()    const {return    m_producer;}
          unsigned    power ()       const {return    m_power;}
          unsigned    modes_count () const {return    m_modes_count;}
          unsigned    price ()       const {return    m_price;}
             
          static bool    by_price (const Iron &lhs, const Iron &rhs){           //Локадьная статическая переменная
               return  lhs.price () < rhs.price ();}
                    
          static bool    by_power (const Iron &lhs, const Iron &rhs){           //Локадьная статическая переменная
               return  lhs.power () < rhs.power ();}
                    
          static bool    by_modes_count (const Iron &lhs, const Iron &rhs){     //Локадьная статическая переменная
               return  lhs.modes_count () < rhs.modes_count ();}
                    
          static bool    by_producer (const Iron &lhs, const Iron &rhs){        //Локадьная статическая переменная
               return  strcmp (lhs.producer (), rhs.producer ()) > 0;}
 
          friend std::istream &operator>> (std::istream &, Iron &);
 
     private:
          unsigned m_price;
          unsigned m_modes_count;
          unsigned m_power;
          char     m_producer[20];
};
 
std::istream &operator>> (std::istream &in, Iron &iron);                        //Ввод данных в программу
std::ostream &operator<< (std::ostream &out, const Iron &iron);                 //Вывод данных из программы
 
typedef void (*algorithm_t)(Iron *, int, Iron::predicate_t);
typedef std::pair<algorithm_t, Iron::predicate_t> sort_kind_t;
 
Iron       *read_irons (std::istream &, int);
void        print_irons(const Iron *, int);
int         read_natural (const char *);
sort_kind_t read_sort_kind ();
 
void insertion_sort (Iron *, int, Iron::predicate_t = Iron::by_price);
void selection_sort (Iron *, int, Iron::predicate_t = Iron::by_price);
void bubble_sort    (Iron *, int, Iron::predicate_t = Iron::by_price);
 
int main (){
     ifstream in ("irons.txt");  
     int count = 0;
     if (not in.good ()){                                                       //Проверка на существование файла
          cerr<<RUS("Невозможно окрыть '")<<FILE_NAME<<RUS("': ")<<strerror(errno)<< endl;
          exit (EXIT_FAILURE);
     }
     (in >> count).ignore();
     Iron  *irons = read_irons (in, count);
 
     print_irons (irons, count);                                                //Вывод данных из файла
     cout << RUS(" == Сортированние утюгов == \n") << endl;
 
     sort_kind_t sort = read_sort_kind();                                       //Сортировка
     sort.first(irons, count, sort.second);
 
     print_irons (irons, count);                                                //Вывод отсортированных данных
     getchar();
}
 
std::istream &operator>> (std::istream &in, Iron &iron){
     in.getline (iron.m_producer, 20);
     in >> iron.m_power;
     in >> iron.m_modes_count;
     in >> iron.m_price;
 
     in.ignore ();
 
     return in;
}
 
Iron *read_irons (std::istream &in, int count){                                 //Ф-ия считывания данных из файла
     Iron *irons = new Iron[count];
     cout << RUS(" -> Считывание ") << count << RUS(" данных из файла") << endl;
     for (int i = 0; i < count; i++){                                           //Проверка на наличие данных
          if (not in.good())
               throw std::runtime_error(RUS("Файл не содержит записей"));
          in >> irons[i];
     }
     return irons;
}
 
std::ostream &operator<< (std::ostream &out, const Iron &iron){
     out << RUS("Страна производитель: ") << iron.producer ()     << endl;
     out << RUS("Мощность            : ") << iron.power ()        << endl;
     out << RUS("Режимы              : ") << iron.modes_count ()  << endl;
     out << RUS("Цена                : ") << iron.price ()        << endl;
     return out;
}
 
void print_irons (const Iron *irons, int count){                                //Ф-ия вывода данных из файла
     cout << RUS(" -> Заданные утюги") << endl;
     for (int i = 0; i < count; i++)
          cout << irons[i] << endl;
}
 
void bubble_sort (Iron *irons, int count, Iron::predicate_t p){                 //Ф-ия пузырьковой сортировки
     for (int i = 0; i < count - 1; i++)
          for (int j = i + 1; j < count; j++)
               if (p (irons[i], irons[j]))
                    std::swap(irons[i], irons[j]);
}
 
void insertion_sort (Iron *irons, int count, Iron::predicate_t p){              //Ф-ия сортировки методом исключений
     Iron key;
     for (int i = 0, j = 0; i < count; i++){
          key = irons[i];
          for (j = i - 1; j >= 0 && p(key, irons[j]); j--)
               irons[j + 1] = irons[j];
          irons[j + 1] = key;
     }
}
 
void selection_sort (Iron *irons, int count, Iron::predicate_t p){              //Ф-ия сортировки методом выборок
     for (int i = 0; i < count - 1; i++){
          int min = i;
          for (int j = i + 1; j < count; j++)
               if (p(irons[j], irons[min]))
                    min = j;
          if (min != i)
               std::swap(irons[i], irons[min]);
     }
}
 
int read_limited (const char *prompt, int lo, int hi){
     cout << prompt << ": " << flush;
     int value;
     while (true){
          cin >> value;
          if (lo <= value && value <= hi)
               break;
          cout << RUS(" ОШИБКА: пожалуйста, введите чило из интервала [") 
               << lo << RUS("..") << hi << RUS("]: ");
     }
     cin.ignore ();
     return value;
}
 
sort_kind_t read_sort_kind (){                                                  //Сортируем
     static const algorithm_t algorithms[] = {                                  //Алгоритм с тремя видами сортировки
          bubble_sort, insertion_sort, selection_sort};
          
     static const Iron::predicate_t fields_predicates[] = {                     //Алгоритм с полями по которым будем сортироваать
         Iron::by_price, Iron::by_power,
         Iron::by_modes_count, Iron::by_producer};
         
     cout << RUS("Выберите алгоритм сортировки: \n");
     cout << RUS(" 1. Метод пызырьков\n");
     cout << RUS(" 2. Метод выборок\n");
     cout << RUS(" 3. Метод исключений\n");
     cout << RUS(" -> ");
     int sort_algorithm = read_limited(RUS("Ваш выбор "), 1, 3) - 1;                
     
     cout << RUS("Выберите поле по которому сортировать\n");
     cout << RUS(" 1. Цена\n");
     cout << RUS(" 2. Мощность\n");
     cout << RUS(" 3. Режимы\n");
     cout << RUS(" 4. Страна производитель\n");
     cout << RUS(" -> ");
     int sort_field = read_limited(RUS("Ваш выбор"), 1, 4) - 1;
     return make_pair(algorithms[sort_algorithm], fields_predicates[sort_field]);
}

#include <iomanip> //  .h