멤버 함수와 멤버 변수

#include <iostream>
#include <stdexcept>
#include <string>

class Circle {
private: // private 멤버 변수
    double radius; // 원의 반지름
    std::string color; // 원의 색상

public:
    // 생성자 (멤버 초기화 리스트 사용)
    Circle(double r, std::string c) : radius(r), color(c) {
        if (!(r >= 0.0)) { // 음수와 NaN을 모두 거부해 불변식을 세움
            throw std::invalid_argument("반지름은 0 이상이어야 합니다.");
        }
        std::cout << "Circle 객체 생성: 반지름 " << radius << ", 색상 " << color << std::endl;
    }

    // 멤버 함수 (게터/세터)
    double getRadius() const {
        return radius;
    }

    void setRadius(double r) {
        if (r >= 0) {
            radius = r;
        } else {
            std::cerr << "오류: 반지름은 음수가 될 수 없습니다." << std::endl;
        }
    }

    const std::string& getColor() const {
        return color;
    }

    void setColor(std::string c) {
        color = c;
    }

    // 원의 넓이를 계산하는 멤버 함수
    double calculateArea() const {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Circle c1(5.0, "빨강"); // 반지름 5.0, 색상 빨강인 원
    std::cout << "c1의 넓이: " << c1.calculateArea() << std::endl; // 출력: c1의 넓이: 78.5397

    Circle c2(10.0, "파랑"); // 반지름 10.0, 색상 파랑인 또 다른 원
    std::cout << "c2의 넓이: " << c2.calculateArea() << std::endl; // 출력: c2의 넓이: 314.159

    c1.setRadius(7.0); // c1의 반지름만 변경
    std::cout << "변경된 c1의 넓이: " << c1.calculateArea() << std::endl; // 출력: 변경된 c1의 넓이: 153.938

    return 0;
}

#include <iostream>
#include <string>

class Account {
private:
    std::string ownerName;
    double balance;

public:
    Account(std::string name, double initialBalance) : ownerName(name), balance(initialBalance) {
        std::cout << "계좌 생성: " << ownerName << "님의 초기 잔액 " << balance << std::endl;
    }

    // 입금 기능 (멤버 함수)
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount; // 멤버 함수는 private 멤버 변수 balance에 직접 접근 가능
            std::cout << amount << "원 입금. 현재 잔액: " << balance << std::endl;
        } else {
            std::cout << "입금액은 양수여야 합니다." << std::endl;
        }
    }

    // 출금 기능 (멤버 함수)
    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount; // private 멤버 변수 balance에 직접 접근 가능
            std::cout << amount << "원 출금. 현재 잔액: " << balance << std::endl;
        } else {
            std::cout << "출금 실패: 유효하지 않은 금액이거나 잔액 부족. 현재 잔액: " << balance << std::endl;
        }
    }

    // 잔액 조회 기능 (게터 멤버 함수)
    double getBalance() const {
        return balance; // private 멤버 변수 balance 값 반환
    }

    // 소유자 이름 조회 기능
    const std::string& getOwnerName() const {
        return ownerName;
    }
};

int main() {
    Account acc1("김미영", 50000.0);
    acc1.deposit(10000.0);    // 10000원 입금
    acc1.withdraw(5000.0);   // 5000원 출금
    std::cout << acc1.getOwnerName() << "님의 최종 잔액: " << acc1.getBalance() << std::endl; // 잔액 확인

    Account acc2("박지훈", 10000.0);
    acc2.withdraw(12000.0); // 잔액 부족으로 출금 실패
    std::cout << acc2.getOwnerName() << "님의 최종 잔액: " << acc2.getBalance() << std::endl;

    return 0;
}

class Sample {
public:
    int value() const;
};

#include <iostream>
#include <string>

class Point {
private:
    int x;
    int y;
    mutable int displayCount{0}; // 좌표가 아닌 진단용 구현 세부

public:
    Point(int _x, int _y) : x(_x), y(_y) {}

    // 값만 반환하는 게터 함수는 const 멤버 함수로 선언하는 것이 좋습니다.
    int getX() const { // const 멤버 함수
        // x = 10; // 컴파일 오류! const 함수 내에서 멤버 변수 변경 불가
        return x;
    }

    int getY() const { // const 멤버 함수
        return y;
    }

    // 객체의 const 여부에 따라 선택되는 두 오버로드
    int& xValue() {
        return x;
    }

    const int& xValue() const {
        return x;
    }

    // 객체의 상태를 변경하는 세터 함수는 const가 될 수 없습니다.
    void setX(int _x) {
        x = _x;
    }

    // Point 정보를 출력하는 함수 (값을 변경하지 않으므로 const가 적합)
    void display() const { // const 멤버 함수
        ++displayCount; // mutable 진단 값만 변경
        std::cout << "좌표: (" << x << ", " << y << ")" << std::endl;
    }

    int getDisplayCount() const {
        return displayCount;
    }
};

// 함수 매개변수로 const 참조자를 사용하는 경우
void printPoint(const Point& p) { // p는 const 객체를 참조
    p.display(); // OK: display()는 const 멤버 함수이므로 호출 가능
    // p.setX(10); // 컴파일 오류: p는 const 참조자이므로 const가 아닌 setX() 호출 불가
}

int main() {
    Point p1(10, 20);
    p1.display(); // 출력: 좌표: (10, 20)

    p1.xValue() = 15; // 비const 오버로드가 int&를 반환
    p1.display(); // 출력: 좌표: (15, 20)

    const Point p2(30, 40); // const 객체 생성
    p2.display(); // OK: display()는 const 멤버 함수이므로 호출 가능
    std::cout << "p2의 x: " << p2.xValue() << std::endl; // const 오버로드 선택
    // p2.setX(35); // 컴파일 오류: p2는 const 객체이므로 const가 아닌 setX() 호출 불가

    printPoint(p1); // p1은 const 참조자로 전달
    printPoint(p2); // p2는 const 참조자로 전달

    return 0;
}

#include <iostream>

class Meter {
private:
    int value;
    inline static int scale{1}; // C++17: 클래스 안 선언이 정의

public:
    explicit Meter(int initialValue) : value(initialValue) {}

    int scaledValue() const {
        return value * scale;
    }

    static void setScale(int nextScale) {
        if (nextScale > 0) {
            scale = nextScale;
        }
    }

    static int readRawValue(const Meter& meter) {
        return meter.value; // 전달받은 객체를 명시하면 private 상태도 읽을 수 있음
    }
};

int main() {
    Meter first(3);
    Meter second(5);

    Meter::setScale(2);
    std::cout << first.scaledValue() << ", " << second.scaledValue() << std::endl;
    std::cout << Meter::readRawValue(first) << std::endl;

    return 0;
}