[객체지향설계] 오버로딩과 메모리 할당에 대하여

C++에서의 메모리 할당

 

 

 

 

LHS와 RHS

 

LHS는 left-hand-side expression, RHS는 right-hand-side expression이다. 굳이 어렵게 생각하지 않고, 표현식에서 왼쪽의 할당받는 주체를 LHS라고 하고, 할당하는 대상을 RHS라고 한다.

 

z = x+y라는 식이 있다면, LHS는 z라고 하고, x+y는 RHS라고 한다.

 

 

C++에서의 메모리 모델

 

• &x (RHS에서만 사용)
  • 변수 x의 주소를 리턴한다.
• x (RHS의 경우)
  • 변수의 주소에 할당된 값을 리턴한다.
• x (LHS의 경우)
  • 변수의 주소에 RHS 값을 저장한다.
• *x (RHS의 경우)
  • 변수의 값이 가리키는 주소의 값을 리턴한다.
• *x (LHS의 경우)
  • 변수의 값이 가리키는 주소에 RHS 값을 저장한다.

 

 

 

const 키워드

 

 

const가 붙은 메모리 주소에 다른 값이 할당 될 수 없도록한다.(immutable)

 

int main() {
    const int x = 16;
    int y = 99;
    x = 20; // x의 주소 값에 더 이상 값을 할당할 수 없다.
    y = 31;
    return 1;
}

 

 

const 가 붙은 pointers

 

int main() {
    const int x = 16;
    int* y = &x;
    *y = 10;
    return 1;
}

 

여기서 y의 타입은 int* 이다. 그리고 y라는 변수에 x의 주소를 저장하는 상황이다.

이때, `int * y = &x` 부분에서 컴파일 에러가 난다. 그 이유는 이미 x의 주소는 freeze 된 상태인데, `int * y = &x`를 허용해준다면 그 주소를 바꿀 수도 있기 때문이다. 즉, y가 실질적으로 x의 주소를 가리키기 때문에 y를 통해 x의 주소를 바꿀 가능성이 생긴다.

 

컴파일에러가 나지 않도록 하기 위해서는 `const int* y`로 저장해야 한다. 이는 y를 따라가면 값을 바꾸지 못한다는 것을 의미한다. 앞서 배운 const의 정의를 생각해보자. const가 붙은 변수는 메모리 주소의 값을 변경할 수 없다.

const가 붙은 `int* y`의 메모리 주소의 값을 변경할 수 없고, 여기에는 x의 주소가 할당된다. 즉, x의 주소의 값을 바꿀 수 없다는 것과 같은 맥락이 된다.

 

 

 

아래 예시 코드로 이를 확인할 수 있다.

 

int main() {
    const int x = 16;
    const int* y = &x; // 여기서는 에러가 나지 않는다.
    *y = 10; // 이 부분은 y가 기리키는 주소의 값을 변경할 수 없기 때문에 에러가 난다.
    return 1;
}

 

 

 

다른 경우를 한번 살펴보자.

 

int main() {
    int x = 16;
    int z = 30;
    
    int* const y = &x;
    y = &z;
    return 1;
}

 

여기서 `int* const y`는 자기 자신이 얼려져 있는 것을 말한다.

앞서 말했듯이 const는 가리키는 대상의 메모리 주소의 값을 변경하지 못하는 것이다. y의 타입은 int*이지만, y 자체는 바꿀 수 없다.

 

`int* y`를 특별하게 생각하지 말자. 어짜피 똑같이 메모리 공간에 할당되는 주소이며, 그 안에 들어있는 값의 타입이 `int*`일 뿐이다. 즉, `int* const y`는 y의 주소의 값을 변경할 수 없다는 것이다. 이는 `y = &z`와 같이 그 주소의 값에 다른 값을 할당하는 것이 불가능함을 의미한다.

 

 

단, y가 가리키는 값인 int* y가 저장하고 있는 포인터의 주소의 값은 변경할 수 있다. 아래 예시를 통해 확인해 보자.

 

int main() {
    int x = 16;
    int* const y = &x;
    x = 20; // OK
    *y = 10; // OK
    return 1;
}

 

 

 

const 가 붙은 class

 

• 멤버 함수에도 const가 붙을 수 있다. 다만, 붙은 부분이 어디냐에 따라 그 의미도 다르다.
  • return되는 부분에 붙은 경우 : return 되는 값이 불변이다.
  • 파라미터 타입에 붙은 경우 : 인자의 값이 불변이다.
  • 함수 이름 뒤에 붙은 경우 : 함수안으로 전달되는 object(this)의 값이 불변이다.

 

 

class Car {
    public:
        Car(std::string name) : name_(name) {}
        const std::string* name() { return name_; } // 리턴 되는 변수가 불변이다.
        void set_name(const std::string name) { name = name + "hi" } // 인자인 name은 불변이라 에러
        void DoSomething() const { name_ = name_ + "hi"; } // 함수로 전달된 object가 불변이기 때문에 name_도 불변이다.(this.name_)
        
    private:
        std::string name_;
        Door doors[4];
};

int main() {
    Car car1("mycar");
    std::string* car_name = car1.name(); // 리턴되는 name이 불변이기 때문에 허용되지 않는다.
    // 가능하게 하려면, const를 붙여 메모리 주소의 값이 변하지 않도록 해야 한다.
    return 1;
}

 

 

위 코드는 const가 각 경우에 따라 안되는 경우를 코드로 나타내었다. 조금 생소한 함수뒤의 const도 그냥 함수 안의 object의 멤버 변수값도 바꿀 수 없다는 뜻이다.

 

 

Shallow copy vs. Deep copy

 

둘 다 copy를 하는 것에 있어 차이는 없다. 다만, 같은 주소를 바라보는 지 다른 주소를 바라보는 지의 차이다. 물론 둘다 포인터여야 한다.

 

• Shallow copy(얕은 복사)
  • 같은 포인터 값을 바라보도록 한다.(값은 같다.)
  • 즉, 메모리 자체를 복사하지 않고, 주소만 복사한다.
  • x = y
• Deep copy(깊은 복사)
  • 완전히 다른 포인터 값을 바라보도록 한다. (값은 같다.)
  • 즉, 메모리 주소를 복사하지 않고, 메모리 자체를 복사한다.
  • `x = new char[3]; strcpy(x, y);`

 

 

 

copy constructor에서의 shallow copy

 

사실 따로 생성하지 않아도 shallow copy는 바로 적용된다. 이는 객체안의 프로퍼티 중 포인터 멤버들을 복사할 때, 메모리 자체를 복사하는 것이 아닌 주소만을 복사한다. 즉, name_이 가리키는 곳의 값을 copy하는 것이 아니라, name_이 가리키는 곳만을 copy하는 것이다.

 

 

이는 car1과 복사된 객체 car2의 멤버 변수 name_이 동일한 주소를 가리키는 것이 되고, 주소에 든 값을 바꾸면 둘 다 동시에 바뀌게 된다.

 

class Car {
    public:
        Car(char* name) {
            name_ = new char[sizeof name];
            strcpy(name_, name);
        }
    Car(const Car& car) : name_(car.name_) {} // shallow copy, 별도로 지정하지 않아도 좋다.
    
    ...
    
    private:
        char* name_;
}


int main() {
    Car car1("mycar");
    Car car2 = car1;
    std::cout << car1.name() << std::endl; // mycar
    std::cout << car2.name() << std::endl; // mycar
    car1.set_name("yourcar");
    std::cout << car1.name() << std::endl; // yourcar
    std::cout << car2.name() << std::endl; // yourcar
}

 

 

copy constructor에서의 Deep copy

 

deep copy는 따로 새로운 메모리 주소를 할당해 주어야 한다. 즉, object를 생성할 때, 새롭게 name의 메모리를 할당해주고 저장해야 한다.

 

class Car {
    public:
        Car(char* name) {
            name_ = new char[sizeof name];
            strcpy(name_, name);
        }

    Car(const Car& car) { // deep copy를 위한 constructor
        name_ = new char[sizeof car.name_];
        strcpy(name_, car.name_);
    }
    
    ...
    
    private:
        char* name_;
}


int main() {
    Car car1("mycar");
    Car car2 = car1;
    std::cout << car1.name() << std::endl; // mycar
    std::cout << car2.name() << std::endl; // mycar
    car1.set_name("yourcar");
    std::cout << car1.name() << std::endl; // yourcar
    std::cout << car2.name() << std::endl; // mycar
}

 

 

생성자에서 멤버 변수의 값을 지정해 주기 위해 새롭게 메모리를 할당해주는 코드를 볼 수 있다.

 

Car(const Car& car) { // deep copy를 위한 constructor
    name_ = new char[sizeof car.name_];
    strcpy(name_, car.name_);
}

 

 

 

 

 

Function calls in C++

 

function에 인자를 어떠한 방식으로 전달해주는 지는 크게 3가지 방식으로 나뉜다.

 

• Call by values
  • 값을 copy하여 전달한다.
• Call by pointers
  • 인자의 주소를 전달한다.
• Call by reference
  • 인자의 참조 값을 전달한다.

 

 

 

Call by values

 

인자의 값을 복사하여 넘겨준다. Caller의 값이 Callee의 변화에 반영되지 않는다. 이는 값이 복사되었기 때문이다.

 

 

class Car {
    public:
        Car(std::string name) : name_(name) { }
        Car(const Car& car) : name_(car.name_ {}
        void set_name(std::string name) { name_ = name; }
        std::string name() { return name_; }
        
    private:
        std::string name_;
};

void ChangeCarName(Car car2, std::string name) {
    car2.set_name(name);
}

int main() {
    Car car1("mycar");
    std::cout << car1.name() << std::endl; // mycar
    ChangeCarName(car1, "yourcar");
    std::cout << car1.name() << std::endl; // mycar
    return 1;
}

 

위 ChangeCarName에서 car1 자체가 복사되어 넘어간다. 이렇게 객체가 함수의 매개변수로 넘어가는 Call by Value는 shallow copy가 진행된다.

 

shallow copy가 진행되면, 클래스 안의 멤버들이 복사가 될 것이다. 여기서 한 번 더 shalllow copy와 deep copy를 짚고 넘어가자. shallow copy는 포인터 멤버가 있을 때, 메모리 자체를 복사하지 않고 그 주소만 복사하는 것이다. deep copy는 포인터 멤버가 있을 때, 메모리 주소 대신 메모리 자체를 복사한다.

 

그러니까 Car의 멤버 중 name_은 포인터 변수가 아니므로, 굳이 shallow copy나 deep copy를 신경 쓸 필요가 없다. 그 값만이 복사되는 것이기 때문이다.(그냥 copy)

 

즉, car2에 복사되는 새로운 name_은 기존의 car1의 name_과 다른 메모리 공간에 같은 값만을 가질 수 있고, car1에서 접근하더라도 mycar만이 출력되는 것이다.

 

 

Call by Pointer

 

Call by Pointer는 인자에 주소를 넘긴다. 

그렇기 때문에 Callee의 변화가 Caller에게 반영된다. 값의 주소가 같기 때문이다. 또한 NULL pointer 또한 값의 인자로써 전달될 수 있기 때문에 이를 검증하는 코드 또한 필요하다.

 

일반적으로 Call by Value보다 빠르기 때문에 많이 사용한다.

 

 

void Add3(int * y) {
    if (y != NULL)
        *y += 3;
}

int main() {
    int x = 1;
    std::cout << x << std::endl; // 1
    Add3(&x); // 주소의 값을 전달한다.
    std::cout << x << std::endl; // 4
}

 

 

 

Call by Reference

 

Call by Pointer와 헷갈릴 수 있다. 차이점은 Call by Pointer는 포인터 값(즉, 주소 값)을 넘겨 주소로써 값을 변경하는 것이다. Call by Reference는 좌변의 값(즉, lvalue)을 넘겨 현재 전달하고자 하는 값의 참조를 넘긴다. 간단하게 생각해보자면 값의 참조 그 자체를 넘기는 것이다.

 

Call by Pointer와 마찬가지로 callee의 변화가 caller에 반영되며, Call by Value 보다 빠르다. 다만, NULL은 허용되지 않는다.

 

void Add3(int& y) {
    y += 3;
}

int main() {
    int x = 1;
    std::cout << x << std::endl; // 1
    Add3(x);
    std::cout << x << std::endl; // 4
    return 1;
}

 

 

return 값이 Copy 되는 경우

 

 

아무 것도 쓰지 않은 경우, 함수에서 리턴 값은 복사되어 전달된다. 값 그 자체가 copy되어 리턴된다고 생각하자. 그래서 리턴된 값을 바꾸어도, 해당 object 내에서의 값은 변할 수 없다.

 

class Car {
    public:
        Car(std::string name) : name_(name) { }
        void set_name(std::string name) { name_ = name; }
        std::string name() { return name_; }
    private:
        std::string name_;
}

int main() {
    Car car1("mycar");
    std::string car_nmae = car1.name();
    car_name += " hi";
    std::cout << car1.name() << std::endl; // mycar
    return 1;
}

 

 

 

 

return 값이 Address인 경우

 

포인터를 리턴하는 경우이다. 이때, 주소를 넘겨주기 때문에 원본의 값이 변경될 수 있다. 또한 포인터이기 때문에 NULL도 리턴될 수 있다.

 

일반적으로 Value를 리턴하는 것 보다 빠르다. (값을 copy하면, 메모리도 더 할당해야 하기 때문)

 

 

class Car {
    public:
        Car(std::string name) : name_(name) { }
        void set_name(std::string name) { name_ = name; }
        std::string* name() { return &name_; } // address를 리턴한다.
    
    private:
        std::string name_;
}

int main() {
    Car car1("mycar");
    std::string* car_nmae = car1.name();
    if (car_name != NULL) // NULL 체크를 꼭 해주자.
        *car_name += " hi";
    std::cout << car1.name() << std::endl; // mycar hi
    return 1;
}

 

return 값이 Reference인 경우

 

값의 참조를 리턴할 때이다. (member field)

원본의 값이 변경 될 수 있으며, NULL 값은 허용되지 않는다. 마찬가지로 Value를 리턴하는 것 보다 빠르다.

 

 

class Car {
    public:
        Car(std::string name) : name_(name) { }
        void set_name(std::string name) { name_ = name; }
        std::string& name() { return name_; } // reference를 리턴한다.
    
    private:
        std::string name_;
}

int main() {
    Car car1("mycar");
    std::string& car_nmae = car1.name();
    car_name += " hi";
    std::cout << car1.name() << std::endl; // mycar hi
    return 1;
}

 

 

 

 

함수에서 지역 변수를 리턴할 때, Address나 Reference를 사용하지 말자.

 

 

GetCarA와 GetCarR에서 tmp_car는 지역 변수이다. 즉, 해당 함수 스코프를 벗어나면 해당 객체의 주소가 파기되기 때문에 사용할 수 없다. 그렇기 때문에 pointer나, reference로 반환하면 error가 나는 것이다.

 

반면, GetCarV에서는 Car("value")라는 객체가 생성되어 복사되어 리턴된다. 그렇기 때문에 함수 스코프를 벗어나도, 사용할 수 있다.

 

이 임시 객체는 `Car car_value`에서 copy constructor가 동작되어 반환되기 때문에 name을 호출할 수 있다는 것이다.

Car GetCarV() {
    return Car("value");
}

Car* GetCarA() {
    Car tmp_car("address");
    return &tmp_car;
}

Car& GetCarR() {
    Car tmp_car("reference");
    return tmp_car;
}

int main() {
    Car car_value = GetCarV();
    std::cout << car_value.name() << std::endl; // OK
    
    Car* car_address = GetCarA();
    std::cout << car_address.name() << std::endl; // ERROR
    
    Car& car_reference = GetCarR();
    std::cout << car_reference.name() << std::endl; // ERROR
    
    return 1;
}

 

 

 

Function Overloading

 

똑같은 이름의 함수를 여러 번 사용할 수 있도록 하는 것이다. C++, Java는 지원하지만 C는 지원하지 않는 특징이 있다.

 

 

• Function descriptor : 리턴 타입, 함수 이름, 파라미터 타입이 일치하는 것
• Function signature : 함수 이름, 파라미터 타입이 일치하는 것

 

이러한 Function Overloading은 Signature가 달라야 정의할 수 있다.

int foo(int x);
int foo(int x, int y);
int foo(char x);
void foo(double x);
void foo(int x); // Error

 

 

다시말해 파라미터의 갯수나 타입이 다르면 재정의 할 수 있다. 기억할 만한 점은 이러한 Function Overloading의 가능하게 하는 것은 컴파일러(Compiler)라는 것이다.

 

이를 우리는 static dispatch라고 한다. 결정해 주는 것 자체는 dispatch라고 하고, static은 컴파일 과정을 의미한다.

(반대로 runtime 시 결정되는 것을 dynamic dispatch라고 한다.)

 

 

 

Overloading resolution rules

 

 

Function Overloading의 과정은 아래와 같이 동작한다.

 

1. viable function을 수집한다.

• 함수 이름이 같고, 파라미터 갯수가 같은 것들을 수집한 것을 의미한다.
• 만약 찾았는데 하나라면 거기서 끝낸다.

2. 여러 개라면 그 중에서 best matched 하나를 뽑는다.

• Exact Match : 인자의 타입과 파라미터 타입이 정확히 일치하는 것
• Promotion : 확장될 수 있는 것(4byte를 넘겼는데, 8byte로 받을 수 있는 것을 뽑는다.). 바이트가 같다면 promotion이 아니다. 이때 승격은 (char, short -> int), (float -> double)만 가능하다.
• Standard type conversion : 타입이 변환될 수 있는 것(int > char). 손실이 발생할 수도 있다. 즉, 자신 보다 byte가 작은 타입으로 변환이 가능하다. 사실 전부 가능한 것 같은데, 손실이 발생할 경우만 기회 비용을 따진다.
• Implicit or User-defined type Conversion
•  Error

 

 

best matched는 위의 순서를 따른다. 기본적으로 함수 이름과 파라미터 갯수가 같은 지 확인한다. 이후, 파라미터 타입의 일치 여부와 확장 여부, 타입 변환 여부 등을 확인한다.

 

 

void foo(int x) { std::cout << "foo(int x)" << std::end; }
void foo(int x, float y) { std::cout << "foo(int x, float y)" << std::endl; }
void foo(float x, float y) { std::cout << "foo(float x, float y)" << std::endl; }
void foo(float x) { std::cout << "foo(float x)" << std::endl; }

int main() {
    foo(3); // Exact match
    foo('a'); // Promotion
    foo(1, 2); // conversion
    foo(1.3f, 2.4); // conversion
    foo(1.3) // 두가지 함수로 바꿀 수 있기 때문에 에러
}

 

위 예시를 하나 하나 살펴보도록 하자.

 

• foo(3) :
  • 동일한 파라미터의 타입이 존재한다. 따라서 Exact Match로 처리해준다.
• foo('a') :
  • 동일한 파라미터는 없으므로, promotion으로 넘어간다. 'a'는 char이므로 1byte이고, foo(int x)가 가능하다.
• foo(1, 2) :
  • 동일한 파라미터는 없으며, void foo(int x, float y)와 void foo(float x, float y)는 승격이 불가능하므로 넘어간다.
  • conversion 단계에서는 여러개가 나오더라도 기회비용이 적은 함수를 선택한다. 만약 이 기회 비용 마저 같다면, 에러이다.
  • 여기서는 foo(int x, float y)가 기회 비용이 적으므로 이를 선택한다.
• foo(1.3f, 2.4) :
  • promotion으로 가능한 것이 없다. byte가 큰 타입으로 받는 것이 없기 때문에 conversion으로 넘어간다.
  • conversion 시 foo(int x, float y)와 foo(float x, float y)가 선택될 수 있다. 이때 기회 비용이 적은 foo(float x, float y)를 선택한다.
• foo(1.3)
  • 손실이 무조건 발생하므로 conversion으로 넘어간다.
  • conversion 시에는 기회 비용이 작은 것을 택한다. 이때 1.3은 double이므로 8byte이고, int는 4 byte, float도 4byte이다. 즉, 동일한 기회비용이 발생하므로, 이는 에러이다.

 

promotion vs. conversion

promotion은 바이트가 자신보다 큰지를 확인한다. 같은 것은 승급되지 않는다. 이때 정수 승격, 실수 승격 기준에 맞아야 한다. 코스트가 같으면 넘어간다.

conversion은 바이트가 자신과 같거나 작은 것으로 변환된다. 따라서 손실이 발생할 수도 있다. 같은 코스트가 있으면 에러가 난다.(코스트는 각 인자마다 하나로 친다.)

 

 

다이나믹 메모리 할당과 해제

 

 

 

Stack과 Call Stack에 대해 간단하게 짚고 넘어가자.

Stack은 먼저 들어온 데이터가 제일 마지막으로 나가는 자료구조로 굉장히 많은 곳에서 사용된다. Programming Languege에서도 이는 마찬가지인데, Call Stack이 그 예이다.

 

Call Stack은 런타임 시에 동작하는 함수들의 호출을 Stack 자료 구조에 접목시킨 것이다.

 

stack에서 각 함수들은 local data를 저장한다. 이 함수들 안에서 다른 함수를 호출(Call)하게 되면, 점점 쌓이는 구조가 되고, 호출한 함수가 종료하면, pop되는 구조가 된다.

 

 

컴파일러는 이렇게 호출된 함수가 얼마나 메모리를 할당하는 지 알고 있다. 그렇기 때문에 함수가 호출되면, Stack에 적절한 메모리 공간을 할당하여 배치할 수 있는 것이다. 이후, 호출이 끝나면, 메모리 안의 변수들을 할당이 해제 된다.

 

 

 

 

Heap memory allocation

 

메모리는 힙 영역 안에서 할당된다. 이렇게 할당하는 과정을 dynamic memory allocation이라고 부른다. 이 메모리의 Size는 런타임 시에 계산되어 할당된다.

 

이러한 dynamic memory allocation은 명시적으로 할당/해제 과정을 나타내 주어야 한다. 또한 이 과정에서 발생할 수 있는 메모리 누수나, Dangling pointer 에러를 조심해야 한다.

 

 

void foo() {
    int* x = (int*) malloc(sizeof(int));
    int* arr = (int*) malloc(sizeof(int)*4);
    Node* n = new Node;
    
    free(x);
    free(arr);
    delete n;
}

 

 

 

new 연산자를 통한 Dynamic allocation

 

• C++에서 new 키워드는 메모리 할당 시에 사용된다.
  • 일반적으로 malloc과 똑같이 동작한다.
  • 다른 점은 new 연산자는 메모리(heap) 영역에 공간을 할당하고 객체를 생성한 후, 그 주소를 반환한다. 또한 constructor를 유발시킨다.
• delete n을 통해서 destructor를 호출할 수 있다.
  • destructor가 호출되기 이전에 다른 명령을 내려 동작을 수행할 수도 있다.
  • delete는 destructor를 호출한다.

 

 

 

메모리 누수(Memory Leak)

 

메모리를 할당해 놓고, 해제하지 않았을 때 생긴다.

 

void bax() {
    Node* n = new Node(3);
    // 메모리 해제 없이 리턴
    return;
}

 

 

아래 예제의 경우, n은 여러 주소를 가리키다가 마지막에 할당된 주소만을 가리키기 때문에 전부 메모리 해제될 수 없다.

 

void bar() {
    Node* n;
    
    for(int i=0; i<100; ++i) {
        n = new Node(i);
    }
    
    delete n;
}

 

 

Dangling pointer

 

이미 할당 해제된 메모리에 접근하려고 할 때 발생하는 에러이다.

 

void foo() {
    Node* n = new Node(3);
    delete n;
    
    n-> ...
}

n을 가리키는 공간이 이미 해제되었는데, 접근하려고 했기 때문에 발생한다. 이로인해 발생할 수 있는 문제로는 Segfault, Security vulnerability, Undefined behavior가 있다.

 

 

 

 

Qualifiers and Keywords

 

 

 

 

 

Static 키워드

 

`static` 키워드가 붙게 되면, 프로그램의 수명 기간동안 할당된다. 즉, 프로그램이 시작할 때부터 할당이 되며 프로그램이 종료될 때 할당 해제된다.

 

void foo() {
    static int count = 0;
    std::cout << count++ << std::endl;
}

int main() {
    for(int i=0; i<10; ++i) {
        foo();
    }
    
    return 1;
}

 

 

객체에서의 Static 키워드

 

마찬가지로 객체에서도 static 키워드가 붙을 수 있다. 이 object는 프로그램이 시작될 때 할당 되고, 끝날 때 해제된다.

 

 

class Node {
    public:
        Node(int value) : value_(value) {
            std::cout << "Object Creation" << std::endl;
        }
    ~Node() {
        std::cout << "Object Deletion" << std::endl;
    }
}


void foo() {
    static Node n(3);
}

int main() {
    std::cout << "Start main" << std::endl;
    foo();
    foo();
    std::cout << "End main" << std::endl;
    return 1;
}

 

 

 

Static 멤버 필드

 

static이 붙은 멤버 필드는 Class로 만들어진 모든 Object에 대해 값을 공유한다. 그래서, object를 통해 static 멤버 필드를 호출하든, Class를 통해 호출하든 값이 공유되기 때문에 동일하다.

 

class Node {
    public:
        Node(int value) : value_(value) {}
        const static int kNodeVersion = 7;
        
    private:
        int value_;
};

int main() {
    Node n1(1);
    Node n2(2);
    
    std::cout << Node::kNodeVersion << std::endl;
    std::cout << n1.kNodeVersion << std::endl;
}

 

 

 

Static 멤버 함수

 

멤버 함수에 static이 붙으면, class 내부의 멤버 변수 중, static이 붙은 멤버 변수밖에 가져오지 못한다. 이는 멤버 변수의 this 변수가 없기 때문이다.

 

 

class Node {
    public:
        Node(int value) : value_(value) {}
        static int GetVersion() {
            value_ = 3; // 불가능
            int x= value_; // 불가능
            this -> kNodeVersion; // 불가능
            return kNodeVersion;
        }
        
    private:
         int value_;
         const static int kNodeVersion  = 7;
};

 

 

 

싱글톤 디자인 패턴

 

오직 단 한번의 Object를 생성하고 싶을 때 싱글톤 디자인 패턴을 사용한다.

해당 객체에 접근하고 싶을 때는 class 내부 메서드를 통해 접근하여야 하며, 새롭게 객체를 생성할 수 없다.

메모리를 아낄 수 있다는 점에서 의의를 둘 수 있다.

 

 

class NodeUtil {
    public:
        static NodeUtil* GetInstance() {
            if (instance_ == NULL) {
                instance_ = new NodeUtil;
            }
            return instance_;
        }
    private:
        NodeUtil() {}
        static NodeUtil* instance_;
}

NodeUtil* NodeUtil::instance_ = NULL;

int main() {
    // 오직 하나의 인스턴스만 생성된다.
    NodeUtil* util1 = NodeUtil::GetInstance();
    NodeUtil* util2 = NodeUtil::GetInstance();
    NodeUtil* util3 = NodeUtil::GetInstance();
    
    // 이외의 방법으로 객체를 생성할 수는 없다.
    NodeUtil util4;
    
    return 1;
}

 

중요하게 기억해야 할 것은 반드시 초기화 코드를 작성해 주어야 한다는 것이다.

`Node* NodeUtil::instance_ = NULL;`라는 코드를 Class 밖에서 써넣어 주어야 한다.

 

 

 

 

Mutable 멤버 필드

 

이전에 const에 대하여 떠올려보자. 함수 이름 뒤에 const가 붙은 것은 그 함수 body 내부에서 필드 값을 변경할 수 없었다. 이는 함수 내부의 this가 const 포인터가 되기 때문이다.

 

하지만, 일부 필드 값을 변경하고 싶은 경우 `mutable`이라는 것을 멤버 필드 앞에 붙이면 바꿀 수 있다.

 

class Node {
    public:
        Node(int value) : value_(value), mutable_count(0), normal_count(0) {}
        int value() const {
            mutable_count_++; // mutable 멤버 필드이기에 가능하다.
            normal_count_++; // 불가능하다.
            return value_;
        }
    private:
        int value_;
        mutable int mutable_count_; // mutable 멤버 필드
        int normal_count_;
}

 

 

 

 

Operator Overloading

 

 

 

Operator overloading

 

Operator 연산에 있어 사용자가 직접 정의할 수 있는 것을 말한다. 간단하게 말해 객체와 객체를 덧셈하지는 못하지만, 그 덧셈 연산 과정에서 각 객체의 멤버 변수의 덧셈으로 바꾸는 등의 동작을 정의할 수 있다는 것이다.

 

 

이러한 기능이 가능한 operator는 아래와 같다.

 

 

Operator overloading의 두 가지 타입

 

 

1. 멤버 함수로써의 Operator overloading

• 첫 번째 operand는 *this가 되고, 다른 것들은 파라미터가 된다.(즉, 두 객체 n1, n2에 대하여 n1 + n2이면, n1이 *this)
• 첫 번째 operand는 반드시 사용자 정의 타입의 객체이어야 한다.
• overloaded operator는 private 멤버 변수 필드에 접근할 수 있다.

 

2. 멤버 함수가 아닌 Operator overloading

 

• All operands는 파라미터로 취급된다.
• 첫 번째 operand가 굳이 사용자 정의 타입의 객체가 될 필요는 없다.
• overloaded operator는 private 멤버 변수 필드에 접근할  수 없다.

 

 

1번의 관한 예시 코드는 아래와 같다.

 

class Node {
    public:
        Node(int value) : value_(value) {}
        
        Node& operator+(Node& node) { // + operator overloading, *this는 n1이다. 인자는 n2이다.
            value_ += node.value_;
            return *this;
        }
        
        operator int() { // 타입 변환에 관한 operator overloading, 리턴 타입은 없으나 리턴한다.
            return value_;
        }
        
};

int main() {
    Node n1(3);
    Node n2(4);
    
    
    std::cout << (int)(n1 + n2) << std::endl;
    return 1;
}

 

 

다음은 2번에 관한 예시 코드이다.

 

class Node {
    public:
        Node(int value) : value_(value) {}
        int value() const { return value_; }
        
    private:
        int value_;
}


int operator*(int x, const Node& n) {
    return x - n.value();
}

double operator*(double x, const Node& n) {
    return x * n.value();
}


int main() {
    Node n(3);
    
    // 10 - 3 = 7이 리턴된다.
    std::cout << 10 * n << std::endl;
    
    // 10 * 3 = 30이 리턴된다.
    std::cout << 10.0 * n << std::endl;
    return 1;
}

 

 

 

이렇게 멤버 함수로 정의할 수 있는 Operator overloading 방식과 그렇지 않은 Operator가 따로 나뉠 수 있다. 아래는 그에 관한 표이다.