Решение всех задач из учебника Стивена Праты

//  sp_Ch11_Pg588_Ex03 - main.cpp
/// Занятия по книге Стивена Праты "Язык программирования С++" (2013, 6-е изд.).
/// Упражнения по программированию. Глава 11, страница 588, упражнение 3.
/*
Модифицируйте код в листинге 11.15 так, чтобы вместо сообщений о
результатах одиночной попытки при конкретной комбинации расстояние/шаг
сообщалось максимальное, минимальное и среднее количество шагов для N попыток,
где N — целое число, вводимое пользователем.
*/
 
#include "Vector.h"     // includes <iostream>
#include <cstdlib>      // rand(), srand() prototypes
#include <ctime>        // time() prototype
#include <vector>
#include <algorithm>    // min_element(), max_element()
#include <numeric>      // accumulate()
 
int main()
{
    using namespace std;
    using VECTOR::Vector;
    srand(time(0));     // seed random-number generator
    double direction;
    Vector step;
    Vector result(0.0, 0.0);
    unsigned long steps = 0;
    double target;
    double dstep;
    vector <unsigned long> stepsResult;
    int attempt = 0;
    cout << "Enter number of attempts: ";
    cin >> attempt;
    while (attempt)
    {
        cout << "Enter target distance: ";
        cin >> target;
 
        cout << "Enter step length: ";
        if (!(cin >> dstep))
            break;
 
        while (result.magval() < target)
        {
            direction = rand() % 360;
            step.reset(dstep, direction, VECTOR::Vector::POL);
            result = result + step;
            steps++;
        }
        stepsResult.push_back(steps);
        result.reset(0,0);
 
        --attempt;
    }
    cout << "The smallest number of steps is "
         << *min_element(stepsResult.begin(), stepsResult.end())
         << '\n';
    cout << "The average number of steps is "
         << accumulate(stepsResult.begin(), stepsResult.end(), 0) / stepsResult.size()
         << '\n';
    cout << "The largest number of steps is "
         << *max_element(stepsResult.begin(), stepsResult.end())
         << '\n';
    cout << "Bye!\n";
/* keep window open
    cin.clear();
    while (cin.get() != '\n')
        continue;
    cin.get();
*/
    return 0;
}

//  sp_Ch11_Pg588_Ex03 - Vector.h
#ifndef VECTOR_H
#define VECTOR_H
 
#include <iostream>
 
namespace VECTOR
{
    class Vector
    {
    public:
        enum Mode {RECT, POL};
    // RECT for rectangular, POL for Polar modes
    private:
        double x;          // horizontal value
        double y;          // vertical value
        double mag;        // length of vector
        double ang;        // direction of vector in degrees
        Mode mode;         // RECT or POL
    // private methods for setting values
        void set_mag();
        void set_ang();
        void set_x();
        void set_y();
    public:
       Vector();
        Vector(double n1, double n2, Mode form = RECT);
        void reset(double n1, double n2, Mode form = RECT);
        ~Vector();
        double xval() const {return x;}       // report x value
        double yval() const {return y;}       // report y value
        double magval() const {return mag;}   // report magnitude
        double angval() const {return ang;}   // report angle
        void polar_mode();                    // set mode to POL
        void rect_mode();                     // set mode to RECT
    // operator overloading
        Vector operator+(const Vector & b) const;
        Vector operator-(const Vector & b) const;
        Vector operator-() const;
        Vector operator*(double n) const;
    // friends
        friend Vector operator*(double n, const Vector & a);
        friend std::ostream & operator<<(std::ostream & os, const Vector & v);
    };
 
}   // end namespace VECTOR
 
#endif // VECTOR_H

//  sp_Ch11_Pg588_Ex03 - Vector.cpp
//  methods for the Vector class
#include <cmath>
#include "vector.h"   // includes <iostream>
 
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;
 
namespace VECTOR
{
    // compute degrees in one radian
    const double Rad_to_deg = 45.0 / atan(1.0);
    // should be about 57.2957795130823
 
    // private methods
    // calculates magnitude from x and y
    void Vector::set_mag()
    {
        mag = sqrt(x * x + y * y);
    }
 
    void Vector::set_ang()
    {
        if (x == 0.0 && y == 0.0)
            ang = 0.0;
        else
            ang = atan2(y, x);
    }
 
    // set x from polar coordinate
    void Vector::set_x()
    {
        x = mag * cos(ang);
    }
 
    // set y from polar coordinate
    void Vector::set_y()
    {
        y = mag * sin(ang);
    }
 
    // public methods
    Vector::Vector()             // default constructor
    {
        x = y = mag = ang = 0.0;
        mode = RECT;
    }
 
    // construct vector from rectangular coordinates if form is r
    // (the default) or else from polar coordinates if form is p
    Vector::Vector(double n1, double n2, Mode form)
    {
        mode = form;
        if (form == RECT)
         {
             x = n1;
             y = n2;
             set_mag();
             set_ang();
        }
        else if (form == POL)
        {
             mag = n1;
             ang = n2 / Rad_to_deg;
             set_x();
             set_y();
        }
        else
        {
             cout << "Incorrect 3rd argument to Vector() -- ";
             cout << "vector set to 0\n";
             x = y = mag = ang = 0.0;
             mode = RECT;
        }
    }
 
    // reset vector from rectangular coordinates if form is
    // RECT (the default) or else from polar coordinates if
    // form is POL
    void Vector:: reset(double n1, double n2, Mode form)
    {
        mode = form;
        if (form == RECT)
         {
             x = n1;
             y = n2;
             set_mag();
             set_ang();
        }
        else if (form == POL)
        {
             mag = n1;
             ang = n2 / Rad_to_deg;
             set_x();
             set_y();
        }
        else
        {
             cout << "Incorrect 3rd argument to Vector() -- ";
             cout << "vector set to 0\n";
             x = y = mag = ang = 0.0;
             mode = RECT;
        }
    }
 
    Vector::~Vector()    // destructor
    {
    }
 
    void Vector::polar_mode()    // set to polar mode
    {
        mode = POL;
    }
 
    void Vector::rect_mode()     // set to rectangular mode
    {
        mode = RECT;
    }
 
    // operator overloading
    // add two Vectors
    Vector Vector::operator+(const Vector & b) const
    {
        return Vector(x + b.x, y + b.y);
    }
 
    // subtract Vector b from a
    Vector Vector::operator-(const Vector & b) const
    {
        return Vector(x - b.x, y - b.y);
    }
 
    // reverse sign of Vector
    Vector Vector::operator-() const
    {
        return Vector(-x, -y);
    }
 
    // multiply vector by n
    Vector Vector::operator*(double n) const
    {
        return Vector(n * x, n * y);
    }
 
    // friend methods
    // multiply n by Vector a
    Vector operator*(double n, const Vector & a)
    {
        return a * n;
    }
 
    // display rectangular coordinates if mode is RECT,
    // else display polar coordinates if mode is POL
    std::ostream & operator<<(std::ostream & os, const Vector & v)
    {
        if (v.mode == Vector::RECT)
             os << "(x,y) = (" << v.x << ", " << v.y << ")";
        else if (v.mode == Vector::POL)
        {
             os << "(m,a) = (" << v.mag << ", "
                 << v.ang * Rad_to_deg << ")";
        }
        else
             os << "Vector object mode is invalid";
        return os;
    }
 
}  // end namespace VECTOR

//  sp_Ch11_Pg588_Ex04 - main.cpp
/// Занятия по книге Стивена Праты "Язык программирования С++" (2013, 6-е изд.).
/// Упражнения по программированию. Глава 11, страница 588, упражнение 4.
/*
Перепишите финальный пример класса Time (листинги 11.10, 11.11 и 11.12) так,
чтобы все перегруженные операции были реализованы с использованием
дружественных функций.
*/
#include <iostream>
#include "Time.h"
 
int main()
{
    using std::cout;
    using std::endl;
    Time aida(3, 35);
    Time tosca(2, 48);
 
    cout << "Aida:\t" << aida << endl;
    cout << "Tosca:\t" << tosca << endl << endl;
 
    cout << "Aida + Tosca:\t" << aida + tosca << endl;   // operator+()
    cout << "Aida - Tosca:\t" << aida - tosca << endl;   // operator-()
    cout << "Aida * 1.17:\t" << aida * 1.17 << endl;     // operator*()
    cout << "10.0 * Tosca:\t" << 10.0 * tosca << endl;   // operator*()
 
    // std::cin.get();
 
    return 0;
}

//  sp_Ch11_Pg588_Ex04 - Time.h
 
#ifndef TIME_H
#define TIME_H
 
#include <iostream>
 
class Time
{
private:
    int hours;
    int minutes;
public:
    Time();
    Time(int h, int m = 0);
    void AddMin(int m);
    void AddHr(int h);
    void Reset(int h = 0, int m = 0);
    friend Time operator+(const Time & t1, const Time & t2);
    friend Time operator-(const Time & t1, const Time & t2);
    friend Time operator*(const Time & t, double m);
    friend Time operator*(double m, const Time & t);
    friend std::ostream & operator<<(std::ostream & os, const Time & t);
 
};
 
#endif // TIME_H

//  sp_Ch11_Pg588_Ex04 - Time.cpp
 
#include "Time.h"
 
Time::Time()
{
    hours = minutes = 0;
}
 
Time::Time(int h, int m )
{
    hours = h;
    minutes = m;
}
 
void Time::AddMin(int m)
{
    minutes += m;
    hours += minutes / 60;
    minutes %= 60;
}
 
void Time::AddHr(int h)
{
    hours += h;
}
 
void Time::Reset(int h, int m)
{
    hours = h;
    minutes = m;
}
 
Time operator+(const Time & t1, const Time & t2)
{
    Time sum;
    sum.minutes = t1.minutes + t2.minutes;
    sum.hours = t1.hours + t2.hours + sum.minutes / 60;
    sum.minutes %= 60;
    return sum;
}
 
Time operator-(const Time & t1, const Time & t2)
{
    Time diff;
    int tot1, tot2;
    tot1 = t1.minutes + 60 * t1.hours;
    tot2 = t2.minutes + 60 * t2.hours;
    diff.minutes = (tot1 - tot2) % 60;
    diff.hours = (tot1 - tot2) / 60;
    return diff;
}
 
Time operator*(double mult, const Time & t)
{
    Time result;
    long totalminutes = t.hours * mult * 60 + t.minutes * mult;
    result.hours = totalminutes / 60;
    result.minutes = totalminutes % 60;
    return result;
}
 
Time operator*(const Time & t, double mult)
{
    Time result;
    long totalminutes = t.hours * mult * 60 + t.minutes * mult;
    result.hours = totalminutes / 60;
    result.minutes = totalminutes % 60;
    return result;
}
 
std::ostream & operator<<(std::ostream & os, const Time & t)
{
    os << t.hours << " hours, " << t.minutes << " minutes";
    return os;
}

//  sp_Ch11_Pg588_Ex05 - main.cpp
/// Занятия по книге Стивена Праты "Язык программирования С++" (2013, 6-е изд.).
/// Упражнения по программированию. Глава 11, страница 588, упражнение 5.
/*
Перепишите класс Stonewt (листинги 11.16 и 11.17) так, чтобы он имел член
состояния, который управляет тем, в какой форме интерпретируется объект:
стоуны, целочисленное значение в фунтах или значение в фунтах с плавающей
точкой. Перегрузите операцию << для замены методов show_stn () и show_lbs ().
Перегрузите операции сложения, вычитания и умножения значений Stonewt.
Протестируйте полученный класс с помощью короткой программы, в которой
используются все методы и друзья класса.
*/
#include <iostream>
#include "Stonewt.h"
 
int main()
{
    Stonewt var_a;
    std::cout << "Object constructed by default constructor: " << var_a << std::endl;
 
    Stonewt var_b(24.5);
    std::cout << "Object constructed from double value: " << var_b << std::endl;
 
    Stonewt var_c(10, 5.5);
    std::cout << "Object constructed from stone, double values: " << var_c << std::endl;
 
    var_c.setmode(0);
    std::cout << "Mode set to STONE: " << var_c << std::endl;
 
    var_c.setmode(1);
    std::cout << "Mode set to iPOUND: " << var_c << std::endl;
 
    var_c.setmode(2);
    std::cout << "Mode set to dPOUND: " << var_c << std::endl;
 
    std::cout << "Mode set to incorrect value:\n";
    var_c.setmode(6);
    std::cout << "Object after that: " << var_c << std::endl;
 
 
    return 0;
}

//  sp_Ch11_Pg588_Ex05 - Stonewt.h
 
#ifndef STONEWT_H
#define STONEWT_H
 
class Stonewt
{
public:
    enum Mode {STONE, iPOUND, dPOUND};
    Stonewt(double lbs);            // constructor for double pounds
    Stonewt(int stn, double lbs);   // constructor for stone, lbs
    Stonewt();                      // default constructor
    ~Stonewt();                     // destructor
    void setmode(int m);            // set mode by user
    friend Stonewt operator+(const Stonewt & stn1, const Stonewt & stn2);
    friend Stonewt operator-(const Stonewt & stn1, const Stonewt & stn2);
    friend Stonewt operator*(const Stonewt & stn1, const Stonewt & stn2);
    friend std::ostream & operator<<(std::ostream & os, const Stonewt & stn);
 
private:
    enum {Lbs_per_stn = 14};        // pounds per stone
    int stone;                      // whole stones
    double pds_left;                // fractional pounds
    double dpounds;                 // entire weight in fractional pounds
    int ipounds;                    // entire weight in whole pounds
    Mode mode;                      // stone or whole pounds or fractional pounds
    void setmode();                 // set mode
};
 
#endif // STONEWT_H

//  sp_Ch11_Pg588_Ex05 - Stonewt.cpp
 
#include <iostream>
#include "Stonewt.h"
 
 
void Stonewt::setmode()
{
    if (pds_left == 0)
        mode = STONE;
    else if (pds_left - int(pds_left))
        mode = dPOUND;
    else
        mode = iPOUND;
}
 
void Stonewt::setmode(int m)
{
    if (m == 0)
        mode = STONE;
    else if (m == 1)
        mode = iPOUND;
    else if (m == 2)
        mode = dPOUND;
    else
    {
        std::cout << "\n\tWarning! Incorrect argument in function setmode()."
                     "\n\tMode set to STONE.\n\n";
        mode = STONE;
    }
}
 
// construct Stonewt object from double value
Stonewt::Stonewt(double lbs)
{
    stone = int (lbs) / Lbs_per_stn;    // integer division
    pds_left = int (lbs) % Lbs_per_stn + lbs - int(lbs);
    dpounds = lbs;
    ipounds = int(lbs);
 
    setmode();
}
 
// construct Stonewt object from stone, double values
Stonewt::Stonewt(int stn, double lbs)
{
    stone = stn;
    pds_left = lbs;
    dpounds = stn * Lbs_per_stn + lbs;
    ipounds = int(stn * Lbs_per_stn + lbs);
 
    setmode();
}
 
Stonewt::Stonewt()          // default constructor, wt = 0
{
    stone = dpounds = ipounds = pds_left = 0;
    mode = STONE;
}
 
Stonewt::~Stonewt()         // destructor
{
}
 
friend Stonewt operator+(const Stonewt & stn1, const Stonewt & stn2)
{
    Stonewt sum;
    
    // милый мой хороший, догадайся сам
    
    return sum;
}
 
friend Stonewt operator-(const Stonewt & stn1, const Stonewt & stn2)
{
    Stonewt diff;
    
    // тут будет код, который Вы напишете самостоятельно
    
    return diff;   
}
 
friend Stonewt operator*(const Stonewt & stn1, const Stonewt & stn2)
{
    Stonewt result;
    
    // тут будет код, который Вы напишете самостоятельно
    
    return result; 
}
 
std::ostream & operator<<(std::ostream & os, const Stonewt & stn)
{
    if (stn.mode == stn.STONE)
        os << stn.stone << " stone, " << stn.pds_left << " pounds.";
    else if (stn.mode == stn.iPOUND)
        os << stn.ipounds << " pounds.";
    else
        os << stn.dpounds << " pounds.";
 
    return os;
}

//  sp_Ch10_Pg532_Ex04 - main.cpp
/// Занятия по книге Стивена Праты "Язык программирования С++" (2013, 6-е изд.).
/// Упражнения по программированию. Глава 10, страница 532, упражнение 4.
/*
Выполните упражнение 4 из главы 9, но преобразуйте структуру Sales и
ассоциированные с ней функции в класс и методы. Замените функцию
setSales (Sales &, double[], int) конструктором. Реализуйте интерактивный
метод setSales (Sales &), используя конструктор. Оставьте класс в
пространстве имен SALES.
*/
#include "Sales.h"
 
int main()
{
    using namespace sales;
 
    double ar[] = {225056.55, 340742.15, 410123.35, 270521.25};
    Sales s1(ar);
    s1.show_sales();
    s1.reset_sales();
    s1.set_sales();
    s1.show_sales();
 
    return 0;
}

//  sp_Ch10_Pg532_Ex04 - Sales.h
#ifndef SALES_H
#define SALES_H
 
namespace sales
{
    static const int QUARTERS = 4;
    class Sales
    {
        public:
            Sales(){}
            ~Sales(){}
            Sales(const double ar[]);
            void reset_sales();
            void set_sales();
            void show_sales();
 
        private:
            double m_sales[QUARTERS];
            double m_average;
            double m_max;
            double m_min;
            double find_min(const double ar[], int arSize);
            double find_max(const double ar[], int arSize);
            double find_average(const double ar[], int arSize);
    };
}
#endif // SALES_H

//  sp_Ch10_Pg532_Ex04 - Sales.cpp
#include <iostream>
#include "Sales.h"
namespace sales
{
    Sales::Sales(const double ar[])
    {
        for (int i = 0; i < QUARTERS; ++i)
            m_sales[i] = ar[i];
 
        m_average = find_average(ar, QUARTERS);
        m_max = find_max(ar, QUARTERS);
        m_min = find_min(ar, QUARTERS);
    }
 
    void Sales::reset_sales()
    {
        for (int i = 0; i < QUARTERS; ++i)
            m_sales[i] = 0;
 
        m_average = 0;
        m_max = 0;
        m_min = 0;
    }
 
    void Sales::set_sales()
    {
        int qty = 0;        // количество продаж за один квартал
        double amount = 0;  // сумма одной продажи
 
        for (int i = 0; i < QUARTERS; ++i)
        {
            m_sales[i] = 0;
 
            std::cout << "\nEnter the quantity of sales for the "
                      << i + 1 << " quarter: ";
            std::cin >> qty;
 
            for (int j = 0; j < qty; ++j)
            {
                std::cout << "\nEnter the " << j + 1 << " amount: ";
                std::cin >> amount;
                m_sales[i] += amount;
            }
        }
 
        m_average = find_average(m_sales, QUARTERS);
        m_max = find_max(m_sales, QUARTERS);
        m_min = find_min(m_sales, QUARTERS);
    }
 
    void Sales::show_sales()
    {
        std::cout << "\nAverage: " << m_average
                  << "\nMaximum: " << m_max
                  << "\nMinimum: " << m_min
                  << std::endl;
    }
 
    double Sales::find_min(const double ar[], int arSize)
    {
        double min_value = ar[0];
        for (int i = 1; i < arSize; ++i)
            if (ar[i] < min_value)
                min_value = ar[i];
 
        return min_value;
    }
 
    double Sales::find_max(const double ar[], int arSize)
    {
        double max_value = ar[0];
        for (int i = 1; i < arSize; ++i)
            if (ar[i] > max_value)
                max_value = ar[i];
 
        return max_value;
    }
 
    double Sales::find_average(const double ar[], int arSize)
    {
        double sum = 0;
        for (int i = 0; i < arSize; ++i)
                sum += ar[i];
 
        return sum/arSize;
    }
 
}//endof namespace sales

#include <iostream>
using namespace std;
#include "complex0.h" // чтобы не перепутать с complex.h
int main()
{
    setlocale(LC_ALL, "Russian");
 
    Complex a(3.0, 4.0); // инициализация (3,4i)
    Complex c;
    cout << "Введите комплексное число (q для отмены):\n";
    while (cin >> c)
    {
        cout << "c это " << c << '\n';
        cout << "значение сопряженного числа (complex conjugate) " << ~c << '\n';
        cout << "a - " << a << endl;
        cout << "a + c = " << a + c << '\n';
        cout << "a - c = " << a - c << '\n';
        cout << "a * c = " << a * c << '\n';
        cout << "2 * c = " << 2 * c << '\n';
        cout << "Введите комплексное число (q для отмены):\n";
    }
    cout << "Вот и все!\n";
 
    return 0;
}

//complex0.h
#ifndef COMPLEX0_H
#define COMPLEX0_H
#include <iostream>
 
class Complex
{
private:
    double real;
    double imaginary;
public:
    Complex();
    Complex(double _x, double _y);
    ~Complex();
 
    friend Complex operator+(const Complex & c1, const Complex & c2);
    friend Complex operator-(const Complex & c1, const Complex & c2);
    friend Complex operator*(const Complex & c1, const Complex & c2);
    friend Complex operator*(double num, const Complex & c2);
    friend Complex operator~(const Complex & c);
 
    friend std::ostream & operator<<(std::ostream & os, const Complex & c);
    friend std::istream & operator>>(std::istream & is,  Complex & c);
};
#endif; // конец COMPLEX0_H;

//complex0.cpp
#include "complex0.h"
Complex::Complex()
{
    real = 0;
    imaginary = 0;
}
 
Complex::Complex(double _x, double _y)
{
    real = _x;
    imaginary = _y;
}
 
Complex::~Complex()
{
}
 
Complex operator+(const Complex & c1, const Complex & c2)
{
    Complex sum;
    sum.real = c1.real + c2.real;
    sum.imaginary = c1.imaginary + c2.imaginary;
    return sum;
}
 
Complex operator-(const Complex & c1, const Complex & c2)
{
    Complex diff;
    diff.real = c1.real - c2.real;
    diff.imaginary = c1.imaginary - c2.imaginary;
    return diff;
}
 
Complex operator*(const Complex & c1, const Complex & c2)
{
    Complex result;
    result.real = c1.real*c2.real - c1.imaginary*c2.imaginary;
    result.imaginary = c1.real*c2.imaginary + c1.imaginary*c2.real;
    return result;
}
 
Complex operator*(double num, const Complex & c)
{
    Complex result;
    result.real = num*c.real;
    result.imaginary = num*c.imaginary;
    return result;
 
}
 
Complex operator~(const Complex & c)
{
    Complex result;
    result.real = c.real;
    result.imaginary = -c.imaginary;
    return result;
 
}
std::ostream & operator<<(std::ostream & os, const Complex & c)
{
    os << "( " << c.real << " , " << c.imaginary << "i )";
    return os;
}
std::istream & operator>>(std::istream & is, Complex & c)
{
    std::cout << "Введите вещественую часть : ";
    is >> c.real; 
    std::cout << "Введите мнимую часть: ";
    is >> c.imaginary;
    std::cout << std::endl;
    return is;
}

//cow.h
class Cow {
    char name[20];
    char * hobby;
    double weight;
public:
    Cow();
    Cow(const char * nm, const char * ho, double wt);
    Cow (const Cow & c);
    ~Cow();
    Cow & operator= (const Cow & c);
    void ShowCow() const; // отображение всех данных cow 
};

//cow.cpp
#define _CRT_SECURE_NO_WARNINGS
#include "cow.h"
#include <iostream>
 
Cow::Cow()
{
    std::cout << "Вызван конструктор по умолчанию" << std::endl;
    name[0] = '\0';
    hobby = new char[1];
    hobby[0] = '\0';
    weight = 0;
}
Cow::Cow(const char * nm, const char * ho, double wt)
{
    std::cout << "Вызван конструктор " << std::endl;
    std::strncpy(name, nm, 20);
    hobby = new char[std::strlen(ho) + 1];
    std::strcpy(hobby, ho);
    weight = wt;
}
 
Cow::Cow(const Cow & c)
{
    std::cout << "Вызван конструктор копирования " << std::endl;
    strncpy(name, c.name, 20);
    hobby = new char[strlen(c.hobby) + 1];
    strcpy(hobby, c.hobby);
    weight = c.weight;
}
Cow::~Cow()
{
    std::cout << "Вызван деструктор:" << std::endl;
    delete[] hobby;
}
 
Cow & Cow::operator=(const Cow & c)
{
    std::cout << "Вызвана операция присваивания" << std::endl;
    if (&c == this)
        return *this;
    delete[] hobby;
    strncpy(name, c.name, 20);
    hobby = new char[strlen(c.hobby) + 1];
    strcpy(hobby, c.hobby);
    weight = c.weight;
    return *this;
}
 
void Cow::ShowCow() const
{
    std::cout << "name: " << name << std::endl;
    std::cout << "hobby: " << hobby << std::endl;
    std::cout << "weight: " << weight << std::endl;
}

//user.cpp
#include <iostream>
#include "cow.h"
 
using namespace std;
 
int main()
{
    {
        setlocale(LC_ALL, "Russian");
        
 
        cout << "Корова №1:\n";
        Cow Cow1;
        cout << "Корова №2:\n";
        Cow Cow2("Кирюша", "Музыка", 89);
        cout << "Корова №3:\n";
        Cow Cow3 = Cow2;
        cout << "Корова №4:\n";
        Cow Cow4;
        Cow4 = Cow2;
 
 
        cout << "---------------------" << endl;
        cout << "Корова №1:\n";
        Cow1.ShowCow();
        cout << "Корова №2:\n";
        Cow2.ShowCow();
        cout << "Корова №3:\n";
        Cow3.ShowCow();
        cout << "Корова №4:\n";
        Cow4.ShowCow();
 
        cout << "---------------------" << endl;
        cout << "Все!\n";
    }   
    cin.get();
    return 0;
}