Отчет 2 (1079245)
Текст из файла
Отчет по Лабораторной работе №2
«Дроби»
Работу выполнила Чёрненькая И.С. ____________
ИУ-5-21
Преподаватель Козлов А.Д. ____________
1 июня 2009 г.
Цель:
Разработать класс для работы с обыкновенными дробями.
Разработка интерфейса класса:
В состав класса frac входят 3 закрытых поля:
n – целочисленная переменная типа int – числитель дроби.
d – целочисленная переменная типа int – знаменатель дроби.
s – целочисленная переменная типа int – знак дроби (в форме коэффициента +1 или –1).
Для класса frac созданы 6 конструкторов: по умолчанию, переводящий целое число в дробь, переводящий вещественное число в дробь, трех компонентный с целой частью, двух компонентный и строковый.
Для класса frac перегружены операции унарного плюса, унарного минуса, сложения, присвоения со сложением, вычитания, присвоения с вычитанием, умножения, присвоения с умножением, деления, присвоения с делением, равно, неравно, больше, меньше, больше или равно, меньше или равно и потокового консольного вывода.
В классе frac определены 2 закрытых метода:
void dize () – проверка на 0 в знаменателе.
void canc () – сокращения дроби.
Алгоритм программы:
Перегрузка бинарного плюса Перегрузка умножения
Текст программы:
Frac.h
#include <iostream>
#include <strstream>
using namespace std;
int gdc (int n, int d) // Наибольший общий делитель
{
int i;
if (n == 0)
return d;
do
{
i = n % d;
n = d;
d = i;
}
while (i != 0);
return n;
}
char* cop (char* _s, int _i, int _j)
{
char* s;
s = new char[_j - _i + 1];
int k = 0;
for (int i = _i, j = _j; i < j; i++, k++)
s[k] = _s[i];
s[k] = '\0';
return s;
}
class frac
{
public:
// Конструкторы
frac () // Конструктор общий
{
n = 0;
d = 1;
s = 1;
}
frac (int _w) // Конструктор вида w
{
if (_w < 0)
{
n = _w * -1;
s = -1;
}
else
{ n = _w;
s = 1;
}
d = 1;
}
frac (double _e) // Конструктор вида e
{
if (_e < 0)
{ s = -1;
_e *= -1;
}
else
s = 1;
n = int(_e);
_e -= int(_e);
d = 1;
while (abs(n) < 214748363)
{
_e *= 10;
n *= 10;
d *= 10;
n += int(_e);
_e -= int(_e);
}
canc ();
}
frac (int _w, int _n, int _d) // Конструктор вида w n/d
{
if (_w < 0)
{ _w *= -1;
s = -1;
}
else
s = 1;
n = _n + _d * _w;
d = _d;
dize ();
canc ();
}
frac (int _n, int _d) // Конструктор вида n/d
{
if (_n < 0)
{ _n *= -1;
s = -1;
}
else
s = 1;
n = _n;
d = _d;
dize ();
canc ();
}
frac (char* _t)
{
int i = 0;
if (_t[i] == '-')
{ s = -1;
i++;
}
else
if (_t[i] == '-')
{ s = 1;
i++;
}
else
s = 1;
int w = 0;
for (int j = i; _t[j] != '\0'; j++)
{
if (_t[j] == ' ')
{
istrstream instr1 (cop (_t, i, j) );
instr1 >> w;
i = ++j;
}
if (_t[j] == '/')
{
istrstream instr2 (cop (_t, i, j) );
instr2 >> n;
istrstream instr3 (cop (_t, ++j, strlen (_t) ) );
instr3 >> d;
}
}
n += w * d;
dize ();
canc ();
}
frac& operator + () // Плюс унарный
{
return *this;
}
frac& operator - () // Минус унарный
{
s *= -1;
return *this;
}
// Сложения
frac& operator + (frac b) // Сложение вида a + b
{
int _n = n * s * b.d + b.n * b.s * d;
int _d = d * b.d;
return frac (_n, _d);
}
frac& operator + (int w) // Сложение вида a + w
{ frac a (w);
return *this + a;
}
frac& operator + (double e) // Сложение вида a + e
{ frac b (e);
return *this + b;
}
friend frac& operator + (int w, frac b) // Сложение вида w + b
{ frac a (w);
return a + b;
}
friend frac& operator + (double e, frac b) // Сложение вида e + b
{ frac a (e);
return a + b;
}
// Присвоения со сложением
frac& operator += (frac b) // Присвоение со сложением вида a += b
{ return *this = *this + b;
}
frac& operator += (int w) // Присвоение со сложением вида a += w
{ frac b (w);
return *this += b;
}
frac& operator += (double e) // Присвоение со сложением вида a += e
{ frac b (e);
return *this += b;
}
// Вычитания
frac& operator - (frac b) // Вычитание вида a - b
{ return *this + -b;
}
frac& operator - (int w) // Вычитание вида a - w
{ frac b (w);
return *this - b;
}
frac& operator - (double e) // Вычитание вида a - e
{ frac b (e);
return *this - b;
}
friend frac& operator - (int w, frac b) // Вычитание вида w - b
{ frac a (w);
return a - b;
}
friend frac& operator - (double e, frac b) // Вычитание вида e - b
{ frac a (e);
return a - b;
}
// Присвоения с вычитанием
frac& operator -= (frac b) // Присвоение с вычитанием вида a -= b
{ return *this = *this - b;
}
frac& operator -= (int w) // Присвоение с вычитанием вида a -= w
{ frac b (w);
return *this -= b;
}
frac& operator -= (double e) // Присвоение с вычитанием вида a -= e
{ frac b (e);
return *this -= b;
}
// Умножения
frac& operator * (frac b) // Умножение вида a * b
{ int _n = n * b.n * s * b.s;
int _d = d * b.d;
return frac (_n, _d);
}
frac& operator * (int w) // Умножение вида a * w
{ frac b (w);
return *this * b;
}
frac& operator * (double e) // Умножение вида a * e
{ frac b (e);
return *this * b;
}
friend frac& operator * (int w, frac b) // Умножение вида w * b
{ frac a (w);
return a * b;
}
friend frac& operator * (double e, frac b) // Умножение вида e * b
{ frac a (e);
return a * b;
}
// Присвоения с умножением
frac& operator *= (frac b) // Присвоение с умножением вида a *= b
{ return *this = *this * b;
}
frac& operator *= (int w) // Присвоение с умножением вида a *= w
{ frac b (w);
return *this *= b;
}
frac& operator *= (double e) // Присвоение с умножением вида a *= e
{ frac b (e);
return *this *= b;
}
// Деления
frac& operator / (frac b) // Деление вида a / b
{ frac c (b.d, b.n);
return *this * c;
}
frac& operator / (int w) // Деление вида a / w
{ frac b (w);
return *this / b;
}
frac& operator / (double e) // Деление вида a / e
{ frac b (e);
return *this / b;
}
friend frac& operator / (int w, frac b) // Деление вида w / b
{
frac a (w);
return a / b;
}
friend frac& operator / (double e, frac b) // Деление вида e / b
{
frac a (e);
return a / b;
}
// Присвоения с делением
frac& operator /= (frac b) // Присвоение с делением вида a /= b
{
return *this = *this / b;
}
frac& operator /= (int w) // Присвоение с делением вида a /= w
{
frac b (w);
return *this /= b;
}
frac& operator /= (double e) // Присвоение с делением вида a /= e
{
frac b (e);
return *this /= b;
}
// Равно
bool operator == (frac b) // Равно вида a == b
{
return (n == b.n) && (d = b.d) && (s == b.s);
}
bool operator == (int w) // Равно вида a == w
{
frac b (w);
return *this == b;
}
bool operator == (double e) // Равно вида a == e
{
frac b (e);
return *this == b;
}
friend bool operator == (int w, frac b) // Равно вида w == b
{
frac a (w);
return a == b;
}
friend bool operator == (double e, frac b) // Равно вида e == b
{
frac a (e);
return a == b;
}
// Неравно
bool operator != (frac b) // Неравно вида a != b
{
return !(*this == b);
}
bool operator != (int w) // Неравно вида a != w
{
frac b (w);
return *this != b;
}
bool operator != (double e) // Неравно вида a != e
{
frac b (e);
return *this != b;
}
friend bool operator != (int w, frac b) // Неравно вида w != b
{
frac a (w);
return a != b;
}
friend bool operator != (double e, frac b) // Неравно вида e != b
{
frac a (e);
return a != b;
}
// Больше
bool operator > (frac b) // Больше вида a > b
{
if (*this != b)
return (*this - b).s > 0;
return false;
}
bool operator > (int w) // Больше вида a > w
{
frac b (w);
return *this > b;
}
bool operator > (double e) // Больше вида a > e
{
frac b (e);
return *this > b;
}
friend bool operator > (int w, frac b) // Больше вида w > b
{
frac a (w);
return a > b;
}
friend bool operator > (double e, frac b) // Больше вида e > b
{
frac a (e);
return a > b;
}
// Меньше
bool operator < (frac b) // Меньше вида a < b
{
if (*this != b)
return (*this - b).s < 0;
return false;
}
bool operator < (int w) // Меньше вида a < w
{
frac b (w);
return *this < b;
}
bool operator < (double e) // Меньше вида a < e
{
frac b (e);
return *this < b;
}
friend bool operator < (int w, frac b) // Меньше вида w < b
{
frac a (w);
return a < b;
}
friend bool operator < (double e, frac b) // Меньше вида e < b
{
frac a (e);
return a < b;
}
// Больше или равно
bool operator >= (frac b) // Больше или равно вида a >= b
{
return !(*this < b);
}
bool operator >= (int w) // Больше или равно вида a >= w
{
frac b (w);
return *this >= b;
}
bool operator >= (double e) // Больше или равно вида a >= e
{
frac b (e);
return *this >= b;
}
friend bool operator >= (int w, frac b) // Больше или равно вида w >= b
{
frac a (w);
return a >= b;
}
friend bool operator >= (double e, frac b) // Больше или равно вида e >= b
{
frac a (e);
return a >= b;
}
// Меньше или равно
bool operator <= (frac b) // Меньше или равно вида a <= b
{
return !(*this > b);
}
bool operator <= (int w) // Меньше или равно вида a <= w
{
frac b (w);
return *this <= b;
}
bool operator <= (double e) // Меньше или равно вида a <= e
{
frac b (e);
return *this <= b;
}
friend bool operator <= (int w, frac b) // Меньше или равно вида w <= b
{
frac a (w);
return a <= b;
}
friend bool operator <= (double e, frac b) // Меньше или равно вида e <= b
{
frac a (e);
Характеристики
Тип файла документ
Документы такого типа открываются такими программами, как Microsoft Office Word на компьютерах Windows, Apple Pages на компьютерах Mac, Open Office - бесплатная альтернатива на различных платформах, в том числе Linux. Наиболее простым и современным решением будут Google документы, так как открываются онлайн без скачивания прямо в браузере на любой платформе. Существуют российские качественные аналоги, например от Яндекса.
Будьте внимательны на мобильных устройствах, так как там используются упрощённый функционал даже в официальном приложении от Microsoft, поэтому для просмотра скачивайте PDF-версию. А если нужно редактировать файл, то используйте оригинальный файл.
Файлы такого типа обычно разбиты на страницы, а текст может быть форматированным (жирный, курсив, выбор шрифта, таблицы и т.п.), а также в него можно добавлять изображения. Формат идеально подходит для рефератов, докладов и РПЗ курсовых проектов, которые необходимо распечатать. Кстати перед печатью также сохраняйте файл в PDF, так как принтер может начудить со шрифтами.
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
