{

float fltfeet = d2.feet +d2.inches/12.0;// преобразовать

// в формат float

fltfeet /= divisor; // выполнить деление

feet = int(fltfeet); // получить футовую часть

inches =(fltfeet - feet)*12.0; // получить дюймовую часть

}

///////////////////////////////////////////////////////////

int main()

{

Distance distarr[100]; // массив из 100 объектов типа

// Distance

Distance total(0, 0.0), average;// прочие расстояния

int count = 0; // считает количество введенных значений

char ch; // признак ответа пользователя

do {

cout << "\nВведите расстояние ";// получить значения

distarr[count++].getdist(); // от оператора, занести

cout << "\nПродолжить (y/n)?"; // их в массив

cin >> ch;

} while(ch != 'n');

for(int j = 0; j < count; j++) // сложить все расстояния

total.add_dist(total, distarr[j]); // в total

average.div_dist(total, count); // разделить на число

cout << "\nСреднее:"; // вывести среднее значение

average.showdist();

cout << endl;

return 0;

}

Глава 8

Ответы на вопросы

1. а, в.

2. Правильный ответ: x3.subtract(x2, x1);

3. Правильный ответ:

x3 = x2 - x1;

4. Истинно.

5. Правильный ответ:

void operator--(){ count--; }

6. Нисколько.

7. б, г.

8. Правильный ответ:

void Distance::operator++()

{

++feet; }

9. Правильный ответ:

Distance Distance :: operator++() {

int f =++feet; float i = inches;

return Distance(f, i);

}

10. Увеличивает переменную до ее использования как незамещенный опера- тор ++.

11. в, д, б, а, г.

12. Истинно.

13. б, в.

14. Правильный ответ:

String String::operator++() {

int len = strlen(str); for(int j = 0; j < len; j++) str[j] == toupper(str[j]))

return String(str); }

10. г.

11. Ложно, если есть программа преобразования; в противном случае истинно.

12. б.

13. Истинно.

14. Конструктор.

15. Истинно, но человеку такое трудно будет понять.

16. г.

17. Атрибутами, операторами.

18. Ложно.

19. а.

Решения упражнений

1. Верное решение:

// ex8_1.cpp

// перегружаемая операция '-' находит разность расстояний

#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////

class Distance // Класс английских расстояний

{

private:

int feet;

float inches;

public: // конструктор без аргументов

Distance(): feet(0), inches(0.0)

{ } // конструктор (два аргумента)

Distance(int ft, float in):feet(ft), inches(in)

{ }

void getdist() // получить расстояние от пользователя

{

cout << "\nВведите число футов:";cin >> feet;

cout << "Число дюймов:";cin >> inches;

}

void showdist() // вывести расстояние

{ cout << feet << "\'-" << inches << '\"'; }

Distance operator+(Distance);// складывает два расстояния

Distance operator-(Distance);// вычитает два расстояния

};

//---------------------------------------------------------

// добавление d2 к расстоянию

Distance Distance::operator+(Distance d2)// вернуть сумму

{

int f = feet +d2.feet; // сложить футы

float i = inches +d2.inches; // сложить дюймы

if(i >= 12.0) // если сумма дюймов превышает 12.0,

{ // уменьшить число дюймов

i -= 12.0; // на 12.0 и

f++; // увеличить число футов н 1

} // вернуть временное

return Distance(f, i);// значение расстояния, равное сумме

}

//---------------------------------------------------------

// вычитание d2 из расстояния

Distance Distance::operator-(Distance d2) // вернуть разность

{

int f = feet - d2.feet; // разность футов

float i = inches - d2.inches; // разность дюймов

if(i < 0) // если число дюймов меньше 0,

{ // увеличить их количество на

i += 12.0; // 12.0 и

f--; // уменьшить число футов на 1

} // вернуть временное расстояние,

return Distance(f, i); // равное разности

}

///////////////////////////////////////////////////////////

int main()

{

Distance dist1, dist3; // определить расстояния

dist1.getdist(); // получить dist1 от пользователя

Distance dist2(3, 6.25);// определить, инициализировать

// dist2

dist3 = dist1 - dist2; // разность

// вывести все расстояния

cout << "\ndist1 ="; dist1.showdist();

cout << "\ndist2 ="; dist2.showdist();

cout << "\ndist3 ="; dist3.showdist();

cout << endl;

return 0;

}

2. Верное решение:

// ex8_2.cpp

// перегружаемая операция '+=' для конкатенации строк

#include <iostream>

#include <cstring> // для strcpy(), strlen()

using namespace std;

#include <process.h> // для exit()

///////////////////////////////////////////////////////////

class String // пользовательский строковый тип

{

private:

enum { SZ = 80 }; // размер объектов String

char str[SZ]; // содержит С-строку

public:

String() // конструктор без аргументов

{ strcpy(str, ""); }

String(char s[]) // конструктор с 1 аргументом

{ strcpy(str, s); }

void display() // вывод строки

{ cout << str; }

String operator+=(String ss)// прибавление строки к

// имеющейся

{// результат сохраняется в имеющейся строке

if(strlen(str) + strlen(ss.str) >= SZ)

{ cout << "\nПереполнение строки"; exit(1); }

strcat(str, ss.str);// добавить аргументную строку

return String(str); // вернуть временный String

}

};

///////////////////////////////////////////////////////////

int main()

{

String s1 = "С Новым Годом!"; // использует конструктор с

// одним аргументом

String s2 = "Ура, товарищи!"; // использует конструктор

// с одним аргументом

String s3; // использует конструктор без аргументов

s3 = s1 += s2;// прибавить s2 к s1, результат - в s3

cout << "\ns1 ="; s1.display(); // вывести s1

cout << "\ns2 ="; s2.display(); // вывести s2

cout << "\ns3 ="; s3.display(); // вывести s3

cout << endl;

return 0;

}

2. Верное решение:

// ex8_3.cpp

// перегружаемая операция '+' складывает два времени

#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////

class time

{

private:

int hrs, mins, secs;

public:

time(): hrs(0), mins(0), secs(0) // конструктор без аргум.

{ } // конструктор с тремя аргументами

time(int h, int m, int s):hrs(h), mins(m), secs(s)

{ }

void display() // формат 11:59:59

{ cout << hrs << ":" << mins << ":" << secs; }

time operator+(time t2) // сложить два времени

{

int s = secs +t2.secs; // сложить секунды

int m = mins +t2.mins; // сложить минуты

int h = hrs +t2.hrs; // сложить часы

if(s > 59) // если слишком много секунд,

{ s -= 60; m++; } // перенести их в одну минуту

if(m > 59) // если слишком много минут,

{ m -= 60; h++; } // перенести их в один час

return time(h, m, s); // вернуть временное значение

}

};

///////////////////////////////////////////////////////////

int main()

{

time time1(5, 59, 59);// создать и инициализировать

time time2(4, 30, 30);// два времени

time time3; // еще одно время создать

time3 = time1 +time2; // сложить два значения времени

cout << "\ntime3 ="; time3.display(); // вывести результат

cout << endl;

return 0;

}

4. Верное решение: // ex8_4.cpp

// работа перегружаемых арифметических операций с типом Int

#include <iostream>

using namespace std;

#include <process.h> // для exit()

///////////////////////////////////////////////////////////

class Int

{

private:

int i;

public:

Int(): i(0) // конструктор без аргументов

{ }

Int(int ii):i(ii) // конструктор с одним аргументом

{ } // (из int в Int)

void putInt() // вывод Int

{ cout << i; }

void getInt() // чтение Int с клавиатуры

{ cin >> i; }

operator int() // операция преобразования

{ return i; } // (Int в int)

Int operator+(Int i2) // сложение

{ return checkit(long double(i) + long double(i2)); }

Int operator-(Int i2) // вычитание

{ return checkit(long double(i) - long double(i2)); }