접근 지정자

#include <iostream>
#include <string>

class User {
public: // public 접근 지정자
    std::string username; // 외부에서 직접 접근 가능
    std::string email;    // 외부에서 직접 접근 가능

    void displayUserInfo() { // 외부에서 직접 호출 가능
        std::cout << "사용자 이름: " << username << ", 이메일: " << email << std::endl;
    }
};

int main() {
    User user1;

    // public 멤버 변수에 직접 접근하여 값 할당
    user1.username = "Alice";
    user1.email = "alice@example.com";

    // public 멤버 함수 호출
    user1.displayUserInfo(); // 출력: 사용자 이름: Alice, 이메일: alice@example.com

    // 외부에서 public 멤버에 직접 접근 가능
    std::cout << "직접 접근: " << user1.username << std::endl;

    return 0;
}

#include <iostream>
#include <string>

class BankAccount {
private: // private 접근 지정자
    std::string accountNumber; // 계좌번호 (외부에서 직접 접근 불가)
    double balance;            // 잔액 (외부에서 직접 접근 불가)

public:
    // 생성자 (다음 장에서 자세히 다룸)
    BankAccount(std::string accNum, double initialBalance) {
        accountNumber = accNum;
        if (initialBalance >= 0) {
            balance = initialBalance;
        } else {
            balance = 0;
            std::cerr << "초기 잔액은 음수가 될 수 없습니다. 0으로 설정합니다." << std::endl;
        }
    }

    // public 멤버 함수 (private 멤버에 접근하여 작업 수행)
    void deposit(double amount) { // 입금
        if (amount > 0) {
            balance += amount;
            std::cout << amount << "원 입금되었습니다. 현재 잔액: " << balance << std::endl;
        } else {
            std::cout << "유효하지 않은 입금액입니다." << std::endl;
        }
    }

    void withdraw(double amount) { // 출금
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            std::cout << amount << "원 출금되었습니다. 현재 잔액: " << balance << std::endl;
        } else {
            std::cout << "출금 실패: 잔액이 부족하거나 유효하지 않은 금액입니다." << std::endl;
        }
    }

    // 잔액을 확인하는 게터 함수 (private 멤버의 값을 외부에 안전하게 노출)
    double getBalance() {
        return balance;
    }

    std::string getAccountNumber() { // 계좌번호 게터
        return accountNumber;
    }
};

int main() {
    BankAccount myAccount("123-456-7890", 1000.0);

    // myAccount.balance = -500; // 컴파일 오류! balance는 private이므로 직접 접근 불가

    std::cout << "초기 잔액: " << myAccount.getBalance() << std::endl; // 게터를 통해 잔액 확인

    myAccount.deposit(500.0);   // public 함수를 통해 입금
    myAccount.withdraw(200.0);  // public 함수를 통해 출금
    myAccount.withdraw(2000.0); // 잔액 부족으로 출금 실패

    std::cout << "최종 잔액: " << myAccount.getBalance() << std::endl;

    return 0;
}

class Animal {
protected: // protected 멤버
    std::string species; // 종은 자식 클래스가 접근 가능
    int age;             // 나이도 자식 클래스가 접근 가능

public:
    Animal(std::string s, int a) : species(s), age(a) {}
    void displaySpecies() {
        std::cout << "종: " << species << std::endl;
    }
};

class Dog : public Animal { // Dog 클래스가 Animal 클래스를 상속받음
public:
    Dog(std::string name, int age) : Animal("개", age) { // 부모 클래스의 생성자 호출
        // 자식 클래스인 Dog의 멤버 함수에서 protected 멤버인 age에 접근 가능
        std::cout << "새로운 강아지 객체 생성! 나이: " << this->age << std::endl;
    }

    void bark() {
        std::cout << "멍멍!" << std::endl;
    }
};

int main() {
    Dog myDog("바둑이", 3);
    myDog.displaySpecies(); // Animal의 public 함수 호출
    myDog.bark();

    // myDog.age = 4; // 컴파일 오류: age는 protected이므로 외부에서 직접 접근 불가
    return 0;
}

class MyClass { // class 키워드 사용
    int privateVar; // 명시하지 않으면 private
public:
    int publicVar;
};

struct MyStruct { // struct 키워드 사용
    int publicVar; // 명시하지 않으면 public
private:
    int privateVar;
};