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

#include <iostream> 
 
using namespace std;
 
int main()
{
   setlocale(0,"Rus");
   float gallons, cufeet;
 
   cout << "Введите количество галоннов: \n";
   cin >> gallons;
   cufeet = gallons / 7.481;
   cout << "Еквивалент в футах = " << cufeet << endl;
    
   return 0;
}

#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main()
{
   setlocale(0,"Rus");
   
    cout << 1990 << setw(8) << 135 << endl
           << 1991 << setw(8) << 7290 << endl 
           << 1992 << setw(8) << 11300 << endl
           << 1993 << setw(8) << 16200 << endl;
  
   return 0;
}

#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    int var = 10;
 
    cout << var << endl;      
    var *= 2;                 
    cout << var-- << endl;    
    cout << var << endl;      
    return 0;
}

#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    cout<<"\nУ лукоморья дуб срубили\nКота на мясо порубили \nА по неведанным дорожкам\nШагали черти в босоножках\n"; 
    return 0;
}

#include <iostream> 
#include <ctype.h>
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    char ch;
    cin >> ch;
    cout << islower(ch);  // При вводе строчной буквы будет 2 при прописной 0. Но есть нюанс, поддерживаються только англ буквы 
    return 0;
}

#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
 
    float a,b,c,d,f;
    cout << "Введите кол-во доларов"<<endl;
    cin >> f;
    b=f/1.487;
    c=f/0.172;
    a=f/0.584;
    d=f/0.00955;
    cout << f <<"доларов = "<< b<<" фунтов стерлинга"<<endl;
    cout << f <<"доларов = "<< c<<" франков"<<endl;
    cout << f <<"доларов = "<< a<<" немецких марок"<<endl;
    cout << f <<"доларов = "<< d<<" японских йен"<<endl;
    return 0;
}

#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    double f,c;
    cout << "Введите количество градусов по Цельсию"<<endl;
    cin >> c;
    f=c*1.8+32;
    cout <<setprecision(3)<< f << " градусов по Фаренгейту "<< endl; // Регуляция кол-во символов после запятой
    return 0;
}

#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    long pop1=2425785, pop2=47, pop3=9761;       
 
    cout << setfill('.') <<setw(8) << "LOCATION" << setw(12) // Обратите внимание на одинарные кавычки
           << "POPULATION" << endl
           <<setw(8) << "Portcity" << setw(12) << pop1 << endl
           << setw(8) << "Hightown" << setw(12) << pop2 << endl
           << setw(8) << "Lowville" << setw(12) << pop3 << endl;
    return 0;
}

#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    char dummychar;
    double a,b,c,d,e,f;
    cout << "Введите а и b"<< endl;
    cin >>a>>dummychar>>b;
    cout << "Введите c и d"<<endl;
    cin >>c>>dummychar>>d;
    cout <<(b*c)+(d*a)<<dummychar<<(b*d)<<endl;
 
    return 0;
}

#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    float a,b,c,f;
    cout << "Введите количество фунтов"<<endl;
    cin >> a;
    cout << "Введите количество шиллингов"<<endl;
    cin >> b;
    cout << "Введите количество пенсов"<<endl;
    cin >> c;
    f = a+(b+c/12)/20;
    cout << "Количество фунтов = " << f << endl;
    return 0;
}

#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main() 
{
     setlocale(0,"Rus");
     cout << setiosflags(ios::left) <<setw(15) << "Фамилия"<< setw(15)<< "Имя"<<setw(15) << "Адресс"<<setw(15)<< "Город"<<endl
            <<setw(15)<< "Иванов"<<setw(15)<<"Петя"<<setw(15)<<"Кленовая 16"<<setw(10)<<"Москва"<<endl
            <<setw(15)<< "Иванов"<<setw(15)<<"Петя"<<setw(15)<<"Кленовая 16"<<setw(10)<<"Москва"<<endl
            <<setw(15)<< "Иванов"<<setw(15)<<"Петя"<<setw(15)<<"Кленовая 16"<<setw(10)<<"Москва"<<endl;
    return 0;
}

#include <iostream> 
 
using namespace std;
 
int main() 
{
setlocale(0,"Rus");
float a,b,z;
int c,k;
cout << "Введите кол-во футов " << endl;
cin >> a;
c = static_cast<int>(a);
b = a - c;
b *= 20;
k = static_cast<int>(b);
z = b - k;
z = z*12;
z = static_cast<int>(z);
k = static_cast<int>(k);
cout << c <<"."<< k <<"."<< z << endl;
return 0;
}

#include <iostream>
using namespace std;
int main()
{
    cout << '\xDB' << '1' << '\xDB' << endl;
    return 0;
}

#pragma once
// elev.h
// header file for elevators -- contains class declarations
 
#include "elev_app.h"                //provided by client
#include "msoftcon.h"                //for console graphics
#include <iostream>
#include <iomanip>                   //for setw()
#include <conio.h>                   //for screen output
#include <stdlib.h>                  //for itoa()
#include <process.h>                 //for exit()
using namespace std;
 
const int LOAD_TIME = 3;   //loading/unloading time (ticks)
const int BUF_LENGTH = 80;   //length of utility string buffer
 
 
class elevator
{
private:
    int current_floor;             //where are we? (0 to nf-1)
    int old_floor;                 //where were we? (0 to nf-1)
    int dest_floor;                 //selected by occupant
    int action;                     //0-stop, 1-query floor, 2-open door, 3-dest_floor
    int loading_timer;             //non-zero if loading
    int unloading_timer;           //non-zero if unloading
 
public:
    elevator();             //constructor
    void record_floor_reqs();   //requers from floors
    void show_floor_reqs() const; //from whic floor request comes
    void master_tick();     //elevator actions
    void car_display();     //display cars
    void set_destination(); //set destinations
    void car_tick1();       //tick1 action
    void car_tick2();       //tick2 action
    void move();            //move car
    void dests_display() const; //shows destination floors
};
////////////////////////////////////////////////////////////////

#pragma warning(disable:4996)
// elev.cpp
// contains class data and member function definitions
 
#include "elev.h"     //include class declarations
/////////////////////////////////////////////////////////////////
//           function definitions for class elevator
/////////////////////////////////////////////////////////////////
//constructor
elevator::elevator()
{
    current_floor = 1;                //start at 0 (user's 1)
    old_floor = 20;                    //remember previous floor
    dest_floor = 1;                     //any buttons yet
    loading_timer = 0;                //not loading yet
    unloading_timer = 0;              //not unloading yet
    action = 0;                         //any action yet
    char ustring[BUF_LENGTH];         //string for floor numbers
 
    init_graphics();                  //initialize graphics
    clear_screen();                   //clear screen
    for (int j = 1; j<=NUM_FLOORS; j++)   //for each floor
    {
        set_cursor_pos(3, NUM_FLOORS - j+1);  //put floor number
        itoa(j, ustring, 10);           //on screen
        cout << setw(3) << ustring;
    }
}  //end constructor
   //--------------------------------------------------------------
void elevator::record_floor_reqs()
{
    char ustring[BUF_LENGTH];  //utility string for input
 
    if (action == 0 && unloading_timer == 0)
    {
        set_cursor_pos(1, 22);      //bottom of screen
        cout << "Enter the floor you're on: ";
        cin.get(ustring, BUF_LENGTH);        //get floor
        cin.ignore(10, '\n');      //eat chars, including newline
        dest_floor = atoi(ustring);    //convert to integer
 
 
        action = 1;                             //to the request
        set_cursor_pos(1, 22); clear_line();     //clear old text
        set_cursor_pos(1, 23); clear_line();
        set_cursor_pos(1, 24); clear_line();
    }
}  //end record_floor_reqs()
   //--------------------------------------------------------------
void elevator::master_tick()         //master time tick
{
    show_floor_reqs();                //display floor requests
    car_tick1();      //send it time tick 1
    car_tick2();      //send it time tick 2
}  //end master_tick()
   //--------------------------------------------------------------
void elevator::show_floor_reqs() const  //display floor requests
{
    set_cursor_pos(3, NUM_FLOORS - dest_floor + 1);
    if (action == 1)
        cout << '!';
    else
        cout << ' ';
}  //end show_floor_reqs()
   //--------------------------------------------------------------
void elevator::car_tick1()           //tick 1 for each car
{
    car_display();                    //display elevator box
    dests_display();                  //display destinations
    if (loading_timer)                 //count down load time
        --loading_timer;
    if (unloading_timer)                //count down unload time
        --unloading_timer;
}  //end car_tick()
   //--------------------------------------------------------------
void elevator::car_display()         //display elevator image
{
    set_cursor_pos(7 , NUM_FLOORS - old_floor+1);
    cout << "   ";                    //erase old position
    set_cursor_pos(6  ,
        NUM_FLOORS - current_floor+1);
    switch (loading_timer)
    {
    case 3:
        cout << "\x01\xDB \xDB ";   //draw car with open door
        break;                      //happy face on left
    case 2:
        cout << " \xDB\x01\xDB ";   //happy face in open door
        set_destination();         //get destinations
        break;
    case 1:
        cout << " \xDB\xDB\xDB ";   //draw with closed door
        break;                      //no happy face
    case 0:
        cout << " \xDB\xDB\xDB ";   //closed door, no
        break;                      //happy face (default)
    }
    set_cursor_pos(6+1 ,
        NUM_FLOORS - current_floor+1);
    switch (unloading_timer)
    {
    case 3:
        cout << "\xDB\x01\xDB ";    //draw car with open door
        break;                      //happy face in car
    case 2:
        cout << "\xDB \xDB\x01";    //draw car with open door
        break;                      //happy face on right
    case 1:
        cout << "\xDB\xDB\xDB ";    //draw with closed door
        break;                      //no happy face
    case 0:
        cout << "\xDB\xDB\xDB ";    //closed door, no
        break;                      //happy face (default)
    }
    old_floor = current_floor;        //remember old floor
}  //end car_display()
   //--------------------------------------------------------------
void elevator::dests_display() const //display destinations
{                                 //   selected by buttons
    set_cursor_pos(1, NUM_FLOORS - dest_floor + 1);
    if (action == 3)
        cout << "->";             //arrow to the floor
    else
        cout << "  ";                //blank
}  //end dests_display()
   //--------------------------------------------------------------
void elevator::car_tick2()           //tick 2 for each car
{
    move();                           //move car if appropriate
}
//--------------------------------------------------------------
void elevator::move()
{                          //if loading or unloading,
    if (loading_timer || unloading_timer)  //don't move
        return;
    if (current_floor == dest_floor)
    {
        if (action == 1)
        {
            action = 2;
            loading_timer = LOAD_TIME;
        }
        if (action == 3)
        {
            action = 0;
            unloading_timer = LOAD_TIME;
        }
        return;
    }
    else if (current_floor < dest_floor)        //if going up, go up
        current_floor++;
    else if (current_floor > dest_floor)   //if going down, go down
        current_floor--;
}  //end move()
//--------------------------------------------------------------
void elevator::set_destination()     //stop, get destinations
{
    char ustring[BUF_LENGTH];          //utility buffer for input
 
    if (action == 2)
    {
        set_cursor_pos(1, 22); clear_line();  //clear top line
        set_cursor_pos(1, 22);
        cout << "\nEnter destination floor: ";
        set_cursor_pos(1, 23);
        cin.get(ustring, BUF_LENGTH);   //(avoid multiple LFs)
        cin.ignore(10, '\n');      //eat chars, including newline
        dest_floor = atoi(ustring);
        action = 3;
        set_cursor_pos(1, 22); clear_line();
        set_cursor_pos(1, 23); clear_line();
        set_cursor_pos(1, 24); clear_line();
        return;
    }
}  //end put_destination()
   //--------------------------------------------------------------

// elev_app.cpp
// client-supplied file
 
#include "elev.h"                //for class declarations
 
int main()
{
    elevator theElevator;
    while (true)
    {
        theElevator.master_tick(); //send time tick to all cars
        wait(1000);                //pause
                                   //get floor requests from user
        theElevator.record_floor_reqs();
    }
    return 0;
}

#pragma once
// elev_app.h
// provides constants to specify building characteristics
 
const int NUM_FLOORS = 20;   //number of floors

void elevator::decide()               //decide what to do
{
    int j;
    //flags indicate if destinations or requests above/below us
    bool destins_above, destins_below;    //destinations
    bool requests_above, requests_below;  //requests
                                          //floor number of closest request above us and below us
    int nearest_higher_req = 0;
    int nearest_lower_req = 0;
    //flags indicate if there is another car, going in the same
    //direction, between us and the nearest floor request (FR)
    bool car_between_up, car_between_dn;
    //flags indicate if there is another car, going in the
    //opposite direction, on the opposite side of the nearest FR
    bool car_opposite_up, car_opposite_dn;
    //floor and direction of other car (not us)
    int ofloor;                          //floor
    direction odir;                      //direction
 
                                         //ensure we don't go too high or too low
    if ((current_floor == NUM_FLOORS - 1 && current_dir == UP)
        || (current_floor == 0 && current_dir == DN))
        current_dir = STOP;
 
    //if there's a destination on this floor, unload passengers
    if (destination[current_floor] == true)
    {
        destination[current_floor] = false;  //erase destination
        if (!unloading_timer)                //unload
            unloading_timer = LOAD_TIME;
        return;
    }
    //if there's an UP floor request on this floor,
    //and if we're going up or stopped, load passengers
    if ((ptrBuilding->get_floor_req(UP, current_floor) &&
        current_dir != DN))
    {
        current_dir = UP;  //(in case it was STOP)
                           //remove floor request for direction we're going
        ptrBuilding->set_floor_req(current_dir,
            current_floor, false);
        if (!loading_timer)                  //load
            loading_timer = LOAD_TIME;
        return;
    }
    //if there's a down floor request on this floor,
    //and if we're going down or stopped, load passengers
    if ((ptrBuilding->get_floor_req(DN, current_floor) &&
        current_dir != UP))
    {
        current_dir = DN;  //(in case it was STOP)
                           //remove floor request for direction we're going
        ptrBuilding->set_floor_req(current_dir,
            current_floor, false);
        if (!loading_timer)                  //load passengers
            loading_timer = LOAD_TIME;
        return;
    }
    //check if there are other destinations or requests
    //record distance to nearest request
    destins_above = destins_below = false;
    requests_above = requests_below = false;
    for (j = current_floor + 1; j<NUM_FLOORS; j++)
    {                                   //check floors above
        if (destination[j])                //if destinations
            destins_above = true;            //set flag
        if (ptrBuilding->get_floor_req(UP, j) ||
            ptrBuilding->get_floor_req(DN, j))
        {                                //if requests
            requests_above = true;           //set flag
            if (!nearest_higher_req)        //if not set before
                nearest_higher_req = j;       //   set nearest req
        }
    }
    for (j = current_floor - 1; j >= 0; j--)      //check floors below
    {
        if (destination[j])                 //if destinations
            destins_below = true;            //set flag
        if (ptrBuilding->get_floor_req(UP, j) ||
            ptrBuilding->get_floor_req(DN, j))
        {                                //if requests
            requests_below = true;           //set flag
            if (!nearest_lower_req)         //if not set before
                nearest_lower_req = j;        //   set nearest req
        }
    }
    //if no requests or destinations above or below, stop
    if (!destins_above && !requests_above &&
        !destins_below && !requests_below)
    {
        current_dir = STOP;
        return;
    }
    //if destinations and we're stopped, or already going the
    //right way, go toward destinations
    if (destins_above && (current_dir == STOP || current_dir == UP))
    {
        current_dir = UP;
        return;
    }
    if (destins_below && (current_dir == STOP || current_dir == DN))
    {
        current_dir = DN;
        return;
    }
    //find out if there are other cars, (a) going in the same
    //direction, between us and the nearest floor request;
    //or (b) going in the opposite direction, on the other
    //side of the floor request
    car_between_up = car_between_dn = false;
    car_opposite_up = car_opposite_dn = false;
 
    for (j = 0; j<NUM_CARS; j++)              //check each car
    {
        if (j != car_number)                 //if it's not us
        {                                //get its floor
            ofloor = ptrBuilding->get_cars_floor(j);   //and
            odir = ptrBuilding->get_cars_dir(j); //direction
 
                                                 //if it's going up and there are requests above us
            if ((odir == UP || odir == STOP) && requests_above)
                //if it's above us and below the nearest request
                if ((ofloor > current_floor
                    && ofloor <= nearest_higher_req)
                    //or on same floor as us but is lower car number
                    || (ofloor == current_floor && j < car_number))
                    car_between_up = true;
            //if it's going down and there are requests below us
            if ((odir == DN || odir == STOP) && requests_below)
                //if it's below us and above the nearest request
                if ((ofloor < current_floor
                    && ofloor >= nearest_lower_req)
                    //or on same floor as us but is lower car number
                    || (ofloor == current_floor && j < car_number))
                    car_between_dn = true;
            //if it's going up and there are requests below us
            if ((odir == UP || odir == STOP) && requests_below)
                //it's below request and closer to it than we are
                if (nearest_lower_req >= ofloor
                    && nearest_lower_req - ofloor
                    < current_floor - nearest_lower_req)
                    car_opposite_up = true;
            //if it's going down and there are requests above us
            if ((odir == DN || odir == STOP) && requests_above)
                //it's above request and closer to it than we are
                if (ofloor >= nearest_higher_req
                    && ofloor - nearest_higher_req
                    < nearest_higher_req - current_floor)
                    car_opposite_dn = true;
        }  //end if(not us)
    }  //end for(each car)
 
    int reqs = 0;
                        //считаем сколько запросов с этажей имеем на данный момент
    for (j = 0; j < NUM_FLOORS; j++)
    {
        if (ptrBuilding->get_floor_req(UP, j) || ptrBuilding->get_floor_req(DN, j))
            reqs++;
    }
 
       //if we're going up or stopped, and there is an FR above us,
       //and there are no other cars going up between us and the FR,
       //or above the FR going down and closer than we are,
       //then go up
    if ((current_dir == UP || current_dir == STOP)
        && requests_above && !car_between_up && !car_opposite_dn)
    {
        current_dir = UP;
        return;
    }
 
    //if we're going down or stopped, and there is an FR below
    //us, and there are no other cars going down between us and
    //the FR, or below the FR going up and closer than we are,
    //then go down
    if ((current_dir == DN || current_dir == STOP)
        && requests_below && !car_between_dn && !car_opposite_up)
    {
        current_dir = DN;
        return;
    }
 
    if (car_number < reqs && requests_above //если лифтов меньше чем запросов с этажей, и над нами есть запрос
        && !ptrBuilding->get_floor_req(ptrBuilding->get_cars_dir(reqs-2), nearest_higher_req))
    {                                                      //и предыдущему лифту не по пути с запросом над нами
        current_dir = UP;
        if (ptrBuilding->get_floor_req(DN, current_floor))
        {
            current_dir = DN;  
                               //remove floor request for direction we're going
            ptrBuilding->set_floor_req(current_dir,
                current_floor, false);
            if (!loading_timer)                  //load passengers
                loading_timer = LOAD_TIME;
        }
        return;
    }
 
    if (car_number < reqs && requests_below //тоже самое только для лифтов идущих сверху вниз.
        && !ptrBuilding->get_floor_req(ptrBuilding->get_cars_dir(reqs - 2), nearest_lower_req))
    {
        current_dir = DN;
        if (ptrBuilding->get_floor_req(UP, current_floor))
        {
            current_dir = UP;  
                               //remove floor request for direction we're going
            ptrBuilding->set_floor_req(current_dir,
                current_floor, false);
            if (!loading_timer)                  //load passengers
                loading_timer = LOAD_TIME;
        }
        return;
    }
 
    //if nothing else happening, stop
    current_dir = STOP;
}  //end decide(), finally

#include <iostream>
#include <locale>
 
using namespace std;
 
class Beta;
 
class Alpha
{
     private:
        int data;
     public:
        Alpha() : data(4){}
         
        friend int fri_func(Alpha aa, Beta bb); 
};
 
class Beta
{
     private:
        int data;
     public:
        Beta() : data(7){}
         
        friend int fri_func(Alpha aa, Beta bb); 
};
 
int fri_func(Alpha aa, Beta bb) 
{ return (aa.data + bb.data); }
 
int main()
{
    setlocale(LC_ALL, ".1251");
    Alpha objA;
    Beta objB;
    
    cout << fri_func(objA, objB) << endl;
    
    system("pause");
    return 0;
}