본문 바로가기
GD's IT Lectures : 기초부터 시리즈/C, C++ 기초부터 ~

[C/C++ 프로그래밍 : 중급] 4. 접근 제어 지시자

by GDNGY 2023. 5. 25.

Chapter 4. 접근 제어 지시자

접근 제어 지시자는 클래스 내의 멤버(변수, 함수)가 외부에서 접근할 수 있는 범위를 제한하는 방법을 제공합니다. 이를 통해 객체 지향 프로그래밍의 핵심 원칙 중 하나인 '정보 은닉'이 가능하며, 이로 인해 프로그램의 안정성과 유지 보수성이 향상됩니다. public, private, protected 세 가지 접근 제어 지시자에 대한 개념과 사용법을 배우게 될 것입니다. 이번 장을 통해 클래스 설계에 있어 접근 제어 지시자의 중요성을 이해해 보도록 합시다.

 

반응형

 

[Chapter 4. 접근 제어 지시자]

 

4.1. 접근 제어 지시자의 이해
4.1.1. 접근 제어 지시자란 무엇인가
4.1.2. 접근 제어 지시자의 필요성
4.1.3. 접근 제어 지시자의 종류

4.2. public 접근 제어 지시자
4.2.1. public의 정의와 사용법
4.2.2. public 멤버의 특징
4.2.3. public 멤버에 대한 접근 규칙
4.2.4. public 접근 제어 지시자 예제와 해석

4.3. private 접근 제어 지시자
4.3.1. private의 정의와 사용법
4.3.2. private 멤버의 특징
4.3.3. private 멤버에 대한 접근 규칙
4.3.4. private 접근 제어 지시자 예제와 해석

4.4. protected 접근 제어 지시자
4.4.1. protected의 정의와 사용법
4.4.2. protected 멤버의 특징
4.4.3. protected 멤버에 대한 접근 규칙
4.4.4. protected 접근 제어 지시자 예제와 해석

4.5. 접근 제어 지시자와 캡슐화
4.5.1. 캡슐화의 이해
4.5.2. 캡슐화와 접근 제어 지시자의 관계
4.5.3. 캡슐화 예제와 해석

4.6. 좋은 클래스 설계와 접근 제어 지시자
4.6.1. 정보 은닉의 중요성
4.6.2. 클래스 설계 시 접근 제어 지시자의 활용
4.6.3. 클래스 설계 예제와 해석

4.1 접근 제어 지시자의 이해

접근 제어 지시자는 C++ 클래스의 멤버에 대한 접근 권한을 관리하는 특별한 키워드입니다. 이를 통해 클래스 외부에서 접근 가능한 멤버와 접근 불가능한 멤버를 명확히 구분할 수 있습니다. 이를 활용하면 더 안정적이고 유지보수가 쉬운 코드를 작성할 수 있습니다. 이 섹션에서는 접근 제어 지시자의 개념과 필요성에 대해 깊이 이해해 볼 것입니다.

4.1.1 접근 제어 지시자란 무엇인가

접근 제어 지시자는 C++의 핵심적인 기능 중 하나로, 객체 지향 프로그래밍에서 중요한 역할을 합니다. 클래스의 멤버 변수나 멤버 함수에 대한 접근을 제어할 수 있는데, 이 접근 제어 지시자에는 public, private, 그리고 protected 세 가지가 있습니다. 

  • public : 해당 멤버에 대한 접근을 제한하지 않습니다. 클래스 내외부에서 모두 접근 가능하며, 이를 통해 객체의 기능을 외부에 제공합니다.
  • private : 해당 멤버에 대해 외부 접근을 완전히 차단합니다. 클래스 외부에서는 접근이 불가능하며, 클래스의 멤버 함수만이 해당 멤버에 접근할 수 있습니다.
  • protected : private와 비슷하지만 약간의 차이가 있습니다. protected는 해당 클래스 및 그 클래스를 상속받은 자식 클래스에서만 접근이 가능합니다.

아래는 간단한 예제 코드입니다:

 

[예제] 

class MyClass {
public:
    int publicVar;   // 이 변수는 어디에서든 접근 가능합니다.
    
private:
    int privateVar;  // 이 변수는 이 클래스 내에서만 접근 가능합니다.
    
protected:
    int protectedVar; // 이 변수는 이 클래스 및 상속받은 클래스에서만 접근 가능합니다.
};

 

이 예제에서 MyClass라는 클래스에는 publicVar, privateVar, protectedVar 세 개의 멤버 변수가 선언되어 있습니다.

publicVar는 public 접근 제어 지시자를 사용해 어디에서든 접근이 가능하게 만들었습니다. 반면에 privateVar는 private 접근 제어 지시자를 사용해 MyClass 내에서만 접근이 가능하도록 제한했습니다. 그리고 protectedVar는 protected 접근 제어 지시자를 사용해 이 클래스와 이 클래스를 상속받는 클래스 내에서만 접근이 가능하게 했습니다.

 

이처럼 접근 제어 지시자를 활용하면 클래스의 멤버에 대한 접근을 세밀하게 제어할 수 있습니다. 이를 통해 클래스의 안정성을 높이고 잘못된 접근으로 인한 버그를 방지할 수 있습니다.

 

그렇다면 왜 이렇게 멤버에 대한 접근을 제어할 필요가 있을까요? 이는 객체 지향 프로그래밍의 중요한 원칙 중 하나인 '정보 은닉' 때문입니다. 정보 은닉은 클래스의 내부 구현을 외부로부터 숨기는 것을 의미합니다. 이를 통해 사용자는 클래스의 내부 구현을 몰라도 되며, 클래스 제작자는 내부 구현을 자유롭게 변경할 수 있습니다. 접근 제어 지시자를 사용하면 이러한 정보 은닉을 손쉽게 구현할 수 있습니다.

 

클래스의 멤버 중에는 외부로 공개할 필요가 없거나, 외부에서 직접 접근할 경우 잘못된 사용으로 인해 문제가 발생할 수 있는 멤버들이 있습니다. 예를 들어, 어떤 클래스의 내부 상태를 나타내는 멤버 변수는 직접 변경될 경우 클래스의 상태가 예상치 못한 방향으로 바뀔 수 있습니다. 이러한 경우 해당 멤버 변수를 private 또는 protected로 설정하여 외부 접근을 제한하고, 대신 멤버 함수를 통해 안전하게 접근하도록 제공할 수 있습니다.

 

다음은 이를 나타낸 C++ 코드입니다:

 

[예제] 

class MyClass {
private:
    int privateVar;  // 이 변수는 이 클래스 내에서만 접근 가능합니다.

public:
    void setPrivateVar(int value) {
        if (value >= 0) {
            privateVar = value;
        } else {
            // 유효하지 않은 값은 거부합니다.
            std::cout << "Invalid value!\n";
        }
    }

    int getPrivateVar() {
        return privateVar;
    }
};

 

이 예제에서 privateVar 멤버 변수는 private로 설정되어 있으므로 클래스 외부에서 직접 접근할 수 없습니다. 대신 public 멤버 함수 setPrivateVar와 getPrivateVar를 통해 privateVar에 안전하게 접근할 수 있습니다. setPrivateVar 함수는 유효한 값인 경우에만 privateVar를 변경하므로, 잘못된 값을 설정하는 것을 방지할 수 있습니다.

 

이처럼 접근 제어 지시자를 사용하면 클래스의 구현을 안전하고 유지 보수하기 쉽게 만들 수 있습니다. 이는 클래스를 사용하는 다른 개발자들에게도 큰 장점이 됩니다. 클래스의 내부 구현을 신경 쓰지 않고도 해당 클래스의 기능을 활용할 수 있기 때문입니다. 이를 통해 생산성을 높이고 코드의 품질을 향상할 수 있습니다.

 

4.1.2 접근 제어 지시자의 필요성

객체 지향 프로그래밍에서 접근 제어 지시자의 필요성은 매우 중요합니다. 접근 제어 지시자는 클래스의 멤버 변수와 멤버 함수에 대한 접근을 제어하며, 이를 통해 '정보 은닉'과 '캡슐화'라는 두 가지 중요한 원칙을 실현할 수 있습니다. 이 두 원칙은 코드의 안정성을 높이고 유지보수를 용이하게 하는데 큰 역할을 합니다.

 

정보 은닉(Information Hiding)은 클래스의 내부 구현을 외부로부터 숨기는 원칙입니다. 클래스를 사용하는 사용자는 클래스의 내부 구현을 알 필요가 없으며, 클래스의 기능만을 알고 사용하면 됩니다. 이를 통해 클래스의 내부 구현이 변경되더라도 사용자에게는 영향이 없게 됩니다. 이런 방식은 코드의 안정성을 높이고 유지보수를 쉽게 합니다.

 

캡슐화(Encapsulation)는 관련된 데이터와 함수를 하나의 클래스 안에 묶는 것을 말합니다. 이를 통해 코드의 구조를 명확하게 하고, 재사용성을 높일 수 있습니다. 접근 제어 지시자를 사용하면, 클래스의 멤버에 대한 접근을 제어하여 캡슐화를 더욱 강화할 수 있습니다.

 

다음은 C++에서 정보 은닉과 캡슐화를 구현한 예시입니다:

 

[예제] 

class BankAccount {
private:
    double balance;  // 은행 계좌의 잔고입니다.

public:
    BankAccount() {
        balance = 0.0;
    }

    void deposit(double amount) {  // 입금 함수입니다.
        if (amount > 0) {
            balance += amount;
        } else {
            std::cout << "Invalid deposit amount.\n";
        }
    }

    void withdraw(double amount) {  // 출금 함수입니다.
        if (amount > 0 && balance >= amount) {
            balance -= amount;
        } else {
            std::cout << "Invalid withdraw amount.\n";
        }
    }

    double getBalance() {  // 잔고를 확인하는 함수입니다.
        return balance;
    }
};


위 코드에서는 BankAccount 클래스의 balance 멤버 변수가 private로 설정되어 있어 외부에서 직접 접근할 수 없습니다. 이는 클래스의 잔고를 잘못 변경하는 것을 방지하며, 이를 통해 클래스의 안정성을 높입니다. 대신 입금(deposit), 출금(withdraw), 잔고 확인(getBalance) 기능을 제공하는 public 멤버 함수를 통해 balance에 접근할 수 있습니다. 이렇게 함으로써 클래스의 내부 구현을 숨기면서도 필요한 기능을 제공할 수 있습니다.

 

접근 제어 지시자를 통해 이처럼 정보 은닉과 캡슐화를 구현하면 코드의 안정성을 높이고 유지보수를 용이하게 하는 등의 이점을 얻을 수 있습니다. 이런 이유로 접근 제어 지시자의 사용은 객체 지향 프로그래밍에서 중요한 부분이며, 특히 C++에서는 클래스를 설계하고 구현할 때 반드시 고려해야 하는 요소입니다.

 

각 접근 제어 지시자는 사용할 수 있는 곳과 용도에 따라 다르게 적용됩니다. 가령, 'public' 지시자는 클래스 외부에서도 접근 가능하게 하여 클래스의 사용자에게 해당 클래스의 기능을 제공하는 인터페이스 역할을 합니다. 'private' 지시자는 클래스 내부에서만 접근 가능하도록 제한하여 정보 은닉을 실현하고, 'protected' 지시자는 클래스 자체와 파생 클래스에서만 접근할 수 있게 하여 클래스의 확장을 위한 기반을 제공합니다.

 

이렇게 각 접근 제어 지시자는 서로 다른 역할을 수행하므로, 클래스를 설계할 때는 각 멤버가 어떤 접근 제어 지시자로 선언되어야 할지 잘 고려해야 합니다. 잘못된 접근 제어 지시자의 사용은 클래스의 안정성을 저해하거나 클래스 사용자에게 혼란을 줄 수 있습니다.

 

그러므로 클래스를 설계할 때는 어떤 멤버를 public으로 할지, private으로 할지, protected로 할지 고민해야 합니다. 이를 잘 결정하는 것은 클래스 설계의 중요한 부분이며, 접근 제어 지시자의 필요성을 잘 이해하고 사용하는 것은 좋은 코드를 작성하는 데 매우 중요합니다.

 

이번 섹션에서는 접근 제어 지시자의 필요성에 대해 배웠습니다. 접근 제어 지시자는 정보 은닉과 캡슐화를 통해 코드의 안정성을 높이고 유지보수를 쉽게 하는 등의 이점을 제공합니다. 다음 섹션에서는 각 접근 제어 지시자에 대해 좀 더 자세히 알아보겠습니다.

 

4.1.3. 접근 제어 지시자의 종류

C++에서는 세 가지 주요 접근 제어 지시자를 제공합니다: public, private, 그리고 protected입니다. 이 세 가지 각각의 접근 제어 지시자는 클래스 내부의 멤버에 대한 접근을 제어하는 방식에 차이를 두고 있습니다.

 

  • public : public 지시자로 선언된 멤버는 어디서든 접근할 수 있습니다. 즉, 해당 클래스의 객체를 통해서도 접근할 수 있으며, 파생 클래스에서도 접근할 수 있습니다.

 

[예제] 

class MyClass {
public:
    int publicVar;
};

 

위의 코드에서, publicVar는 public으로 선언되었기 때문에 어디서든 접근이 가능합니다.

[예제] 

MyClass obj;
obj.publicVar = 10; // 가능

 

  • private : private 지시자로 선언된 멤버는 해당 클래스 내부에서만 접근할 수 있습니다. 즉, 클래스 외부나 파생 클래스에서는 접근할 수 없습니다.


[예제]

class MyClass {
private:
    int privateVar;
};

 

위의 코드에서, privateVar는 private으로 선언되었으므로 클래스 외부에서 접근하려고 하면 오류가 발생합니다.

[예제] 

MyClass obj;
obj.privateVar = 10; // 오류! private 멤버에 접근할 수 없습니다.

 

  • protected : protected 지시자로 선언된 멤버는 해당 클래스 내부와 파생 클래스 내부에서만 접근할 수 있습니다. 즉, 클래스 외부에서는 접근할 수 없지만, 파생 클래스에서는 접근이 가능합니다.


[예제] 

class MyClass {
protected:
    int protectedVar;
};

 

위의 코드에서, protectedVar는 protected로 선언되었으므로 클래스 외부에서 접근하려고 하면 오류가 발생하지만, 파생 클래스에서는 접근이 가능합니다.

 

이 세 가지 접근 제어 지시자는 C++에서 클래스의 멤버에 대한 접근을 제어하는 데 사용되며, 각각은 서로 다른 접근 레벨을 제공합니다. 그래서 어떤 멤버에 어떤 접근 제어 지시자를 사용할지를 잘 결정하는 것이 중요합니다.

 

이어서, 접근 제어 지시자에 대한 더욱 깊은 이해를 돕기 위해 상속 관계에서의 접근 제어 지시자에 대해 알아보겠습니다.

 

상속은 기본 클래스의 멤버들을 파생 클래스에 "물려주는" 방식으로 작동합니다. 하지만, 이 과정에서 접근 제어 지시자는 중요한 역할을 합니다.

 

다시 말하면, public 멤버는 파생 클래스에서도 접근이 가능하지만, private 멤버는 파생 클래스에서 접근이 불가능합니다. protected 멤버는 부모 클래스와 파생 클래스 내부에서 접근이 가능하지만, 파생 클래스의 객체를 통해서는 접근이 불가능합니다.

 

[예제] 

class Base {
public:
    int publicVar;
private:
    int privateVar;
protected:
    int protectedVar;
};

class Derived : public Base {
    void function() {
        publicVar = 10; // 가능
        privateVar = 20; // 오류! private 멤버에 접근할 수 없습니다.
        protectedVar = 30; // 가능
    }
};

int main() {
    Derived d;
    d.publicVar = 10; // 가능
    d.privateVar = 20; // 오류! private 멤버에 접근할 수 없습니다.
    d.protectedVar = 30; // 오류! protected 멤버에 접근할 수 없습니다.
    return 0;
}


이 예제에서 Derived 클래스는 Base 클래스를 상속받고 있습니다. Derived 클래스의 메서드 내에서는 public 멤버와 protected 멤버에 접근이 가능하지만, private 멤버에는 접근할 수 없습니다.

 

또한, main 함수에서 Derived 클래스의 객체를 통해 public 멤버에는 접근이 가능하지만, protected 멤버와 private 멤버에는 접근할 수 없습니다.

 

이처럼 접근 제어 지시자는 C++의 객체 지향 프로그래밍에서 중요한 역할을 수행하며, 클래스의 설계 및 구현에서 중요한 부분을 차지합니다. 각 멤버의 적절한 접근 제어 지시자를 선택함으로써, 클래스의 안전성을 보장하고 코드의 가독성을 높일 수 있습니다. 다음 섹션에서는 각 접근 제어 지시자에 대해 좀 더 자세히 알아보도록 하겠습니다.

 

4.2. public 접근 제어 지시자

클래스나 구조체의 'public' 멤버에 대해 배웁니다. 'public'은 가장 개방적인 접근 제어 지시자로서, 이를 사용하면 클래스나 구조체의 멤버에 어디서든 접근할 수 있습니다. 이는 객체 지향 프로그래밍에서 중요한 개념인 '캡슐화'와 상반되는 측면이 있지만, 이는 클래스의 사용성을 높이고 사용자와의 상호작용을 돕는 데 있어 필요한 요소입니다. 이 섹션에서는 'public' 멤버의 성질과 활용 예를 자세히 알아보겠습니다.

4.2.1. public의 정의와 사용법

'public' 접근 제어 지시자는 C++에서 가장 일반적으로 사용되며, 멤버에 가장 개방적인 접근을 허용합니다. 클래스 또는 구조체에 선언된 'public' 멤버는 프로그램의 어디에서든 직접 접근할 수 있습니다. 즉, 클래스 또는 구조체의 객체를 통해 'public' 멤버를 사용할 수 있습니다.

이제 'public' 멤버를 선언하고 사용하는 방법에 대한 예제를 살펴보겠습니다.

[예제] 

class Circle {
public: // 이하 public 멤버
    double radius;
    
    Circle(double r) { // 생성자
        radius = r;
    }
    
    double getArea() { // 면적을 계산하는 메서드
        return 3.14 * radius * radius;
    }
};

int main() {
    Circle c(5.0); // radius가 5.0인 Circle 객체를 생성
    c.radius = 10.0; // public 멤버이므로 객체를 통해 직접 접근 가능
    double area = c.getArea(); // public 메서드이므로 객체를 통해 호출 가능
    return 0;
}


위의 예제에서는 Circle이라는 클래스를 정의하고 있습니다. 이 클래스는 radius라는 'public' 멤버 변수와 getArea()라는 'public' 멤버 함수를 가지고 있습니다. 이 클래스의 객체를 생성하면 radius 변수에 직접 접근할 수 있으며, getArea() 함수를 호출할 수 있습니다.

 

클래스를 정의할 때 멤버 변수나 함수 앞에 'public' 키워드를 붙여서 이 멤버가 'public'임을 표시합니다. 'public' 키워드 다음에 오는 모든 멤버들은 기본적으로 'public' 속성을 가집니다.

 

이처럼 'public' 접근 제어 지시자를 사용하면 클래스나 구조체의 멤버에 외부에서 쉽게 접근할 수 있으므로, 사용자 친화적인 클래스를 설계할 수 있습니다. 하지만, 'public' 멤버에 대한 접근을 제어하지 않으면 객체의 상태를 예기치 않게 변경할 수 있는 위험이 있으므로, 반드시 필요한 경우에만 사용해야 합니다.

 

4.2.2. public 멤버의 특징

'public' 멤버는 클래스 또는 구조체 외부에서 자유롭게 접근할 수 있는 특징이 있습니다. 즉, 클래스 객체를 통해 해당 멤버에 직접 접근하거나, 멤버 함수를 호출할 수 있습니다. 이러한 특성 덕분에, 'public' 멤버는 클래스의 인터페이스를 정의하는데 중요한 역할을 합니다.

 

'public' 멤버의 주요 특징은 다음과 같습니다:

  • 'public' 멤버는 클래스나 구조체의 객체를 통해 외부에서 직접 접근할 수 있습니다.
  • 'public' 멤버 함수는 객체의 메서드로서 호출할 수 있습니다.
  • 'public' 멤버는 클래스의 인터페이스를 정의하는데 사용됩니다.

아래는 'public' 멤버의 특징을 보여주는 코드 예제입니다:

 

[예제] 

class Person {
public: // 이하 public 멤버
    string name; // public 멤버 변수
    int age; // public 멤버 변수

    Person(string n, int a) { // 생성자
        name = n;
        age = a;
    }
    
    void introduce() { // public 멤버 함수
        cout << "Hello, my name is " << name << " and I am " << age << " years old.\n";
    }
};

int main() {
    Person person("John", 25); // Person 객체 생성
    person.name = "Jane"; // public 멤버 변수에 직접 접근
    person.introduce(); // public 멤버 함수 호출
    return 0;
}

 

위 코드에서는 Person이라는 클래스를 정의하고 있습니다. 이 클래스는 name과 age라는 두 개의 'public' 멤버 변수와 introduce()라는 'public' 멤버 함수를 가지고 있습니다. 클래스의 객체를 생성하면, name과 age 변수에 직접 접근하거나 introduce() 함수를 호출할 수 있습니다. 이런 특징 덕분에 'public' 멤버는 클래스의 사용 방법을 정의하는 인터페이스 역할을 합니다. 

 

그러나, 'public' 멤버는 외부에서 자유롭게 접근할 수 있기 때문에, 객체의 상태를 예기치 못하게 변경하는 것을 주의해야 합니다. 따라서 클래스 설계 시에는 이러한 점을 고려하여, 반드시 필요한 경우에만 멤버를 'public'으로 설정하는 것이 좋습니다. 

 

4.2.3. public 멤버에 대한 접근 규칙

'public' 멤버에 대한 접근 규칙은 상당히 간단합니다. 'public' 멤버는 클래스 또는 구조체의 인스턴스를 통해 어디서든 접근할 수 있습니다. 이는 클래스 또는 구조체의 외부, 그리고 내부의 다른 멤버 함수에서도 마찬가지입니다. 

 

아래는 'public' 멤버에 대한 접근 규칙을 보여주는 코드 예제입니다:

 

[예제] 

class Test {
public:
    int publicVar;

    void access() {
        publicVar = 10; // 클래스 내부에서 public 멤버에 접근
    }
};

int main() {
    Test t;
    t.publicVar = 20; // 클래스 외부에서 public 멤버에 접근
    t.access(); // 멤버 함수를 통해 내부에서 public 멤버에 접근
    return 0;
}

위 코드에서 publicVar라는 'public' 멤버 변수는 클래스 Test의 인스턴스인 t를 통해 클래스 외부에서 직접 접근할 수 있습니다. 또한, 클래스 내부의 멤버 함수 access에서도 publicVar에 직접 접근이 가능합니다. 이런 방식으로 'public' 멤버는 클래스의 내부와 외부에서 자유롭게 접근할 수 있는 특성을 가집니다.

 

그러나, 이런 자유로운 접근성은 캡슐화와 객체지향 프로그래밍의 기본 원칙을 위반할 수 있습니다. 특히, 객체의 상태를 쉽게 변경할 수 있으므로, 객체의 안정성을 해칠 수 있습니다. 따라서 'public' 멤버를 잘 활용하면서도 동시에 객체의 상태를 안전하게 유지하는 방법에 대해 신중하게 고려해야 합니다.

 

일반적으로는 클래스의 내부 상태를 나타내는 멤버 변수는 'private'이나 'protected'로 설정하고, 클래스의 기능을 제공하는 멤버 함수(메서드)만을 'public'으로 설정하는 것이 바람직합니다. 이렇게 하면, 클래스를 사용하는 코드는 클래스의 내부 구현을 직접 다루지 않고도, 'public' 메서드를 통해 클래스의 기능을 이용할 수 있습니다. 이는 캡슐화의 원칙을 지키는 동시에, 코드의 가독성과 유지보수성을 높이는 데에도 도움이 됩니다.

 

4.2.4. public 접근 제어 지시자 예제와 해석

'public' 접근 제어 지시자를 사용하는 방법을 이해하는데 도움이 될만한 예제를 아래에 준비했습니다. 아래의 예제는 'public' 멤버의 사용법과 이를 활용한 클래스의 동작 방식을 보여줍니다.

 

[예제] 

class Car {
public: // public 접근 제어 지시자 아래에 정의된 멤버들은 어디서든 접근 가능
    string brand;
    int year;

    // 생성자
    Car(string b, int y) {
        brand = b;
        year = y;
    }

    void printDetails() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car car1("Toyota", 2015); // Car 클래스의 인스턴스 생성
    car1.printDetails(); // 'public' 멤버 함수 호출

    cout << "Brand of Car1: " << car1.brand << endl; // 'public' 멤버 변수에 직접 접근
    return 0;
}


위 코드에서, Car 클래스는 두 개의 'public' 멤버 변수와 두 개의 'public' 멤버 함수를 가지고 있습니다. brand와 year는 'public' 멤버 변수로, 어디서든 접근할 수 있습니다. 또한, Car() 생성자와 printDetails() 함수는 'public' 멤버 함수로, 클래스 인스턴스를 통해 호출할 수 있습니다. 

 

'public' 접근 제어 지시자 아래에 위치한 멤버들은 클래스 외부에서도 접근이 가능하다는 것을 알 수 있습니다. main 함수에서 car1.brand를 통해 'public' 멤버 변수에 직접 접근하였고, car1.printDetails()를 통해 'public' 멤버 함수를 호출하였습니다.

 

이렇게 'public' 접근 제어 지시자는 클래스의 외부에서도 멤버에 접근할 수 있도록 해줍니다. 그러나 이러한 특성은 데이터를 보호하기 위한 캡슐화 원칙에는 반하는 부분이므로, 신중하게 사용해야 합니다. 일반적으로는 데이터를 표현하는 멤버 변수는 'private'으로 설정하고, 이에 접근하는 멤버 함수는 'public'으로 설정하는 것이 바람직합니다.

 

4.3. private 접근 제어 지시자

클래스 또는 구조체의 멤버를 클래스 내부에서만 접근 가능하게 합니다. 이는 C++의 핵심 원칙 중 하나인 캡슐화를 지원하며, 객체의 상태를 보호하고 무분별한 수정으로부터 안전하게 합니다. 클래스 외부에서는 'private' 멤버를 직접 볼 수 없으므로, 'public' 멤버 함수를 통해 간접적으로 접근하거나 수정해야 합니다.

4.3.1. private의 정의와 사용법

"private"은 클래스의 멤버를 클래스 외부에서 접근할 수 없도록 보호하는 접근 제어 지시자입니다. 이는 클래스의 구현 세부사항을 숨기는 중요한 방법으로, 클래스의 사용자가 클래스 내부의 구현에 의존하지 않도록 합니다. 이를 통해 클래스의 사용자는 클래스의 인터페이스에만 집중할 수 있고, 클래스의 설계자는 내부 구현을 자유롭게 변경할 수 있습니다.

 

사용법을 이해하기 위해 예제 코드를 보겠습니다.

 

[예제] 

class Box {
private:
    int length;
    int width;
    int height;

public:
    Box(int l, int w, int h) {
        length = l;
        width = w;
        height = h;
    }

    int getVolume() {
        return length * width * height;
    }
};


위 코드에서 length, width, height는 Box 클래스의 private 멤버입니다. 이들은 클래스 외부에서 직접 접근할 수 없으며, Box 클래스 내부에서만 사용할 수 있습니다. 클래스 외부에서 이들을 사용하려면 public 멤버 함수인 getVolume을 통해 간접적으로 접근해야 합니다. 

 

Box 클래스의 객체를 만들고 사용해보겠습니다.

 

[예제] 

int main() {
    Box box(3, 4, 5);
    std::cout << "The volume of the box is: " << box.getVolume() << std::endl;
    return 0;
}

 

이 예제에서 Box 객체의 length, width, height에 직접 접근할 수 없습니다. 대신 getVolume 함수를 사용하여 객체의 부피를 계산하고 출력했습니다. 이렇게 private 멤버는 클래스의 내부 상태를 보호하고, 클래스의 사용자가 내부 구현에 의존하지 않도록 하는 역할을 합니다.

 

4.3.2. private 멤버의 특징

  • private 멤버에 대해 좀 더 깊이 이해하기 위해서는 private 멤버의 몇 가지 주요 특징을 알아야 합니다.

    캡슐화 : private 멤버는 클래스 내부에서만 접근이 가능하므로, 이를 통해 클래스의 내부 데이터를 보호하고 캡슐화합니다. 이는 클래스의 사용자가 클래스의 세부 구현을 알 필요 없이 사용할 수 있게 해 주며, 이를 통해 클래스를 더 안정적이고 재사용 가능하게 만듭니다.

 

[예제] 

class Circle {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double getArea() { return 3.14 * radius * radius; }
};

int main() {
    Circle c(5.0);
    std::cout << "The area of the circle is: " << c.getArea() << std::endl;
    return 0;
}

 

이 예제에서 원의 반지름인 radius는 private 멤버이므로, Circle 클래스 외부에서 접근할 수 없습니다. 대신, 클래스 외부에서는 public 메서드인 getArea()를 통해 원의 면적을 얻을 수 있습니다.

 

  • 데이터 은닉 : private 멤버는 클래스 외부에서 접근할 수 없으므로, 클래스의 사용자가 내부 구현에 의존하지 않도록 합니다. 이를 통해 클래스의 내부 구현이 바뀌더라도 클래스의 사용자는 영향을 받지 않습니다.

 

[예제] 

class Rectangle {
private:
    int length;
    int width;

public:
    Rectangle(int l, int w) : length(l), width(w) {}
    int getArea() { return length * width; }
    void setLength(int l) { length = l; }
    void setWidth(int w) { width = w; }
};

int main() {
    Rectangle r(5, 3);
    std::cout << "The area of the rectangle is: " << r.getArea() << std::endl;
    r.setLength(6);
    std::cout << "The area of the rectangle after changing the length is: " << r.getArea() << std::endl;
    return 0;
}

 

이 예제에서도 Rectangle의 length와 width 멤버는 private이므로, 직접 접근할 수 없습니다. 하지만 setLength()와 setWidth() 등의 public 메서드를 통해 이들 값을 변경할 수 있습니다. 이렇게 내부 데이터를 직접 변경하는 대신 메서드를 통해 변경하면, 클래스의 사용자는 내부 구현에 의존하지 않고 클래스를 사용할 수 있습니다.

 

이처럼 private 멤버는 캡슐화와 데이터 은닉을 제공하여 클래스의 안정성과 재사용성을 높이는 중요한 역할을 합니다. 이는 객체 지향 프로그래밍의 핵심 원칙 중 하나입니다.

 

4.3.3. private 멤버에 대한 접근 규칙

C/C++에서 private 멤버는 클래스 내부에서만 직접적으로 접근이 가능하다는 규칙에 따라 동작합니다. 이는 클래스의 사용자로부터 세부 구현을 은닉하며, 클래스의 개발자는 내부 데이터를 보호하고 외부로부터 보호할 수 있습니다. 그러나 이러한 접근 제한을 이해하고 관리하는 것은 중요하며, 특히 다음과 같은 두 가지 주요 규칙을 기억해야 합니다.

 

private 멤버는 클래스 외부에서 직접 접근할 수 없습니다: private 멤버는 클래스의 메서드 또는 생성자 등 클래스 내부에서만 접근할 수 있습니다. 이를 통해 데이터를 보호하고 캡슐화할 수 있습니다.

 

[예제] 

class Example {
private:
    int data;

public:
    Example(int value) : data(value) {}
    int getData() { return data; }
};

int main() {
    Example ex(10);
    // ex.data = 20;  // 컴파일 오류, private 멤버에 접근할 수 없습니다.
    std::cout << "Data: " << ex.getData() << std::endl;
    return 0;
}


위 예제에서 data는 private 멤버로, 클래스 외부에서 직접적으로 접근하려 시도하면 컴파일 오류가 발생합니다. 그러나 public 멤버 함수 getData()를 통해 간접적으로 접근할 수 있습니다.

private 멤버는 클래스 내부에서만 수정할 수 있습니다: private 멤버의 값을 변경하려면 클래스 내부의 메서드를 사용해야 합니다. 이를 통해 데이터의 유효성을 유지하고, 클래스가 안정적인 상태를 보장하는 데 도움이 됩니다.

 

[예제] 

class Example {
private:
    int data;

public:
    Example(int value) : data(value) {}
    void setData(int value) { data = value; }
    int getData() { return data; }
};

int main() {
    Example ex(10);
    ex.setData(20);  // private 멤버 데이터 값을 변경합니다.
    std::cout << "Data: " << ex.getData() << std::endl;
    return 0;
}

 

이 예제에서 setData() 메서드는 클래스 내부에서 private 멤버 data의 값을 변경하는 것을 허용합니다. 이 메서드를 통해 클래스 외부에서도 데이터 값을 안전하게 변경할 수 있습니다.

 

이러한 규칙을 통해 private 멤버는 클래스의 구현을 보호하고 외부로부터 내부 데이터를 보호합니다. 이는 코드의 안정성과 재사용성을 높이며, 개발자가 클래스의 세부 구현에 대해 더 잘 통제할 수 있게 합니다. 이것이 바로 객체 지향 프로그래밍의 핵심 원칙 중 하나인 캡슐화의 핵심입니다.

 

4.3.4. private 접근 제어 지시자 예제와 해석

'private 접근 제어 지시자 예제와 해석' 섹션에 오신 것을 환영합니다! 이 섹션에서는 실제로 C++ 코드에서 private 접근 제어 지시자가 어떻게 사용되는지를 살펴보겠습니다. 코드 예제를 통해 이해를 돕겠습니다.

 

[예제] 

// C++ 코드 예제
#include <iostream>

class MyClass {
private:
    int secretData; // private 멤버 변수

public:
    MyClass(int data) {
        secretData = data;
    }

    void DisplaySecretData() {
        std::cout << "The secret data is: " << secretData << std::endl;
    }
};

int main() {
    MyClass obj(123);
    obj.DisplaySecretData();
    // obj.secretData = 456; // 컴파일 에러: 'secretData' is private within this context
    return 0;
}

 

위의 예제에서 MyClass는 secretData라는 private 멤버 변수를 가지고 있습니다. secretData는 MyClass 클래스의 인스턴스 내부에서만 접근 가능합니다. 이는 'private' 접근 제어 지시자를 통해 보장됩니다.

 

클래스의 생성자는 secretData에 값을 할당하는데 사용되며, 이는 클래스 내부에서 이루어지므로 허용됩니다. 그리고 클래스 내부의 DisplaySecretData() 메서드는 secretData에 접근하여 그 값을 출력합니다. 이 메서드는 클래스 외부에서 호출할 수 있지만, secretData에 대한 직접적인 접근은 허용하지 않습니다.

 

main() 함수에서는 MyClass의 인스턴스를 생성하고, DisplaySecretData() 메서드를 호출하여 secretData를 출력합니다. 그러나 secretData에 직접 접근하려 하면 컴파일 에러가 발생합니다. 이는 'private' 키워드를 통해 secretData가 클래스 외부에서 보호받고 있기 때문입니다.

 

따라서 'private' 접근 제어 지시자를 통해 클래스의 멤버를 보호하면서, 그것들을 안전하게 조작할 수 있는 메서드를 제공하는 것이 중요합니다. 이를 통해 데이터의 무결성을 유지하고 코드의 안정성을 높일 수 있습니다. 이것이 바로 캡슐화의 원칙이 적용되는 곳입니다.

 

4.4. protected 접근 제어 지시자

C++에서 특별한 상황에서 사용됩니다. 이는 클래스의 멤버가 같은 클래스 내부와 파생된 클래스에서 접근 가능하도록 하는 역할을 합니다. 'private'와 비슷하지만, 파생 클래스에서의 접근을 허용한다는 차이점이 있습니다. 이로 인해 클래스를 확장하는 데 있어서 유용하며, 코드의 재사용성을 높여주는 데 기여합니다.

4.4.1 protected의 정의와 사용법

C++에서 protected 접근 제어 지시자는 특별한 역할을 합니다. protected 멤버는 해당 클래스와 파생 클래스 내부에서 접근할 수 있지만, 그 외의 곳에서는 접근할 수 없습니다. 이는 private 멤버와 비슷하지만 protected 멤버는 파생 클래스에서 접근 가능한 점이 다릅니다.

 

예제 코드를 살펴봅시다:

 

[예제] 

class Base {
protected:
  int protected_member;
};

class Derived : public Base {
public:
  void AccessProtected() {
    protected_member = 10; // 이 곳에서는 접근 가능
  }
};

int main() {
  Derived d;
  d.AccessProtected(); // 가능
  d.protected_member = 5; // 불가능, 직접 접근 불가
}

 

위의 예제에서 Base 클래스는 protected_member라는 protected 멤버를 가지고 있습니다. Derived 클래스는 Base 클래스를 상속받기 때문에 protected_member에 접근할 수 있습니다. 그러나 main 함수에서는 Derived 객체의 protected_member에 직접 접근하는 것은 불가능합니다.

 

이렇게 protected 멤버는 private 멤버와 같이 클래스 외부에서 직접적인 접근을 제한하면서, 파생 클래스에서는 접근을 허용함으로써 클래스의 확장을 용이하게 합니다. 이러한 특성은 코드 재사용을 촉진하고 클래스 간의 관계를 보다 정교하게 설계하는 데에 도움을 줍니다.

 

protected 접근 제어 지시자를 사용할 때는 클래스의 설계를 신중히 고려해야 합니다. 만약 클래스가 너무 많은 상세 내용을 노출하면 내부 구현을 변경할 때 파생 클래스에 영향을 줄 수 있기 때문입니다. 따라서 클래스의 내부 구현이 외부에 노출되지 않도록 최소한의 protected 멤버만을 제공하는 것이 좋습니다.

 

4.4.2. protected 멤버의 특징

상속

먼저, protected 멤버는 클래스를 상속한 자식 클래스 내에서 접근이 가능합니다. 이는 private 멤버와 달리, 자식 클래스가 부모 클래스의 멤버를 직접 사용할 수 있게 해 줍니다. 이는 코드의 재사용성을 향상하며, 상속 계층을 통한 추상화를 가능하게 합니다.

 

[예제] 

class Parent {
protected:
  int protectedVar;
};

class Child : public Parent {
public:
  void AccessProtectedVar() {
    protectedVar = 10;  // 가능: Child는 Parent의 protected 멤버에 접근할 수 있다.
  }
};

 

캡슐화

그러나 protected 멤버는 외부에서 직접 접근이 불가능합니다. 이 점은 public 멤버와는 대조적입니다. 이 특성은 객체 지향 프로그래밍의 핵심 원칙인 캡슐화를 지원합니다. 클래스는 내부 상태를 protected 멤버로 숨긴 채, 이를 조작하는 메서드만 public으로 노출하므로 클래스의 사용자는 클래스의 내부 구현에 대해 알 필요가 없습니다.

 

간접 접근

비록 protected 멤버는 외부에서 직접 접근할 수 없지만, public 메서드를 통해 간접적으로 접근하는 것은 가능합니다. 즉, 클래스는 protected 멤버를 캡슐화하고, 이에 대한 안전한 인터페이스를 제공함으로써 외부 코드가 클래스의 상태를 안전하게 조작할 수 있게 해 줍니다.

 

[예제] 

class MyClass {
protected:
  int protectedVar;
public:
  void SetProtectedVar(int value) {
    protectedVar = value;  // 외부에서 이 public 메서드를 통해 protected 멤버에 접근 가능
  }
};

 

 

정보 은닉

protected 접근 제어자는 또한 정보 은닉을 지원합니다. 클래스의 사용자는 클래스의 public 인터페이스만을 알면 되므로, 클래스의 구현이 변경되더라도 이를 사용하는 코드는 영향을 받지 않게 됩니다. 이는 유지 보수성을 향상시키고 버그를 줄이는 데 도움이 됩니다.

 

이처럼 protected 접근 제어자는 객체 지향 프로그래밍에서 중요한 도구입니다. 이는 코드의 재사용성을 향상시키고, 캡슐화와 정보 은닉을 통해 코드의 안정성과 유지 보수성을 향상하는 데 큰 역할을 합니다. 다음 섹션에서는 protected 접근 제어자의 사용 예시를 더 자세히 알아보겠습니다.

 

4.4.4. protected 접근 제어 지시자 예제와 해석

이제 protected 접근 제어 지시자의 사용 예시를 통해 이 특징을 좀 더 구체적으로 이해해봅시다. 

 

아래는 간단한 C++ 코드의 예입니다.

 

[예제] 

class Animal {
protected:
  int age;
public:
  void setAge(int a) {
    age = a;
  }
};

class Dog : public Animal {
public:
  void printAge() {
    cout << "Dog's age: " << age << endl; // 가능: Dog 클래스는 부모 클래스인 Animal의 protected 멤버에 접근할 수 있다.
  }
};

 

위의 코드에서 Animal 클래스는 protected 멤버 변수 age와 public 메소드 setAge를 가지고 있습니다. protected 멤버 변수 age는 Animal 클래스 밖에서는 직접 접근할 수 없습니다. 하지만 Animal 클래스를 상속받은 Dog 클래스에서는 age에 접근할 수 있습니다. 이는 protected 접근 제어 지시자의 핵심 특징이며, 이를 통해 클래스의 멤버 변수에 안전하게 접근할 수 있습니다.

 

더 나아가, public 메소드메서드 setAge는 Animal 클래스의 외부에서 age 변수에 접근할 수 있는 유일한 방법입니다. 이는 캡슐화 원칙을 따르고 있습니다. 즉, 클래스의 내부 상태는 외부로부터 숨겨져 있으며, 외부에서는 클래스가 제공하는 메서드를 통해서만 상태를 변경할 수 있습니다. 이렇게 해서 코드의 안정성이 보장되며, 유지 보수가 쉬워집니다.

 

이제 실제로 Dog 객체를 생성하고 setAge와 printAge 메소드를 사용해 보겠습니다.

 

[예제] 

int main() {
  Dog dog;
  dog.setAge(5);  // Animal의 public 메소드를 통해 age에 접근
  dog.printAge(); // 출력: Dog's age: 5
  return 0;
}

 

이 예제에서는 setAge 메소드를메서드를 사용하여 Dog 객체의 age를 설정하였고, printAge 메서드를 사용하여 설정된 age를 출력하였습니다. 이를 통해 protected 멤버에 안전하게 접근하는 것이 어떤 것인지 볼 수 있습니다.

 

이처럼 protected 접근 제어 지시자는 상속과 캡슐화라는 객체 지향 프로그래밍의 두 가지 핵심 원칙을 지원합니다. 이를 통해 코드의 재사용성을 높이고 안정성을 보장할 수 있습니다.

 

4.5. 접근 제어 지시자와 캡슐화

"접근 제어 지시자와 캡슐화"는 객체 지향 프로그래밍의 중심 주제로, 이는 클래스의 멤버 데이터와 함수를 외부로부터 보호하며, 정보를 숨기는 기법을 중점적으로 다룹니다. C++에서는 public, private, protected 세 가지 접근 제어 지시자를 사용하여 캡슐화를 구현합니다. 이러한 지시자들은 클래스의 멤버에 대한 접근 권한을 제어하고, 캡슐화를 통해 데이터의 무분별한 접근을 막고 코드의 안정성을 유지하는데 큰 역할을 합니다.

4.5.1. 캡슐화의 이해

"캡슐화"라는 용어는 객체 지향 프로그래밍에서 굉장히 중요한 개념입니다. 캡슐화는 데이터와 그 데이터를 조작하는 함수를 함께 묶는 프로세스를 말합니다. 이것은 우리가 일상생활에서 볼 수 있는 캡슐의 원리와 매우 유사하며, 이러한 메커니즘이 프로그래밍 세계에서 어떻게 작동하는지를 살펴보면 많은 도움이 될 것입니다.

 

다음은 C++에서 캡슐화를 구현하는 간단한 예제입니다:

 

[예제] 

class Rectangle {
private:
    int length;
    int breadth;

public:
    void setLength(int l) {
        length = l;
    }

    void setBreadth(int b) {
        breadth = b;
    }

    int getArea() {
        return length * breadth;
    }
};

 

여기서, length와 breadth는 Rectangle 클래스의 멤버 데이터로, 직접적으로 접근할 수 없게 되어 있습니다. 이는 private 접근 제어 지시자에 의해 제어되며, 이 변수들에 대한 모든 접근은 클래스의 멤버 함수를 통해 제어됩니다. 이렇게 함으로써, 우리는 이 데이터에 대한 접근을 제한하고, 이 데이터를 사용하는 방법을 제어할 수 있게 됩니다. 이것이 바로 캡슐화의 핵심 원칙입니다.

 

이 예제에서, setLength와 setBreadth 함수를 사용하여 데이터를 설정하고, getArea 함수를 사용하여 이 데이터를 바탕으로 결과를 얻을 수 있습니다. 이것이 바로 캡슐화의 강력함입니다 - 사용자는 결과를 얻는 방법에 대해 신경 쓸 필요 없이, 간단한 인터페이스를 통해 복잡한 작업을 수행할 수 있게 됩니다.

 

물론, 이러한 원칙은 단순한 사각형 클래스를 넘어서서도 적용됩니다. 실제 생활에서 우리는 자동차를 운전하거나 컴퓨터를 사용하는 등, 복잡한 시스템을 조작할 때 캡슐화의 원리를 일상적으로 활용하고 있습니다. 이러한 복잡한 시스템들은 대부분의 사용자가 그 내부 작동 방식을 이해하지 못하더라도 쉽게 사용할 수 있도록 설계되었으며, 이는 모두 캡슐화의 강력한 원칙 덕분입니다.

 

4.5.2. 캡슐화와 접근 제어 지시자의 관계

캡슐화는 데이터를 '숨기는' 것이 아니라, 데이터를 보호하고 제어하는 것을 의미합니다. 이는 클래스의 내부 데이터를 직접적으로 변경하지 못하게 하고, 대신 제공된 메서드를 통해 데이터에 접근하고 수정하게 하는 것을 목표로 합니다. 이 과정에서 접근 제어 지시자는 매우 중요한 역할을 담당합니다.

 

접근 제어 지시자(private, protected, public)는 클래스 내의 멤버 변수와 메서드에 대한 접근을 제한하며, 이는 객체 지향 프로그래밍에서 데이터의 무분별한 접근을 방지하는 데 필수적인 역할을 합니다. 즉, 캡슐화는 접근 제어 지시자를 통해 실현됩니다.

 

다음은 C++에서 캡슐화와 접근 제어 지시자를 함께 사용하는 예제입니다.

 

[예제] 

class Circle {
private:
    double radius; // 직접 접근할 수 없음

public:
    void setRadius(double r) { // 반지름 설정
        if (r >= 0) // 음수 값 방지
            radius = r;
        else
            radius = 0;
    }

    double getArea() { // 면적 계산
        return 3.14 * radius * radius;
    }
};

 

이 클래스에서는 radius 멤버 변수가 private 접근 제어 지시자를 사용하여 외부에서 직접적으로 접근할 수 없도록 했습니다. 그러나 public 접근 제어 지시자를 사용하여 setRadius와 getArea라는 메서드를 통해 간접적으로 radius에 접근할 수 있게 했습니다. 이렇게 해서 클래스 내부의 데이터를 보호하면서도 필요한 경우 해당 데이터를 제어할 수 있게 하였습니다. 이것이 바로 캡슐화와 접근 제어 지시자가 어떻게 상호 작용하는지 보여주는 좋은 예입니다. 

 

이러한 방식은 코드의 안정성과 유지 보수성을 크게 향상시킵니다. 왜냐하면 사용자가 클래스 내부의 데이터를 임의로 변경할 수 없기 때문에 예상치 못한 사이드 이펙트를 방지할 수 있고, 클래스의 내부 구현을 변경하더라도 해당 클래스를 사용하는 코드를 변경할 필요가 없기 때문입니다. 이것이 바로 캡슐화와 접근 제어 지시자가 중요한 이유입니다.

 

4.5.3. 캡슐화 예제와 해석

캡슐화는 클래스의 멤버 데이터를 보호하고, 그 데이터에 접근하는 방법을 제어하는 중요한 객체 지향 프로그래밍 원칙입니다. C++에서는 접근 제어 지시자를 이용하여 멤버 변수와 메서드의 접근 가능성을 제어하며, 이를 통해 데이터를 캡슐화합니다.

 

다음은 캡슐화를 이해하는데 도움이 될 예제입니다.

 

[예제] 

// C++
class BankAccount {
private:
    double balance; // 보호되는 멤버 데이터

public:
    BankAccount() : balance(0.0) {} // 생성자

    void deposit(double amount) { // 입금 메서드
        if (amount > 0) // 양수만 입금 가능
            balance += amount;
    }

    void withdraw(double amount) { // 출금 메서드
        if (amount > 0 && balance >= amount) // 출금 금액이 양수이고 잔액보다 작거나 같아야 함
            balance -= amount;
    }

    double getBalance() const { // 잔액 확인 메서드
        return balance;
    }
};

 

위 코드는 'BankAccount'라는 이름의 클래스를 정의한 것입니다. 이 클래스는 'balance'라는 이름의 private 멤버 변수를 포함하고 있습니다. 이 변수는 클래스의 외부에서 직접 접근할 수 없습니다. 이렇게 하면, 'balance' 변수를 무분별하게 수정하는 것을 방지할 수 있습니다. 대신에, 'deposit', 'withdraw', 그리고 'getBalance'라는 public 메서드를 통해 간접적으로 'balance' 변수에 접근하고 조작할 수 있습니다.

 

여기서 'deposit' 메서드는 양수 금액을 'balance'에 더하며, 'withdraw' 메서드는 양수 금액을 'balance'에서 빼는 역할을 합니다. 그리고 이 두 메서드는 모두 양수 금액만 처리할 수 있도록 설계되었습니다. 이렇게 하면, 잘못된 데이터가 'balance'에 들어가는 것을 막을 수 있습니다.

 

마지막으로, 'getBalance' 메서드를 통해 현재 'balance'의 값을 얻을 수 있습니다. 이 메서드는 'balance'의 값을 변경하지 않으며, 단지 조회하는 역할만 합니다.

 

이렇게 클래스의 멤버 데이터를 직접 접근할 수 없도록 하고, 대신에 메서드를 통해 간접적으로 접근하고 조작하도록 하는 것이 바로 캡슐화입니다. 이를 통해 데이터의 무분별한 접근을 제한하고, 데이터의 정확성과 안정성을 유지할 수 있습니다.

 

4.6. 좋은 클래스 설계와 접근 제어 지시자

좋은 클래스 설계에서는 접근 제어 지시자의 적절한 사용이 중요합니다. 이를 통해 클래스의 내부 데이터를 보호하고 캡슐화를 실현할 수 있습니다. private 지시자를 통해 클래스의 데이터를 직접적인 변경으로부터 보호하고, public 또는 protected 메서드를 통해 안전하게 접근하게 할 수 있습니다. 이렇게 데이터와 메서드의 접근을 잘 관리하는 것이 객체지향 설계의 핵심 원칙 중 하나이며, 이를 통해 유지보수와 코드 재사용성이 향상됩니다.

4.6.1. 정보 은닉의 중요성

좋은 소프트웨어 설계에서 정보 은닉의 개념은 핵심적인 역할을 합니다. 정보 은닉은 클래스 내부의 복잡성을 숨기고 외부로부터의 접근을 제한하는 개념입니다. 이는 개발자가 의도하지 않은 방식으로 클래스의 내부 데이터가 변경되는 것을 방지하며, 프로그램의 안정성과 유지보수성을 높이는데 기여합니다.

 

C++에서는 private 접근 제어 지시자를 이용하여 정보 은닉을 구현할 수 있습니다. 이를 이용하면 클래스의 멤버 변수나 멤버 함수에 대한 직접적인 접근을 제한할 수 있습니다.

 

[예제] 

class MyClass {
private:
    int myData;
public:
    void setMyData(int data) {
        myData = data;
    }
    int getMyData() {
        return myData;
    }
};


위의 C++ 코드에서, myData는 private 멤버로서 클래스 외부에서 직접 접근할 수 없습니다. 이를 통해 데이터의 안정성을 보장하고, 데이터 변경을 위해 반드시 setMyData 함수를 이용하도록 강제합니다. 

 

getMyData 함수는 클래스 외부에서 myData 값을 안전하게 얻을 수 있는 유일한 방법입니다. 이처럼 접근 제어 지시자를 이용하여 멤버 변수에 대한 직접적인 접근을 제한하고, 멤버 함수를 통해서만 접근하도록 하는 것이 정보 은닉의 핵심 원칙입니다. 

 

정보 은닉을 적용함으로써, 클래스를 사용하는 개발자는 클래스의 내부 구조나 동작 원리에 대해 신경 쓰지 않고도 이를 안전하게 사용할 수 있습니다. 또한 클래스 설계자는 클래스의 내부 구현을 필요에 따라 변경할 수 있으며, 이러한 변경이 클래스를 사용하는 코드에 영향을 미치지 않도록 보장할 수 있습니다. 이는 소프트웨어의 유연성과 확장성을 높이는 데 크게 기여합니다.

 

4.6.2. 클래스 설계 시 접근 제어 지시자의 활용

클래스를 설계할 때, 접근 제어 지시자를 적절히 활용하는 것은 매우 중요합니다. 접근 제어 지시자를 통해 클래스의 내부 데이터와 함수를 보호하며, 외부로부터의 접근을 통제할 수 있습니다. 이로 인해 코드의 안정성과 유지보수성이 향상됩니다.

 

접근 제어 지시자의 기본적인 활용 원칙은 데이터를 private로, 그 데이터에 접근하는 메서드를 public으로 만드는 것입니다. 이는 데이터를 보호하고 메서드를 통해서만 접근하도록 강제하는 방식으로, 정보 은닉의 원칙을 지킵니다.

 

[예제] 

class Employee {
private:
    string name;
    int age;
public:
    void setName(string n) { name = n; }
    string getName() { return name; }
    void setAge(int a) { age = a; }
    int getAge() { return age; }
};


위의 C++ 코드에서는 name과 age 변수를 private으로 선언하여 외부로부터 보호하고 있습니다. 이 변수들에 대한 접근은 setName, getName, setAge, getAge와 같은 public 메서드를 통해서만 가능하게 만들었습니다. 

 

또한, protected 접근 제어 지시자는 상속 관계에 있는 클래스에서만 접근이 가능하도록 제한합니다. 이를 통해 부모 클래스의 멤버를 자식 클래스에서 접근하도록 허용하면서, 외부로부터는 그 접근을 보호할 수 있습니다.

 

[예제] 

class Parent {
protected:
    int id;
public:
    void setId(int i) { id = i; }
    int getId() { return id; }
};

class Child : public Parent {
public:
    void printId() { cout << id << endl; }
};

 

이 C++ 코드에서 Child 클래스는 Parent 클래스를 상속받고 있습니다. Parent 클래스의 id 멤버는 protected로 선언되었으므로, Child 클래스 내에서 접근이 가능합니다.

 

이렇게 접근 제어 지시자를 적절히 활용하면 코드의 안정성을 높이고 유지보수를 쉽게 할 수 있습니다. 또한, 코드의 구조를 명확하게 이해하고 수정할 수 있게 돕습니다. 클래스 설계에 있어 접근 제어 지시자의 활용은 중요한 부분이므로, 적절한 접근 제어 지시자의 선택과 사용은 반드시 고려해야 합니다.

 

4.6.3. 클래스 설계 예제와 해석

좋은 클래스 설계에는 정보 은닉과 캡슐화 원칙을 충실히 따르는 것이 중요합니다. 이를 통해 클래스의 안정성과 유지 보수성을 높일 수 있습니다. 이번 섹션에서는 접근 제어 지시자를 사용하는 클래스 설계에 대한 예제와 그 설명을 제공하겠습니다.

 

먼저, 'Employee'라는 클래스를 생각해봅시다. 이 클래스는 직원의 정보를 보유하고 있으며, 이러한 정보는 외부에서 직접 수정하는 것을 허용하지 않아야 합니다. 대신, 적절한 메서드를 통해서만 데이터에 접근하고 수정할 수 있어야 합니다. 이를 C++로 표현하면 아래와 같습니다.

 

[예제] 

class Employee {
private:
    string name;
    int age;
public:
    Employee(string n, int a) : name(n), age(a) {} // Constructor

    void setName(string n) { name = n; }
    string getName() const { return name; }
    
    void setAge(int a) { 
        if(a >= 0 && a <= 120) // Reasonable age range
            age = a; 
        else
            cout << "Invalid age entered!" << endl;
    }
    int getAge() const { return age; }
};

 

여기서 name과 age는 private 접근 제어 지시자 아래에 있으므로 외부에서 직접 접근할 수 없습니다. 이들에 대한 접근은 각각의 getter와 setter 메서드를 통해서만 가능합니다. 이러한 방식은 정보 은닉 원칙을 따르는 좋은 예시입니다.

 

더 나아가, setAge 메서드에서는 전달된 나이 값이 합리적인 범위에 있는지를 검사하여, 데이터의 무결성을 보장하고 있습니다. 이처럼 메서드를 통해 데이터를 유효성 검사하고 제어하는 것은 캡슐화의 핵심 원칙 중 하나입니다.

 

이제 Employee 클래스의 사용 예를 살펴보겠습니다.

 

[예제] 

int main() {
    Employee e1("John Doe", 30); // Create an Employee object
    cout << e1.getName() << " is " << e1.getAge() << " years old." << endl;

    e1.setAge(35); // Update age
    cout << e1.getName() << " is now " << e1.getAge() << " years old." << endl;

    e1.setAge(200); // Invalid age
    cout << e1.getName() << " is still " << e1.getAge() << " years old." << endl;

    return 0;
}

 

이 예제에서는 Employee 객체를 생성하고, 그 이름과 나이를 출력하는 것을 볼 수 있습니다. 그 후 나이를 변경하고, 변경된 나이를 출력하는 것을 볼 수 있습니다. 또한, 부적합한 나이를 설정하려고 시도했지만, setAge 메서드에서 이를 거부하여 객체의 상태가 유지되는 것을 확인할 수 있습니다.

 

이러한 방식으로 클래스를 설계하면, 클래스의 내부 데이터를 보호하고 데이터의 무결성을 보장할 수 있습니다. 이는 좋은 클래스 설계의 핵심 원칙이며, 접근 제어 지시자를 적절히 활용하여 이를 달성할 수 있습니다.

 

 

 

2023.05.17 - [GD's IT Lectures : 기초부터 시리즈/C, C++ 기초부터 ~] - [C/C++ 프로그래밍 : 중급] 3. 생성자와 소멸자

 

[C/C++ 프로그래밍 : 중급] 3. 생성자와 소멸자

Chapter 3. 생성자와 소멸자 객체의 생명주기에 필수적인 이 두 기능을 이해하면, 메모리 관리를 효과적으로 할 수 있습니다. 즉, 이는 안정성과 성능을 위해 필수적인 개념입니다. 이 장에서는 생

gdngy.tistory.com

 

반응형

'GD's IT Lectures : 기초부터 시리즈 > C, C++ 기초부터 ~' 카테고리의 다른 글

[C/C++ 프로그래밍 : 중급] 6. 다형성  (0) 2023.05.29
[C/C++ 프로그래밍 : 중급] 5. 상속  (0) 2023.05.26
[C/C++ 프로그래밍 : 중급] 3. 생성자와 소멸자  (0) 2023.05.17
[C/C++ 프로그래밍 : 중급] 2. 클래스와 객체  (0) 2023.05.16
[C/C++ 프로그래밍 : 중급] 1. 객체 지향 프로그래밍의 개념  (0) 2023.05.16

관련글

댓글

티스토리툴바