[C++] Constructor, Copy/Move Semantics

📚 C++ 생성자와 복사/이동 semantics

🔸 Member Initializer List (멤버 초기화 리스트)

문제가 되는 코드

class Cat
{
public:
    Cat() { mAge = 1; }
    Cat(int age) { mAge = age; }
private:
    int mAge;
};

class Zoo
{
public:
    Zoo(int kittyAge) { mKitty = Cat(kittyAge); }  // ❌ 비효율적!
private:
    Cat mKitty;
};

int main()
{
    Zoo cppZoo(4);
    return 0;
}

문제점: 불필요한 임시 객체 생성
1. Zoo 생성자가 실행되기 전에 mKitty의 기본 생성자 Cat()가 먼저 호출됨
2. 생성자 본문에서 Cat(kittyAge)로 임시 객체를 생성
3. 임시 객체를 mKitty에 대입 (복사 또는 이동)
4. 임시 객체 소멸

→ 총 2번의 생성자 호출 + 1번의 대입 연산 발생

Member Initializer List로 해결

class Zoo
{
public:
    Zoo(int kittyAge) : mKitty{kittyAge} {}  // ✅ 효율적!
private:
    Cat mKitty;
};

장점:

• mKitty를 생성과 동시에 초기화
• 불필요한 기본 생성자 호출 제거
• 임시 객체 생성 없음
• 단 1번의 생성자 호출만 발생

Member Initializer List 사용 규칙

• () 대신 {}를 사용하면 더 안전 (narrowing conversion 방지)
• 멤버 변수 선언 순서대로 초기화됨 (초기화 리스트 순서와 무관)
• const 멤버 변수와 참조 멤버 변수는 반드시 초기화 리스트를 사용해야 함

class Example
{
public:
    Example(int a, int b, int c) 
        : mA{a}           // 멤버 변수
        , mB{b}           // 콤마로 구분
        , mC{c} {}        // 마지막도 콤마 가능
        
private:
    int mA;
    int mB;
    int mC;
};

🔸 Copy/Move Constructor & Assignment

기본 예제 코드

class Cat
{
public:
    Cat() = default;  // 기본 생성자는 컴파일러가 자동 생성
    
    Cat(std::string name, int age) 
        : mName{std::move(name)}
        , mAge{age}
    {
        std::cout << mName << " constructor" << std::endl;
    }
    
    ~Cat()
    {
        std::cout << mName << " destructor" << std::endl;
    }
    
    // Copy Constructor (복사 생성자)
    Cat(const Cat& other) 
        : mName{other.mName}
        , mAge{other.mAge}
    {
        std::cout << mName << " copy constructor" << std::endl;
    }
    
    // Move Constructor (이동 생성자)
    Cat(Cat&& other) noexcept
        : mName{std::move(other.mName)}
        , mAge{other.mAge}
    {
        std::cout << mName << " move constructor" << std::endl;
    }
    
    // Copy Assignment (복사 대입 연산자)
    Cat& operator=(const Cat& other)
    {
        if (&other == this) return *this;  // Self-assignment 체크
        
        mName = other.mName;
        mAge = other.mAge;
        std::cout << mName << " copy assignment" << std::endl;
        return *this;
    }
    
    // Move Assignment (이동 대입 연산자)
    Cat& operator=(Cat&& other) noexcept
    {
        if (&other == this) return *this;  // Self-assignment 체크
        
        mName = std::move(other.mName);
        mAge = other.mAge;
        std::cout << mName << " move assignment" << std::endl;
        return *this;
    }
    
    void print() const
    {
        std::cout << mName << " " << mAge << std::endl;
    }
    
private:
    std::string mName;
    int mAge;
};

사용 예제

int main()
{
    Cat kitty{"kitty", 1};              // 일반 생성자
    Cat kitty2{kitty};                  // 복사 생성자
    Cat kitty3{std::move(kitty)};       // 이동 생성자
    
    Cat bori{"bori", 1};
    Cat nabi{"nabi", 2};
    
    //bori = nabi;						// 복사 대입 연산자
    bori = std::move(nabi);             // 이동 대입 연산자
    
    bori.print();  // nabi 2 (nabi의 데이터를 가져옴)
    nabi.print();  // (empty) 2 (mName이 이동되어 비어있음)
    
    return 0;
}

• 일반/복사/이동 생성자
  
• 복사/이동 대입 연산자
  

🔸 Self-Assignment 문제와 해결

Self-Assignment란?

Cat kitty{"kitty", 1};
kitty = kitty;              // 자기 자신을 대입
kitty = std::move(kitty);   // 자기 자신을 이동

문제 상황

• 기본 타입(int, string 등) 멤버만 있으면 큰 문제 없음
• 포인터 멤버 변수가 있으면 심각한 문제 발생 가능

class Cat
{
    std::string* mName;  // 포인터 멤버
    
public:
    Cat& operator=(const Cat& other)
    {
        delete mName;              // 1. 자신의 메모리 해제
        mName = new std::string(*other.mName);  // 2. other도 같은 객체면?
        // → 이미 해제된 메모리를 읽으려고 시도! (Undefined Behavior)
        return *this;
    }
};

해결 방법: Self-Assignment 체크

Cat& operator=(const Cat& other)
{
    if (&other == this) return *this;  // ✅ 자기 자신이면 바로 리턴
    
    mName = other.mName;
    mAge = other.mAge;
    std::cout << mName << " copy assignment" << std::endl;
    return *this;
}

Cat& operator=(Cat&& other) noexcept
{
    if (&other == this) return *this;  // ✅ 이동에서도 체크 필요
    
    mName = std::move(other.mName);
    mAge = other.mAge;
    std::cout << mName << " move assignment" << std::endl;
    return *this;
}

🔸 noexcept 키워드

noexcept를 붙여야 하는 함수
1. Destructor (소멸자)
2. Move Constructor (이동 생성자)
3. Move Assignment (이동 대입 연산자)

이유:

• 위 세 함수는 새로운 리소스를 요청하지 않음
• 따라서 메모리 할당 실패 등의 예외가 발생할 가능성이 없음
• noexcept를 명시하면 컴파일러가 더 효율적인 코드를 생성할 수 있음
• STL 컨테이너가 move semantics를 안전하게 사용할 수 있음

~Cat() noexcept {}  // 소멸자는 암묵적으로 noexcept이지만 명시 가능

Cat(Cat&& other) noexcept 
    : mName{std::move(other.mName)}
    , mAge{other.mAge} {}

Cat& operator=(Cat&& other) noexcept
{
    if (&other == this) return *this;
    mName = std::move(other.mName);
    mAge = other.mAge;
    return *this;
}

noexcept의 중요성

std::vector<Cat> cats;
cats.push_back(Cat{"kitty", 1});

// vector가 크기를 늘릴 때:
// - Move constructor가 noexcept면 → 이동 사용 (빠름)
// - noexcept가 없으면 → 복사 사용 (느림, 안전함)

🔸 특수 멤버 함수 제어

함수 사용 금지: = delete

class Cat
{
public:
    Cat(const Cat& other) = delete;  // 복사 생성자 사용 금지
    Cat& operator=(const Cat& other) = delete;  // 복사 대입 사용 금지
};

int main()
{
    Cat kitty{"kitty", 1};
    Cat kitty2{kitty};  // ❌ 컴파일 에러!
    return 0;
}

사용 사례:

• 복사하면 안 되는 리소스 관리 클래스 (파일 핸들, 뮤텍스 등)
• 싱글톤 패턴 구현
• 이동만 허용하고 복사는 금지하려는 경우

C++11 이전 방식

class Cat
{
private:
    Cat(const Cat& other);  // 선언만 하고 구현하지 않음
    Cat& operator=(const Cat& other);
    // private이므로 외부에서 호출 불가
    // 구현이 없으므로 클래스 내부에서도 링크 에러 발생
};

Rule of Zero/Three/Five

• Rule of Zero: 특수 멤버 함수를 하나도 정의하지 않음 (컴파일러에게 맡김)
• Rule of Three: 소멸자, 복사 생성자, 복사 대입 중 하나를 정의하면 나머지도 정의
• Rule of Five: 위 3개 + 이동 생성자 + 이동 대입 (C++11 이후)

---

<참고 자료>

코드없는 프로그래밍
C++ Constructors and Destructors