{{ label!='' ? 'Label : ' : (q!='' ? '검색 : ' : '전체 게시글') }} {{ label }} {{ q }} {{ ('('+(pubs|date:'yyyy-MM')+')') }}

[C++] 스터디 CPPALOM 5주차: 열혈 C++ 프로그래밍 Chap 10-12

(파워 포인트 파일(.pptx)을 Markdown으로 변환하여 업로드하였음)



# <br>연산자 오버로딩

* C++의 모든 연산자는 내부적으로 operator+, operator- 등으로 호출된다.
  * 이는 다음 두 가지 방식으로 오버로딩할 수 있다:
  * 멤버 함수에 의한 연산자 오버로딩
  * 전역 함수에 의한 연산자 오버로딩

```C++
int main(void)
{
    Point pos1(3, 4);
    Point pos2(10, 20);
    Point pos3=pos1.operator+(pos2);
    pos1.ShowPosition();
    pos2.ShowPosition();
    pos3.ShowPosition();
    Point pos4=pos1+pos2;
    pos4.ShowPosition();
    return 0;
}
```

```C++
class Point 
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    Point operator+(const Point &ref)    //operator+��� �̸��� �Լ�
    {
        Point pos(xpos+ref.xpos, ypos+ref.ypos);
        return pos;
    }
};
```

```C++
[3, 4]
[10, 20]
[13, 24]
```

* 전역 함수에 의한 연산자 오버로딩
  * 오버로딩된 전역 함수는 Point 객체의 멤버에 접근해야 한다.
  * 따라서 friend 키워드를 이용해 이를 허용한다.

```C++
int main(void)
{
    Point pos1(3, 4);
    Point pos2(10, 20); 
    Point pos3=pos1+pos2;
    pos1.ShowPosition();
    pos2.ShowPosition();
    pos3.ShowPosition();
    return 0;
}
```

```C++
class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    friend Point operator+(const Point &pos1, const Point &pos2);
}; 
Point operator+(const Point &pos1, const Point &pos2)
{
    Point pos(pos1.xpos+pos2.xpos, pos1.ypos+pos2.ypos);
    return pos;
} 
```

```C++
[3, 4]
[10, 20]
[13, 24]
```

# <br>오버로딩이 가능한 연산자의 종류

* 가능
* 불가능
  * +형변환 연산자

![](img%5Cweek5_subin0.png)

![](img%5Cweek5_subin1.png)

![](img%5Cweek5_subin2.png)

![](img%5Cweek5_subin3.png)

# <br>오버로딩의 주의사항

* 본래의 의도를 벗어난 형태의 연산자 오버로딩을 피한다.
* 연산자의 우선순위와 결합성은 바뀌지 않는다.
* 매개변수의 디폴트 값 설정이 불가능하다.
* 연산자의 순수 기능까지 빼앗을 수 없다.
  * 가령:

```C++
int operator+(const int num1, const int num2)
{
    return num1 * num2;
}
```

# <br>단항 연산자의 오버로딩

* 전위 증감 연산자의 경우:
  * 멤버 함수로 오버로딩한 경우 매개변수가 없음
  * 전역 함수로 오버로딩한 경우 매개변수가 참조 하나

```C++
class Point 
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    Point& operator++()
    {
        xpos+=1;
        ypos+=1;
        return *this;
    }
    friend Point& operator--(Point &ref);
};
Point& operator--(Point &ref)
{
    ref.xpos-=1;
    ref.ypos-=1;
    return ref;
}
```

```C++
int main(void)
{
    Point pos(1, 2);
    ++pos;
    pos.ShowPosition();
    --pos;
    pos.ShowPosition(); 
    ++(++pos);
    pos.ShowPosition();
    --(--pos);
    pos.ShowPosition();
    return 0;
}
```

```C++
[2, 3]
[1, 2]
[3, 4]
[1, 2]
```

* 후위 증감 연산자의 경우:
  * 멤버 함수로 오버로딩한 경우 매개변수가 int
  * 전역 함수로 오버로딩한 경우 매개변수가 참조와 int

```C++
class Point 
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    Point& operator++() 
    {
        xpos+=1;
        ypos+=1;
        return *this;
    }
    const Point operator++(int)
    {
        const Point retobj(xpos, ypos);   // const Point retobj(*this);
        xpos+=1;
        ypos+=1;
        return retobj;
    }
    friend Point& operator--(Point &ref);
    friend const Point operator--(Point &ref, int);
};
```

```C++
int main(void)
{
    Point pos(3, 5);
    Point cpy;
    cpy=pos--;
    cpy.ShowPosition();
    pos.ShowPosition();
    cpy=pos++;
    cpy.ShowPosition(); 
    pos.ShowPosition();
    return 0;
}
```

```C++
Point& operator--(Point &ref)
{
    ref.xpos-=1;
    ref.ypos-=1;
    return ref;
}
const Point operator--(Point &ref, int)
{
    const Point retobj(ref);
    ref.xpos-=1;
    ref.ypos-=1;
    return retobj;
}
```

```C++
[2, 3]
[1, 2]
[3, 4]
[1, 2]
```

```C++
class X 
{
public: // members (with implicit this pointer):
    X* operator&(); // prefix unary & (address of)
    X operator&(X); // binary & (and)
    X operator++(int); // postfix increment
    X operator&(X,X); // error : ternary
    X operator/(); // error : unary /
};
// nonmember functions :
X operator-(X); // prefix unary minus
X operator-(X,X); // binary minus
X operator--(X&,int); // postfix decrement
X operator-(); // error : no operand
X operator-(X,X,X); // error : ternary
X operator%(X); // error : unary 
```

# <br>반환형에서의 const 선언과 const 객체

이 후위 연산은 const 객체를 반환한다.

따라서 다음과 같은 문장이 불가능하다:

해당 함수가 반환하는 객체가 const형이기 때문!

```C++
const Point operator++(int)
{
    const Point retobj(xpos, ypos);
    xpos += 1;
    ypos += 1;
    return retobj;
}
const Point operator--(int)
{
    const Point retobj(xpos, ypos);
    xpos -= 1;
    ypos -= 1;
    return retobj;
}
```

```C++
int main(void)
{
    Point pos(3, 5);
    (pos++)++;
    (pos--)--;
}
```

# <br>교환법칙 문제의 해결

* 곱셈 연산자의 경우 교환법칙이 성립한다.
  * 하지만 멤버 함수의 형태로 오버로딩이 되면, 멤버 함수가 정의된 클래스 객체가 오버로딩 된 연산자의 왼편에 와야 한다!

```C++
#include <iostream>
using namespace std;
class Point 
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    Point operator*(int times) 
    {
        Point pos(xpos*times, ypos*times);
        return pos;
    }
};
```

```C++
int main(void)
{
    Point pos(1, 2);
    Point cpy;
    cpy=pos*3;
    cpy.ShowPosition();
    cpy=3*pos; // error!
    cpy.ShowPosition();
    return 0;
}
```

* 따라서 전역 함수 기반으로 이를 해결할 수 있다.
  * 이것이 friend를 사용해야 하는 이유이다!

```C++
class Point 
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    Point operator*(int times) 
    {
        Point pos(xpos*times, ypos*times);
        return pos;
    }
    friend Point operator*(int times, Point & ref);
};
Point operator*(int times, Point & ref)
{
    return ref*times;
}
```

```C++
int main(void)
{
    Point pos(1, 2);
    Point cpy;
    cpy=3*pos;
    cpy.ShowPosition();
    cpy=2*pos*3;
    cpy.ShowPosition();
    return 0;
}
```

# <br>cout, cin, endl

```C++
namespace mystd 
{
    using namespace std;
    class ostream
    {
    public:
        void operator<< (char * str) 
        {
            printf(" _%s_ ", str);
        }
        void operator<< (char str) 
        {
            printf(" _%c_ ", str);
        }
        void operator<< (int num) 
        {
            printf(" _%d_ ", num);
        }   
        void operator<< (double e) 
        {
            printf(" _%g_ ", e);
        }
        void operator<< (ostream& (*fp)(ostream &ostm))
        {
            fp(*this);
        }
    };
    ostream& endl(ostream &ostm)
    {
        ostm<<'\n';
        fflush(stdout);
        return ostm;
    }
    ostream cout;
}
```

* 이들 역시 연산자 오버로딩으로 입출력을 해결하고 있었다.
  * <<, >> 연산자는 계속해서 ostream, istream을 반환한다.
  * 이를 이용해서 우리는 연속해서 입출력을 수행할 수 있다.

```C++
int main(void)
{
    using mystd::cout;
    using mystd::endl;
    cout<<"Simple String";
    cout<<endl;
    cout<<3.14;
    cout<<endl;
    cout<<123;
    endl(cout);
    return 0;
}
```

# <br><<, >> 연산자의 오버로딩

```C++
class Point 
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    {  }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl; 
    }
    friend ostream& operator<<(ostream&, const Point&);
};
ostream& operator<<(ostream& os, const Point& pos)
{
    os<<'['<<pos.xpos<<", "<<pos.ypos<<']'<<endl; 
    return os;
}
```

* cout, cin의 소스를 수정할 수 없다.
  * 따라서, 전역 함수를 이용해서 오버로딩을 한다.
* 이를 이용해 사용자 정의 객체를 ostream으로 << 연산하였을 때, 객체의 정보가 나타나게 할 수 있다.
  * Java의 toString()을 C++에서는 이렇게 구현한다.

```C++
int main(void)
{
    Point pos1(1, 3);
    cout<<pos1;
    Point pos2(101, 303);
    cout<<pos2;
    return 0;
}
```

```C++
[1, 3]
[101, 303]
```

# <br>디폴트 대입 연산자

대입 연산자 역시 오버로딩이 가능하며, 디폴트 대입 연산자가 존재한다.

```C++
class First
{
private:
    int num1, num2;
public:
    First(int n1=0, int n2=0) : num1(n1), num2(n2)
    {  }
    void ShowData() { cout<<num1<<", "<<num2<<endl; }
};
class Second
{
private:
    int num3, num4;
public:
    Second(int n3=0, int n4=0) : num3(n3), num4(n4)
    {  }
    void ShowData() { cout<<num3<<", "<<num4<<endl; }
    Second& operator=(const Second& ref)
    {
        cout<<"Second& operator=()"<<endl;
        num3=ref.num3;
        num4=ref.num4;
        return *this;
    }
};
```

```C++
int main(void)
{
    First fsrc(111, 222);
    First fcpy;
    Second ssrc(333, 444);
    Second scpy;
    fcpy=fsrc;
    scpy=ssrc;
    fcpy.ShowData();
    scpy.ShowData();
    First fob1, fob2;
    Second sob1, sob2;
    fob1=fob2=fsrc;
    sob1=sob2=ssrc;
    fob1.ShowData();
    fob2.ShowData();
    sob1.ShowData();
    sob2.ShowData();
    return 0;
}
```

```C++
Second& operator=()
111, 222
333, 444
Second& operator=()
Second& operator=()
111, 222
111, 222
333, 444
333, 444
```

# <br>디폴트 대입 연산자의 문제점

* 이 역시 디폴트 복사 생성자에서 보인 문제점과 유사하다.
  * 얕은 복사로 인해 문제가 발생할 수 있다!
* 소멸자의 호출 과정에서 이미 소멸한 객체를 소멸시키면서 문제가 발생한다.
* 다음과 같이 해결할 수 있다:

```C++
class Person
{
    char * name;
    int age;
public:
    Person(char * myname, int myage)
    {
        int len=strlen(myname)+1;
        name=new char[len];
        strcpy(name, myname);
        age=myage;
    }
    void ShowPersonInfo() const
    {
        cout<<"이름: "<<name<<endl;
        cout<<"나이: "<<age<<endl;
    }
    ~Person()
    {
        delete []name;
        cout<<"called destructor!"<<endl;
    }
};
```

```C++
int main(void)
{
    Person man1("Lee dong woo", 29);
    Person man2("Yoon ji yul", 22);
    man2=man1;
    man1.ShowPersonInfo();
    man2.ShowPersonInfo();
    return 0;
}
```

```C++
Person& Person::operator=(const Person& ref)
{
    delete []name;
    int len=strlen(ref.name)+1;
    name= new char[len];
    strcpy(name, ref.name);
    age=ref.age;
    return *this;
}
```

```C++
이름: Lee dong woo
나이: 29
이름: Lee dong woo
나이: 29
called destructor!
```

# <br>상속 구조에서의  대입 연산자

```C++
class First
{
private:
    int num1, num2;
public:
    First(int n1=0, int n2=0) : num1(n1), num2(n2)
    {  }
    void ShowData() { cout<<num1<<", "<<num2<<endl; }
    First& operator=(const First&ref)
    {
        cout<<"First& operator=()"<<endl;
        num1=ref.num1;
        num2=ref.num2;
        return *this;
    }
};
class Second : public First
{
private:
    int num3, num4;
public:
    Second(int n1, int n2, int n3, int n4) 
        : First(n1, n2), num3(n3), num4(n4)
    {  }
    void ShowData() 
    {
        First::ShowData();
        cout<<num3<<", "<<num4<<endl; 
    }    
};
```

유도 클래스의 디폴트 대입 연산자는 기초 클래스의 대입 연산자 역시 호출한다.

하지만 유도 클래스의 대입 연산자를 오버로딩하면, 기초 클래스의 대입 연산자를 명시적으로 호출해줘야 한다:

```C++
Second& operator=(const Second &ref)
{
    cout<<"Second& operator=()"<<endl;
    First::operator=(ref);
    num3=ref.num3;
    num4=ref.num4;
    return *this;
}
```

```C++
int main(void)
{
    Second ssrc(111, 222, 333, 444);
    Second scpy(0, 0, 0, 0);
    scpy=ssrc;
    scpy.ShowData();
    return 0;
}
```

```C++
First& operator=()
111, 222
333, 444
```

# <br>멤버 초기자의 성능 향상 확인

```C++
class AAA
{
private:
    int num;
public:
    AAA(int n=0): num(n)
    {  
        cout<<"AAA(int n=0)"<<endl;
    }
    AAA(const AAA &ref): num(ref.num)
    {  
        cout<<"AAA(const AAA & ref)"<<endl;
    }
    AAA & operator=(const AAA &ref)
    {
        num=ref.num;
        cout<<"operator=(const AAA &ref)"<<endl;
        return *this;
    }
};class BBB
{
private:
    AAA mem;
public:
    BBB(const AAA & ref)
        : mem(ref)
    {  }
};class CCC
{
private:
    AAA mem;
public:
    CCC(const AAA & ref)
    {
        mem=ref;
    }
};
```

CCC 클래스의 경우 인자를 대입하는 연산이 추가로 호출된다.

BBB의 경우 즉시 AAA의 생성자를 호출하게 할 수 있으므로, 연산이 단순해진다.

```C++
int main(void)
{
    AAA obj1(12);
    cout<<"*********************"<<endl;
    BBB obj2(obj1);
    cout<<"*********************"<<endl;
    CCC obj3(obj1);
    return 0;
}
```

```C++
AAA(int n=0)*********************
AAA(const AAA& ref)
*********************
AAA(int n=0)
operator=(const AAA& ref)
```

# <br>인덱스 연산자 오버로딩

* C, C++의 배열 접근은 경계 검사를 하지 않는다.
  * error-prone!
* operator[]를 오버로딩함으로써, 이러한 경계 검사를 수행할 수 있다.

```C++
class BoundCheckIntArray 
{
private:
    int * arr;
    int arrlen;
public:
    BoundCheckIntArray(int len) :arrlen(len)
    {
        arr=new int[len];
    }
    int& operator[] (int idx)
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    ~BoundCheckIntArray()
    {
        delete []arr;
    }
};
```

```C++
int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i=0; i<5; i++)
        arr[i]=(i+1)*11;
    for(int i=0; i<6; i++)
        cout<<arr[i]<<endl;
    return 0;
}
```

```C++
11
22
33
44
55
Array index out of boud exception
```

# <br>const 오버로딩 활용

```C++
class BoundCheckIntArray 
{
private:
    int * arr;
    int arrlen;
    BoundCheckIntArray(const BoundCheckIntArray& arr) { }
    BoundCheckIntArray& operator=(const BoundCheckIntArray& arr) { }
public:
    BoundCheckIntArray(int len) :arrlen(len)
    {
        arr=new int[len];
    }
    int& operator[] (int idx)
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int GetArrLen() const 
    {
        return arrlen;
    }
    ~BoundCheckIntArray()
    {
        delete []arr;
    }
```

operator[]는 const가 아니므로, ShowAllData()에서 호출될 수 없다.

```C++
void ShowAllData(const BoundCheckIntArray& ref)
{
    int len=ref.GetArrLen();
    for(int idx=0; idx<len; idx++)
        cout<<ref[idx]<<endl; // compile error!
}
```

```C++
int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i=0; i<5; i++)
        arr[i]=(i+1)*11; 
    ShowAllData(arr); // compile error!
    return 0;
}
```

```C++
class BoundCheckIntArray 
{
private:
    int * arr;
    int arrlen;
    BoundCheckIntArray(const BoundCheckIntArray& arr) { }
    BoundCheckIntArray& operator=(const BoundCheckIntArray& arr) { }
public:
    ...
    int& operator[] (int idx)
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int operator[] (int idx) const 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    ...
};
```

* 따라서 const를 추가한 함수를 하나 더 오버로딩 한다!
  * const 역시 함수 시그니처에 포함되므로, 두 개를 오버로딩해야 한다.

```C++
void ShowAllData(const BoundCheckIntArray& ref)
{
    int len=ref.GetArrLen();
    for(int idx=0; idx<len; idx++)
        cout<<ref[idx]<<endl;
}
```

```C++
int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i=0; i<5; i++)
        arr[i]=(i+1)*11; 
    ShowAllData(arr);
    return 0;
}
```

# <br>객체 배열 클래스

```C++
class BoundCheckPointArray 
{
private:
    Point * arr;
    int arrlen;
    BoundCheckPointArray(const BoundCheckPointArray& arr) { }
    BoundCheckPointArray& operator=(const BoundCheckPointArray& arr) { }
public:
    BoundCheckPointArray(int len) :arrlen(len)
    {
        arr=new Point[len];
    }
    Point& operator[] (int idx)
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    Point operator[] (int idx) const 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
};
```

다음 코드는 객체의 저장을 객체 간의 대입 연산으로  수행한다.

```C++
int main(void)
{
    BoundCheckPointArray arr(3);
    arr[0]=Point(3, 4);
    arr[1]=Point(5, 6);
    arr[2]=Point(7, 8);
    for(int i=0; i<arr.GetArrLen(); i++)
        cout<<arr[i];
    return 0;
}
```

```C++
[3, 4]
[5, 6]
[7, 8]
```

```C++
typedef Point * POINT_PTR;
class BoundCheckPointPtrArray 
{
private:
    POINT_PTR * arr;
    int arrlen;
    BoundCheckPointPtrArray(const BoundCheckPointPtrArray& arr) { }
    BoundCheckPointPtrArray& operator=(const BoundCheckPointPtrArray& arr) { }
public:
    BoundCheckPointPtrArray(int len) :arrlen(len)
    {
        arr=new POINT_PTR[len];
    }
    POINT_PTR& operator[] (int idx)
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    POINT_PTR operator[] (int idx) const 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
};
```

다음 코드는 객체의 주소 값을 이용해서 값을 관리한다.

```C++
int main(void)
{
    BoundCheckPointPtrArray arr(3);
    arr[0]=new Point(3, 4);
    arr[1]=new Point(5, 6);
    arr[2]=new Point(7, 8);
    for(int i=0; i<arr.GetArrLen(); i++)
        cout<<*(arr[i]);
    delete arr[0];
    delete arr[1];
    delete arr[2];
    return 0;
}
```

```C++
[3, 4]
[5, 6]
[7, 8]
```

# <br>new, delete 연산자 오버로딩

* 기본적으로 제공되는 new 연산자가 하는 일은 다음과 같다:
  * 메모리 공간의 할당
  * 생성자의 호출
  * 할당하고자 하는 자료형에 맞게 반환된 주소 값의 형 변환
* 하지만 new 연산자를 오버로딩하면, 메모리 공간의 할당만 오버로딩할 수 있다.
* delete 역시 오버로딩할 수 있으며, 메모리 공간의 소멸을 책임진다.
  * void 포인터 형 대상의 delete 연산을 허용하지 않는다면, char 포인터 형으로 변환해서 delete 연산을 진행하면 된다.

* 객체 생성이 완성된 상태가 아닌데, 오버로딩된 new 멤버 함수의 호출이 가능한 이유:
  * 이들은 static으로 선언된 함수이다.

```C++
class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y) {  }
    friend ostream& operator<<(ostream& os, const Point& pos);
    void * operator new (size_t size)
    {
        cout<<"operator new : "<<size<<endl;
        void * adr=new char[size];
        return adr;
    }
    void operator delete (void * adr)
    {
        cout<<"operator delete ()"<<endl;
        delete []adr;
    }
};
ostream& operator<<(ostream& os, const Point& pos)
{
    os<<'['<<pos.xpos<<", "<<pos.ypos<<']'<<endl;
    return os;
}
```

```C++
int main(void)
{
    Point * ptr=new Point(3, 4);
    cout<<*ptr;
    delete ptr;
    return 0;
}
```

```C++
operator new : 8
[3, 4]
operator delete ()
```

```C++
class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y) {  }
    friend ostream& operator<<(ostream& os, const Point& pos);
    void * operator new (size_t size)
    {
        cout<<"operator new : "<<size<<endl;
        void * adr=new char[size];
        return adr;
    }
    void * operator new[] (size_t size)
    {
        cout<<"operator new [] : "<<size<<endl;
        void * adr=new char[size];
        return adr;
    }
    void operator delete (void * adr)
    {
        cout<<"operator delete ()"<<endl;
        delete []adr;
    }
    void operator delete[] (void * adr)
    {
        cout<<"operator delete[] ()"<<endl;
        delete []adr;
    }
};
```

* new[]와 delete[] 역시 유사하다.
  * 괄호 안의 숫자를 이용해서 사이즈를 계산해 해당 함수의 인자로 넘겨준다.

```C++
int main(void)
{
    Point * ptr=new Point(3, 4);
    Point * arr=new Point[3];
    delete ptr;
    delete []arr;
    return 0;
}
```

```C++
operator new : 8
operator new [] : 24
operator delete ()
operator delete[] ()
```

# <br>포인터 연산자 오버로딩

```C++
class Number
{
private:
    int num;
public:
    Number(int n) : num(n) {  }
    void ShowData() { cout<<num<<endl; }
    Number * operator->()
    {
        return this;
    }
    Number & operator*()
    {
        return *this;
    }
};
```

* ->, * 역시 오버로딩 할 수 있다.
  * -> : 포인터가 가리키는 객체의 멤버에 접근
  * *  : 포인터가 가리키는 객체에 접근
* 주의점:
  * -> 연산자의 경우 객체 그 자체를 넘기면 된다.
  * num->ShowData();
  * num.operator->() ShowData();
  * num.operator->() -> ShowData();
  * 중간의 과정에서 문법적으로 성립하는 부분이 있으므로, 컴파일러는 자동적으로 -> 연산자를 하나 더 추가하여 해석을 진행한다.

```C++
int main(void)
{
    Number num(20);
    num.ShowData();
    (*num)=30;
    num->ShowData();
    (*num).ShowData();
    return 0;
}
```

# <br>펑터

```C++
class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y) 
    {  }
    Point operator+(const Point & pos) const 
    {
        return Point(xpos+pos.xpos, ypos+pos.ypos);
    }
    friend ostream& operator<<(ostream& os, const Point& pos);
};
ostream& operator<<(ostream& os, const Point& pos)
{
    os<<'['<<pos.xpos<<", "<<pos.ypos<<']'<<endl;
    return os;
}
```

Functor(a.k.a Function Object)

operator() 오버로딩을 이용해서 함수처럼 동작하게 만드는 객체

```C++
class Adder
{
public:
    int operator()(const int &n1, const int &n2)
    {
        return n1+n2;
    }
    double operator()(const double &e1, const double &e2)
    {
        return e1+e2;
    }
    Point operator()(const Point &pos1, const Point &pos2)
    {
        return pos1+pos2;
    }
};
```

```C++
int main(void)
{
    Adder adder;
    cout<<adder(1, 3)<<endl;
    cout<<adder(1.5, 3.7)<<endl;
    cout<<adder(Point(3, 4), Point(7, 9));
    return 0;
}
```

# <br>펑터 예시

```C++
// sort algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector
bool myfunction (int i,int j) { return (i<j); }
struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;
int main () {
  int myints[] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33
  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33
  // using function as comp
  std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)
  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';
  return 0;
}
```

이를 이용해서 마치 인터페이스처럼 다룰 수 있다.

일종의 Strategy Pattern

# <br>형 변환 연산자

```C++
class Number
{
private:
    int num;
public:
    Number(int n=0) : num(n)
    {
        cout<<"Number(int n=0)"<<endl;
    }
    Number& operator=(const Number &ref)
    {
        cout<<"operator=()"<<endl;
        num=ref.num;
        return *this;
    }
    operator int ()    // 형 변환 연산자의 오버로딩
    {
        return num;
    }
    void ShowNumber() { cout<<num<<endl; }
};
int main(void)
{
    Number num1;
    num1=30;
    Number num2=num1+20;
    num2.ShowNumber();
    return 0;
}
```

* 원시 타입으로도 변환할 수 있다.
  * num1+20을 하기 위해 num1은 자동으로 int 형으로 변환된다.
  * 이 때, 먼저 num1의 operator+()가 호출된다.
    * 이 경우 존재하지 않으므로,
  * operator int ()가 호출되어 num1을 int로 변환한다.

```C++
Number(int n=0)
Number(int n=0)
operator=()
Number(int n=0)
30
```

* 심지어 다음도 가능하다!
  * 두 개의 인자 역시 중괄호를 이용해 명시하면 자동으로 형 변환이 수행된다.

```C++
#include <iostream>
using namespace std;
class Number
{
private:
    int num;
    int num2;
public:
    Number(int n) : num(n)
    {
        cout<<"Number(int n=0)"<<endl;
    }
    Number(int n, int n2) : num(n), num2(n2)
    {
        cout<<"Number(int n, int n2)"<<endl;
    }
    Number& operator=(const Number &ref)
    {
        cout<<"operator=()"<<endl;
        num=ref.num;
        num2=ref.num2;
        return *this;
    }
    void ShowNumber() { cout<<num<< "," << num2 <<endl; }
};
```

```C++
int main(void)
{
    Number num(50);
    num = {10, 20};
    num.ShowNumber();
    return 0;
}
```

```C++
Number(int n=0)
Number(int n, int n2)
operator=()
10,20
```

# <br>string

* C++ 표준 라이브러리에는 string 클래스가 정의되어 있다.
  * char* 대신, string 클래스를 이용해서 문자열을 다루는 것이 권장된다.

```C++
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
    string str1="I like ";
    string str2="string class";
    string str3=str1+str2;
    cout<<str1<<endl;
    cout<<str2<<endl;
    cout<<str3<<endl;
    str1+=str2;
    if(str1==str3)  
        cout<<"동일 문자열!"<<endl;
    else
        cout<<"동일하지 않은 문자열!"<<endl;
    string str4;
    cout<<"문자열 입력: ";
    cin>>str4;
    cout<<"입력한 문자열: "<<str4<<endl;
    return 0;
}
```

```C++
I like
string class
I like string class
동일 문자열!
문자열 입력: Hi~
입력한 문자열: Hi~
```

# <br>표준 string 클래스의 분석

* 문자열을 인자로 전달받는 생성자의 정의
  * 둘은 동치이다:
* 이는 다음과 같이 정의될 것이다:

```C++
string str1="I like ";
string str2="string class";
```

```C++
string str1("I like ");
string str2("string class");
```

```C++
String::String(const char* s)
{
    len=strlen(s)+1;
    str=new char[len];
    strcpy(str, s);
}
```

* 생성자, 소멸자, 복사 생성자, 대입 연산자의 정의
  * 문자열의 길이는 일정치 않으므로, 메모리 공간을 생성자 내에서 동적 할당해야 한다.
  * 이로 인해서 소멸자를 정의해야 하며, 깊은 복사를 하는 복사 생성자와 대입 연산자까지 함께 정의해야 한다.

```C++
String::String()
{
    len=0;
    str=NULL;
}
String::String(const String& s)
{
    len=s.len;
    str=new char[len];
    strcpy(str, s.str);
}
String::~String() 
{
    if(str!=NULL)
        delete []str; 
}
String& String::operator= (const String& s)
{
    if(str!=NULL)
        delete []str;
    len=s.len;
    str=new char[len];
    strcpy(str, s.str);
    return *this;
}
```

* 결합된 문자열로 초기화된 객체를 반환하는 + 연산자의 오버로딩
  * 이는 str3에 str1과 str2가 이어진 문자열이 저장된다.
* 정의는 다음과 같을 것이다:

```C++
String str3=str1+str2;
```

```C++
String String::operator+ (const String& s)
{
    char* tempstr=new char[len+s.len-1];
    strcpy(tempstr, str);
    strcat(tempstr, s.str);
    String temp(tempstr);
    delete []tempstr;
    return temp;
}
```

* 문자열을 덧붙이는 += 연산자의 오버로딩
  * 이는 str1의 문자열에 str2의 문자열이 덧붙여진 형태로 저장된다.
* 정의는 다음과 같을 것이다:

```C++
String& String::operator+= (const String& s)
{
    len+=(s.len-1);
    char* tempstr=new char[len];
    strcpy(tempstr, str);
    strcat(tempstr, s.str);
    if(str!=NULL)
        delete []str;
    str=tempstr;
    return *this;
}
```

* 내용 비교를 진행하는 == 연산자의 오버로딩
  * == 연산을 통해 두 문자열이 동일한지 아닌지를 알 수 있다.
* 정의는 다음과 같을 것이다:

```C++
if(str1==str3)     
    cout<<"동일 문자열!"<<endl;
else
    cout<<"동일하지 않은 문자열!"<<endl;
```

```C++
bool String::operator== (const String& s)
{
    return strcmp(str, s.str) ? false : true;
}
```

* 콘솔 입출력이 가능하도록 <<, >> 연산자의 오버로딩
  * << 연산자를 이용한 출력과 >> 연산자를 이용한 입력이 가능해야 한다.
* 정의는 다음과 같을 것이다:

```C++
String str4;
cout<<"문자열 입력: ";
cin>>str4;
cout<<"입력한 문자열: "<<str4<<endl;
```

```C++
ostream& operator<< (ostream& os, const String& s)
{
    os<<s.str;
    return os;
}
istream& operator>> (istream& is, String& s)
{
    char str[100];
    is>>str;
    s=String(str);
    return is;
}
```

댓글

댓글 쓰기

이 블로그의 인기 게시물

[코딩의탑] 5층: 포탈(Portal), 더 나아가기

이미지
2층에서 많은 부족함이 있었죠..   2층 에서 우리가 구현한 포탈은 다음과 같은 부족함이 있습니다: 포탈을 단순히 월드에 배치하기만 했으며, 포탈 건의 요구사항을 고려하지 않았습니다. 가령 포탈은 벽에 생성될 수 있어야 합니다. 플레이어의 포탈 이동만을 고려했습니다. 큐브 등 다른 오브젝트 역시 통과할 수 있어야 합니다. 포탈에 걸쳐있는 오브젝트는 포탈 양면에서 보일 수 있어야 합니다. 즉, 오브젝트의 복사가 이루어져야 합니다. Near plane clippng으로 인해 포탈에 들어가기 직전 카메라가 평면과 겹치는 순간, 포탈 평면의 뒷면 모습이 비춰집니다. 포탈에 비추는 플레이어의 모습이 3인칭으로 보여야 합니다. 효율적인 포탈 재귀 렌더링 방법이 필요합니다. 복습해봅시다. 벡터와 점의 변환   포탈 건너편으로 이동하는 효과를 주기 위해서, 우리는 적절히 오브젝트를 이동 및 회전시켜야 합니다. 속도 역시 적절한 방향으로 보존되어야 하죠. 포탈   먼저 위치와 속도는 3차원 벡터로 표현될 수 있습니다. 그리고 이것이 포탈과 포탈 사이에서 자연스럽게 이어져야 하죠. 마치 포탈이 붙어있는 것처럼요! 다음 그림을 참고해보세요. 블루 포탈과 오렌지 포탈은 서로가 위 방향 축을 기준으로 180도 회전한 상태에서 맞붙어있는 것처럼 느껴야 합니다. 블루 포탈과 오렌지 포탈   이는 각 포탈을 일종의 지역 좌표계로 생각해볼 수 있습니다. 포탈의 [앞 방향 벡터, 우측 방향 벡터, 위 방향 벡터]를 각각 [X, Y, Z]축으로 삼는 셈이죠. 우리는 마치 "이어져 있는" 환상을 선사해야 하므로, 한쪽 지역 좌표계의 좌표 값을 그대로 다른쪽 지역 좌표계의 좌표 값으로 자연스럽게 넘겨주면 됩니다. 다양한 방법이 있겠지만 성능을 위해, 각 축에 대한 내적의 값을 이용하도록 합시다. 각 축은 정규화되어 있고 수직이므로, 내적을 이용할 수 있습니다. 좌표계의 변환 소스 코드: APortal::TransformVectorToDestSpace(), Tra...
자세한 내용 보기

[코딩의탑] 4층: 툰 쉐이딩

이미지
가끔은 만화스러운 느낌이 좋을 때도 있죠.   셀 쉐이딩(Cel shading)이라고도 불리는 툰 쉐이딩 기법은 절제된 빛 표현으로 화면을 그리는 비사실적(non-photorealistic) 렌더링 기법 중 하나입니다.  <Borderlands 시리즈>   이러한 툰 쉐이딩은 다양한 방식으로 실현되고 있으며, 언리얼 엔진을 활용한 툰 쉐이딩 역시 어렵지 않습니다. 특히, 포스트 프로세싱을 이용하여 만화스럽게 후처리를 해주는 방법은 클라이언트 프로그래머들이 손쉽게 사용할 수 있는 방법입니다.   하지만, 포스트 프로세싱을 이용한 툰 쉐이딩은 다음과 같은 단점이 존재하는데요: 포스트 프로세싱 자체의 비용이 존재합니다. 특정한 머티리얼에만 툰 쉐이딩을 적용하기 어렵습니다. (커스텀 스텐실 버퍼를 활용하는 것이 대표적인 방법이며, 이는 개발자를 피곤하게 합니다)   따라서, 우리는 포스트 프로세싱을 활용하지 않는 툰 쉐이딩을 구현해보도록 하죠. 우리는 다음을 구현할 것입니다: 특정 물체의 윤곽선을 추가로 렌더링합니다. 특정 물체의 음영을 부드럽지 않은 단계별 음영으로 변경합니다. 이들의 사용 여부와 윤곽선 굵기, 색을 머티리얼 에디터 속성으로 결정할 수 있습니다. 반복되는 컴파일을 줄이기 위해 머티리얼 인스턴스로 만들 수 있으며, 윤곽선의 굵기를 재컴파일 없이 변경할 수 있습니다.   이는  언리얼 엔진 5의 소스를 직접 수정하는 방법임에 주의하세요. 이러한 방법 역시 마법이 아니므로, 비용이 존재합니다. 이는 차차 이야기하도록 하겠습니다. 그 전에 언리얼 엔진 5를 살펴보도록 하죠. 렌더링 패스 디퍼드 쉐이딩으로 렌더링에 필요한 다양한 정보를 담는 버퍼들   언리얼 엔진은 기본적으로 PC 게임에 한해 디퍼드 쉐이딩을 수행합니다. 디퍼드 쉐이딩이란 포워드 쉐이딩의 반대 개념입니다. 한 물체를 렌더링한다고 생각해보죠. 그 물체의 3차원 세계 좌표와 물체 표면의 법선, 표면 거칠기의 정도,...
자세한 내용 보기

[코딩의탑] 3층: 바다 렌더링

이미지
바다를 그려봅시다.   수많은 게임들은 바다를 배경으로 하고 있습니다. 굳이 바다를 게임의 메인 배경으로 하지 않더라도, 게임 어느 중간에는 꼭 바다를 볼 수 있는 순간이 나오기 마련이죠.  <Sea of Thieves>   이러한 바다를 유체역학적 지식으로 구현하는 것은 쉽지 않습니다. 화면에 보이는 입자가 너무 많아 현실적으로 계산 능력이 부족하기 때문입니다. 따라서 많은 게임들은 바다를 구현하기 위해서 수많은 편법을 활용하고 있습니다. 대표적인 방법은 Displacement Mapping(변위 매핑)을 이용하는 것이죠.  Displacement Mapping   Displacement Mapping이란 Displacement Map을 이용해 물체를 구성하는 일련의 정점들을 재배치하는 것을 의미합니다. 가령, 평평한 격자의 물체가 있고 다음과 같은 두 개의 Displacement Map이 있다면 우리는 파도와 같은 현상을 만들어낼 수 있습니다. 하나는 큰 파도(저주파)를, 다른 하나는 작은 파도(고주파)를 재현합니다. 흰색일수록 위에 있으며, 검은색일수록 아래에 있게 됩니다.   이러한 Displacement Map들을 겹친 후에, 서로 다른 방향으로 움직이게 만들고 겹쳐진 값을 이용해서 Displacement Mapping을 한다면 저렴한 연산으로 파도와 같은 환상을 만들어낼 수 있습니다. 하지만 이 방법은 정적으로 파도가 만들어진다는 한계가 있습니다. 바람의 방향, 파도의 세기 등을 조절하기가 어렵죠. 조금 더 멋진 Displacement Map을 만들 수 있는 방법이 있을까요? Jerry Tessendorf의 'Simulating Ocean Water'   영화 프로듀서이자 교수인 Tessendorf는 그럴듯한 바다를 시뮬레이션할 수 있는 방법을 논문으로 정리해 제안하였습니다. 제가 다룰 내용을 간단히 요약하면 다음과 같습니다: 파도는 일종의 사인파와 코사인파의 합입니다. 따라서 ...
자세한 내용 보기