[C to C++] friend, 연산자 오버로딩

C++/C to C++

[C to C++] friend, 연산자 오버로딩

nodeal 2019. 1. 31. 12:47

추가되는 기능

C++ class/struct에서는 멤버 변수를 선언과 함께 초기화할 수 있다.

class Object {
    private:
    int value = 0;

    public:
    void print() {
        std::cout << value << std::endl;
    }
};

int main() {
    Object o;
    o.print();
}

C++ class/struct에서는 기본 연산자를 오버로딩할 수 있다.

class Object {
    private:
    int value = 0;

    public:
    Object operator+(int add) {
        value += add;

        return *this;
    }

    void print() {
        std::cout << value << std::endl;
    }
};

int main() {
    Object o1;
    Object o2 = o1 + 10;
    o2.print();
}

객체 선언시 다른 객체를 대입할 때는 복사 생성자가 호출되고, 객체가 선언된 이후 다른 객체를 대입할 때는 대입 연산자가 호출된다.

class Object {
    private:
    int value = 0;

    public:
    Object(const Object& o) {
        std::cout << "Object(const Object&) << std::endl;
        value = o.value;
    }

    Object& operator=(const Object& o) {
        std::cout << "operator=(const Object&)" << std::endl;
        value = o.value;

        return *this;
    }

    void print() {
        std::cout << value << std::endl;
    }
};

int main() {
    Object o1;
    Object o2 = o1;
    Object o3;
    o3 = o1;
}

Object(const Object&)
operator=(const Object&)

Class 정의 내에 friend로 선언된 class는 private 멤버에 접근할 수 있다.

class A {
    friend class B;
    
    private:
    int value = 10;
};

class B {
    public:
    int get_A_value(A a) {
        return a.value;
    }
};

int main() {
    A a;
    B b;
    std::cout << b.get_A_value(a) << std::endl;
    
    return 0;
}

멤버 함수 정의시 friend 기호를 붙인다면 class 외부 전역 함수처럼 쓰인다. 이때, class의 private 멤버에는 접근할 수 있다.

class A {
    private:
    int value = 10;
    
    public:
    friend int get_value(A a) {
        return a.value;
    }
};

class B {
    public:
    int get_A_value(A a) {
        return get_value(a);
    }
};

int main() {
    A a;
    B b;
    std::cout << b.get_A_value(a) << std::endl;
    
    return 0;
}

목표

vector class에 맞는 적절한 기본 연산자를 오버로딩한다.

디자인

다음 연산자를 오버로딩한다.

vector& operator=(const vector& v)
인수로 받는 vector의 멤버 변수를 적절히 복사한 다음 자기 자신의 참조를 반환한다.
vector& operator+=(int element)
friend std::ostream& operator<<(std::ostream& ostream, const vector& v)
인수로 받는 std::ostream에 적절한 출력을 한 다음 std::ostream을 반환한다. 이때 chaining을 위해 참조를 반환한다. chaining은 다음의 꼴을 갖는다.
```
std::cout << v1 << v2 << ... << std::endl;
```
chaining을 사용하지 않을 때는 다음과 같이 구현해야한다.
```
std::cout << v1;
std::cout << v2;
...
std::cout << endl;
```

int& operator[](int index)
v[index] 꼴의 접근을 정의한다. 이때, v[index] = element; 꼴의 식을 사용할 수 있다.

int operator[](int index)
v[index] 꼴의 접근을 정의한다. 이때, v[index] = element; 꼴의 식을 사용할 수 없다.

class Object {
    private:
    int arr[10];

    public:
    int& operator[](int index) {
        std::cout << "mutable" << std::endl;
        return arr[index];
    }

    int operator[](int index) const {
        std::cout << "immutable" << std::endl;
        return arr[index];
    }
};

int main() {
    Object o1;
    const Object o2;
    o1[2] = 10; // OK
    o2[2] = 10; // Error
}

구현

constexpr int INITIAL_SIZE = 10;

class vector {
    private:
    int* data;
    int capacity;
    int length;
    
    bool ensure_capacity(int to_add) const {
        return length + to_add < capacity;
    }
    
    void increase_capacity() {
        auto tmp = data;
        data = new int[capacity * 2];
        std::copy(tmp, tmp + length, data);
        delete[] tmp;
        capacity *= 2;
    }
    
    void shiftLeft(int offset, int width) {
        int tail_length = length - offset - width;
        int* tail = new int[tail_length];
        std::copy(data + offset + width, data + length, tail);
        std::copy(tail, tail + tail_length, data + offset);
        delete[] tail;
    }
    
    void shiftRight(int offset, int width) {
        int tail_length = length - offset;
        int* tail = new int[tail_length];
        std::copy(data + offset, data + length, tail);
        std::copy(tail, tail + tail_length, data + offset + width);
        delete[] tail;
    }
    
    public:
    vector() {
        data = new int[INITIAL_SIZE];
        capacity = INITIAL_SIZE;
        length = 0;
    }
    
    vector(const vector& v) {
        data = new int[v.capacity];
        capacity = v.capacity;
        length = v.length;
        std::copy(v.data, v.data + v.length, data);
    }
    
    ~vector() {
        delete[] data;
    }
    
    void add(int element) {
        if (!ensure_capacity(1))
            increase_capacity();
        
        *(data + length++) = element;
    }
    
    void add(int index, int element) {
        if (!ensure_capacity(1))
            increase_capacity();
        
        shiftRight(index, 1);
        *(data + index) = element;
        length++;
    }
    
    int get(int index) const {
        return *(data + index);
    }
    
    int set(int index, int element) {
        auto tmp = *(data + index);
        *(data + index) = element;
        return tmp;
    }
    
    int remove(int index) {
        auto tmp = *(data + index);
        shiftLeft(index, 1);
        length--;
        
        return tmp;
    }
    
    void print() const {
        std::cout << '{';
        for (int i = 0; i < length; i++)
            std::cout << *(data + i) << ((i < length - 1) ? ", " : "");
        std::cout << '}' << std::endl;
    }
    
    vector& operator=(const vector& v) {
        data = new int[v.capacity];
        capacity = v.capacity;
        length = v.length;
        std::copy(v.data, v.data + capacity, data);
        
        return *this;
    }
    
    vector& operator+=(int element) {
        add(element);
        
        return *this;
    }
    
    int& operator[](int index) {
        return *(data + index);
    }
    
    int operator[](int index) const {
        return *(data + index);
    }

    std::ostream& operator<<(std::ostream& ostream, const vector& v) {
        ostream << '{';
        for (int i = 0; i < length; i++)
            ostream << *(data + i) << ((i < length - 1) ? ", " : "");
        ostream << '}';
    }
};