Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++"

#include <iostream>
#include <conio.h>
using namespace std;
int main ()
{
 int fynt;
 int shiling;
 int pens;
 int a;
 int b;
 int c;
 int d;
 int e;
 cout << "vvedite kollichestvo fyntov : " ;
 cin >> fynt;
 cout << "vvedite kollichestvo shilingov : ";
 cin >> shiling;
 cout << "vvedite kollichestvo pensov : ";
 cin >> pens;
 a = shiling*12 ;
 b = a + pens;
 c = b/100;
 d = b - c*100; 
 e = c + fynt;
 cout << "fyntov : " << e << endl;
 cout << "pensov : " << d << endl;
getch();
return 0;
}

#include <iostream>
#include <cmath>
using namespace std;
int main()
{
    setlocale(0, "Rus");
    int funt, shil, pens;
    float dfunt;
    cout <<"Введите количество фунтов: " ;
    cin >>funt;
    cout <<"Введите количество шиллингов: " ;
    cin >>shil;
    cout <<"Введите количество пенсов: " ;
    cin >>pens;
    dfunt=funt+((shil*12.0+pens)/240.0);
    cout <<"Десятичных фунтов: ";
    printf("%.2f\n", dfunt);
    return 0;
}

#include "stdafx.h"
#include <iostream>
using namespace std;
//////////////////////////////////////////////////////////////////////
class sterling
{
    private:
        long pounds;
        int shilling;
        int pense;
    public:
        // конструктор без параметров
        sterling() : pounds(0), shilling(0), pense(0)
        { }
        // конструктор с одним аргументом
        sterling(double decfunt)
        {
            pounds = (long) decfunt;
            shilling = (int) ((decfunt - pounds) * 20);
            pense = (int) ((((decfunt - pounds) * 20) - shilling) * 12);
        }
        // конструктор с тремя аргументами
        sterling(long f, int s, int p) : pounds(f), shilling(s), pense(p)
        { }
        // методы 
        //--------------------------------------
        // получения значений от пользователя
        void getSterling()
        {
            cout << "Введите фунты: "; cin >> pounds;
            cout << "Введите шиллингы: "; cin >> shilling;
            cout << "Введите пенсы: "; cin >> pense;
        }
        // вывод значений на экран
        void putSterling() const
        {
            cout << pounds << "." << shilling << "." << pense;
        }
        // перегруженные операции
        //--------------------------------------
        // операция сложения
        sterling operator + (sterling st2);
        // операция вычитания
        sterling operator - (sterling st2);
        // операция умножения
        sterling operator * (sterling st2);
        // операция деления на sterling
        sterling operator / (sterling st2);
        // операция деления на double
        sterling operator / (double st2);
        // операция double для преобразования к типу double
        operator double()
        {
            return (pounds * 240 + shilling * 12 + pense) / 240.0;
        }
};
//--------------------------------------------------------------------
sterling sterling :: operator + (sterling st2)
{
    return sterling(double(sterling(pounds, shilling, pense)) + double(st2));
}
//--------------------------------------------------------------------
sterling sterling :: operator - (sterling st2)
{
    return sterling(double(sterling(pounds, shilling, pense)) - double(st2));
}
//--------------------------------------------------------------------
sterling sterling :: operator * (sterling st2)
{
    return sterling(double(sterling(pounds, shilling, pense)) * double(st2));
}
//--------------------------------------------------------------------
sterling sterling :: operator / (sterling st2)
{
    return sterling(double(sterling(pounds, shilling, pense)) / double(st2));
}
//--------------------------------------------------------------------
sterling sterling :: operator / (double st2)
{
    return sterling(double(sterling(pounds, shilling, pense)) / st2);
}
//--------------------------------------------------------------------
void line()
{
    for(int i = 0; i < 22; i++)
        cout << "--";
    cout << endl;
}
//////////////////////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_ALL,"");
    
    sterling st, st1, st2;
 
    cout << "Введите первую сумму: " << endl; st1.getSterling();
    line();
    cout << "Введите вторую сумму: " << endl; st2.getSterling();
 
    double d = 1.234;
 
    cout << endl << "Операции: " << endl;
    line();
 
    st = st1 + st2; cout << "Сумма: ";
    st1.putSterling(); cout << " + "; st2.putSterling(); cout << " = "; st.putSterling(); cout << endl;
    line();
 
    st = st1 - st2; cout << "Вычисление: ";
    st1.putSterling(); cout << " - "; st2.putSterling(); cout << " = "; st.putSterling(); cout << endl;
    line();
 
    st = st1 * st2; cout << "Умножение: ";
    st1.putSterling(); cout << " * "; st2.putSterling(); cout << " = "; st.putSterling(); cout << endl;
    line();
 
    st = st1 / st2; cout << "Деление: ";
    st1.putSterling(); cout << " / "; st2.putSterling(); cout << " = "; st.putSterling(); cout << endl;
    line();
 
    st = st1 / d; cout << "Деление на double: ";
    st1.putSterling(); cout << " / "; cout << d << " = "; st.putSterling(); cout << endl;
    line();
 
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <iostream>
using namespace std;
//////////////////////////////////////////////////////////////////////////////////
class sterling
{
    private:
        long pounds;
        int shilling;
        int pense;
    public:
        // констуктор без аргументов
        sterling() : pounds(0), shilling(0), pense(0)
        { }
        // конструктор с одним аргументом
        sterling(double decfunt)
        {
            pounds = (long) decfunt;
            shilling = (int) ((decfunt - pounds) * 20);
            pense = (int) ((((decfunt - pounds) * 20) - shilling) * 12);
        }
        // конструктор с тремя аргументами
        sterling(long f, int s, int p) : pounds(f), shilling(s), pense(p)
        { }
        //доступ до поля pounds
        long getPounds() const
        {
            return pounds;
        }
        //доступ до поля shilling
        int getShilling() const
        {
            return shilling;
        }
        //доступ до поля pense
        int getPense() const
        {
            return pense;
        }
        // методы 
        //--------------------------------------
        // получения значений от пользователя
        void getSterling()
        {
            cout << "Введите фунты: "; cin >> pounds;
            cout << "Введите шиллингы: "; cin >> shilling;
            cout << "Введите пенсы: "; cin >> pense;
        }
        // вывод значений на экран
        void putSterling() const
        {
            cout << pounds << "." << shilling << "." << pense;
        }
 
};
//////////////////////////////////////////////////////////////////////
class bMoney
{
    private:
        long double money;
    public:
        //конструктор без аргументов
        bMoney() : money(0.0) 
        { }
        //конструктор с одним аргументом
        bMoney(long double m) : money(m)
        { }
        // преобразование bMoney в long double
        operator long double()
        {
            return money;
        }
        //вывод bMoney на экран
        void showMoney()
        {
            cout << money << endl;
        }
        //преобразование sterling в bMoney
        bMoney(sterling st)
        {
            long funts = st.getPounds();
            int shill = st.getShilling();
            int pens = st.getPense();
            money = ((funts * 240 + shill * 12 + pens) / 240.0) * 50; //50 - один фунт
        }
 
};
//--------------------------------------------------------------------
void line()
{
    for(int i = 0; i < 22; i++)
        cout << "--";
}
///////////////////////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_ALL,"");
    
    sterling st;
    cout << "Введите сумму (фунты, шиллингы и пенсы): " << endl;
    st.getSterling();
    bMoney bmoney(123.321);
    line();
    
    cout << endl << "\nВходящие данные: ";
    cout << "\nsterling:  "; st.putSterling();
    cout << "\nbMoney:    "; bmoney.showMoney();
    cout << endl;
    line();
 
    cout << "\nПреобразование sterling и bMoney: ";
    bMoney sterlingToBmoney = bmoney;   
    sterlingToBmoney.showMoney();
    line();
 
    cout << "\nПреобразование bMoney в sterling: ";
    sterling bMoneyToSterling = bmoney;
    bMoneyToSterling.putSterling();
    cout << endl;
    line();
    cout << endl << endl;;
 
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    string name;
    string lastName;
    string patronymic;
    unsigned long number;
 
    int n = 0;
    char ans;
 
    ofstream outfile("PERSONS.TXT");
 
    do{
    
        cout << "Введите имя: "; cin >> name;
        cout << "Введите фамилию: "; cin >> lastName;
        cout << "Введите отчество: "; cin >> patronymic;
        cout << "Введите номер: "; cin >> number;
        
        outfile << name
                << ' '
                << lastName
                << ' '
                << patronymic
                << ' '
                << number;              
 
        cout << "Продолжить (y/n)? ";
        cin >> ans;
        n++;
    }while(ans != 'n');
        
    cout << "Файл записан\n";
    outfile.close();
 
    ifstream infile("PERSONS.TXT");
    cout << "Люди: " << endl; 
 
    while(!infile.eof())
    {
        infile >> name >> lastName >> patronymic >> number;
        cout << name << ", " << lastName << ", " << patronymic << ", " << number << endl;
    }
    
    cout << endl;
 
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////
class time
{
    private:
        int hours;
        int minutes;
        int seconds;
    public:
        // конструктор без аргументов
        time() : hours(0), minutes(0), seconds(0)
        { }
        // конструктор с тремя аргументами
        time(int h, int m, int s) : hours(h), minutes(m), seconds(s)
        { }
        
        // ввод времени
        void get_time()
        {
            cout << "   Введите часы: "; cin >> hours;
        
            if(cin.good())
            {
                cin.ignore(4, '\n');
                if(hours > 23 || hours < 0)
                {
                    cout << "Значение часов должно быть между 0 и 23!" << endl;
                    cout << "   Введите часы: "; cin >> hours;
                }
            }
            
            cout << "   Введите минуты: "; cin >> minutes;
            if(cin.good())
            {
                cin.ignore(4, '\n');
                if(minutes > 59 || minutes < 0)
                {
                    cout << "Неправильно введены минуты. Желаемый диапазон от 0 до 59!" << endl;
                    cout << "   Введите минуты: "; cin >> minutes;
                }
            }
 
            cout << "   Введите секунды: "; cin >> seconds;
            if(cin.good())
            {
                cin.ignore(4, '\n');
                if(seconds > 59 || seconds < 0)
                {
                    cout << "Неправильно введены секунды. Желаемый диапазон от 0 до 59!" << endl;
                    cout << "   Введите секунды: "; cin >> seconds;
                }
            }           
        }
 
        // вывод времени
        void put_time() const
        {
            cout << "\n   Время = ";
            if(hours < 10)
                cout << "0";
            cout << hours << ":";
            if(minutes < 10)
                cout << "0";
            cout << minutes << ":";
            if(seconds < 10)
                cout << "0";
            cout << seconds << endl;
        }
};
///////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    time thetime;
    char ans;
 
    do{
        thetime.get_time();
        thetime.put_time();
        
        cout << "Продолжить (y/n)? ";
        cin >> ans;
        cout << endl;
    }while(ans != 'n');
 
    system("pause");
    return 0;
}

// 05.cpp
// ввод даты и её вывод с использованием структур
 
# include <iostream>
 
using namespace std;
///////////////////////////////////////////////
struct date
{
    int day;
    int month;
    int year;
};
///////////////////////////////////////////////
int main()
{
    date userdate; // дата, введённая пользователем
 
    do             // пока пользователь не введёт корректный год
    {
        do         // пока пользователь не введёт корректный месяц
        {
            do     // пока пользователь не введёт корректный день месяца
            {
                cout << "Введите день месяца: ";
                cin >> userdate.day;
                if (userdate.day > 31)
                {
                    cout << "Ошибка! Дней в месяце не может быть больше 31." << endl;
                }
                if (userdate.day < 1)
                {
                    cout << "Ошибка! День не может быть нулём и ";
                    cout << "быть отрицательным числом." << endl;
                }
            }
            while (userdate.day < 1 || userdate.day > 31);
            cout << "Введите номер месяца: ";
            cin >> userdate.month;
            if (userdate.month > 12)
            {
                cout << "Ошибка! В году не может больше 12 месяцев." << endl;
            }
            if (userdate.month < 1)
            {
                cout << "Ошибка! Месяц не может быть нулём или ";
                cout << "отрицательным числом." << endl;
            }
            if ((userdate.month == 4 && userdate.day == 31) ||
                (userdate.month == 6 && userdate.day == 31) ||
                (userdate.month == 9 && userdate.day == 31) ||
                (userdate.month == 11 && userdate.day == 31))
            {
                cout << "Ошибка! В выбранном вами месяце не может быть";
                cout << " 31 день" << endl;
            }
            if (userdate.month == 2 && userdate.day > 29)
            {
                cout << "Ошибка! В феврале не может быть больше 29 дней" << endl;
            }
        }
        while (userdate.month < 1 || userdate.month > 12 ||
              (userdate.month == 4 && userdate.day == 31) ||
              (userdate.month == 6 && userdate.day == 31) ||
              (userdate.month == 9 && userdate.day == 31) ||
              (userdate.month == 11 && userdate.day == 31) ||
              (userdate.month == 2 && userdate.day > 29));
        cout << "Введите год: ";
        cin >> userdate.year;
        if (userdate.year < 0)
        {
            cout << "Ошибка! Год не может быть меньше нуля: слишком давно";
            cout << " это было=)" << endl;
        }
        if (((userdate.year % 4 != 0 && userdate.year % 100 != 0) ||
            (userdate.year % 400 != 0)) && userdate.month == 2 &&
            userdate.day == 29)
        {
            cout << "Ошибка! Вы ввели не високосный год, а у вас ";
            cout << "выбран февраль и 29-е число" << endl;
        }
    }
    while (userdate.year < 0 || (((userdate.year % 4 != 0 &&
           userdate.year % 400 != 0) || userdate.year % 400 != 0) &&
           userdate.month == 2 && userdate.day == 29));
 
    cout << "Ваша дата: " << userdate.day << "." << userdate.month << "."
    << userdate.year << endl;
    return 0;
}

#include "stdafx.h"
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////
template <class type>
void swaps(type& a, type& b)
{
    type temp = a;
    a = b;
    b = temp;
}
///////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    int Int1 = 1, Int2 = 2;
    float Float1 = 1.0F, Float2 = 2.0F;
    char Char1 = 1, Char2 = 2;
 
    cout << "int: " << Int1 << " <> " << Int2 << " --> ";
    swaps(Int1, Int2); cout << Int1 << ", " << Int2
         << endl << "float: " << Float1 << " <> " << Float2 << " --> ";
    swaps(Float1, Float2); cout << Float1 << ", " << Float2
         << endl << "char: " << (int)Char1 << " <> " << (int)Char2 << " --> ";
    swaps(Char1, Char2); cout << (int)Char1 << ", " << (int)Char2 << endl << endl;
 
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <iostream>
using namespace std;
const int MAX = 5;
///////////////////////////////////////////////////////
template <class type>
type amax(type mas[], int size)
{
    type max = mas[0];
    for(int i = 0; i < size; i++)
        if(max < mas[i])
            max = mas[i];
    return max;
}
///////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    int intMas[MAX] = {5, 15, 10, 27, 9};
    float floatMas[MAX] = {7.0, 2.0, 30.0, 330.0, 24.0};
    char charMas[MAX] = {1, 3, 2, 5, -1};
 
    cout << "Максимальный элемент intMas = " << amax(intMas, MAX) << endl
         << "Максимальный элемент floatMas = " << amax(floatMas, MAX) << endl
         << "Максимальный элемент charMas = " << (int)amax(charMas, MAX) << endl
         << endl;
 
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <iostream>
using namespace std;
const int LIMIT = 100;    // размер массива
///////////////////////////////////////////////////////
template <class type>
class safearray
{
    private:
        type arr[LIMIT];
    public:
        type& operator[](int n)
        {
            if(n < 0 || n >= LIMIT)
            {
                cout << "\nОшибочный индекс!"; exit(1);
            }
            return arr[n];
        }
};
///////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    safearray<int> sa1;
    // задаем значения элементов
    for(int j = 0; j < LIMIT; j++)
        sa1[j] = j * 10;    
    // показываем элементы
    for(int j = 0; j < LIMIT; j++)
    {
        int temp = sa1[j];  
        cout << "Элемент " << j << " равен " << temp << endl;
    }
 
    safearray<float> sa2;
    // задаем значения элементов
    for(int j = 0; j < LIMIT; j++)
        sa2[j] = j * 0.2;    
    // показываем элементы
    for(int j = 0; j < LIMIT; j++)
    {
        float temp = sa2[j];  
        cout << "Элемент " << j << " равен " << temp << endl;
    }
 
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <iostream>
#include <process.h> // for exit();
using namespace std;
////////////////////////////////////////////////////////////////////
template <class type>
class fraction
{
  private:
      type chis;
      type znam;    
  public:
      // конструктор без аргументов
      fraction() : chis(0), znam(0)
      { }
      // конструктор с двумя аргументами
      fraction(type c, type z) : chis(c), znam(z) 
      { }
      // получения значений от пользователя
      void get()
      {
          cin >> chis >> znam;
          if((chis == 0) || (znam == 0))
              exit(1);
      }
      // вывод значений на экран
      void show(char tp)
      {
          if(tp = 'c')
              cout << int(chis) << " / " << int(znam) << endl;
          else
              cout << chis << " / " << znam << endl;
      }
      //-------------------------------------------------------------
      // метод выбора операции
      //-------------------------------------------------------------
      fraction operation(fraction dr1, fraction dr2, char op, char tp)
      {
          fraction dr;
          switch(op)
          {
            case '+' : 
            {
                dr = dr1 + dr2;
                cout << "\nСумма дробей: "; 
                dr.show(tp);
            }break;
            case '-' :
            {
                dr = dr1 - dr2;
                cout << "\nРазность дробей: ";
                dr.show(tp);
            }break;
            case '*' : 
            {
                dr = dr1 * dr2;
                cout << "\nПроизведение дробей: ";
                dr.show(tp);
            }break;
            case '/' : 
            {
                if(tp = 'c')
                    cout << "Деление больших чисел невозможно!" << endl;
                else
                {
                    dr = dr1 / dr2;
                    cout << "\nДеление дробей: ";
                    dr.show(tp);
                }
            }break;
            default : cout << 0; break;
          }
          return dr;
      }
      //-------------------------------------------------------------
      // перегружання операция сложения
      //-------------------------------------------------------------
      fraction operator + (fraction dr2)
      {
          type ch = chis * dr2.znam + znam * dr2.chis;
          type zn = znam * dr2.znam;
          lowterms(ch, zn);
          return fraction(ch, zn);
      }
      //-------------------------------------------------------------
      // перегружання операция вычитания
      //-------------------------------------------------------------
      fraction operator - (fraction dr2)
      {
          type ch = chis * dr2.znam - znam * dr2.chis;
          type zn = znam * dr2.znam;
          lowterms(ch, zn);
          return fraction(ch, zn);
      }
      //-------------------------------------------------------------
      // перегружання операция умножения
      //-------------------------------------------------------------
      fraction operator * (fraction dr2)
      {
          type ch = chis * dr2.chis;
          type zn = znam * dr2.znam;
          lowterms(ch, zn);
          return fraction(ch, zn);
      }
      //-------------------------------------------------------------
      // перегружання операция деления
      //-------------------------------------------------------------
      fraction operator / (fraction dr2)
      {
          type ch = chis * dr2.znam;
          type zn = znam * dr2.chis;
          lowterms(ch, zn);
          return fraction(ch, zn);
      }
      //-------------------------------------------------------------
      // сокращение дробей
      //-------------------------------------------------------------
      void lowterms(type& chis, type& znam)
      {
          type tnum, tden, temp, gcd;
          tnum = labs(chis);
          tden = labs(znam);
 
          while(tnum != 0)
          {
              if(tnum < tden)
              {
                  temp = tnum;
                  tnum = tden;
                  tden = temp;
              }
              tnum -= tden;
          }
 
          gcd = tden;
          chis /= gcd;
          znam /= gcd;
      }
};
//////////////////////////////////////////////////////////////////////
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    char type, oper, ans;   
 
    do{
        cout << "Выберите тип данных: \n's' - short \n'i' - int \n'l' - long \n'c' - char" << endl;
        cin >> type;
        switch(type)
        {
            case 's' :
            {
                fraction<short> dr, dr1, dr2;
                cout << "   Введите первую дробь, операцию и вторую дробь: ";
                dr1.get();
                cin >> oper;
                dr2.get();
                dr.operation(dr1, dr2, oper, type);
            }break;
            case 'i' :
            {
                fraction<int> dr, dr1, dr2;
                cout << "   Введите первую дробь, операцию и вторую дробь: ";
                dr1.get();
                cin >> oper;
                dr2.get();
                dr.operation(dr1, dr2, oper, type);
            }break;
            case 'l' :
            {
                fraction<long> dr, dr1, dr2;
                cout << "   Введите первую дробь, операцию и вторую дробь: ";
                dr1.get();
                cin >> oper;
                dr2.get();
                dr.operation(dr1, dr2, oper, type);
            }break;
            case 'c' :
            {
                fraction<char> dr, dr1, dr2;
                cout << "   Введите первую дробь, операцию и вторую дробь: ";
                dr1.get();
                cin >> oper;
                dr2.get();
                dr.operation(dr1, dr2, oper, type);
            }break;
            default : cout << "   Нету такой команды!" << endl;
        }
 
        cout << "\nЖелаете продолжить (y/n)? ";
        cin >> ans;
    }while(ans != 'n');   
 
    system("pause");
    return 0;
}