생성자와 소멸자

#include <string>

// 클래스 선언 (헤더 파일)
class MyClass {
private:
    int number{0};
    std::string text;

public:
    MyClass(); // 1. 기본 생성자 (매개변수가 없는 생성자)
    MyClass(int a, std::string b); // 2. 매개변수가 있는 생성자 (오버로딩)
    // ... 다른 멤버들 ...
};

// 생성자 정의 (소스 파일)
MyClass::MyClass() { // 1. 기본 생성자 정의
    // 멤버 변수 초기화
}

MyClass::MyClass(int a, std::string b) // 2. 매개변수가 있는 생성자 정의
    : number(a), text(b) {}

#include <iostream>
#include <string>

class Book {
private:
    std::string title;
    std::string author;
    int year;

public:
    // 1. 기본 생성자 (Default Constructor)
    // 매개변수가 없으며, 객체 생성 시 초기값을 지정하지 않을 때 호출됩니다.
    Book() : title("제목 없음"), author("작가 미상"), year(0) {
        std::cout << "기본 생성자 호출: 책 정보가 초기화되었습니다.\n";
    }

    // 2. 매개변수가 있는 생성자 (Parameterized Constructor)
    // 객체 생성 시 초기값을 전달받아 멤버 변수를 초기화합니다.
    Book(std::string t, std::string a, int y) : title(t), author(a), year(y) {
        std::cout << "매개변수 생성자 호출: " << title << " 책이 생성되었습니다.\n";
    }

    void displayBookInfo() {
        std::cout << "제목: " << title << ", 저자: " << author << ", 출판년도: " << year << std::endl;
    }
};

int main() {
    // 1. 기본 생성자 호출하여 객체 생성
    Book book1; // Book() 생성자 호출
    book1.displayBookInfo(); // 출력: 제목: 제목 없음, 저자: 작가 미상, 출판년도: 0

    std::cout << "--------------------------------\n";

    // 2. 매개변수 생성자 호출하여 객체 생성
    Book book2("어린 왕자", "앙투안 드 생텍쥐페리", 1943); // Book("...", "...", ...) 생성자 호출
    book2.displayBookInfo(); // 출력: 제목: 어린 왕자, 저자: 앙투안 드 생텍쥐페리, 출판년도: 1943

    std::cout << "--------------------------------\n";

    // 힙에 동적 할당 시에도 생성자 호출
    Book* book3 = new Book("구름빵", "백희나", 2004); // Book("...", "...", ...) 생성자 호출
    book3->displayBookInfo(); // 출력: 제목: 구름빵, 저자: 백희나, 출판년도: 2004
    delete book3; // 힙 객체 해제 (이때 소멸자 호출)

    return 0;
}

class MyClass {
private:
    int member;

public:
    explicit MyClass(int value);
};

MyClass::MyClass(int value) : member(value) {}

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int id;
    const double GPA; // const 멤버 변수는 반드시 초기화 리스트에서 초기화해야 함

public:
    // 멤버 초기화 리스트를 사용한 생성자
    Student(std::string n, int i, double g) : name(n), id(i), GPA(g) {
        std::cout << "Student 객체 생성: " << name << std::endl;
    }

    void displayInfo() {
        std::cout << "이름: " << name << ", 학번: " << id << ", GPA: " << GPA << std::endl;
    }
};

int main() {
    Student s1("김민수", 2023001, 3.85);
    s1.displayInfo();

    // GPA를 목록에서 빠뜨린 별도 생성자를 선언하면 const 멤버를 초기화하지 못해 오류입니다.
    return 0;
}

// 클래스 선언 (헤더 파일)
class MyClass {
public:
    MyClass(); // 생성자
    ~MyClass(); // 소멸자
    // ... 다른 멤버들 ...
};

// 소멸자 정의 (소스 파일)
MyClass::~MyClass() {
    // 리소스 해제 코드
}

#include <iostream>
#include <stdexcept>

class MyArray {
private:
    int* data; // 동적으로 할당된 정수 배열을 가리키는 포인터
    int size;

public:
    // 생성자: 동적으로 메모리 할당
    MyArray(int s) : data(nullptr), size(s) {
        if (size > 0) {
            data = new int[size]; // 힙에 size만큼의 int 배열 할당
            std::cout << "MyArray 생성자 호출: " << size << "개의 정수 배열 할당됨. 주소: " << data << std::endl;
            for (int i = 0; i < size; ++i) {
                data[i] = 0; // 초기화
            }
        } else {
            data = nullptr;
            size = 0;
            std::cout << "MyArray 생성자 호출: 유효하지 않은 크기. 배열 할당되지 않음.\n";
        }
    }

    // raw 포인터를 직접 소유하므로 얕은 복사를 금지합니다.
    MyArray(const MyArray&) = delete;
    MyArray& operator=(const MyArray&) = delete;
    MyArray(MyArray&&) = delete;
    MyArray& operator=(MyArray&&) = delete;

    // 소멸자: 동적으로 할당된 메모리 해제
    ~MyArray() {
        if (data != nullptr) {
            delete[] data; // new[]로 할당한 메모리는 delete[]로 해제
            std::cout << "MyArray 소멸자 호출: 할당된 메모리 " << size * sizeof(int) << " 바이트 해제됨.\n";
        } else {
            std::cout << "MyArray 소멸자 호출: 해제할 메모리가 없습니다.\n";
        }
    }

    // 배열 요소에 접근하는 함수 (안전하게)
    int& operator[](int index) { // [] 연산자 오버로딩 (뒤에서 자세히 학습)
        if (index < 0 || index >= size) {
            throw std::out_of_range("배열 인덱스 범위를 벗어났습니다.");
        }
        return data[index];
    }

    void display() {
        std::cout << "배열 내용: [";
        for (int i = 0; i < size; ++i) {
            std::cout << data[i] << (i == size - 1 ? "" : ", ");
        }
        std::cout << "]\n";
    }
};

int main() {
    // 1. 스택에 MyArray 객체 생성
    std::cout << "--- 스택 객체 생성 시작 ---\n";
    MyArray arr1(5); // MyArray 생성자 호출 (5개 정수 배열 할당)
    arr1[0] = 10;
    arr1[4] = 50;
    arr1.display(); // 출력: 배열 내용: [10, 0, 0, 0, 50]
    std::cout << "--- 스택 객체 생성 끝 ---\n";
    // main 함수 종료 시 arr1의 소멸자가 자동으로 호출되어 메모리 해제

    std::cout << "\n--- 힙 객체 생성 시작 ---\n";
    // 2. 힙에 MyArray 객체 동적 생성
    MyArray* arr2 = new MyArray(3); // MyArray 생성자 호출 (3개 정수 배열 할당)
    (*arr2)[0] = 100; // arr2->operator[](0)
    arr2->display();  // 출력: 배열 내용: [100, 0, 0]

    std::cout << "--- 힙 객체 사용 중 ---\n";
    delete arr2; // delete 표현식이 소멸자를 호출한 뒤 객체 저장 공간을 해제
    arr2 = nullptr;
    std::cout << "--- 힙 객체 소멸 완료 ---\n";

    // 범위 벗어난 인덱스 접근 시도 (오류 발생 예시)
    // MyArray bad_arr(2);
    // bad_arr[10] = 100; // 오류 발생!

    return 0; // main 함수 종료 시 arr1의 소멸자가 호출됨
}

#include <iostream>
#include <string>

class Point {
public:
    int x{0};
    int y{0};
    // 사용자 선언 생성자가 없음 -> Point()가 암시적으로 선언됨
};

class RequiredPoint {
public:
    RequiredPoint(int x, int y) : x(x), y(y) {}

    int x;
    int y;
};

class Line {
public:
    Point p1; // Point 객체 (기본 생성자 호출됨)
    Point p2;
    // 사용자 선언 생성자가 없음 -> Line()이 암시적으로 선언됨
};

int main() {
    Point pt; // 암시적으로 선언된 Point() 기본 생성자 호출
    std::cout << "Point.x: " << pt.x << ", Point.y: " << pt.y << std::endl; // 0, 0

    RequiredPoint required(10, 20);
    std::cout << "RequiredPoint.x: " << required.x << std::endl;
    // RequiredPoint missing; // 오류: 호출할 기본 생성자가 없음

    Line l; // 암시적으로 선언된 Line(), 이어서 p1과 p2의 Point() 호출
    std::cout << "Line.p1.x: " << l.p1.x << ", Line.p1.y: " << l.p1.y << std::endl;

    return 0;
}