C++ 객체 생성 규칙(생성, 복사, 이동, 소멸), 생성자 초기화, 생성자 오버로딩, 정규 타입

객체 생성자(Object Constructors)와 소멸자(Destructor)

- 올바르게 동작하려면 기본 연산을 하나도 구현하지 않거나 (0의 규칙) 모두 구현 (6의 규칙) 해야 한다

 

<the rule of zero>

- 기본 연산을 정의하지 않아도 되면 그렇게 하라

- 가장 단순하고, 명료한 의미를 준다

 

<the rule of six>

- 복사, 이동, 소멸자의 의미는 서로 밀접하게 연관되어 있어, 만약 이들 중 하나가 선언되면, 다른 함수들도 고려할 필요가 있다

- 복사/이동/소멸자 함수를 =default 또는 =delete로 선언하면, 컴파일러는 이동 생성자 및 이동 할당 연산자의 묵시적 선언이 안된다.

- 이동 생성자 또는 이동 할당 연산자를 =default 또는 =delete로 선언하면, 묵시적으로 생성된 복사 생성자 또는 복사 할당 연산자가 삭제된 것으로 정의된다

- 이들 중 하나가 선언되자마자 나머지는 모두 선언해야 한다. 모든 잠재적인 이동을 더 비싼 복사본으로 바꾸거나 클래스를 이동 전용으로 만드는 것과 같은 원치않는 효과를 피하기 위해서이다.

 

 

 

 

 

6가지 기본 연산자(default operations) 와 소멸자(Destructor)

 

 

(1) 기본 생성자 (Default Constructor)

• 설명: 매개변수가 없는 생성자. 클래스 객체를 초기화할 때 호출된다
• 역할: 객체를 초기 상태로 초기화하는 역할을 한다
• 자동 생성 조건: 클래스에 사용자가 생성자를 명시적으로 정의하지 않으면, 컴파일러가 자동으로 기본 생성자를 생성한다

class MyClass {
public:
    MyClass() = default;  // 기본 생성자
};
MyClass obj;  // 기본 생성자가 호출됩니다.

 

 

(2) 소멸자 (Destructor)

• 설명: 객체가 범위를 벗어나거나 삭제될 때 호출되는 함수.
• 역할: 객체가 소멸될 때 리소스를 해제하거나, 정리 작업을 수행한다.
• 자동 생성 조건: 클래스에 사용자가 소멸자를 명시적으로 정의하지 않으면, 컴파일러가 자동으로 소멸자를 생성한다.
• 오직 하나만 존재하며 파라미터는 없다

class MyClass {
public:
    ~MyClass() {
        // 리소스 해제 코드
    }
};
MyClass obj;  // 범위를 벗어나면 소멸자가 호출됩니다.

 

 

(3) 복사 생성자 (Copy Constructor)

• 설명: 다른 객체로부터 복사하여 새로운 객체를 생성할 때 호출되는 생성자.
• 역할: 기존 객체의 값을 복사하여 새로운 객체를 초기화한다
• 자동 생성 조건: 클래스에 사용자가 복사 생성자를 명시적으로 정의하지 않으면, 컴파일러가 자동으로 복사 생성자를 생성함

class MyClass {
public:
    MyClass(const MyClass& other) {
        // 복사 생성 코드
    }
};
MyClass obj1;
MyClass obj2 = obj1;  // 복사 생성자가 호출됩니다.

 

- 값 타입은 일반적으로 복사 가능해야 하며 값 타입은 내용(contents)에 관한 것으로 값 타입이 복사되면 항상 두 개의 독립적인 값이 생기고 각자 수정될 수 있어야 한다.  예를 들어, int나 double 같은 기본 타입은 복사하면 두 개의 독립적인 값이 생긴다. 하나의 값을 바꾸더라도 다른 값에는 영향을 주지 않는다.

 

(예외) -  클래스 계층구조의 인터페이스: 복사가 꼭 필요하지 않거나, 원치 않는 상황도 있다.

              예를 들어, 어떤 클래스는 복사하는 대신에 참조나 포인터를 통해 접근하는 것이 더 효율적일 수 있다.

           - 리소스 핸들(파일, 소켓 등)은 복사 가능할 수도 있고 그렇지 않을 수도 있음

           - 논리적, 성능상의 이유로 이동(move)하도록 타입이 정의될 수 있음

( std::unique_ptr처럼, 복사 대신 이동을 요구하는 타입도 있다. 이러한 타입은 한 번에 하나의 객체만 리소스를 가질 수 있도록 설계되었다. 복사하는 대신, 소유권을 다른 객체로 "이동"시키는 것이 더 적합한 경우 )

 

 

 

(4) 복사 대입 연산자 (Copy Assignment Operator)

• 설명: 하나의 객체를 다른 객체에 대입할 때 호출되는 연산자.
• 역할: 기존 객체의 값을 다른 객체로 복사.
• 자동 생성 조건: 클래스에 사용자가 복사 대입 연산자를 명시적으로 정의하지 않으면, 컴파일러가 자동으로 복사 대입 연산자를 생성한다

class MyClass {
public:
    MyClass& operator=(const MyClass& other) {
        // 복사 대입 코드
        return *this;
    }
};
MyClass obj1, obj2;
obj1 = obj2;  // 복사 대입 연산자가 호출됩니다.

 

 

(5) 이동 생성자 (Move Constructor)

• 설명: 임시 객체나 소유권이 이전되는 객체로부터 자원을 이동하여 새로운 객체를 생성할 때 호출되는 생성자.
• 역할: 자원의 복사 대신 이동을 통해 성능을 최적화
• 자동 생성 조건: 클래스에 사용자가 이동 생성자를 명시적으로 정의하지 않으면, 컴파일러가 자동으로 이동 생성자를 생성.단, 클래스가 복사 생성자나 복사 대입 연산자를 명시적으로 정의하지 않았을 때만 생성된다

class MyClass {
public:
    MyClass(MyClass&& other) noexcept {
        // 이동 생성 코드
    }
};
MyClass obj1 = MyClass();  // 이동 생성자가 호출됩니다. 우측값(rvalue)으로 객체를 생성하는 방법

 

- 이동 생성자는 객체를 복사하는 대신, 우측값(rvalue) 객체의 자원을 이동시켜 새로운 객체를 생성하는 생성자이다. 이는 깊은 복사(deep copy)보다 더 효율적으로 자원을 관리할 수 있다. 특히, 대량의 데이터를 다루거나 동적 메모리 할당이 많은 경우 이동 생성자는 큰 성능 이점을 제공한다.

- 우측값(rvalue)은 더 이상 필요하지 않거나 임시적으로 사용되는 값이므로, 불필요한 복사를 피하고 객체의 자원을 효율적으로 관리할 수 있다. 예를 들어, 큰 데이터를 포함하는 객체를 복사하는 대신, 이동을 통해 더 빠르게 새로운 객체를 생성할 수 있다.

 

C++ Shallow Copy(얕은 복사)와 Deep Copy(깊은 복사)

 

 

 

(6) 이동 대입 연산자 (Move Assignment Operator)

• 설명: 하나의 객체로부터 다른 객체로 자원을 이동할 때 호출되는 연산자.
• 역할: 자원의 복사 대신 이동을 통해 성능을 최적화
• 자동 생성 조건: 클래스에 사용자가 이동 대입 연산자를 명시적으로 정의하지 않으면, 컴파일러가 자동으로 이동 대입 연산자를 생성. 단, 클래스가 복사 생성자나 복사 대입 연산자를 명시적으로 정의하지 않았을 때만 생성된다

class MyClass {
public:
    MyClass& operator=(MyClass&& other) noexcept {
        // 이동 대입 코드
        return *this;
    }
};
MyClass obj1, obj2;
obj1 = std::move(obj2);  // 이동 대입 연산자가 호출됩니다.

 

 

< C+11 도입 개념 : noexcept >

 

이동 생성자와 이동 할당 연산자에서 예외가 발생하지 않도록 noexcept 키워드를 사용하여야 한다

noexcept는 함수가 예외를 던지지 않는다는 것을 컴파일러에게 알리는 키워드. 즉, noexcept가 붙은 함수는 예외가 발생하지 않을 것을 보장한다

 

 

왜 noexcept를 사용하는가?

• 안전성: 이동 연산에서 예외가 발생하지 않도록 보장하여 프로그램이 예외로 인해 예기치 않게 중단되는 상황을 방지
• 성능 최적화: 표준 라이브러리와 같은 여러 함수(특히 벡터, 리스트 등의 컨테이너)는 이동 생성자나 이동 할당 연산자가 noexcept로 표시되어 있는 경우에만 이동을 사용한다. 만약 noexcept가 없다면, 복사 연산을 사용할 수밖에 없기 때문에 성능이 저하될 수 있다.
• 예를 들어, 벡터가 내부적으로 메모리를 확장할 때, 기존 요소들을 새로운 메모리 공간으로 이동해야 한다. 이 과정에서 이동 연산이 예외를 던질 수 있다면, 벡터는 복사 연산을 사용해야만 한다. 복사는 이동보다 훨씬 비용이 많이 든다

class MyClass {
public:
    MyClass(MyClass&& other) noexcept {  // 이동 생성자에 noexcept 추가
        // 자원을 이동하는 코드
    }

    MyClass& operator=(MyClass&& other) noexcept {  // 이동 할당 연산자에 noexcept 추가
        if (this != &other) {
            // 자원 이동 코드
        }
        return *this;
    }

 

 

 

 

 

정규 타입(regular type)

 

정규 타입(Regular Type)은 C++와 같은 프로그래밍 언어에서 특정 객체 타입이 일관되고 예상 가능한 방식으로 동작하는지 확인하기 위해 사용되는 개념이다. 정규 타입은 다음과 같은 연산과 행동을 지원하고, 이러한 연산이 직관적으로 예상되는 방식으로 작동해야 한다는 것을 의미한다

 

정규 타입(Regular Type)은 복사 가능성, 동등성 비교, 그리고 일관된 구조적 규칙을 만족해야 한다. 이 개념은 코드에서 예측 가능한 동작을 보장하고, 객체 간의 상호작용을 직관적이고 명확하게 만든다. int 타입은 정규 타입의 좋은 예로, 복사와 비교가 가능하며, 이러한 연산이 직관적으로 작동한다.

이와 같은 정규 타입의 개념을 따름으로써, 프로그래밍에서 더욱 견고하고 유지보수하기 쉬운 코드를 작성할 수 있다.

 

 

1. 복사 가능성 (Copyability)

정규 타입은 복사 가능해야 한다. 즉, 객체를 다른 객체에 복사할 수 있어야 하며, 복사된 객체는 원본 객체와 동일한 값을 가져야 한다

int a = 10;
int b = a;  // b는 a의 복사본, b == 10

 

 

2. 동등성 비교 (Equality Comparison)

정규 타입은 동등성 비교 연산자 (==)를 지원해야 한다. 즉, 두 객체가 동일한지를 비교할 수 있어야 하며, 이 연산은 직관적으로 예상되는 결과를 반환해야 한다.

int x = 5;
int y = 5;
bool isEqual = (x == y);  // isEqual은 true

 

 

3. 구조적 규칙 (Structural Rules)

정규 타입은 일반적으로 다음과 같은 구조적 규칙을 따라야 한다

• 복사 생성자와 복사 대입 연산자는 해당 객체의 모든 데이터를 정확하게 복사해야 한다
• == 연산자와 != 연산자는 논리적으로 일관된 결과를 반환해야 한다. 즉, a == b가 참이면 a != b는 거짓이어야 한다.
• 정규 타입의 객체는 복사와 비교 외에도 값의 일관성을 유지해야 하며, 예상치 못한 동작을 하지 않아야 한다

struct Point {
    int x, y;
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};
Point p1 = {1, 2};
Point p2 = p1;  // p2는 p1의 복사본
bool isEqual = (p1 == p2);  // isEqual은 true

 

 

< 정규 타입의 예시: int >

  ex) int 타입은 정규 타입의 모든 기준을 충족하는 좋은 예이다:

- 복사 가능성: int 타입의 변수는 다른 변수로 복사할 수 있으며, 복사된 변수는 원본 변수와 동일한 값을 가진다.

- 동등성 비교: int 타입의 변수들은 == 연산자로 비교할 수 있으며, 논리적으로 일관된 결과를 제공한다

- 구조적 규칙: int 타입은 기본 타입으로 정의되어 있으며, 복사와 비교 동작이 일관되고 예측 가능하게 정의되어 있다.

 

 

 

 

 

 

생성자 오버로딩(Constructor Overloading)

 

동일한 클래스 내에 여러 개의 생성자를 정의하는 기법이다. 각 생성자는 매개변수의 수나 타입이 다르게 정의되고 이를 통해 객체를 다양한 방식으로 초기화할 수 있다. 컴파일러는 객체를 생성할 때 제공된 인수에 따라 적절한 생성자를 자동으로 선택한다.

쉽게 말해, 같은 이름을 가진 여러 개의 생성자를 만드는 것을 의미한다. 이 생성자들은 서로 다른 매개변수를 사용해 객체를 다양한 방식으로 초기화할 수 있다.

class Rectangle {
private:
    int width;
    int height;

public:
    // 1. 기본 생성자 (Default Constructor)
    // 매개변수가 없는 생성자입니다. 
    // Rectangle()처럼 인수가 없이 객체를 생성할 때 사용됩니다. 객체를 기본 상태로 초기화합니다.
    Rectangle() {
        width = 0;
        height = 0;
    }

    // 2. 매개변수가 있는 생성자 (Parameterized Constructor)
    // 인수로 제공된 값에 따라 객체의 멤버 변수를 초기화합니다. 
    // 여기서는 너비와 높이를 초기화하는 데 사용됩니다.
    Rectangle(int w, int h) {
        width = w;
        height = h;
    }

    // 3. 복사 생성자 (Copy Constructor)
    // 기존 객체를 복사하여 새로운 객체를 생성할 때 사용됩니다. 
    // 복사 생성자는 객체를 동일한 값으로 초기화해야 할 때 유용합니다.
    Rectangle(const Rectangle &rect) {
        width = rect.width;
        height = rect.height;
    }

    void display() {
        std::cout << "Width: " << width << ", Height: " << height << std::endl;
    }
};

 

<장점>

 

유연성: 다양한 방식으로 객체를 초기화할 수 있어, 사용자에게 더 많은 선택지를 제공

코드의 가독성: 각 생성자가 특정한 초기화 목적을 가지므로, 코드의 가독성이 높아짐

재사용성: 동일한 클래스 내에서 다양한 상황에 맞는 초기화 로직을 제공함으로써, 클래스의 재사용성이 증가

 

 

<주의사항>

- 생성자 오버로딩을 사용할 때는 각 생성자가 서로 다른 시그니처(매개변수의 수나 타입)를 가져야 한다.

- 너무 많은 생성자 오버로딩은 클래스의 복잡성을 증가시킬 수 있으므로, 필요한 경우에만 적절하게 사용해야 한다.

 

 

 

 

 

 

생성자 초기화

 

생성자를 초기화하는 방법은 다음과 같다. 왼쪽의 코드를 오른쪽 코드처럼 간편하게 표현할 수 있다.

 

 

 

- 의도하지 않은 형변환을 피하기

 

생성자 초기화는 new 키워드를 사용해 객체를 생성할 때, 그 객체가 완전히 초기화된 상태로 만들어지도록 보장하는 작업이다. 이 때, explicit 키워드를 사용하면 해당 생성자는 명시적으로 호출되어야 하며, 암시적 형 변환이나 임시 객체 생성으로 호출되지 않게 된다. explicit 키워드는 C++에서 단일 매개변수 생성자가 암시적(implicit)으로 호출되는 것을 방지하기 위해 사용된다. explicit 키워드를 사용하지 않으면, 컴파일러는 단일 매개변수 생성자(하나의 인수만 받아서 객체를 초기화하는 생성자)를 사용해 의도하지 않은 형변환을 자동으로 수행할 수 있다.

때로는 이 자동 변환이 의도치 않은 버그를 유발할 수 있기 때문에, 필요에 따라 explicit 키워드를 사용하는 것이 중요하다.

 

#include <iostream>

class MyClass {
public:
    // explicit 키워드를 사용한 단일 매개변수 생성자
    explicit MyClass(int value) : value_(value) {
        std::cout << "MyClass 생성자 호출, 값: " << value_ << std::endl;
    }

    void display() const {
        std::cout << "MyClass 객체의 값: " << value_ << std::endl;
    }

private:
    int value_;
};

int main() {
    // MyClass obj1 = 10;  // 오류 발생: 암시적 변환이 허용되지 않음
    MyClass obj1(10);    // 명시적으로 생성자 호출
    obj1.display();

    MyClass obj2(20);    // 명시적으로 생성자 호출
    obj2.display();

    return 0;
}

#include <iostream>

class MyClass {
public:
    // explicit 키워드를 사용하지 않은 단일 매개변수 생성자
    MyClass(int value) : value_(value) {
        std::cout << "MyClass 생성자 호출, 값: " << value_ << std::endl;
    }

    void display() const {
        std::cout << "MyClass 객체의 값: " << value_ << std::endl;
    }

private:
    int value_;
};

int main() {
    MyClass obj1 = 10;  // int를 MyClass로 자동 변환
    obj1.display();

    MyClass obj2(20);   // 일반적인 생성자 호출
    obj2.display();

    return 0;
}

 

 

- 복사 및 이동 생성자에 'explicit'을 사용하지 않는 이유??

 

복사 및 이동 생성자는 원래부터 자동으로 객체 간의 형변환을 수행하지 않기 때문이다.

만약 이 생성자들을 explicit으로 선언하면, 값에 의한 전달(pass-by-value) 또는 반환(return by value)이 복잡해지고 성능이 저하될 수 있다.

 

 

 

 

 

 

삭제된 생성자 선언하기(Deleted Constructor)

 

삭제된 생성자를 선언하는 코드는 소멸자와는 다른 개념이다. 삭제된 생성자를 선언하는 코드는 특정 생성자나 연산자, 함수 등을 명시적으로 사용할 수 없도록 만들 때 사용된다. ( 기본 생성자를 사용하지 못하게 할 때, 특정 복사 생성자나 복사 연산자를 삭제하고 싶을 때, 특정 연산자를 사용하지 못하게 할 때 등)

 

ex)

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;  // 복사 생성자 삭제
    NonCopyable& operator=(const NonCopyable&) = delete;  // 복사 할당 연산자 삭제
    
    // 다른 멤버 함수들...
};