Типы данных, определённые программистом
Цель работы: Получение навыков в создании новых типов данных и определении множества операций над ними.
Домашнее задание.
Изучить материал по темам: конструкторы, деструкторы и доступность компонентов класса; компонентные данные и компонентные функции; друзья классов; расширение действия стандартных операций; шаблоны классов.
Лабораторное задание
1. Набрать и отладить программу №1
//Программа №1
#include "stdafx.h" //pch.h
#include <string.h>
#include <iostream>
#include <MATH.H>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
// class Matr
//-------------------------------------------------------------------
template <class T>
class Matr
{
long line;
long col;
T ** matr;
public:
virtual ~Matr(); //Деструктор
Matr(long l, long c); // Конструктор
Matr():line(0), col(0), matr(NULL) {} //Конструктор по умолчанию
T * operator[](long i) { return matr[i]; }
template <class T>
friend Matr<T> operator*(Matr<T>& A, Matr<T>& B);
template <class T>
|
|
friend Matr<T> operator*(double K, const Matr<T>& A);
Matr<T> operator+(const Matr<T>& A);
Matr<T> operator-(const Matr<T> A);
void display();
//семантика копирования
Matr(const Matr<T>& A); //Конструктор копии
const Matr<T>& operator=(const Matr<T>& A);
//семантика перемещения
Matr(Matr<T>&& A); //Конструктор переноса
const Matr<T>& operator=(Matr<T>&& A);
};
//
//-----------------------------------------------------------------
template <class T>
const Matr<T>& Matr<T>::operator=(Matr<T>&& A)
{
std::swap(matr, A.matr);
std::swap(line, A.line);
std::swap(col, A.col);
// cout << " \n operator perenos =";
return *this;
}
// Matr<T>::Matr()
//-------------------------------------------------------------------
template <class T>
Matr<T>::Matr(Matr<T>&& A): matr(A.matr), line(A.line),col(A.col)
{
A.matr = nullptr;
A.line = 0;
A.col = 0;
// cout << "\n Konstr perenos";
}
// Matr<T>::Matr()
//-------------------------------------------------------------------
template <class T>
Matr<T>::Matr(long l1, long col1)
{
line = l1;
col = col1;
matr = new T*[line];
if (matr == NULL) cout << "Out of memory";
for (int i = 0; i < line; i++) {
matr[i] = new T[col];
if (matr[i] == NULL) cout << "Out of memory";
}
// cout << "\n konstructor matr =" <<(unsigned long)matr;
}
// Matr<T>::Matr(Matr<T>& A)
//-------------------------------------------------------------------
template <class T>
Matr<T>::Matr(const Matr<T>& A):line(A.line), col(A.col)
{
matr = new T*[line];
if (matr == NULL) cout << "Out of memory";
for (int i = 0; i < line; i++) {
matr[i] = new T[col];
if (matr[i] == NULL) cout << "Out of memory";
}
for (long j = 0; j<line; j++) {
for (int i = 0; i<col; i++) {
matr[j][i] = A.matr[j][i];
}
}
// std::cout << "\n konstr copy matr = "<<(unsigned long)matr;
|
|
}
// Matr<T>::~Matr()
//-------------------------------------------------------------------
template <class T>
Matr<T>::~Matr()
{
for (int i = 0; i < line; i++) delete matr[i];
delete matr;
// cout << "\n Destructor matr = "<<(unsigned long) matr;
}
// void display(const Matr<T>& A)
//-------------------------------------------------------------------
template <class T>
void Matr<T>::display() {
cout << "\n";
for (int i = 0; i<line;i++) {
cout << "\n";
for (int j = 0; j < col; j++)
cout << matr[i][j] << "\t";
}
}
// Matr<T>::operator*()
//-------------------------------------------------------------------
template <class T>
Matr<T> operator*(Matr<T>& A, Matr<T>& B)
{
if (!(A.col == B.line)) cout << "\n A*B A.col!= B.line";
Matr<T> arMatr(A.line, B.col);
long l1 = A.line;
long col1 = A.col;
long col2 = B.col;
for (long i = 0; i < l1; i++) {
for (long j = 0; j < col2; j++) {
arMatr[i][j] = 0;
for (long k = 0; k < col1; k++) {
arMatr[i][j] += A[i][k] * B[k][j];
}
}
}
return arMatr;
}
// Matr::operator=()
//-------------------------------------------------------------------
template <class T>
const Matr<T>& Matr<T>::operator=(const Matr<T>& A)
{
if (this == &A) return *this;
line = A.line;
col = A.col;
for (long i = 0; i<A.line; i++) {
for (long j = 0; j<A.col; j++) {
matr[i][j] = A.matr[i][j];
}
}
// cout << "\n operator =";
return *this;
}
// Matr<T>::operator*()
//-------------------------------------------------------------------
template <class T>
Matr<T> operator*(double K, const Matr<T>& A)
{
Matr<T> M(A.line, A.col);
for (long i = 0; i<A.line; i++) {
for (long j = 0; j<A.col; j++) {
M.matr[i][j] = K * A.matr[i][j];
}
}
return M;
}
// Matr<T>::operator+()
//-------------------------------------------------------------------
template <class T>
Matr<T> Matr<T>::operator+(const Matr<T>& B)
{
if (this->line!= B.line || this->col!= B.col) {
cout << "\n A!= B";
Matr<T> M(0, 0);
return M;
}
Matr<T> M(B.line, B.col);
for (long i = 0; i<B.line; i++) {
for (long j = 0; j<B.col; j++) {
M.matr[i][j] = this->matr[i][j] + B.matr[i][j];
}
}
return M;
}
// Matr<T>::operator-()
//-------------------------------------------------------------------
template <class T>
Matr<T> Matr<T>::operator-(const Matr<T> A)
{
if (line!= A.line) {
cout << "\n - no A.line = B.line";
Matr<T> M(0, 0);
return M;
}
if (col!= A.col) {
cout << "\n - no A.line = B.line";
Matr<T> M(0, 0);
return M;
}
Matr<T> M(A.line, A.col);
for (long i = 0; i<A.line; i++) {
for (long j = 0; j<A.col; j++) {
M.matr[i][j] = matr[i][j] - A.matr[i][j];
}
}
return M;
}
// TMatr()
//-------------------------------------------------------------------
template <class T>
Matr<T> TMatr(Matr<T>& M) {
Matr<T> TM(M.col, M.line);
for (int i = 0; i < M.line; i++)
for (int j = 0; j < M.col; j++)
TM[j][i] = M[i][j];
return TM;
}
void main() {
Matr<double> A(2, 2), B(2, 2);
A[0][0] = A[0][1] = A[1][0] = A[1][1] = 1;
B[0][0] = B[0][1] = B[1][0] = B[1][1] = 2;
A.display();
B.display();
B = (2.5*A - A + B)*B;
B.display();
B = A;
B.display();
getchar();
}
2. В каждую компонентную функцию вставить строку программы, печатающую, что именно эта компонентная функция вызвана. (В конструктор, например, вставить строку cout<<"\n Это конструктор.";) и объяснить последовательность вызовов компонентных функций при выполнении main().
3. До определить множество операций над матрицами, т.е. написать компонентные функции, реализующие операции ==,!=, >, <, A * const, cout<<A. Считать, что матрица А > матрицы В, если max |aij |> max |bij|; i = 1,…,N; j = 1, …, M.
4. Определить новый тип данных, комплексное число, и множество операций над ним.
5. Написать отчет.
Содержание отчета
5. Титульный лист отчета должен содержать название, цель лабораторной работы, группу и фамилию студента, выполнившего её, и фамилию преподавателя, проверившего отчет.
|
|
6. Выполненное домашнее задание.
7. Тексты программ, написанных при выполнении 3 и 4 пунктов лабораторного задания.
Контрольные вопросы.
1. Для чего используется конструктор копии? В каких случаях наличие конструктора копии в классе обязательно, для правильной работы программы, а в каких нет?
2. Как работает компонентная функция operator=? В каких случаях наличие компонентной функции operator= в классе обязательно, для правильной работы программы, а в каких нет?
3. Конструктор преобразования типа. Приведите примеры явного и неявного вызова конструктора преобразования типа для класса комплексное число.
4. Перегрузка операций. Запишите множество перегружаемых и не перегружаемых операций языка С++. Расскажите о свойствах перегруженных операций.
5. Напишите класс vector (вектор) и определите над ним множество операций { +, -, ==, =,!=, скалярное произведение}.
6. Напишите класс str (строка) и определите над ним множество операций { +, -, ==, =,!=, <, >}.
7. Напишите класс круг и определите над ним множество операций {==,!=, <,> } (по площади).
8. Напишите класс квадрат и определите над ним множество операций {==,!=, <,> } (по площади).
9. Напишите класс список, обеспечивающий: вставку, удаление, доступ к элементу в списке.
10. Деструктор, его назначение и сигнатура.
11. Добавьте в класс Matr статическую компонентную функцию и статическое поле данных, в котором хранится количество объектов типа Matr.
12. Напишите компонентные функции, обеспечивающие сохранение и восстановление объекта типа Matr из файла.
13. В чем состоит идея инкапсуляции данных? В чем её основное достоинство? С помощью каких средств языка С++ она реализуется в программе? Приведите примеры класса, написанного с инкапсулированными данными и нет.