6.3.3. Шаблоны классов. Пример 6.4 (шаблон класса Комплексное число)

Шаблоны позволяют реализуют в языке С++ такое отношение между классами, как инстанцирование. При создании шаблона класса тип одного или нескольких его переменных членов задаются в качестве параметра. При использовании этого шаблона необходимо будет указать, какой тип использовать в качестве параметра. Это и называется инстанцированием. Например, обобщенный класс Complex. Многие классы, которые используются для хранения и управления гомогенными структурами данных, реализуют в виде шаблонов. И действительно, независимо от типов хранимых в нем элементов, класс Complex должен выполнять одни и те же функции

Процесс генерации объявления класса по шаблону и аргументу называется инстанцированием шаблона.

/////////////////////////////////////////////////////////////////////////////

// Прикладное программирование

// Пример 6.4. Шаблон класса Комплексное число

// complex.h

//

// Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru

// СПб НИУ ИТМО

/////////////////////////////////////////////////////////////////////////////

// проверка на повторное подключение файла

#if !defined COMPLEX_H

#define COMPLEX_H

#include <iostream>

using namespace std;

/////////////////////////////////////////////////////////////////////////////

// шаблон класса Комплексное число

template <class PAR>

class Complex

{

private:

// вещественная и мнимая часть комплексного числа

PAR m_re, m_im;

public:

// конструкторы

Complex<PAR>();

Complex<PAR>(PAR re, PAR im=PAR(0));

Complex<PAR>(const Complex<PAR>& other);

public:

// получение параметров комплексного числа

PAR GetRe() const;

PAR GetIm() const;

// изменение параметров комплексного числа

void Set(PAR re, PAR im=PAR(0));

// оператор умножения

Complex<PAR> operator*(const Complex<PAR>& other) const;

// оператор умножения на число

Complex<PAR> operator*(const PAR& other) const;

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

Complex<PAR>& operator*=(const Complex<PAR>& other);

// оператор присваивания

Complex<PAR>& operator=(const Complex<PAR>& other);

// оператор равенства

bool operator== (const Complex<PAR>& other) const;

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

Complex<PAR> operator~() const;

// унарный минус

Complex<PAR> operator-() const;

// ввод/вывод комплексного числа

template <class PAR>

friend ostream& operator<< (ostream& out, const Complex<PAR>& x);

template <class PAR>

friend istream& operator>> (istream& out, Complex<PAR>& x);

};

/////////////////////////////////////////////////////////////////////////////

// конструктор по умолчанию

template <class PAR>

Complex<PAR>::Complex()

: m_re(0.)

, m_im(0.)

{

}

/////////////////////////////////////////////////////////////////////////////

// полный конструктор

template <class PAR>

Complex<PAR>::Complex(PAR re, PAR im)

: m_re(re)

, m_im(im)

{

}

/////////////////////////////////////////////////////////////////////////////

// конструктор копирования

template <class PAR>

Complex<PAR>::Complex(const Complex<PAR>& x)

: m_re(x.m_re)

, m_im(x.m_im)

{

}

////////////////////////////////////////////////////////////////////////////

// получение вещественной части комплексного числа

template <class PAR>

PAR Complex<PAR>::GetRe() const

{

return m_re;

}

/////////////////////////////////////////////////////////////////////////////

// получение мнимой части комплексного числа

template <class PAR>

PAR Complex<PAR>::GetIm() const

{

return m_im;

}

/////////////////////////////////////////////////////////////////////////////

// изменение параметров комплексного числа

template <class PAR>

void Complex<PAR>::Set(PAR re, PAR im)

{

m_re=re;

m_im=im;

}

/////////////////////////////////////////////////////////////////////////////

// оператор умножения

template <class PAR>

Complex<PAR> Complex<PAR>::operator*(const Complex<PAR>& other) const

{

return Complex<PAR>(m_re*other.m_re-m_im*other.m_im,

m_re*other.m_im-m_im*other.m_re);

}

/////////////////////////////////////////////////////////////////////////////

// оператор умножения на число

template <class PAR>

Complex<PAR> Complex<PAR>::operator*(const PAR& other) const

{

return Complex<PAR>(m_re*other, m_im*other);

}

/////////////////////////////////////////////////////////////////////////////

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

template <class PAR>

Complex<PAR>& Complex<PAR>::operator*=(const Complex<PAR>& other)

{

Complex temp(*this);

m_re=temp.m_re*other.m_re - temp.m_im*other.m_im;

m_im=temp.m_re*other.m_im + temp.m_im*other.m_re;

return (*this);

}

/////////////////////////////////////////////////////////////////////////////

// унарный минус

template <class PAR>

Complex<PAR> Complex<PAR>::operator-() const

{

return Complex<PAR>(-m_re, -m_im);

}

/////////////////////////////////////////////////////////////////////////////

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

template <class PAR>

Complex<PAR> Complex<PAR>::operator~() const

{

return Complex<PAR>(m_re, -m_im);

}

/////////////////////////////////////////////////////////////////////////////

// оператор равенства

template <class PAR>

bool Complex<PAR>::operator== (const Complex<PAR>& other) const

{

return (m_re == other.m_re && m_im == other.m_im);

}

/////////////////////////////////////////////////////////////////////////////

// оператор присваивания

template <class PAR>

Complex<PAR>& Complex<PAR>::operator=(const Complex<PAR>& other)

{

if(this != &other)

{

m_re=other.m_re;

m_im=other.m_im;

}

return *this;

}

/////////////////////////////////////////////////////////////////////////////

// вывод комплексного числа на экран

template <class PAR>

ostream& operator<< (ostream& out, const Complex<PAR>& x)

{

return (out<<"("<<x.m_re<<","<<x.m_im<<")");

}

/////////////////////////////////////////////////////////////////////////////

// ввод комплексного числа с клавиатуры

template <class PAR>

istream& operator>> (istream& in, Complex<PAR>& x)

{

return (in>>x.m_re>>x.m_im);

}

/////////////////////////////////////////////////////////////////////////////

#endif //defined Complex_H

 

/////////////////////////////////////////////////////////////////////////////

// Прикладное программирование

// Пример 6.4. Шаблон класса Комплексное число

// test_complex.cpp

//

// Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru

// СПб НИУ ИТМО

/////////////////////////////////////////////////////////////////////////////

#include <iostream>

using namespace std;

// подключение описания класса

#include "complex.h"

/////////////////////////////////////////////////////////////////////////////

// пример использования шаблона класса Complex

void main()

{

Complex<int> a(5), b(3,3);

Complex<double> c(1.144, -0.155);

cout<<a<<" "<<b<<" "<<c<<endl;

}

/////////////////////////////////////////////////////////////////////////////