Код:
Лабораторная работа 1
"Простые типы данных. Элементарный ввод/вывод"
Цель работы: Изучение базовых простых типов языка С и функций
стандартной библиотеки для форматированного и неформатированного
ввода с консоли и вывода на консоль.
1. Напишите программу ввода в память с последующей печатью на
экране следующей информации о себе:
- фамилия и имя,
- дата рождения,
- место рождения.
2. Напишите программы перевода знаковых целых 4-х байтовых чисел:
а) из десятичной системы счисления в восьмеричную и
шестнадцатеричную;
б) из восьмеричной системы счисления в десятичную и
шестнадцатеричную;
в) из шестнадцатеричной системы счисления в восьмеричную и
десятичную;
Для выполнения задания используйте потоковый ввод-вывод.
3. Напишите программу ввода вещественного числа и вывода его
на экран в следующей форме:
- округленным до целого,
- в экспоненциальной форме с двумя знаками после запятой,
- с количеством знаков после запятой, задаваемым пользователем.
Контрольные вопросы
1. Какие простые типы данных существуют в языке С?
2. Какие типы данных для работы с целыми числами существуют в
языке С, в чем отличия между ними?
3. Какие типы данных для работы с вещественными числами
существуют в языке С, в чем отличия между ними?
4. Какие специальные символьные константы языка Вы знаете?
5. Как указывается система счисления для целых констант?
6. Как указывается спецификация формата для функций
форматированного ввода/вывода, какие существуют спецификации
формата?
7. Какие Вы знаете функции форматированного ввода/вывода?
8. Какие функции осуществляют неформатированный ввод/вывод?
9. Как в языке С хранят, вводят и выводят строки символов?
10. Что такое экспоненциальная запись вещественного числа и
как напечатать в этой форме число?
Лабораторная работа 2
"Операции и их приоритет. Операторы условия, цикла и
безусловной передачи управления"
Цель работы: Изучение операций языка С и их приоритета. Организация
вычислительного процесса с помощью операторов условия, цикла и
безусловной передачи управления.
Пример программы:
// Программа преобразует однобайтовое целое число из десятичной
// или шестнадцатеричной системы счисления в двоичную.
// Программа работает в диалоге с пользователем.
#include <iostream.h> // прототипы функций стандартной
// библиотеки
main()
{
unsigned char num; // переменная для преобразуемого числа
short i,j; // вспомогательные переменные
char binary[9]; // строка для вывода двоичного числа
char ch; // переменная для организации диалога с пользователем
for(;;) // бесконечный цикл
{
// вывод сообщения
cout<<"\n"
"Введите D, если будете вводить число в десятичной системе счисления\n"
"или H, если в шестнадцатеричной системе счисления.\n"
"Для выхода - E : ";
cin>>ch; // ввод символа
// анализ введенного символа
if(ch=='d' || ch=='D')
{
cout<<"\nЧисло :";
cin>>dec>>i; // ввод десятичнго числа
}
else if(ch=='h' || ch=='H')
{
cout<<"\nЧисло :";
cin>>hex>>i; // ввод шестнадцатеричного числа
}
else if(ch=='e' || ch=='E')
break; // выход из цикла
else
{ // предупреждающее сообщение и переход к началу цикла
cout<<"\nОшибочный ввод!\n";
continue;
}
// проверка правильности введенного числа
if(i<0 || i>255)
{ // предупреждающее сообщение и переход к началу цикла
cout<<"Введенное число не является беззнаковым целым"
"однобайтовым!\n";
continue;
}
else num=i;
// преобразование числа num в строку binary
for(i=0,j=128;i<8;i++)
{
// если бит установлен, записываем символ 1, иначе символ 0
binary[i]=(num&j) ? '1':'0';
j>>=1; // сдвигаем вправо на 1 разряд
}
binary[i]=0; // получаем Z-строку
// вывод результата преобразования
cout<<endl<<binary<<endl;
}
return 0;
}
Рабочее задание
1. Усовершенствуйте программу перевода целых чисел из одной
системы счисления в другую, создав удобный диалог с
пользовтелем и дополнив преобразованием двоичных чисел.
Программа преобразует из двоичной, или восьмеричной, или
десятичной, или шестнадцатеричной систем счисления во все
эти системы.
2. Напишите программу нахождения в массиве целых чисел
минимума и максимума. Содержимое массива задается
пользователем.
3. Напишите программу сортировки массива целых чисел по убыванию
и нахождения среднего значения элементов массива. Содержимое
массива задается пользователем.
Контрольные вопросы
1. Какие арифметические операции существуют в языке С?
2. Какие поразрядные логические операции существуют в языке С?
3. Какие операции отношения и логические операции Вы знаете?
4. Что определяет оператор sizeof?
5. Как явно преобразуются типы?
6. Каким образом можно получить адрес переменной?
7. Какие Вы знаете операторы управления вычислительным процессом?
8. Какие 3 типа циклов реализованы в языке?
9. Для чего предназначены операторы continue и break?
10. Как работает оператор множественного выбора switch?
Лабораторная работа 3
"Указатели и их связь с массивами. Функции. Модели памяти.Видимость
и время жизни переменных. Локальные и глобальные переменные"
Цель работы: Изучение указателей на данные и функции,
динамического отведения памяти, реализации функций, использования
моделей памяти. Изучение способов задания и использования локальных
и глобальных переменных.
Пример программы
// Программа заполняет массив однобайтовых целых чисел однобайтовыми
// псевдослучайными числами в диапазоне от 0 до 15. Размер массива
// задается пользователем в диапазоне от 1 до 10000. Для этого
// массива вычисляется и выводится на экран гистограмма частот
// появления чисел. По ключу H(h) с командной строки программа
// выводит на экран справочную информацию о себе
#include <iostream.h> // прототипы функций стандартной библиотеки
#include <iomanip.h>
#include <windows.h>
#include <stdlib.h>
// прототипы функций
void set_array(unsigned char *, unsigned);
unsigned * calc_hist(unsigned char *, unsigned, unsigned *);
void print_hist(unsigned *);
void clrscr()
{
HANDLE hConsole;
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
COORD coordScreen = { 0, 0 }; /* here's where we'll home the
cursor */
BOOL bSuccess;
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */
DWORD dwConSize; /* number of character cells in
the current buffer */
/* get the number of character cells in the current buffer */
bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
/* fill the entire screen with blanks */
bSuccess = FillConsoleOutputCharacter( hConsole, (TCHAR) ' ',
dwConSize, coordScreen, &cCharsWritten );
/* get the current text attribute */
bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
/* now set the buffer's attributes accordingly */
bSuccess = FillConsoleOutputAttribute( hConsole, csbi.wAttributes,
dwConSize, coordScreen, &cCharsWritten );
/* put the cursor at (0, 0) */
bSuccess = SetConsoleCursorPosition( hConsole, coordScreen );
return;
}
// главная функция
main(int argc,char **argv)
{
char *helpstr=
"Программа заполняет массив однобайтовых целых чисел\n"
"однобайтовыми псевдослучайными числами в диапазоне\n"
"от 0 до 15. Размер массива задается пользователем в диапазоне\n"
"от 1 до 10000. Для этого массива вычисляется и выводится на экран\n"
"гистограмма частот появления чисел.\n";
unsigned char *array; // указатель на массив данных
unsigned n; // размер массива
unsigned *hist; // указатель на массив-гистограмму
clrscr(); // очистка экрана
if(argc>1) // есть ли ключ в командной строке
// этот ключ h
if(argv[1][0]=='h' || argv[1][0]=='H')
{ // вывод справочной информации
cout<<helpstr;
return 0; // закончить программу
}
// ввод количества элементов массива
cout<<"\nВведите количество элементов массива\n";
cin>>n;
// проверка правильности ввода
if(n<1 || n>10000)
{ // сообщение об ошибке
cout<<"Неправильное количество элементов массива"<<n<<" !\n";
return 0; // закончить программу
}
// отведение памяти под массив данных
array=new(unsigned char[n]);
// проверка отведения памяти
if(array==NULL)
{ // сообщение об ошибке
cout<<"Ошибка отведения памяти!\n";
return 0; // закончить программу
}
// отведение памяти под массив-гистограмму и обнуление его
hist=new(unsigned[16]);
// проверка отведения памяти
if(hist==NULL)
{ // сообщение об ошибке
cout<<"Ошибка отведения памяти!\n";
delete(array);
return 0; // закончить программу
}
memset(hist, 0, sizeof(unsigned[16]));
// вызов функции заполнения массива псевдослучайными числами
set_array(array,n);
// вызов функции вычисления гистограммы
hist=calc_hist(array,n,hist);
// вызов функции печати гистограммы
print_hist(hist);
// освобождение памяти
delete(array);
delete(hist);
return 0;
}
// функция заполнения массива псевдослучайными числами
void set_array(unsigned char *data, unsigned size)
{
unsigned i;
unsigned char *ptr=data;
// заполнение массива
for(i=0;i<size;i++)
*ptr++=(char)(16.0*rand()/RAND_MAX);
}
// функция вычисления гистограммы
unsigned* calc_hist(unsigned char *data, unsigned size, unsigned *h)
{
unsigned i;
// вычисление гистограммы
for(i=0;i<size;i++)
h[data[i]]++;
return h; // возвращает указатель на массив-гистограмму
}
// функция печати гистограммы
// масштабирует на 40 символов
void print_hist(unsigned *h)
{
unsigned i,j,npos,maxh;
// нахождение максимума в массиве гистограмм
for(maxh=0,i=0;i<16;i++)
if(maxh<h[i]) maxh=h[i];
// вывод гистограммы на экран
for(i=0;i<16;i++)
{
cout<<setw(2)<<i<<":";
npos=40l*h[i]/maxh;
for(j=0;j<npos;j++) cout<<"*";
cout<<" "<<h[i]<<endl;
}
}
Рабочее задание
1. Напишите программу вывода на экран имени исполняемого модуля
и параметров, передаваемых в программу с командной строки.
2. Модернизируйте приведенный выше пример программы так, чтобы
значения гистограммы отображалось не длиной строки, а высотой
столбца. Опишите указатель на массив данных как глобальную
переменную. Функции вычисления и вывода гистограммы вынесите
в отдельный файл. Введите с помощью директивы #define константу,
задающую максимальное псевдослучайное число, записываемое в
массив.
Лабораторная работа 4
"Указатели, массивы и связные списки"
Цель работы: Изучение указателей на данные, динамического отведения
памяти и их использование для построения связных списков
Пример программы:
// Программа открывает для чтения файл, имя которого задано первым
// аргументом командной строки и создает файл, заданный вторым
// аргументом командной строки. После этого программа записывает
// все слова, встретившиеся в первом файле во второй файл.
// Каждое слово записывается с новой строки.
#include <iostream.h>
#include <fstream.h>
#include <ctype.h>
// Функция возвращает 1, если входной символ принадлежит русскому или
// латинскому алфавиту. Иначе возвращает 0.
int isletter(unsigned char ch)
{
if ((ch>='a' && ch<='z') || (ch>='A' && ch<='Z') ||
(ch>=(unsigned char)'А' && ch<=(unsigned char)'п') ||
(ch>=(unsigned char)'р' && ch<=(unsigned char)'ё'))
return 1;
else
return 0;
}
main(int argc,char **argv)
{
if(argc != 3) // в командной строке должно быть 3 параметра
{ // вывод справочной информации
cout<<"l4 from to";
return 1; // закончить программу
}
ifstream from(argv[1]); // открываем входной файл
if (!from)
{
cout<<"Не открывается входной файл :"<<argv[1]<<endl;
return 1;
}
ofstream to(argv[2]); // открываем выходной файл
if (!to)
{
cout<<"Не открывается выходной файл :"<<argv[2]<<endl;
return 1;
}
int ch; // переменная для хранения очередного символа
int isWord = 0; // Флаг, показывающий что предыдущий символ принадлежал
// русскому или латинскому алфавиту
while ((ch = from.get()) != EOF) // Цикл чтения и обработки очередного
// символа
{
if (isWord == 0)
{
if (isletter(ch))
{
isWord = 1;
to<<(char)ch; // запись в выходной файл очередной символ текущего слова
}
}
else
{
if (isletter(ch))
to<<(char)ch;
else
{
isWord = 0;
to<<endl; // переход на новую строку после очередного слова
}
}
}
return 0;
}
Рабочее задание
Напишите программу подсчета количества повторений всех слов,
встретившихся в файле, заданном первым аргументом командной
строки, и записи полученных результатов в файл, имя которого
задается вторым аргументом. Для ускорения работы программы
найденные слова необходимо хранить в отсортированном связном
списке.
Элемент связного списка может быть представлен структурой:
struct CLIST{
CLIST *next;
CLIST *prev;
char *word;
}
При обнаружении нового слова память под его хранение
выделяется с помощью оператора new, либо забирается часть
заранее выделенного массива:
char array[65536];
Лабораторная работа 5
"Реализация классов в языке С++. Объекты и методы."
Цель работы: Изучение базовых понятий объектно-ориентированного
проектирования и реализации классов в языке С++,
создание конструкторов и деструкторов класса,
перегрузка операторов. Изучение потоков ввода/вывода С++.
Пример программы:
// Программа реализует класс TIME, объектом которого является время.
// С помощью перегрузки операторов реализован ряд арифметических и
// логических операций работы со временем. Построение класса
// является типичным для принципов объектно-ориентированного
// программирования. Сами данные о времени скрыты и доступ к ним
// осуществляется только из функций класса или с помощью
// подставляемых (inline) методов GetHour, GetMin, GetSec.
// Для класса TIME реализованы 2 конструктора: один - конструктор
// по умолчанию без параметров присваивает членам-данным класса
// значение времени в системе, второй - получает количество часов,
// минут, секунд (0 по умолчанию). В перегруженных операторах
// иллюстрируется использование указателя this и передача параметров
// в функции по ссылке, в скрытой функции CountSec передача
// указателя на класс. Методы AssignSystemTime и Print явно
// объявлены как подставляемые. В функциях Print и Input показана
// простейшая работа с библиотеками классов потокового ввода/вывода
// (iostream). В функции main демонстрируется работа с классом TIME.
#include <iostream.h> // заголовочные файлы стандартных
#include <windows.h> // библиотек
#define TRUE 1 // макроопределения для BOOL
#define FALSE 0
#define MAX_HOUR 24 // максимальное количество часов
#define MAX_MINUTE 60 // максимальное количество минут
#define MAX_SEC 60 // максимальное количество секунд
// объявление класса для работы со временем
class TIME
{
private: // скрытый раздел
unsigned Hour; // часы
unsigned Min; // минуты
unsigned Sec; // секунды
// скрытые функции
long CountSec(TIME *);
TIME SecToHMS(long sec);
void getSystemTime();
public: // доступный раздел
TIME(); // конструктор без аргументов
// конструктор с целочисленными аргументами,
TIME(unsigned short hour,unsigned short min,
unsigned short sec=0);
// деструктор не выполняет ни каких действий
~TIME() { }
// функция получения количества часов
unsigned short GetHour() { return Hour; }
// функция получения количества минут
unsigned short GetMin() { return Min; }
// функция получения количества секунд
unsigned short GetSec() { return Sec; }
// функция присвоения определенного времени
short AssignTime(unsigned short hour,unsigned short min,
unsigned short sec=0);
// функция присвоения системного времени
void AssignSystemTime();
// функция печати времени
void Print();
// функция задания времени пользователем
void Input();
// перегрузка операторов
void operator = (TIME &); // присваивания значения
BOOL operator == (TIME &); // логического равенства
BOOL operator != (TIME &); // логического неравенства
BOOL operator > (TIME &); // логическое больше
BOOL operator < (TIME &); // логическое меньше
void operator +=(TIME &); // суммирования и присваивания значения
void operator +=(long); // суммирования и
// присваивания значения
void operator -=(TIME &); // вычитания и присваивания значения
void operator -=(long); // вычитания
// и присваивания значения
TIME operator -(TIME &); // вычитания
TIME operator +(TIME &); // суммирования
};
// конструктор без аргументов берет текущее время системы
TIME::TIME()
{
getSystemTime();
}
// конструктор с целочисленными аргументами,
// sec==0 по умолчанию
TIME::TIME(unsigned short hour,unsigned short min,
unsigned short sec)
{
// проверка правильности данных
if(hour<MAX_HOUR && min<MAX_MINUTE && sec<MAX_SEC)
{
Hour=hour; // часы
Min=min; // минуты
Sec=sec; // секунды
} // если ошибка в данных то берем системное время
else getSystemTime();
}
// функция задания времени,
// sec==0 по умолчанию
// возвращает 1 при попытке ошибочного присвоения
short TIME::AssignTime(unsigned short hour,unsigned short min,
unsigned short sec)
{
// проверка правильности данных
if(hour<MAX_HOUR && min<MAX_MINUTE && sec<MAX_SEC)
{
Hour=hour; // часы
Min=min; // минуты
Sec=sec; // секунды
return 0;
} // если ошибка в данных то берем системное время
getSystemTime();
return 1;
}
// функция определяет системное время и присваевает его
// переменным класса
void TIME::getSystemTime()
{
SYSTEMTIME t;
GetLocalTime(&t); // получаем системное время
Hour=t.wHour;
Min=t.wMinute;
Sec=t.wSecond;
}
// преобразование времени в количество секунд
// получает указатель на класс TIME
long TIME::CountSec(TIME *t)
{
return (long)t->Hour*MAX_MINUTE*MAX_SEC+t->Min*MAX_SEC+t->Sec;
}
// преобразование количества секунд в часы, минуты, секунды
// и запись часов, минут и секунд в переменные класса
TIME TIME::SecToHMS(long sec)
{
TIME tmp;
// нормализация, если количество секунд отрицательное
while(sec<0l) sec=MAX_HOUR*MAX_MINUTE*MAX_SEC+sec;
do {
tmp.Hour=sec/(MAX_MINUTE*MAX_SEC);
sec-=tmp.Hour*(MAX_MINUTE*MAX_SEC);
} while(tmp.Hour>MAX_HOUR);
tmp.Min=sec/(MAX_SEC);
sec-=tmp.Min*(MAX_SEC);
tmp.Sec=sec;
return tmp;
}
// функция определяет системное время и присваевает его
// переменным класса
// функция реализована как подставляемая (inline)
inline void TIME::AssignSystemTime()
{
getSystemTime();
}
// функция печати времени
// функция реализована как подставляемая (inline)
inline void TIME::Print()
{
cout<<Hour<<":"<<Min<<":"<<Sec<<endl;
}
// функция задания времени пользователем
void TIME::Input()
{
// вводим часы с контролем ошибки
do { cout<<"\nHour: ";
cin>>Hour;
} while(Hour>=MAX_HOUR);
// вводим минуты с контролем ошибки
do { cout<<"\nMin: ";
cin>>Min;
} while(Min>=MAX_MINUTE);
// вводим секунды с контролем ошибки
do { cout<<"\nSec: ";
cin>>Sec;
} while(Sec>=MAX_SEC);
}
// перегруженный оператор присваивания значения
void TIME::operator = (TIME &t)
{
if(this==&t) return; // попытка присвоить самого себя
Hour=t.Hour; // присваивание
Min=t.Min;
Sec=t.Sec;
}
// перегруженный оператор логического равенства
BOOL TIME::operator == (TIME &t)
{
if(this==&t) return TRUE; // сам себе равен
// проверяем равенство
return (Hour==t.Hour && Min==t.Min && Sec==t.Sec);
}
// перегруженный оператор логического равенства
BOOL TIME::operator != (TIME &t)
{
if(this==&t) return FALSE; // сам себе равен
// проверяем неравенство
return (Hour!=t.Hour || Min!=t.Min || Sec!=t.Sec);
}
// перегруженный оператор логическое больше
BOOL TIME::operator > (TIME &t)
{
if(this==&t) return FALSE; // сам себе равен
// определяем, какое время больше
if(Hour>t.Hour) return TRUE; // сравниваем часы
else if(Hour<t.Hour) return FALSE;
else // часы равны
{
if(Min>t.Min) return TRUE; // сравниваем минуты
else if(Min<t.Min) return FALSE;
else // минуты равны
{
if(Sec>t.Sec) return TRUE; // сравниваем секунды
else return FALSE;
}
}
}
// перегруженный оператор логическое меньше
BOOL TIME::operator < (TIME &t)
{
if(this==&t) return FALSE; // сам себе равен
// определяем, какое время больше
if(Hour<t.Hour) return TRUE; // сравниваем часы
else if(Hour>t.Hour) return FALSE;
else // часы равны
{
if(Min<t.Min) return TRUE; // сравниваем минуты
else if(Min>t.Min) return FALSE;
else // минуты равны
{
if(Sec<t.Sec) return TRUE; // сравниваем секунды
else return FALSE;
}
}
}
// перегруженный оператор суммирования и присваивания значения
// прибавляется часы, минуты и секунды
void TIME::operator += (TIME &t)
{
*this=SecToHMS( CountSec(this) + CountSec(&t) );
}
// перегруженный оператор суммирования и присваивания значения
// прибавляется количество секунд
void TIME::operator += (long sec)
{
*this=SecToHMS( CountSec(this) + sec );
}
// перегруженный оператор вычитания и присваивания значения
void TIME::operator -= (TIME &t)
{
*this=SecToHMS( CountSec(this) - CountSec(&t) );
}
// перегруженный оператор вычитания и присваивания значения
// вычитает количество секунд
void TIME::operator -= (long sec)
{
*this=SecToHMS( CountSec(this) - sec );
}
// перегруженный оператор вычитания
// результат часы, минуты, секунды
TIME TIME::operator - (TIME &t)
{
return SecToHMS( CountSec(this) - CountSec(&t) );
}
// перегруженный оператор сложения
TIME TIME::operator + (TIME &t)
{
return SecToHMS( CountSec(this) + CountSec(&t) );
}
// пример использования класса TIME
void main()
{
TIME t1; // объявление класса TIME: вызывается конструктор
// без аргументов
TIME t3(10,20); // объявление класса TIME: вызывается конструктор
// с аргументами, секунды по уолчанию == 0
TIME t4(5,15,30),t5(5,16,31); // объявление 2-х классов TIME:
// вызываются конструкторы с аргументами
TIME *t2=new TIME; // объявление указателя на класс TIME и
// отведение памяти под класс, после отведения памяти
// вызывается конструктор без аргументов
TIME *t6; // объявление указателя на класс TIME
t6=new TIME(23,5,18); // отведение памяти под класс,
// после отведения памяти
// вызывается конструктор с аргументами
// проверка отведения памяти под класс, на который указывает t6
if(t6==NULL)
{
cerr<<"Ошибка выделения памяти!"<<endl;
return;
}
// печать начальных значений переменных
cout<<endl<<"Начальные значения переменных:"<<endl;
t1.Print(); t2->Print(); // напечатает системное время
t3.Print(); // напечатает 10:20:0
t4.Print(); // напечатает 5:15:30
t5.Print(); // напечатает 5:16:31
t6->Print(); // напечатает 23:5:18
// арифметические действия с переменными
t1=t5-t4;
cout<<"t1=t5-t4 : "; t1.Print();
*t2=t3+t4;
cout<<"t2=t3+t4 : "; t2->Print();
*t6-=t3;
cout<<"t6-=t3 : "; t6->Print();
t5+=*t2;
cout<<"t5+=t2 : "; t5.Print();
*t6+=42L;
cout<<"t6+=42 : "; t6->Print();
t5-=1L;
cout<<"t5-=1 : "; t5.Print();
// ввод значений переменных пользователем
cout<<"Введите время"<<endl;
t1.Input(); t1.Print();
t2->AssignTime(12,0); // присвоение времени - полдень
t2->Print();
// логические операции
if(t1==*t2)
cout<<"Введенное время - полдень."<<endl;
else if(t1>*t2)
cout<<"Введенное время больше полудня."<<endl;
else
cout<<"Введенное время меньше полудня."<<endl;
t3.AssignSystemTime(); // присвоение времени равного
// текущему системному времени
cout<<"Текущее время в системе:";
t3.Print();
if(t3>t1)
cout<<"Введенное время меньше текущего."<<endl;
else if(t3<t1)
cout<<"Введенное время больше текущего."<<endl;
else
cout<<"Введенное время равно текущему."<<endl;
// печать количества часов
cout<<"Количество часов текущего времени : "<<t3.GetHour();
delete t2; // освобождение памяти
delete t6;
}
Рабочее задание
1. Создайте класс для работы с одномерными массивами
вещественных чисел. Массив имеет произвольную (отличную
от 0) нижнюю и произвольную верхнюю границу. Класс
контролирует правильность обращения к элементам массива
(выход за границу массива). Напишите тестовую программу с
использованием реализованного класса. При попытке записи
или чтения за границами массива должно генерироваться
исключение.
2. Создать класс, объектами которого являются даты.
Для этого класса реализовать следующие методы:
- сравнение дат,
- определение суммы двух дат,
- определение результирующей даты, если к дате прибавить
(или отнять) несколько дней.
- определение количества дней в определенном месяце,
- определение дня недели по дате,
- получение текущей даты,
- задание даты пользователем,
- печать даты.
Ряд методов целесообразно реализовать перегрузкой операторов.
Напишите тестовую программу с использованием методов
реализованного класса для проверки их правильности.
Контрольные вопросы
1. Какими основными свойствами характеризуются объектно-
ориентированные языки программирования?
2. Что такое объекты и методы?
3. Каким образом описываются классы?
4. Что такое конструктор и деструктор класса и когда они
вызываются?
5. Как ограничить видимость для членов класса?
6. Что означает ключевое слово this?
7. Какие операторы в С++ динамически выделяют и освобождают
память?
8. Что такое inline-подстановка?
9. Как и для каких целей осуществляется перегрузка операторов?
10. Какие операторы можно перегружать?
Лабораторная работа 6
Перегрузка операторов в языке C++
// Пример программы, вычисляющей сумму, разность и факториал
// двух чисел
#include <iostream.h>
class MyInt
{
int i;
public:
MyInt(int n = 0) {i = n;}
operator int() {return i;}
};
inline istream& operator>> (istream& s, MyInt& i)
{
int j;
cin>>j;
i = j;
return s;
}
int factorial(int n)
{
if (n <= 0)
return 0;
if (n == 1)
return 1;
return n*factorial(n-1);
}
int main()
{
char str[20];
do
{
cout<<"1 Сложение\n";
cout<<"2 Вычитание\n";
cout<<"3 Вычисление факториала\n";
cout<<"4 Выход\n";
cout<<"Выберите действие > ";
cin>>str;
if (str[1] != 0)
cout<<"Неверный ввод\n";
else
if (str[0] == '4')
break;
switch (str[0])
{
case '1':
case '2':
{
MyInt a, b;
cout<<"Введите число a > ";
cin>>a;
cout<<"Введите число b > ";
cin>>b;
if (str[0] == '1')
cout<<"a+b="<<a+b<<endl;
else
cout<<"a-b="<<a-b<<endl;
break;
}
case '3':
{
MyInt a;
cout<<"Введите число a > ";
cin>>a;
cout<<"Факториал a равен "<<factorial(a)<<endl;
break;
}
default:
cout<<"Неверный ввод\n";
}
}while(1);
return 0;
}
Рабочее задание
1. Модернизируйте функцию factorial так, чтобы она не была
рекурсивной.
2. Измените класс MyInt так, чтобы программа работала с числами
разрядностью 80 бит (например вычислялся бы факториал 24)
без изменения функции main.
