접근 지정자

#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() const {
        return balance;
    }

    std::string getAccountNumber() const { // 계좌번호 게터
        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;
}

#include <iostream>
#include <string>

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 클래스를 상속받음
private:
    std::string name;

public:
    Dog(const std::string& dogName, int dogAge)
        : Animal("개", dogAge), name(dogName) {}

    void copyAgeFrom(const Dog& other) {
        age = other.age; // 허용: other의 정적 타입이 Dog
    }

    void compareWith(const Animal& base) {
        // age = base.age; // 컴파일 오류: 임의의 Animal 객체를 통한 접근
        (void)base;
    }

    void display() const {
        std::cout << name << " / " << species << " / " << age << std::endl;
    }
};

int main() {
    Dog myDog("바둑이", 3);
    Dog olderDog("누렁이", 5);
    myDog.copyAgeFrom(olderDog);
    myDog.displaySpecies(); // Animal의 public 함수 호출
    myDog.display();

    // 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;
};

int main() {
    MyClass classValue;
    MyStruct structValue;
    classValue.publicVar = 1;
    structValue.publicVar = 2;
    return classValue.publicVar + structValue.publicVar == 3 ? 0 : 1;
}