Листинг 3.1. Первая программа 5 страница

};

// спецификация CTrapeze – — трапеция (производный класс)

class CTrapeze: public CTriangle

{

protected:

double m_d, m_h; // четвёертая сторона и высота

public:

CTrapeze ();

CTrapeze (double, double, double, double, double);

~CTrapeze ();

void setFigure (double, double, double, double, double);

void getFigure (double&, double&, double&, double&, double&) Äconst;

double getArea () const; // вычисление площади трапеции

};

// Realizations.cpp - Реализации классов

#pragma once

#include "Specifications.h"

// реализация CFigure – — геометрическая фигура (базовый класс)

CFigure:: CFigure (): m_a (0.0), m_b (0.0) { }

CFigure:: CFigure (double a, double b): m_a (a), m_b (b) { }

CFigure:: ~CFigure () { }

void CFigure:: setFigure (double a, double b) { m_a = a; m_b = b; }

void CFigure:: getFigure (double& a, double& b) const

{ a = m_a; b = m_b; }

// чистая виртуальная функция не имеет реализации в базовом классе

// реализация CTriangle – — треугольник (производный класс)

CTriangle:: CTriangle (): CFigure (), m_c (0.0) { }

CTriangle:: CTriangle (double a, double b, double c)

: CFigure (a, b), m_c (c) { }

CTriangle:: ~CTriangle () { }

void CTriangle:: setFigure (double a, double b, double c)

{ CFigure:: setFigure (a, b); m_c = c; }

void CTriangle:: getFigure (double& a, double& b, double& c) const

{ CFigure:: getFigure (a, b); c = m_c; }

// реализация чистой виртуальной функции

// площадь треугольника вычисляется по формуле Герона

#include <cmath>

using namespace std;

double CTriangle:: getArea () const

{

double p = (m_a + m_b + m_c) / 2;

return sqrt (p * (p - m_a) * (p - m_b) * (p - m_c));

}

// реализация CRectangular – — прямоугольник (производный класс)

CRectangular:: CRectangular (): CFigure () { }

CRectangular:: CRectangular (double a, double b)

: CFigure (a, b) { }

CRectangular:: ~CRectangular () { }

// реализация чистой виртуальной функции

double CRectangular:: getArea () const { return m_a * m_b; }

// реализация CParallelogram – — параллелограмм (производный класс)

// член-данное m_с базового класса CTriangle – — это высота параллелограмма

CParallelogram:: CParallelogram (): CTriangle () { }

CParallelogram:: CParallelogram (double a, double b, double h)

: CTriangle (a, b, h) { }

CParallelogram:: ~CParallelogram () { }

// реализация чистой виртуальной функции

double CParallelogram:: getArea () const { return m_a * m_c; }

// реализация CTrapeze – — трапеция (производный класс)

CTrapeze:: CTrapeze (): CTriangle (), m_d (0.0), m_h (0.0) { }

CTrapeze:: CTrapeze (double a, double b, double c, double d, double h)

: CTriangle (a, b, c), m_d (c), m_h (h) { }

CTrapeze:: ~CTrapeze () { }

void CTrapeze::

setFigure (double a, double b, double c, double d, double h)

{ CTriangle:: setFigure (a, b, c); m_d = d; m_h = h; }

void CTrapeze::

getFigure (double& a, double& b, double& c, double& d, double& h) const

{ CTriangle:: getFigure (a, b, c); d = m_d; h = m_h; }

// реализация чистой виртуальной функции

double CTrapeze:: getArea () const

{ return 0.5 * (m_a + m_b) * m_h; }

// main.cpp - главная функция

#include <iostream>

using namespace std;

#include "Specifications.h"

void view (double, double);

void view (double, double, double);

void view (double, double, double, double, double);

int main ()

{

// объявление массива указателей на базовый класс

CFigure* pF [ 4 ];

// объявление массива указателей с инициализацией названиями фигур

char* name [ ] =

{ "Triangle", "Trapeze", "Parallelogram", "Rectangular" };

// создание объектов разных типов

CTriangle triangle (3.0, 4.0, 2.0);

CTrapeze trapeze (5.0, 2.0, 1.9, 2.8, 1.8);

CParallelogram parallelogram (15.2, 28.75, 18.3);

CRectangular rectangular (100.5, 24.13);

// инициализация массива pF адресами созданных объектов

pF [ 0 ] = &triangle; pF [ 1 ] = &trapeze;

pF [ 2 ] = &parallelogram; pF [ 3 ] = &rectangular;

// цикл вывода состояния созданных объектов и их площадей

double a, b, c, d, h;

for (int i = 0; i < 4; i++)

{

cout << '\n' << name [ i ] << " (";

switch (i)

{

case 0:

triangle.getFigure (a, b, c);

view (a, b, c); cout << ")\t\t\t"; break;

case 1:

trapeze.getFigure (a, b, c, d, h);

view (a, b, c, d, h); cout << ")\t\t"; break;

case 2:

parallelogram.getFigure (a, b, h);

view (a, b, h); cout << ")\t"; break;

case 3:

rectangular.getFigure (a, b);

view (a, b); cout << ")\t\t"; break;

}

cout << "AREA = " << pF [ i ] -> getArea () << endl;

}

// цикл изменения данных объектов, вывода их состояния и площадей

for (int i = 0; i < 4; i++)

{

cout << '\n' << name [ i ] << " (";

switch (i)

{

case 0:

triangle.setFigure (3, 3, 3);

triangle.getFigure (a, b, c);

view (a, b, c); cout << ")\t\t\t"; break;

case 1:

trapeze.setFigure (5, 2, 1.8, 1.8, 1.9);

trapeze.getFigure (a, b, c, d, h);

view (a, b, c, d, h); cout << ")\t\t"; break;

case 2:

parallelogram.setFigure (14, 15, 14);

parallelogram.getFigure (a, b, h);

view (a, b, h); cout << ")\t\t"; break;

case 3:

rectangular.setFigure (1005, 2413);

rectangular.getFigure (a, b);

view (a, b); cout << ")\t\t"; break;

}

cout << "AREA = " << pF [ i ] -> getArea () << endl;

}

return 0;

}

// определение перегруженной функции вывода переменных

void view (double a, double b)

{ cout << a << ", " << b; }

void view (double a, double b, double c)

{ view (a, b); cout << ", " << c; }

void view (double a, double b, double c, double d, double h)

{ view (a, b, c); cout << ", " << d << ", " << h; }

Листинг 17.1. Пример программы эквивалентной перегрузки оператора ->

#include <iostream>

#include <string>

using namespace std;

class C

{

string m_s;

public:

C (): m_s ("") { }

C (const string& s): m_s (s) { }

~ C () { }

string getS () const { return m_s; };

C* operator -> () { return this; }

C& operator * () { return *this; }

C& operator [ ] (const unsigned int i) { return this [ i ]; }

};

int main ()

{

C o ("class member access operator");

cout << "Overloaded operator ->\t" << o -> getS () << endl;

cout << "Overloaded operator *\t" << (*o).getS () << endl;

cout << "Overloaded operator [ ]\t" << o [ 0 ].getS () << endl;

cout << "Standard operator.\t" << o.getS () << endl;

return 0;

}

Листинг 17.2. Пример программы с перегрузкой оператора [ ] для одномерного массива

class C

{

public:

int* m_p; int m_n;

C (int n = 10): m_n (n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = 0;

}

~ C () { delete [ ] m_p; }

int& operator [ ] (const unsigned int i) const

{ return m_p [ i ]; }

};

#include <iostream>

using namespace std;

int main ()

{

int arr [ ] = { 1, -2, -3, -4, 5 }; C o (5);

for (int i = 0; i < 5; i++)

if (arr [ i ] < 0)

// оператор [ ] слева от оператора =

o [ i ] = -arr [ i ];

else o [ i ] = arr [ i ];

// оператор [ ] справа от оператора =

int x; x = o [ 2 ];

cout << x << endl; // выводится 3

for (int i = 0; i < 5; i++) // выводится 1 2 3 4 5

cout << o [ i ] << '\t';

cout << endl;

return 0;

}

Листинг 17.3. Пример программы с перегрузкой оператора [ ] для двухмерного массива

class C

{

public:

int** m_p; int m_m, m_n;

C (int m = 10, int n = 10): m_m (m), m_n (n)

{

m_p = new int* [ m_m ];

for (int i = 0; i < m_m; i++)

m_p [ i ] = new int [ m_n ];

for (int i = 0; i < m_m; i++)

for (int j = 0; j < m_n; j++)

m_p [ i ] [ j ] = 0;

}

~ C ()

{

for (int i = 0; i < m_m; i++) delete [ ] m_p [ i ];

delete [ ] m_p;

}

int* operator [ ] (const unsigned int i) const

{ return m_p [ i ]; }

};

#include <iostream>

using namespace std;

int main ()

{

int arr [ ] [ 2 ] = { 1, -2, -3, -4, 5 }; C o (3, 2);

// присваивание значений элементам матрицы в объекте

for (int i = 0; i < 3; i++)

for (int j = 0; j < 2; j++)

o [ i ] [ j ] = -arr [ i ] [ j ];

// вывод состояния объекта

for (int i = 0; i < 3; i++)

{

for (int j = 0; j < 2; j++)

cout << o [ i ] [ j ] << '\t';

cout << endl;

}

// использование [ ] в правой части оператора присваивания

int x = o [ 2 ] [ 0 ];

cout << x << endl;

return 0;

}

Листинг 17.4. Пример программы с перегрузкой оператора =

class C

{

public:

int* m_p; int m_n;

C (int n = 10): m_n (n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = 0;

}

C (C& o): m_n (o.m_n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = o.m_p [ i ];

}

~ C () { delete [ ] m_p; }

int& operator [ ] (const unsigned int i) const

{ return m_p [ i ]; }

// перегрузка оператора =

C& operator = (C& right)

{

if (m_n!= right.m_n)

{

// освобождение ранее выделенной памяти

delete [ ] m_p;

// модификация размера массива

m_n = right.m_n;

// выделение нового блока памяти

m_p = new int [ m_n ];

}

// копирование элементов

for (int i = 0; i < m_n; i++)

m_p [ i ] = right.m_p [ i ];

// возврат ссылки на модифицированный массив

return *this;

}

};

#include <iostream>

using namespace std;

void view (C&);

int main ()

{

// создание объекта obj

C obj (4); // в объекте obj массив 0 0 0 0

// присваивание значений элементам массива в объекте obj

for (int i = 0; i < obj.m_n; i++)

obj [ i ] = (i + 1) * 2; // вызывается оператор [ ]

cout << "\nobj:\t\t"; view (obj);

// создание объекта через указатель

C* p = new C (6); // в объекте массив 0 0 0 0 0 0

cout << "\n*p:\t\t"; view (*p);

// элементы массива объекта, на который указывает p,

// получают значения элементов массива из объекта obj

*p = obj; // вызывается оператор =

cout << "\n*p = obj:\t"; view (*p);

// создание объекта через указатель с одновременной инициализацией

C* pCopy = new C (*p); // вызывается конструктор копии

cout << "\nCOPY *p:\t"; view (*pCopy);

// множественное присваивание

C x, y; x = y = obj;

cout << "\nx = y = obj:\n";

cout << "\nx:\t\t"; view (x);

cout << "\ny:\t\t"; view (y);

// разрушение объектов

delete p; delete pCopy;

return 0;

}

// функция вывода состояния объектов типа C

void view (C& o)

{

for (int i = 0; i < o.m_n; i++) cout << o [ i ] << '\t';

cout << endl;

}

Листинг 17.5. Пример программы с перегрузкой ++

class CPoint

{

public:

int m_x, m_y;

CPoint (): m_x (0), m_y (0) { }

CPoint (int x, int y): m_x (x), m_y (y) { }

~CPoint () { }

CPoint& operator ++ () // префиксный оператор

{ ++m_x; ++m_y; return *this; }

CPoint& operator ++ (int unused) // постфиксный оператор

{ m_x++; m_y++; return *this; }

};

#include <iostream>

using namespace std;

int main ()

{

CPoint a, b (-8, 6);

++a; cout << a.m_x << '\t' << a.m_y << endl; // выводится 1 1

b++; cout << b.m_x << '\t' << b.m_y << endl; // выводится -7 7

return 0;

}

Листинг 17.6. Пример программы с перегрузкой бинарных операторов + и –

// c.h - спецификация C

#pragma once

class C

{

public:

int* m_p; int m_n;

C (int = 10); C (C&); ~ C ();

int& operator [ ] (const unsigned int) const;

C& operator = (C&);

C operator + (const C&) const; // сложение объектов

C operator + (const int&) const; // сложение объекта с числом

C operator - (const C&) const; // вычитание объектов

};

// c.сpp - реализация C

#include "c.h"

C:: C (int n): m_n (n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = 0;

}

C:: C (C& o): m_n (o.m_n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = o.m_p [ i ];

}

C:: ~ C () { delete [ ] m_p; }

// перегрузка [ ]

int& C:: operator [ ] (const unsigned int i) const

{ return m_p [ i ]; }

// перегрузка =

C& C:: operator = (C& right)

{

if (m_n!= right.m_n)

{ delete [ ] m_p; m_n = right.m_n; m_p = new int [ m_n ]; }

for (int i = 0; i < m_n; i++) m_p [ i ] = right.m_p [ i ];

return *this;

}

// перегрузка сложения объектов

C C:: operator + (const C& right) const

{

C tmp (m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp.m_p [ i ] = m_p [ i ] + right.m_p [ i ];

return tmp;

}

// перегрузка сложения объекта с числом

C C:: operator + (const int& right) const

{

C tmp (m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp.m_p [ i ] = m_p [ i ] + right;

return tmp;

}

// перегрузка вычитания объектов

C C:: operator - (const C& right) const

{

C tmp (m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp.m_p [ i ] = m_p [ i ] - right.m_p [ i ];

return tmp;

}

// main.cpp - главная функция

#include <iostream>

using namespace std;

#include "c.h"

void view (C&); // вывод состояния объекта

int main ()

{

C o1 (5), o2 (5);

for (int i = 0; i < o1.m_n; i++)

{ o1 [ i ] = (i + 1) * 2; o2 [ i ] = i; }

cout << "\no1:\t\t"; view (o1);

cout << "o2:\t\t"; view (o2);

// сложение объектов o1 и o2

C res;

res = o1 + o2; // вызываются + (объект) и =

cout << "\nres = o1 + o2:\t"; view (res);

// сложение с числом

int x (5); C o3 (5);

cout << "\no3:\t\t"; view (o3);

res = o3 + x; // вызываются + (число) и =

cout << "res = o3 + 5:\t"; view (res);

// вычитание объектов

res = o3 - o2; // вызываются - и =

cout << "\nres = o3 - o2:\t"; view (res);

// вывод состояния исходных объектов

cout << "\no1:\t\t"; view (o1);

cout << "o2:\t\t"; view (o2);

cout << "o3:\t\t"; view (o3);

return 0;

}

// функция вывода состояния объектов типа C

void view (C& o)

{

for (int i = 0; i < o.m_n; i++) cout << o [ i ] << '\t';

cout << endl;

}

Листинг 17.7. Пример перегрузки оператора ++ при помощи дружественных функций

class CPoint

{

public:

int m_x, m_y;

CPoint (): m_x (0), m_y (0) { }

CPoint (int x, int y): m_x (x), m_y (y) { }

~CPoint () { }

// объявление функций-друзей

friend CPoint& operator ++ (CPoint&); // префиксный ++

friend CPoint& operator ++ (CPoint&, int); // постфиксный ++

};

// главная функция

#include <iostream>

using namespace std;

int main ()

{

CPoint a, b (-8, 6);

++a; cout << a.m_x << '\t' << a.m_y << endl; // выводится 1 1

b++; cout << b.m_x << '\t' << b.m_y << endl; // выводится -7 7

return 0;

}

// определение функций

CPoint& operator ++ (CPoint& o)

{ ++o.m_x; ++o.m_y; return o; }

CPoint& operator ++ (CPoint& o, int unused)

{ o.m_x++; o.m_y++; return o; }

Листинг 17.8. Пример перегрузки бинарных операторов + и – при помощи дружественных функций

// c.h - спецификация C

#pragma once

class C

{

int* m_p; int m_n; // закрытые данные

public:

C (int = 10); // конструктор по умолчанию

C (C&); // конструктор копирования

~ C (); // деструктор

int getN (void) const; // возврат размера массива

// операторные функции-члены

int& operator [ ] (const unsigned int) const;

C& operator = (C&);

// операторные функции-друзья

// оператор +

friend C operator + (const C&, const C&); // объект + объект

friend C operator + (const C&, const int&);// объект + число

friend C operator + (const int&, const C&);// число + объект

// оператор -

friend C operator - (const C&, const C&); // объект - объект

// функция-друг для вывода состояния объекта

friend void view (const C&);

};

// c.сpp - реализация C

#include "c.h"

C:: C (int n): m_n (n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = 0;

}

C:: C (C& o): m_n (o.m_n)

{

m_p = new int [ m_n ];

for (int i = 0; i < m_n; i++) m_p [ i ] = o.m_p [ i ];

}

C:: ~ C () { delete [ ] m_p; }

int C:: getN (void) const { return m_n; }

// перегрузка оператора [ ]

int& C:: operator [ ] (const unsigned int i) const

{ return m_p [ i ]; }

// перегрузка оператора =

C& C:: operator = (C& right)

{

if (m_n!= right.m_n)

{ delete [ ] m_p; m_n = right.m_n; m_p = new int [ m_n ]; }

for (int i = 0; i < m_n; i++) m_p [ i ] = right.m_p [ i ];

return *this;

}

// main.cpp - главная функция

#include <iostream>

using namespace std;

#include "c.h"

// прототипы глобальных функций

C operator + (const C&, const C&); // сложение объектов

C operator + (const C&, const int&); // сложение объекта с числом

C operator + (const int&, const C&); // сложение числа с объектом

C operator - (const C&, const C&); // вычитание объектов

void view (const C&); // вывод состояния объекта

int main ()

{

C o1 (5), o2 (5);

for (int i = 0; i < o1.getN (); i++)

{ o1 [ i ] = (i + 1) * 2; o2 [ i ] = i; }

cout << "\no1:\t\t"; view (o1);

cout << "o2:\t\t"; view (o2);

// сложение объектов o1 и o2

C res; res = o1 + o2;

cout << "\nres = o1 + o2:\t"; view (res);

// сложение объекта o3 с числом x

int x (5); C o3 (5);

cout << "\no3:\t\t"; view (o3);

res = o3 + x; // объект + число

cout << "res = o3 + 5:\t"; view (res);

res = x + o3; // число + объект

cout << "res = 5 + o3:\t"; view (res);

// вычитание объектов

res = o3 - o2; // объект - объект

cout << "\nres = o3 - o2:\t"; view (res);

res = o2 - o3; // объект - объект

cout << "res = o2 - o3:\t"; view (res);

// вывод состояния исходных объектов

cout << "\no1:\t\t"; view (o1);

cout << "o2:\t\t"; view (o2);

cout << "o3:\t\t"; view (o3);

return 0;

}

// функция вывода состояния объектов типа C

void view (const C& o)

{

for (int i = 0; i < o.m_n; i++) cout << o [ i ] << '\t';

cout << endl;

}

// все следующие функции используют перегруженный оператор [ ]

// перегрузка оператора + (сложение объектов)

C operator + (const C& left, const C& right)

{

C tmp (left.m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp [ i ] = left [ i ] + right [ i ];

return tmp;

}

// перегрузка оператора + (сложение объекта с числом)

C operator + (const C& left, const int& right)

{

C tmp (left.m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp [ i ] = left [ i ] + right;

return tmp;

}

// перегрузка оператора + (сложение числа с объектом)

C operator + (const int& left, const C& right)

{

C tmp (right.m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp [ i ] = left + right [ i ];

return tmp;

}

// перегрузка оператора - (вычитание объектов)

C operator - (const C& left, const C& right)

{

C tmp (left.m_n);

for (int i = 0; i < tmp.m_n; i++)

tmp [ i ] = left [ i ] - right [ i ];

return tmp;

}

Листинг 17.9. Пример перегрузки оператора <<

#include <iostream>

using namespace std;

class CPoint

{

int m_x, m_y;

public:

CPoint (): m_x (0), m_y (0) { }

CPoint (int x, int y): m_x (x), m_y (y) { }

~CPoint () { }

int getX () { return m_x; } int getY () { return m_y; }

};

ostream& operator << (ostream& str, CPoint p)

{ return (str << p.getX() << '\t' << p.getY() << endl); }

int main ()

{ CPoint a (5, 7); cout << a; return 0; } // выводится 5 7

Листинг 17.10. Пример перегрузки оператора >>

#include <iostream>

using namespace std;

class CPoint

{

int m_x, m_y;

public:

CPoint (): m_x (0), m_y (0) { }

CPoint (int x, int y): m_x (x), m_y (y) { }

~CPoint () { }

int getX () { return m_x; } int getY () { return m_y; }

};

istream& operator >> (istream& str, CPoint& p)

{

int x (0), y (0); str >> x >> y;

p = CPoint (x, y); return str;

}

int main ()

{

CPoint a; cin >> a;

cout << a.getX () << '\t' << a.getY () << endl;

return 0;

}

Листинг 17.11. Пример перегрузки операторов для класса CMatrix с помощью функций-друзей

// Martix.h - спецификация CMatrix

#pragma once

#include <iostream>

using namespace std;

class CMatrix

{

int m_m; int m_n; int** m_p;

public:

int getM () const { return m_m; }

int getN () const { return m_n; }

CMatrix (const int = 10, const int = 10); ~CMatrix ();

// перегрузка оператора [ ]

int* operator [ ] (const unsigned int i) const;

// перегрузка оператора =

CMatrix& operator = (const CMatrix&);

// перегрузка оператора >> (ввод матрицы)

friend istream& operator >> (istream&, CMatrix&);

// перегрузка оператора << (вывод матрицы)

friend ostream& operator << (ostream&, const CMatrix&);

// перегрузка оператора * (умножение матриц)

friend CMatrix operator * (const CMatrix&, const CMatrix&);

// перегрузка оператора - (изменение отрицательных элементов)

friend CMatrix& operator - (CMatrix&);

// перегрузка оператора == (сравнение матриц на равенство)

friend bool operator == (const CMatrix&, const CMatrix&);

// перегрузка оператора!= (сравнение матриц на неравенство)

friend bool operator!= (const CMatrix&, const CMatrix&);

};

// Matrix.cpp - реализация CMatrix

#include "Matrix.h"

CMatrix:: CMatrix (const int m, const int n) //: m_m (m), m_n (n)

{

m_m = m; m_n = n; m_p = new int* [ m_m ];

for (int i = 0; i < m_m; i++) m_p [ i ] = new int [ m_n ];

for (int i = 0; i < m_m; i++)

for (int j = 0; j < m_n; j++) m_p [ i ] [ j ] = 0;

}

CMatrix:: ~CMatrix ()

{

for (int i = 0; i < m_m; i++) delete [ ] m_p [ i ];

delete [ ] m_p;

}

// перегрузка оператора [ ]

int* CMatrix:: operator [ ] (const unsigned int i) const

{ return m_p [ i ]; }

// перегрузка оператора =

CMatrix& CMatrix:: operator = (const CMatrix& right)

{

// освобождение ранее выделенной памяти для левого операнда

for (int i = 0; i < m_m; i++) delete [ ] m_p [ i ];

delete [ ] m_p;

// выделение новой оперативной памяти для левого операнда

m_m = right.m_m; m_n = right.m_n; m_p = new int* [ m_m ];

for (int i = 0; i < m_m; i++) m_p [ i ] = new int [ m_n ];

// модификация левого операнда

for (int i = 0; i < m_m; i++)

for (int j = 0; j < m_n; j++)

m_p [ i ] [ j ] = right.m_p [ i ] [ j ];

return *this;

}

// main.cpp - главная функция

#include <iostream>

using namespace std;

#include "Matrix.h"

// прототипы функций-друзей

istream& operator >> (istream&, CMatrix&);

ostream& operator << (ostream&, const CMatrix&);

CMatrix operator * (const CMatrix&, const CMatrix&);

CMatrix& operator - (CMatrix&);

bool operator == (const CMatrix&, const CMatrix&);

bool operator!= (const CMatrix&, const CMatrix&);

int main ()

{

// объявление матриц

CMatrix A (2, 3); CMatrix B (3, 3);

// ввод матриц

cout << "Enter A (" << A.getM () * A.getN () << " elements)\n";

cin >> A;

cout << "Enter B (" << B.getM () * B.getN () << " elements)\n";

Дата добавления: 2015-09-29