Operator Overloading, Operator Conversions

당신에게 한 class가 주어졌다 - Complex

class Complex
{
public:
int a, b;
};

연산자(operators)는 operator function으로 overload된다. 그리고 이 연산자는 특별한 이름을 가진 규칙적인 함수이다.

이름은 operator keyword 다음에 overload된 operator sign으로 시작한다.

문법은 다음과 같다:

type operator sign(parameters) { /*...body...*/ }

 Complex class를 위해 + 와 << 연산자를 overload 해보자.

+ 연산자는 complex addition 규칙에 따라 complex 수를 더해야 한다.

(a+ib)+(a+id) = (a+c) + i(b+d)

stream insertion operator << 를 stream에 "a+ib"를 더하도록 overload 해야한다.

cout << c << endl;

위 문장은  a = c.a와 b= c.b인 "a+ib"로 출력해야 한다.

Input Format

overloaded operator +는 두 개의 complex numbers(a+ib 와 c+id)를 인수로 받아서 단일 complex number로 반환한다.

overloaded operator <<는 "a+ib"를 overloaded operator에 인수로 넘겨진 complex number의 a가 실수부이고 

b가 허수부인 stream에 더한다.

Sample Input

3+i4
5+i6

Sample Output

8+i10

solution)

//Operator Overloading
 
#include<iostream>
#include<string>
using namespace std;
 
class Complex
{
public:
    int a, b;
    void input(string s)    //문자열들을 숫자로 분리시켜야 함
    {
        int v1 = 0;
        int i = 0;    //전역 변수로 전체 문자열을 컨트롤
        while (s[i] != '+')    // + 이전의 숫자들 처리
        {
            v1 = v1 * 10 + s[i] - '0';    // 이전의 한 자리 수 값의 자리수를 높이고 1의 자리수를 더함
            i++;
        }
        while (s[i] == ' ' || s[i] == '+' || s[i] == 'i')    // 공백, +, i 기호 나오면 스킵
        {
            i++;
        }
        int v2 = 0;
        while (i<(int)s.length()) // + 이전의 숫자 처리와 같은 과정, i는 그대로 값이 유지되기 때문에 남은 길이에 대해서 처리
        {
            v2 = v2 * 10 + s[i] - '0';    
            i++;
        }
        a = v1;
        b = v2;
    }
};
 
Complex operator+ (Complex &com1, Complex &com2)
{
    return{ com1.a + com2.a, com1.b + com2.b };
}
 
ostream& operator<< (ostream& os, const Complex& c)
{
    os << c.a << "+i" << c.b << endl;
    return os;
}
 
int main()
{
    Complex x, y;
    string s1, s2;
    cin >> s1;
    cin >> s2;
    x.input(s1);
    y.input(s2);
    Complex z = x + y;
    cout << z << endl;
 
 
}
 

Understanding the Arithmetic Conversions

bool flag;         char cval;

short sval;         unsigned short usval;

int ival;         unsigned int uival;

long lval;         unsigned long ulval;

float fval;         double dval;

3.14159L + 'a';     // 'a' promoted to int, then that int converted to long double

dval + ival;         // ival converted to double

dval + fval;         // fval converted to double

ival = dval;         // dval converted (by truncation) to int

flag = dval;         // if dval is 0, then flag is false, otherwise true

cval + fval;         // cval promoted to int, then that int converted to float

sval + cval;         // sval and cval promoted to int

cval + lval;         // cval converted to long

ival + ulval;         // ival converted to unsigned long

usval + ival;         // promotion depends on the size of unsigned short and int

uival + lval;         // conversion depends on the size of unsigned int and long