Перегрузка операторов C++, часть четвёртая - преобразования типов

float a, b;
int c = 4;
a = 1.25F;
b = a * c

b = a * static_cast<float>(c);

// mconv.cpp

#include <iostream>

class Distance
{
private:
  const float MTF;
  int feet;
  float inches;
public:
  // Конструктор без аргументов определяет состояние вновь созданных
  // объявлением без инициализации объектов и их свойств
  Distance() : MTF(3.280833F), feet(0), inches(0.0F) {}
  // Конструктор с одним аргументом определяет
  // явное и неявное преобразование переменной базового типа float
  // в экземпляр класса Distance
  Distance(float meters) : MTF(3.280833F)
  {
    float fltfeet = MTF * meters;
    feet = static_cast<int>(fltfeet);
    inches = 12.0F * (fltfeet - static_cast<float>(feet));
  }
  // Конструктор с двумя аргументами определяет состояние
  // вновь созданных объектов объявлением с инициализацией
  Distance(int f, float i) : MTF(3.280833F), feet(f), inches(i) {}
  // Функция getdist() даёт возможность инициировать
  // созданный объект с запросом данных у пользователя программы,
  // в данной реализации программы использоваться не будет
  void getdist()
  {
    std::cout << "Enter feet: ";
    std::cin >> feet;
    std::cout << "Enter inches: ";
    std::cin >> inches;
  }
  // Функция showdist() выведет на экран значение объекта в
  // заданной форме
  void showdist() const { std::cout << feet << "\'-" << inches << "\"\n"; }
  // Функция operator float() определяет преобразование экземпляра
  // класса Distance в переменную базового типа float 
  operator float() const
  {
    float fracfeet = inches / 12.0F;
    fracfeet += static_cast<float>(feet);
    return fracfeet / MTF;
  }
};

int main()
{
  float mtrs;
  // Тестируем конструктор класса Distance
  // с одним аргументом, создаём экземпляр dist1
  // и преобразуем при его создании
  // метры (2.35) в футы и дюймы - неявное преобразование
  Distance dist1 = 2.35F;
  // Выводим на экран значение dist1 в заданной форме
  // в футах и дюймах
  std::cout << "dist1 = ";
  dist1.showdist();
  // Преобразуем значения переменной dist1
  // в переменную базового типа float с помощью соответствующей
  // функции operator float() - явное преобразование
  mtrs = static_cast<float>(dist1);
  // Выводим на экран значение переменной dist1
  // в метрах, ожидаем увидеть 2.35 метра
  std::cout << "dist1 = " << mtrs << " meters\n";
  // Тестируем конструктор класса Distance с двумя аргументами,
  // создаём экземпляр класса Distance
  Distance dist2(7, 8.51949F);
  // Преобразуем значения этого экземпляра в
  // переменную базового типа float - неявное преобразование
  // опять работает функция operator float()
  mtrs = dist2;
  // Выводим на экран значение переменной dist1
  // в метрах, ожидаем 2.35 метра
  std::cout << "dist2 = " << mtrs << " meters\n";
}

g++ -o exe -Wall mconv.cpp
./exe

// sconv.cpp

#include <iostream>
#include <cstring>

class String
{
private:
  static const int SZ = 80;
  char str[SZ];
public:
  // Конструктор без аргументов определяет состояние
  // объявленных без инициализации экземпляров этого класса
  String() { str[0] = '\n'; }
  // Первый конструктор с одним аргументом принимает
  // строковый массив и копирует его в соответствующее
  // свойство экземпляра - преобразование строкового массива в объект
  String(char s[]) { strcpy(str, s); }
  // Второй конструктор с одним аргументом принимает
  // строковую константу и копирует её в соответствующее
  // свойство экземпляра - преобразование строковой константы в объект
  String(const char * s) { strcpy(str, s); }
  // Функция display() выводит на терминал
  // значение экземпляра в заданной форме
  void display() const { std::cout << str; }
  // Функция operator char*() определяет
  // механизм преобразование экземпляра в строку
  operator char*() { return str; }
};

int main()
{
  // Объявляем экземпляр класса
  String s1;
  // Объявляем и инициализируем строковый массив
  char xstr[] = "Lorem Ipsum Dolor! ";
  // Копируем данные строкового массива в экземпляр
  // класса String - работает первый конструктор с одним аргументом
  s1 = xstr;
  // Выводим значение экземпляра s1 на экран терминала
  s1.display();
  // Объявляем второй экземпляр класса String
  // и инициализируем его с помощью строковой константы
  // работает второй конструктор с одним аргументом
  String s2 = "Proin Consectetur Mauris.";
  // Преобразуем экземпляр s2 в строку
  // и выводим её на экран терминала - работает функция operator char*()
  std::cout << static_cast<char*>(s2) << std::endl;
  return 0;
}

// tconv1.cpp

#include <iostream>
#include <string>

class time12
{
private:
  bool pm;
  int hrs;
  int mins;
public:
  time12() : pm(true), hrs(0), mins(0) {}
  time12(bool ap, int h, int m) : pm(ap), hrs(h), mins(m) {}
  void display() const;
};

void time12::display() const
{
  std::cout << hrs << ":";
  if (mins < 10) std::cout << '0';
  std::cout << mins << ' ';
  std::string am_pm = pm ? "p.m." : "a.m.";
  std::cout << am_pm << std::endl;
}

class time24
{
private:
  int hours;
  int minutes;
  int seconds;
public:
  time24() : hours(0), minutes(0), seconds(0) {}
  time24(int h, int m, int s) : hours(h), minutes(m), seconds(s) {}
  void display() const;
  // Функция operator time12() определяет механизм преобразования
  // экземпляра time24 в экземпляр time12
  operator time12() const;
};

void time24::display() const
{
  if (hours < 10) std::cout << '0';
  std::cout << hours << ':';
  if (minutes < 10) std::cout << '0';
  std::cout << minutes << ':';
  if (seconds < 10) std::cout << '0';
  std::cout << seconds << std::endl;
}

time24::operator time12() const
{
  int hrs24 = hours;
  bool pm = hours < 12 ? false : true;
  int roundMins = seconds < 30 ? minutes : minutes + 1;
  if (roundMins == 60)
  {
    roundMins = 0;
    ++hrs24;
    if (hrs24 == 12 || hrs24 == 24)
      pm = (pm == true) ? false : true;
  }
  int hrs12 = (hrs24 < 13) ? hrs24 : hrs24 - 12;
  if (hrs12 == 0)
  {
    hrs12 = 12;
    pm = false;
  }
  return time12(pm, hrs12, roundMins);
}

int main()
{
  // Объявляем переменные h, m, s
  int h, m, s;
  while (true)
  {
    // Запрашиваем у пользователя ввод показаний часов, минут и секунд
    std::cout << "Enter 24-hour time:\n";
    std::cout << "   Hours (0 to 23): ";
    std::cin >> h;
    // Если пользователь ввёл показания часов больше 23
    if (h > 23)
      // Прерываем исполнение программы
      return 1;
    std::cout << "   Minutes:         ";
    std::cin >> m;
    std::cout << "   Seconds:         ";
    std::cin >> s;
    // С помощью полученных от пользователя данных
    // создаём экземпляр класса time24
    time24 t24(h, m, s);
    // Для контроля выводим значения полученного экземпляра
    // на терминал в заданной форме
    std::cout << "You entered: ";
    t24.display();
    // Создаём экземпляр класса time12 и преобразуем в него
    // исходный объект time24 - работает функция operator time12()
    // определённая в исходном объекте (time24)
    time12 t12 = t24;
    // Выводим на экран терминала полученный объект
    // в заданной форме
    std::cout << "12-hour time: ";
    t12.display();
    std::cout << std::endl;
  }
  return 0;
}

g++ -o exe -Wall tconv1.cpp
./exe

// tconv2.cpp

#include <iostream>
#include <string>

class time24
{
private:
  int hours;
  int minutes;
  int seconds;
public:
  time24() : hours(0), minutes(0), seconds(0) {}
  time24(int h, int m, int s) : hours(h), minutes(m), seconds(s) {}
  void display() const;
  // Три дополнительные функции, которые будут использованы
  // для реализации механизма преобразования объектов
  int getHrs() const { return hours; }
  int getMins() const { return minutes; }
  int getSec() const { return seconds; }
};

class time12
{
private:
  bool pm;
  int hrs;
  int mins;
public:
  time12() : pm(true), hrs(0), mins(0) {}
  time12(bool ap, int h, int m) : pm(ap), hrs(h), mins(m) {}
  // Дополнительный конструктор в котором будет реализован механизм
  // преобразования объектов
  time12(time24 t);
  void display() const;
};

time12::time12(time24 t)
{
  int hrs24 = t.getHrs();
  pm = t.getHrs() < 12 ? false : true;
  mins = (t.getSec() < 30) ? t.getMins() : t.getMins() + 1;
  if (mins == 60)
  {
    mins = 0;
    ++hrs24;
    if (hrs24 == 12 || hrs24 == 24)
      pm = (pm == true) ? false : true;
  }
  hrs = (hrs24 < 13) ? hrs24 : hrs24 - 12;
  if (hrs == 0)
  {
    hrs = 12;
    pm = false;
  }
}

g++ -o exe -Wall tconv2.cpp
./exe

// explicit.cpp

#include <iostream>

void fancyDist(Distance d);

class Distance
{
private:
  const float MTF;
  int feet;
  float inches;
public:
  Distance() : MTF(3.280833F), feet(0), inches(0) {}
  // Конструктор с одним аргументом, с помощью которого
  // осуществляется преобразование float в экземпляр
  Distance(float meters) : MTF(3.280833F)
  {
    float fltfeet = MTF * meters;
    feet = static_cast<int>(fltfeet);
    inches = 12.0F * (fltfeet - static_cast<float>(feet));
  }
  void showdist() { std::cout << feet << "\'-" << inches << "\"\n"; }
};

int main()
{
  // Создаём экземпляр и инициализируем его с помощью
  // конструктора с одним аргументом
  Distance dist1(2.35F);
  dist1.showdist();
  // Создаём объект путём неявного преобразования типов
  // этот вариант использования необходимо предотвратить
  Distance dist2 = 2.35F;
  std::cout << "dist2 = ";
  dist2.showdist();
  // Создаём переменную типа float
  float mtrs = 2.35F;
  std::cout << "dist3 ";
  // Неявное преобразование float в экземпляр класса Distance
  // этот вариант использования тоже необходимо предотвратить
  fancyDist(mtrs);
  return 0;
}

void fancyDist(Distance d)
{
  std::cout << "(in feet and inches) = ";
  d.showdist();
}