Cpp-Tutorials/FunctionOverloadingTemplate at master · anubhavrohatgi/Cpp-Tutorials · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <iostream>

using namespace std;


template<class T>
class complexType
{
public:
    complexType();
    complexType(T realPart,T imagPart);

    void setComplex(T realPart, T imagPart);

    void getComplex(T& realPart,T& imagPart) const;

    complexType<T> operator +(const complexType<T>& alpha) const;

    complexType<T> operator !() const;

    complexType<T> operator *(const complexType<T>& alpha) const;

    bool operator ==(const complexType<T>& alpha) const;

    friend ostream& operator<<(ostream& out, const complexType<T>& complex) {
        out << "("; //Step a
        out << complex.realpart; //Step b
        out << ", "; //Step c
        out << complex.imagPart; //Step d
        out << "i)"; //Step e
        return out;
    }

private:
    T realpart;
    T imagPart;
};


template<class T>
complexType<T>::complexType(){
    //nothing
}


template<class T>
complexType<T>::complexType(T realPart,T imagPart) {
    this->realpart = realPart;
    this->imagPart = imagPart;
}


template<class T>
void complexType<T>::setComplex(T realPart, T imagPart) {
    this->realpart = realPart;
    this->imagPart = imagPart;
}

template<class T>
void complexType<T>::getComplex(T& realPart, T& imagPart) const {
    realpart = this->realpart;
    imagPart = this->imagPart;
}


template<class T>
complexType<T> complexType<T>::operator +(const complexType<T>& alpha) const {

    complexType<T> temp;
    temp.realpart =  this->realpart + alpha.realpart;
    temp.imagPart = this->imagPart + alpha.imagPart;
    return temp;
}


template<class T>
complexType<T> complexType<T>::operator *(const complexType<T>& alpha) const {

    complexType<T> temp;
    temp.realpart =  (this->realpart * alpha.realpart) - (this->imagPart * alpha.imagPart);
    temp.imagPart =  (this->realpart * alpha.imagPart) + (this->imagPart * alpha.realpart);
    return temp;
}


template<class T>
complexType<T> complexType<T>::operator !() const {

    complexType<T> temp;
    temp.realpart =  (this->realpart);
    temp.imagPart =  -1*(this->imagPart);
    return temp;
}


template<class T>
bool complexType<T>::operator ==(const complexType<T>& alpha) const {
    return (this->realpart == alpha.realpart &&
    this->imagPart == alpha.imagPart);
}


int main(int argc, char *argv[])
{
    complexType<int> cm1,cm2(4,5);
    cm1.setComplex(2,3);


    std::cout<<cm1<<cm2<<std::endl;
    std::cout<<" Add = "<<cm1+cm2<<std::endl;
    std::cout<<" Multiply = "<<cm1*cm2<<std::endl;
    std::cout<<" Conjugate = "<<!cm1<<std::endl;

    return 0;
}