헬스쟁이 프로그래머

class Vector
{

private:
    float x;
    float y;
    float z;

public:
    Vector(float x, float y, float z):
    x(x), y(y), z(z)
    {
    }
    //단항 연산자 -
    Vector operator-() const
    {
        return Vector(-x,-y,-z);
    }
    
    //단항 연산자 +
    Vector operator+() const
    {
        return *this;
    }
    
    //이항 연산자 +
    Vector operator+(const Vector& v) const
    {
        return Vector(this.x + v.x, this.y + v.y, this.z + v.z);
    }
    
    //이항 연산자 -
    Vector operator-(const Vector& v) const
    {
        return Vector(this.x - v.x, this.y - v.y, this.z - v.z);
    }
    
    //스칼라 이항 연산자 *
    Vector operator*(float v) const
    {
        return Vector(this.x * v, this.y * v, this.z * v);
    }
    
    //Vector 이항 연산자 * (dot product)
    Vector operator*(Vector v) const
    {
        return this.x * v.x +  this.y * v.y + this.z * v.z;
    }
    
    //이항 연산자 /
    Vector operator/(float v) const
    {
        return Vector(this.x / v, this.y / v, this.z / v);
    }
    
    //전위 연산자 --
    Vector& operator--()
    {
        --x;
        --y;
        --z;
        return *this;
    }
    
    //전위 연산자 ++
    Vector& operator++()
    {
        ++x;
        ++y;
        ++z;
        return *this;
    }
    
    //후위 연산자 ++
    Vector& operator++(int)
    {
        Vector temp = *this;
        ++(*this);
        return temp;
    }
    
    friend Vector operator*(float v1, const Vector& v2);
    
    //후위 연산자 --
    Vector& operator--(int)
    {
        Vector temp = *this;
        --(*this);
        return temp;
    }   
}

Vector operator*(float v1, const Vector& v2)
{
    return Vector(v2.x * v1, v2.y * v1, v3.z * v1);
}

int main()
{
    const Vector v1(1,1,1);
    const Vector v2(2,2,2);
    
    Vector v3 = +v1;
    Vector v4 = -v1;
    Vector v5 = ++v3;
    Vector v6 = --v4;
    Vector v7 = v1++;
    Vector v8 = v1--;
    Vector v9 = v1 + v2;
    Vector v10 = v1 - v2;
    Vector v11 = v1 * 8.0f;
    Vector v12 = v1 / 8.0f;
    float v13 = v11 * v12
    
    Vector v14 = 3.0f * v12; 
}

구현한 연산자 오버로딩은 사칙 연산을 부분적으로 구현한 것이다.

몇가지 유의사항은 아래와 같다.

1.  - 오버로딩 함수

Vector operator-() const
{
    return Vector(-x,-y,-z);
}

- 오버로딩 함수에 const 를 붙이는 이유는 const this 포인터를 사용하기 위함이다. (사용자가 const 객체를 이용할 경우를 대비함)

2. 후위 연산자 오버로딩 함수

//후위 연산자 ++
Vector& operator++(int)
{
    Vector temp = *this;
    ++(*this);
    return temp;
}

후위 연산자 오버로딩 함수는 한번의 복사가 필요하다. 

3. 만든 객체의 연산자 오버로딩 다른 방법

class Vector
{
    //code...
    friend Vector operator*(float v1, const Vector& v2);
}

우선 전역에 함수를 정의 하기전에 Vector class의 private으로 숨긴 데이터를 이용하기 위해 friend 키워드로 접근 가능하게 한다.

Vector operator*(float v1, const Vector& v2)
{
    return Vector(v2.x * v1, v2.y * v1, v3.z * v1);
}

전역으로 위와같이 함수를 구현하면 아래와 같이 순서를 바꿔서도 만들 수 있다. (but 코드구조가 별로 인듯..)

Vector v14 = 3.0f * v12;

쿠키 코딩 끝!

#include <iostream>
#include <functional>

using namespace std;

class Person
{
public:
    void print(int i)
    {
        cout << i << endl;
    }
    
};


int main()
{
    function<void(Person*, int)> func = &Person::print;
    
    Person person;
    func(&person, 1);
}

functional 라이브러리에 포함되어 있는 function <t>를 사용하여 객체의 멤버함수 포인터를 얻는 방법이다.

function<void(Person*, int)> func = &Person::print;

위의 코드에서 &Person::print는 pring 함수의 주소 값을 의미한다.

func(&person, 1);

func 안에 &person 을 넣는 이유는 클래스 내부의 멤버함수는 항상 암시적으로 this 포인터가 첫 번째 매개 변수로 들어가기 때문이다.

배운 것

1. function 을 이용한 class 멤버 함수 포인터 정의 간략화

class Person
{
private:
    const string _name;
    float _weight;
    float _height;
public:
    Person(const string& name, float weight, float height)
        : _name(name), _weight(weight), _height(height)
    {
    }
    
    float getWeight(/*const Person* this */) const
    {
        return _weight;
    }
};

int main()
{
    const Person person0("Donghee", 84.f, 178.8.f);
    person0.getWeight();
}

Person class의 getWeight에 const 키워드를 붙임으로써 Class 사용자는 Person Class를 Const로 선언하고 해당 멤버함수를 사용할 수 있다.

새로 배운 점

1. Class의 멤버함수는 암시적으로 this 포인터를 받는다.

2. Class를 const로 선언하는 사용하는 것을 대비할 때에는 get 함수에 대해 const 키워드를 붙이자. 

struct Transaction
{
    const int txID;
    const int fromID;
    const int toID;
    const int value;
}

class TransactionBuilder
{
private:
    int _fromID;
    int _toID;
    int _value;
    
public:
    Transaction build()
    {
    	int txID = _fromID ^ _toID ^ _value;
        return Transaction {txID, _fromID, _toID, _value};
    }
    
    TransactionBuilder& setFromID(int fromID)
    {
    	_fromID = fromID;
        return *this;
    }
    
    TransactionBuilder& settoID(int toID)
    {
    	_toID = toID;
        return *this;
    }
    
    TransactionBuilder& setvalue(int value)
    {
    	_value = value;
        return *this;
    }
}

int main()
{
    Transaction ts = TransactionBuilder().
    setFromID(10).
    settoID(20).
    setvalue(30).
    build();
}

this 포인터를 이용한 빌더 패턴이다.

set 함수들의 반환이 객체의 참조를 반환하는데 이때 현재 객체의 포인터 지정자를 반환하여 자기 자신을 반환하는 원리이다.

Village.h 파일 코드

#include <vector>

Class Person;
Class Village
{
private:
	std::vector<Person> persons;
public:
	void add(Person);
}

Village.cpp 파일 코드

#include "Village.h"
#include "Person.h"

void Village::add(Person person)
{
	persons.push_back(person)
}

1. Village 는 Person class를 사용한다. 하지만 Person의 Header 파일을 사용하지 않는다.

-> 의존 관계를 풀기 위해 -> Person의 코드가 수정될 경우 Village 까지 연쇄적으로 재빌드 해야함.

2. Village의 add 함수는 Village의 Header파일에서 선언만하고 정의는 Village.cpp 파일에서 정의함.