Рекомендация: прочитайте задачу! Выполните ее и сравните полученный результат с картинкой CMD
Если вы полностью уверены что не можете осилить эту задачу, советую вам просмотреть код и полностью в нем разобраться! Протестировать все в отладчике!
Создайте класс для работы с матрицами.Предусмотреть,как минимум,функции:сложение матриц
умножение матриц
транспонирования матриц
получение произвольного элемента матрицы и установка.
#include <iostream>
#include <time.h>
using namespace std;
#define STOP_CMD system("pause");
#define COLOR_CMD system("color 0A");
class Matrix
{
public:
Matrix() :arr(nullptr), row(0), col(0) {}
Matrix(int r, int c);
~Matrix();
void show() { // SHOW
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++)
cout << arr[i][j] << " ";
cout << endl;
}
cout << endl;
}
void transpose() //transpose
{
int t;
for (int i = 0; i < this->row; ++i)
{
for (int j = i; j < this->col; ++j)
{
t = this->arr[i][j];
this->arr[i][j] = this->arr[j][i];
this->arr[j][i] = t;
}
}
}
void Rand_Matrix(int max, int min) { // RAND MATRIX
for (size_t i = 0; i < row; i++)
for (size_t j = 0; j < col; j++)
arr[i][j] = min + (rand() % max - min);
}
int Get_Element(int row, int col) { // GET ELEMENT
for (size_t i = 0; i < this->row; i++) {
for (size_t j = 0; j < this->col; j++)
if (i == row && j == col)
return arr[i][j];
}
}
void Set_Element(int row, int col, int Element) { // GET ELEMENT
for (size_t i = 0; i < this->row; i++) {
for (size_t j = 0; j < this->col; j++)
if (i == row && j == col)
arr[i][j] = Element;
}
}
int ** operator + (Matrix & ob) { // overload +
for (size_t i = 0; i < this->row; i++) {
for (size_t j = 0; j < this->col; j++)
this->arr[i][j] = this->arr[i][j] + ob.arr[i][j];
}
return arr;
}
int ** operator * (Matrix & ob) { // overload *
for (size_t i = 0; i < this->row; i++) {
for (size_t j = 0; j < this->col; j++)
this->arr[i][j] = this->arr[i][j] * ob.arr[i][j];
}
return arr;
}
private:
int row, col;
int ** arr;
};
Matrix::Matrix(int r, int c)
{
this->row = r;
this->col = c;
arr = new int *[row]();
for (int i = 0; i < row; i++)
arr[i] = new int [col]();
}
Matrix::~Matrix()
{
for (int i = 0; i < row; i++)
delete[] arr[i];
delete[] arr;
}
int main() {
COLOR_CMD
srand(time(NULL));
Matrix matrix(10, 10), matrix1(10, 10);
//-----------------------------------------
cout << "Demontration matrix" << endl;
matrix.Rand_Matrix(10, 1);
matrix.show();
cout << endl;
cout << "Demontration matrix1" << endl;
matrix1.Rand_Matrix(10, 1);
matrix1.show();
cout << endl;
//-----------------------------------------
// show overload operator +
//-----------------------------------------
cout << "Demontration matrix + matrix1" << endl;
matrix + matrix1;
matrix.show();
cout << endl;
//-----------------------------------------
// show overload operator *
//-----------------------------------------
cout << "Demontration matrix * matrix1" << endl;
matrix * matrix1;
matrix.show();
cout << endl;
//-----------------------------------------
// show transpose matrix
//-----------------------------------------
cout << "Demontration transpose matrix * matrix1" << endl;
matrix.transpose();
matrix.show();
cout << endl;
//-----------------------------------------
// show Get_Element matrix
//-----------------------------------------
int Element = matrix.Get_Element(5, 5);
cout << "Element = " << Element << endl;
//-----------------------------------------
// show Set_Element matrix
//-----------------------------------------
matrix.Set_Element(5, 5, 99);
cout << "SHOW MATRIX [i] = 5 [j] = 5 ELEMENT = 99" << endl;
matrix.show();
cout << endl;
STOP_CMD
return 0;
}
#include <iostream>
#include <string>
using namespace std;
#define SYSTEM_COLOR system("color 0A");
#define SYSTEM_STOP system("pause");
class Time
{
public:
Time() :minutes(0), hours(0) {}
Time(int h, int m);
void show() {
cout << hours << ":" << minutes << endl;
}
void Set_Hours(int h) {
if (h <= 12 && h >= 0 || h <= 24 && h >= 0)
this->hours = h;
else
cout << "ERRO INPUT hours" << endl;
}
int Get_Hours() {
return this->hours;
}
void Set_Minutes(int m) { //Method Conversion
if (m <= 60 && m >= 0) this->minutes = m;
else
cout << "ERRO INPUT minutes" << endl;
}
int Get_Minutes() {
return this->minutes;
}
void Convertion(int h) {
switch (h)
{
case 0: {
this->hours = 12;
break;
}
case 1: {
this->hours = 13;
break;
}
case 2: {
this->hours = 14;
break;
}
case 3: {
this->hours = 15;
break;
}
case 4: {
this->hours = 16;
break;
}
case 5: {
this->hours = 17;
break;
}
case 6: {
this->hours = 18;
break;
}
case 7: {
this->hours = 19;
break;
}
case 8: {
this->hours = 20;
break;
}
case 9: {
this->hours = 21;
break;
}
case 10: {
this->hours = 22;
break;
case 11: {
this->hours = 23;
break;
}
case 12: {
this->hours = 24;
break;
}
}
default:
break;
}
}
Time operator+(const Time &ob) { // Overload operator +
return Time(this->hours + ob.hours, this->minutes + ob.minutes);
}
Time operator-(const Time &ob) { // Overload operator -
return Time(this->hours - ob.hours, this->minutes - ob.minutes);
}
bool operator==(const Time &ob) { // Overload operator ==
if(this->hours == ob.hours && this->minutes == ob.minutes)
return true;
else
return false;
}
private:
int minutes;
int hours;
};
Time::Time(int h, int m) {
this->hours = h;
this->minutes = m;
}
int main() {
SYSTEM_COLOR
Time time1(10, 52), time2(05, 12), result;
time1.show();
time2.show();
//--------------------------------
// show Operators overloads +
//--------------------------------
result = time1 + time2;
result.show();
//--------------------------------
// show Operators overloads -
//--------------------------------
result = time1 - time2;
result.show();
//--------------------------------
// show Operators overloads ==
//--------------------------------
Time time3(10, 50), time4(10, 50);
bool result1;
result1 = time3 == time4;
cout << "Result [operator==] = " << result1 << endl;
//--------------------------------
// show Operators convertion
//--------------------------------
Time time5(9, 52);
time5.Convertion(9);
time5.show();
SYSTEM_STOP
return 0;
}
#include <iostream>
#include <time.h>
#include <string>
using namespace std;
#define STOP_SYSTEM system("pause");
#define SYSTEM_COLOR system("color 0A");
class Array
{
public:
Array() :size(0), arr(nullptr) { cout << "CONSTRUCTOR DEFAULT WORK!" << endl; STOP_SYSTEM }
Array(int s);
~Array();
Array(const Array &ob);
void Set_Size(int s) { this->size = s; }
int Get_Size() { return size; }
void show() {
for (size_t i = 0; i < size; i++)
{
cout << *(arr + i) << "\t";
}
cout << endl;
}
void Rand_Array(int max, int min) { // RAND ARRAY
srand(time(NULL));
for (int i = 0; i < size; i++)
arr[i] = min + rand() % (max - min);
}
int & operator[](int s) { // Overload []
return arr[s];
}
void operator+(Array & r){ // Overload +
for(int i = 0; i < this->size; i++)
this->arr[i] + r.arr[i];
}
void operator-(Array & r) { // Overload -
for (int i = 0; i < this->size; i++)
this->arr[i] - r.arr[i];
}
void operator=(Array & r) { // Overload =
Array tmp;
for (int i = 0; i < this->size; i++)
tmp.arr[i] = r.arr[i];
}
Array & operator++(int) { // Overload ++
this->size++;
int * buf = new int[this->size]();
for (size_t i = 0; i < size - 1; i++)
{
buf[i] = this->arr[i];
if (i == size - 2)
buf[i + 1] = 99; // ADD NUMBER 99 in END ARRAY
}
cout << endl;
cout << endl;
this->arr = new int[this->size]();
for (size_t i = 0; i < size; i++)
{
this->arr[i] = buf[i];
}
delete[] buf;
return *this;
}
Array & operator--(int) { // Overload ++
this->size--;
int * buf = new int[this->size];
for (size_t i = 0; i < this->size; i++)
{
buf[i] = this->arr[i];
}
if(this->arr != nullptr)
delete[] this->arr;
this->arr = new int[this->size]();
for (size_t i = 0; i < this->size; i++)
{
this->arr[i] = buf[i];
}
delete[] buf;
return *this;
}
private:
int size;
int * arr;
};
Array::Array(int s)
{
cout << "CONSTRUCTOR WITH PARAMETRS WORK!" << endl;
STOP_SYSTEM
this->size = s;
arr = new int[size]();
}
Array::~Array()
{
cout << "DESTRUCTOR WORK! adress = " << this << endl;
STOP_SYSTEM
delete[] arr;
arr = nullptr;
}
Array::Array(const Array &ob) { // CONSTRUCTOR COPY
cout << "CONSTRUCTOR COPY WORK!" << endl;
STOP_SYSTEM
this->size = ob.size;
this->arr = new int[ob.size];
for (int i = 0; i < ob.size; i++)
{
this->arr[i] = ob.arr[i];
}
}
int main() {
SYSTEM_COLOR
int SIZE = 25;
//----------------------------------
// show overload operators []
//----------------------------------
Array arr(SIZE);
arr.Rand_Array(10, 1);
arr.show();
//----------------------------------
// show overload operators +
//----------------------------------
cout << endl;
Array arr1(SIZE);
arr1.Rand_Array(10, 1);
arr1.show();
//----------------------------------
// show overload operators =
//----------------------------------
cout << endl;
Array result(SIZE);
for(int i = 0; i < SIZE; i++)
result[i] = arr[i] + arr1[i];
result.show();
//------------------------------------------------------
// show overload operators ++ ADD in END ARRAY NUMBER 99
//------------------------------------------------------
cout << endl;
result++;
result.show();
//----------------------------------
// show overload operators --
//----------------------------------
cout << endl;
result--;
result.show();
cout << endl;
STOP_SYSTEM
return 0;
}
Демонстрация класса Test
Демонстрация класса на тему friend static и перегрузка операторов
//-------------------------------------------
/*Автор Домбровский Игорь Владимирович*/
//-------------------------------------------
//Демонстрация класса на тему friend static и перегрузка операторов
#include <iostream> // Подключить библиотеку iostream ввода и вывода
using namespace std; // Пространство имен std
#define STOP_CMD system("pause"); // Константа поставить консоль на паузу
#define COLOR_CMD system("color 0A"); // Константа покрасить консольный шрифт в зеленый
class Test // Учебный Класс Test
{
public: // Открытое поле
static int a; // Переменная static
//------------------------------------------------
Test():x(0), y(0){} // Конструктор по умолчанию
Test(int x, int y);
~Test(); // Деструктор
//------------------------------------------------
friend void Method_Friend(Test & ob); // Дружественная функция можно обращаться через обьект класса к полям private
//------------------------------------------------
int & operator++(int tmp) { // Перегрузка оператора ++
this->x++;
this->y++;
return tmp;
}
int & operator--(int tmp) { // перегрузка оператора --
this->x--;
this->y--;
return tmp;
}
void Set_X(int x) { this->x = x; } //Метод SET X Установить значение x
int Get_X() { return x; } //Метод GET X Получить значение x
void Set_Y(int y) { this->y = y; } //Метод SET Y Установить значение y
int Get_Y() { return y; } //Метод GET Y Получить значение y
void Set_A(int a) { this->a = a; } //Метод SET A Установить значение a static переменная
int Get_A() { return a; } //Метод GET A Получить значение a static переменная
//------------------------------------------------
void show() { // Метод show показ элементов на экран
cout << "x = " << x << " y = " << y << " static a = " << Test::a << endl; // Вывод на экран переменных (x, y)
}
//------------------------------------------------
private: // Закрытое поле
int x;
int y;
};
//---------------------------------------------------------------------
int Test::a = 0; // Инициализация переменной a с ключевым словом static
//---------------------------------------------------------------------
Test::Test(int x, int y) // конструктор с параметрами
{
this->x = x; // Демонстрация указателя this Присвоим именно той переменной x та что в private а не в конструкторе.
this->y = y; // Демонстрация указателя this Присвоим именно той переменной y та что в private а не в конструкторе.
}
Test::~Test() // Демонстрация деструктора
{
cout << "Work Destructor = " << this << endl; // Указатель this покажет текущий адрес
STOP_CMD
}
Test & Plus_One(Test & ob) { // Демонстрация перегрузки оператора ++
ob++;
return ob;
}
Test & Minus_One(Test & ob) { // Демонстрация перегрузки оператора --
ob--;
return ob;
}
void Method_Friend(Test & ob) { // Есть прототип friend мы можем обращаться к полям private
ob.x *= ob.x;
ob.y *= ob.y;
}
//void Method_Friend1(Test & ob) { // Обычная функция без прототипа friend - Это ошибка!!!
// ob.x *= ob.x; // У нас нет прав добраться к полям private!
// ob.y *= ob.y;
//}
int main() { // Открыть скобку главной функции main
COLOR_CMD // Сделаем не большу красоту Константа красит консоль в зеленый а точнее ее шрифт!
Test ob(20, 10); // Создание обьекта и вызов конструктора с параметрами для передачи ему int x = 20, int y = 10
ob.show(); // Демонстрация x и y на экран через обьект класса вызов метода show тот же вывод x, y
Plus_One(ob); // Демонстрация перегрузки оператора инкермента Прибавить одним движением руки у (x и y) еденицу
ob.show(); // Демонстрация x и y на экран через обьект класса вызов метода show тот же вывод x, y
Minus_One(ob); // Демонстрация перегрузки оператора инкермента Отнять одним движением руки у (x и y) еденицу
ob.show(); // Демонстрация x и y на экран через обьект класса вызов метода show тот же вывод x, y
/*Демонстрация переменной static*/
//--------------------------------
Test ob1;
ob1.a = 55; // Переменной a присвоим значение 55
ob1.show(); // Вывод через ob1
ob.a = 25; // Через другой обьект переменной а с ключевым словом static присвоим 25
ob.show(); // вывод через ob
ob1.show(); // Вывод через ob1 и видим что переменная а уже не 55! Это демонстрация static!!!
ob1.Set_A(54); // Установим значение переменной static a = 54 через обьект класса ob1
ob.show(); // Вывод переменной static a через обьект класса ob и получаем через другой обьект уже 54!
//--------------------------------
/*Демонстрация с обычной переменной без ключевого слова static*/
ob.Set_X(125); // Через обьект класса ob присвоим переменной x значение 125
ob.show(); // Через обьект класса ob вызовим метод show в котором мы видим что переменная x = 125
ob1.show(); // Через обьект класса ob1 вызовим метод show и видем что переменная x = 0
//--------------------------------
STOP_CMD // Константа которая ставит на паузу консоль пока мы не нажмем любую клавишу
return 0; // Вернуть 0 и сказать что программа завершена успешно!
} // Закрыть скобку главной функции main
Демонстрация Перегрузки операторов ввода и вывода а так же повысим безопасность нашего класса с помощью статика
//-------------------------------------------
/*Автор Домбровский Игорь Владимирович*/
//-------------------------------------------
//-----------------------------------------------------------------------------------------------------------------
//Демонстрация Перегрузки операторов ввода и вывода а так же повысим безопасность нашего класса с помощью статика
//-----------------------------------------------------------------------------------------------------------------
#include <iostream>
#include <string>
using namespace std;
#define STOP_CMD system("pause");
#define COLOR_CMD system("color 0A");
class Person
{
public:
Person() {};
Person(string n, string s, string a);
~Person() { cout << "Destructor adress = " << this << endl; }
void show(Person * arr, int size) { // Берем указатель на arr и выводим его на экран
if (size <= id) { // Проверка size
for (size_t i = 0; i < size; i++)
{
cout << arr[i] << endl; // Перегрузка оператора вывода
}
}
else
cerr << "Error size very big!" << endl;
}
void show_ID() {
cout << "ID = " << Person::id << endl;
}
int & operator[](size_t & size) { // Перегрузка оператора []
Person arr;
return arr[size];
}
friend ostream & operator<<(ostream &out, Person &ob); //Перегрузка оператора <<
friend std::istream& operator>> (std::istream &in, Person &point); //Перегрузка оператора >>
private:
string name;
string surname;
string age;
static int id;
string input;
};
int Person::id = 0;
Person::Person(string n, string s, string a)
{
this->name = n;
this->surname = s;
this->age = a;
id++;
}
ostream & operator<<(ostream &out, Person &ob) {
out << ob.name << "\n" << ob.surname << "\n" << ob.age << "\n" << endl;
return out;
}
std::istream& operator>> (std::istream &in, Person &ob)
{
in >> ob.name;
in >> ob.surname;
in >> ob.age;
Person::id++;
return in;
}
int main() {
COLOR_CMD
Person * arr = new Person[5];
arr[0] = { "Igor", "Dombrovsky", "29" };
arr[1] = { "Vladimir", "Dombrovsky", "53" };
arr[2] = { "Elena", "Dombrovskay", "49" };
arr[3] = { "Natalia", "Dombrovskay", "36" };
arr[4] = { "Aleksey", "Dombrovsky", "5" };
arr->show(arr, 5);
Person * arr1 = new Person[3];
cin >> arr[0];
cin >> arr[1];
cin >> arr[2];
arr1->show(arr, 3);
arr1->show_ID(); // Вызов метода show_ID Смотрим на значение ID
STOP_CMD
return 0;
}
