[객체지향설계] 객체 지향과 C++ 기본

 

프로그래밍의 세계에서 객체 지향 설계는 복잡한 문제를 논리적이고 효율적으로 해결하는데 도움을 주는 프로그래밍 패러다임 중 하나이다. 이제부터, c++ 언어를 사용하여 객체 지향 설계에 대해 공부해 보고자 한다.

 

c++은 객체 지향 프로그래밍을 지원하는 강력한 언어로, 클래스, 객체, 상속, 다형성, 캡슐화와 같은 개념을 효과적으로 구현할 수 있도록 한다. 물론, c++을 공부하는데 있어서도 굉장한 도움이 될 것이다.

 

 

OOP에 대하여

 

OOP는 객체 지향 설계에 있어 빼놓을 수 없는 개념이다. 무조건 머리에 집어넣도록 하자.

 

• Class and Object(클래스, 객체)
• Abstraction(추상화)
• Encapsulation(캡슐화)
• Inheritance(상속)
• Polymorphism(다형성)

 

 

 

Class and Object

 

 

사실 Class와 Object는 어느정도 프로그래밍을 해보았다면, 들어본 바가 꽤 있을 것이다. 흔히들 붕어빵 틀(class), 붕어빵(object)라고 비유하기도 하고, 설계도와 건축물이라고 비유하기도 한다. 즉, 그 개념을 인지하는데 있어서는 크게 어렵지 않다는 말이다.

 

그래도 조금 개념적으로 서술하자면, Class는 object의 일반적인 구조이며 object의 분류로 볼 수 있다. 그 예시로 Car, Animal, Human 이런 것들이 class인데 어떠한 구체적인 object, 가령 고양이 같은 object는 Animal이라는 class로 분류될 수 있지 않은가.

 

이러한 class는 properties와 behaviors로 구성된다. 즉, attibute와 methods로 볼 수도 있다. 이는 속성 값과 어떤 행동 양식을 가질 수 있는 지 기술한 것이다.

 

Object는 Class의 인스턴스이다. state와 Behavior으로 구성되어 있다. state는 class의 properties와 관계가 있으며, 현재 object가 가지고 있는 properrties이다. state는 바뀔 수 있다는 것이 특징이다.

 

behavior는 object가 할 수 있는 actions을 뜻한다. 별 특별한 의미가 있다기 보단, 사용할 수 있는 method를 말하는 듯 싶다.

 

 

 

 

추상화(Abstraction)

 

굳이 깊게 파고들 필요가 없거나, 관계 가 없는 것들은 숨기는 것이다. 우리가 자동차 엑셀을 밟을 때 굳이 엑셀 밟음으로써 생기는 동작원리를 깊게 이해할 필요가 없는 것과 마찬가지이다. 즉, 굳이 디테일한 이해 없이 object를 사용할 수 있도록 하는 것. 그것이 추상화이다.

 

코드에서 우리는 이러한 추상화를 알게 모르게 사용하고 있을지도 모른다. class안에 method를 만들고, main 함수에서 그 method 내용을 굳이 상관 쓰지 않고, 사용하는 것도 전부 추상화의 일종이다.

 

 

 

 

 

캡슐화(Encapsulation)

 

인가되지 않은 어떤 접근에 대해서는 내부 상태(internal states)를 지키는 것을 말한다. 즉, 외부에서 건드리면 안되는 것들에 대해서는 캡슐을 씌워 밖에서 건드리지 못하도록 해야한다는 말이다. 코드에서는 오직 class가 제공해주는 interface를 통해서만 state가 변하는 것을 허용해 주어야 한다. 코드에서 이는 private같은 것으로 구현할 수 있다.

 

 

 

 

 

상속(Inheritance)

 

상속은 굉장히 알아야 할 것이 많다. 이 또한 이후에 알아가기로 하고, 기본적인 개념만 숙지하자.

상속은 부모 클래스를 하위 자식 클래스로 attibute와 methods를 넘겨주는 것을 말한다. 이는 여러 조건에 의해 넘겨지는 것도 있고, 조금 다르게 동작하는 것도 있다. 하지만 분명한 것은 그 클래스들관의 관계는 부모/자식 관계라는 것이다.

 

이를 super class(자식) / sub class(부모), child class(자식) / parent class(부모), derived class(자식) / base class(부모)로 매핑할 수 있다.

 

자식은 부모의 기능을 물러 받아 그 이상을 할 수 있다는 것을 기억하자.

 

 

 

 

다형성(Polymophism)

 

다형성은 꽤 중요하다. 또 상속이라는 것도 사실 하나의 다형성을 지원하는 방법 중 하나이기도 하다.

 

다형성은 객체의 다양한 형태나 타입을 가질 수 있는 능력을 말한다. 즉, 상속도 부모 클래스가 하위 클래스의 인스턴스를 포용할 수 있다는 것을 생각해보자. 헷갈리면 안되는 것이 다형성은 더 넓은 범위를 포용할 수 있는 것이 더 크다고 보아야 한다.

 

가령, 차는 버스가 될 수 있지만 버스는 차가 될 수 없다는 걸로 이해해보자. 아무튼, 이러한 다형성은 두가지 종류로 나뉜다.

 

• Static polymorphism
  • 이는 컴파일 이전에서 컴파일까지가 범위이다.
  • Method overloading
  • Method overriding
• Dynamic polymorphism
  • 이는 런타임 시가 범위이다.
  • Virtual function calls

 

 

해당 두가지 경우와 어떤 시기에 실행되는 지 제대로 파악할 필요가 있다.

 

 

 

 

Class와  Constuctor, Namespace

 

 

 

Class 선언

 

class Door {
};

class Car {
	public:
		Car(std::string name) : name_(name) {}
		std::string name() { return name_; }
		Door getDoor(int index) { return doors_[index]; }
        
 	private:
		std::string name_;
		Door doors_[4];
}

 

Class의 선언 방법은 어렵지 않다. 다른 언어와 마찬가지로 class name { ... } 로 쓰면 된다.

 

 

 

Object 생성

 

생성하는 방법이 여러가지가 있다.

 

• Direct initialization
  • Car car("mycar")
    • "암묵적"으로 Car class의 constructor를 부른다.
  • Car car = Car("mycar")
    • "명시적"으로 Car class의 constructor를 부른다.
• Conversion
  • Car car = std::string("mycar")
    • 암묵적으로, string value를 class Car의 object로 변환한다.
  • Car car = (Car) "mycar"
    • 명시적으로, string value를 class Car의 object로 변환한다.

 

근데, 사용하는 것은 명시적으로 constructor를 부르는 Car car = Car("mycar")를 많이 사용하는 것 같다.

 

 

 

접근 제어자

 

Private, Protected, Public으로 나뉜다.

 

• Private
  • 클래스 내부에서만 접근 가능하다.
• Protected
  • class 내부이거나, 상속 받은 class 내부에서만 사용할 수 있다.
• Public
  • 어디에서나 접근 가능하다.

 

 

 

Constructor

 

아래와 같이 생성자를 선언해 줄 수 있다.

name(parameter*) : (, member-field(expression*))* { body-statement }

 

또한 정의할 수 있는 constructor로는 몇가지 종류가 있다.

 

1. Default Contructor

 

parameter를 가지지 않는 생성자이다. 혹은 파라미터가 있어도 기본 값이 지정된 생성자를 말한다.

이 생성자는 Compiler가 자동으로 생성한다. 단, 사용자가 직접 정의한 생성자가 없을 때만 가능하다.

 

암묵적으로 모든 멤버 필드에 대해 default constructor를 부른다. 만약에 멤버 필드에 대해서 아무런 default constructor가 없다면, Compiler는 에러를 내놓는다.

 

// default constructor가 생성 못함
class Door {
    public:
        Door(std::string color) : color(color) {} // User-defined constructor with one parameter
    private:
        std::string color;
};

class Car {
     public:
         // Car() : name("mycar") { } // Default constructor
         // std::string name() { return name; }
     private:
         std::string name;
         Door doors; // Error: no matching function for call to 'Door::Door()'
};
 
int main() {
    Car car1; // Error: no matching function for call to 'Door::Door()'

    return 1;
}

 

2. Implicit Conversion constructor

 

생성자가 적어도 하나의 파라미터가 있고, explicit 이라는 키워드가 앞에 붙지 않은 constructor를 의미한다.

이 생성자의 역할은 파라미터 값의 타입이 class의 object로 변환되게 해준다. c++11 버전이후로, 이 생성자의 파라미터로 아무것도 없거나 그 이상의 값이 되어도 아무런 상관이 없어졌다. 이는 explicit이라는 키워드가 지정되지 않은 constructor가 implicit conversion constructor라는 것을 의미하기도 한다.

 

Google C++ style guide는 굳이 이러한 type constructor를 쓰지 않는 것을 추천한다.

 

class Car {
    public:
        Car(std::string name) : name_(name) { } // Implicit converting constructor
        ...
}

int main() {
    Car car1("mycar");
    Car car2 = Car("mycar");
    Car car3 = "mycar"s;
    Car car4 = (Car) "mycar";
}

 

 

3. Explicit conversion constructor

 

오직 하나의 파라미터를 가지며, explicit 이라는 키워드로 구성된 constructor이다.

이 constructor는 위의 Implicit conversion과 달리 파라미터 타입이 class의 object로 변환하지 못하도록 한다.

 

Google C++ style guide는 모든 constructor가 explicit conversion constructor로 정의하는 것을 추천한다.

 

 

class Car {
    public:
        explicit Car(std::string name) : name_(name) { }
        
    private:
        std::string name_;
        Door doors[4]
};

int main() {
    Car car1("mycar");
    Car car2 = Car("mycar");
    Car car3 = "mycar"s; // 이건 자동으로 타입 변환이 불가능하다.
    Car car4 = (Car) "mycar";
}

 

 

3. Copy constructor

 

object를 copy하기 위한 consructor이다. 이는 복사하려는 object의 모든 멤버 필드 값을 복사하여 집어넣는다.

또한 모든 멤버 필드에 대해서 shallow copy를 진행한다. 만약 shallow copy가 아닌 deep copy를 원한다면, 따로 만들어주어야 한다.

 

아래 예시를 보면, 생성자에 직접적으로 Explicit이 붙어 있지 않다. 즉, 생성자 호출 시 Implicit 혹은 Explicit하게 호출하는 것을 허용한다는 것을 말한다.

 

반면, 생성자에 Explicit이 붙어있다면, Implicit 호출은 불가능하며, 오직 Explicit을 통해 호출하여야 한다.

class Car {
    public:
        Car() : name_("mycar") {}
        Car(const Car& car) : name_(car.name_) {
            for(int i=0; i<4; ++i) {
                doors_[i] = car.doors_[i];
            }
        }
    private:
        std::string name_;
        Door doors_[4];
};

int main() {
    Car car;
    Car car2(car); // Implicit copy constructor call
    Car car3 = Car(car2); // Explicit copy constructor call
    Car car4 = car3;
}

 

 

얕은 복사(Shallow copy) : 원본 객체와 복사한 객체가 서로 같은 데이터를 참조하는 것. 즉, 포인터가 
깊은 복사(Deep copy) : 원본 객체와 복사한 객체가 완전히 독립적인 데이터 참조를 가지는 것.


즉, 얕은 복사는 포인터가 같은 거고, 깊은 복사는 값만 복사하고 포인터가 다른다고 생각할 수 있다.

 

 

C++의 Class에서 친구 관계(Friends)

 

C++에서는 friends라는 관계를 Class내에서 정의할 수 있다. 하지만 말만 친구지 사실 상 나만 친구로 생각하는 일방적인 친구 관계이다. 내가 친구로 생각하는 대상 class에서는 나의 기능을 전부 사용할 수 있으나, 나는 대상 class의 기능을 사용할 수 없다. 좀 호구같은 관계이다.

 

class Person {
    public:
        void CallCat() {
            cat_ -> Move(); // Error가 난다.
        }
        
    private:
        Hand hands_[2];
        Leg legs_[2];
        Cat* cat_;
        friend Cat; // 나만 친구인 관계
}

 

 

class Cat {
    public:
        void TouchHuman() {
        	// 날 친구로 생각하는 친구의 것은 사용할 수 있음.
            Hand left_hand = owner_ -> hands_[0];
            Leg right_hand = owner_ -> legs_[0];
        }
        
    private:
        Leg legs_[4];
        Person* owner;
        void Move() { ... }
}

 

 

 

 

 

C++에서의 선언과 정의

 

 

Class에서의 함수의 선언

 

private로 지정된 멤버 필드에 대한 조작을 위해 함수를 선언해 줄 수도 있다. 크게 어려운 것은 없고 간단하게 Return 타입과 함수 이름, 그리고 파라미터 정보만 작성해주면 된다.

 

 

class Car {
    public:
        Car(std::string name);
        void set_name(std::string name);
        std::string name();
        
    public:
        std::string name_;
}

 

 

Class에서의 함수의 정의

 

앞선 class에 대한 선언파일은 .h 파일에서 작성한다. 실질적으로 작동 과정에 대한 부분은 .cc 파일 혹은 .cpp에서 진행할 수 있다. 앞선, 정의와 구조가 동일하도록 작성해주면 된다.

 

ReturnType className::FunctionName(parameters { Body statement; }

 

즉, 위와 같이 clasName과 "::" 를 통해서 그 class에 정의된 Function 내용을 작성해줄 수 있다.

조금 기억해야 할 것은 h 파일 내에서 include 시킨 내용에 대해서는 굳이 h 파일을 포함 시킨 cc 파일 내에서 다시 작성할 필요는 없다는 것이다. 이렇듯, h 파일과 cc 파일을 나누는 이유는 모듈화와 유지보수 측면에서 유리하기 때문이다.

 

 

즉, 아래와 같이 cc 파일에서 h 파일을 포함 시켜준다.

 

#include <iostream>
#include "car.h"

int main() {
    Car car("mycar");
    std::cout << car.name() << std::endl;
    return 1;
}

 

 

 

 

 

 

Class에서의 좋은 Pratice

 

 

• Class의 이름은 Pascal cases이다.

class Cat { ... };
class Person { ... };
class ChungnamUniv { ... };

 

어느 곳에 가든, 코드 컨벤션은 지키는 것이 신상에 좋다. C++에서 class의 이름은 Pascal Case로 작성해주자.

 

• 오직 멤버 필드에 대한 public access만을 가지는 데이터 구조에서는 clsss 대신에 struct를 사용하자.

struct Point {
    int x_;
    int y_;
}

 

사실 동작 자체는 Class나 Struct나 동일하지만, public한 접근만을 가지는 데이터 구조라면 struct를 사용해야 한다.

 

 

• 멤버 변수는 snake_case이며, 마지막에는 _(underscore)를 붙여준다.

class Person {
    int age_;
    std::string home_address_;
};

사용하는 이유는 local에 있는 변수와 member 변수 간의 구분을 위해서이다.

 

 

• 멤버 함수는 Upper-Carmel-Case를 사용한다.

사실 상 Pascal과 동일하게 작성한다. 기억할 만한 차이점이 있다면, 멤버 변수에 대한 getter 함수가 있을 때는 그 멤버 변수의 일름과 동일하게 함수 이름을 작성해준다.

class Person {
    int DoSomthing() { ... }
    int age() { return age_; }
    int age_;
};

 

 

• 멤버 필드를 작성할 때, 접근 제어자는 public에서 private 순으로 작성하도록 한다.

 

class Person {
    public:
        int age() { return age_; }
        int DoSomething1() { ... }
        
    protected:
        int DoSomething2() { ... }
    
    private:
        int age_;
        std::string home_address_;
}

 

 

 

• 당연하지만, 선언과 정의에 대한 파일은 나누어 놓자.(즉, cc파일과 h파일을 구분하여 두자.)

 

• 모든 constructor는 Explicit하게 작성하자.

앞서 배웠듯, implicit은 타입에 대한 conversion이 자동으로 이루어지지만, Explicit은 그것을 제한한다. 언뜻보면 편한것 아닌가 생각할 수 있지만 이는 치면적인 프로그래밍 오류로 이어질 수 있다. 이러한 이유로 인해 왠만하면 constructor는 Explicit하게 작성하자.

 

 

Class Person {
    public:
        explicit Person(int age);
        explicit Person(int age, std::string addr);
    
    private:
        int age_;
        std::string home_address_;
}

// Person p(3)으로 하면, int 값이 파라미터 값으로 들어옴이 명백하다.
// Person p = 3은 암묵적으로 타입을 변환하여 object를 생성하는 방법이다.

 

object를 생성하는 방법에 있어 헷갈린다면 앞서 배운 object 생성 방법에 대해 다시한번 보고 오길 바란다.

 

 

 

Namespace

 

 

namespace는 함수, 변수, class들을 포함하는 특수한 코드 영역이다. C++ 내에서는 같은 식별자를 정의할 수 없지만 이 namespace를 사용한다면 가능해진다.

 

하지만, 같은 namespace 안에서는 식별자가 중복되면 안된다. 또한 main function은 다른 namespaces에 속할 수 없다.

 

 

 

#include <iostream>

namespace ns1 {
    int value = 3;
}

namespace ns2 {
    std::string value("Hi there");
}

int main() {
    std::cout << ns1::value << std::endl;
    std::cout << ns2::value << std::endl;
}

 

 

 

Nested namespace

 

namespace안에는 여러 namespace를 중첩된 구조로 사용할 수 있다.

역시나, 같은 식별자의 변수를 동시에 선언할 수 있다.

 

#include <iostream>

namespace ns1 {
    void foo() {
        std::cout << "foo() in ns1" << std::endl;
    }
    
    namespace ns2() {
        void foo() {
            std::cout << "foo() in ns2" << std::endl;
        }
        
        namespace ns3() {
            void foo() {
                std::cout << "foo() in ns3" << std::endl;
            }
        }
    }
    
    namespace ns4() {
        void foo() {
            std::cout << "foo() in ns3" << std::endl;
        }
    }
}

int main() {
  ns1::foo();
  ns1::ns2::foo();
  ns1::ns2::ns3::foo();
  ns1::ns4::foo();
}

또한 기본적으로 이렇게 nested되게 작성된 namespace안에서 식별자를 찾을 때는 안에서 부터 밖으로 찾는다.

 

 

같은 namespace의 분리된 작성

 

아래와 같이 namespace를 쓸 때 굳이 한번에 다쓰지 않아도 좋다.

namespace ns1 {
    void foo() {
        std::cout << "foo() in ns1" << std::end;
    }
}

namespace ns1 {
    void bar() {
        std::cout << "bar() in ns1" << std::end;
    }
}

int main() {
    ns1::foo();
    ns1::bar();
    return 0;
}

 

 

namespace에서의 좋은 Pratice

 

• namespace는 snake-cases 작성한다.

namespace theory { ... }
namespace object_oriented { ... }
namespace good_practice_in { ... }

 

 

 

• 어떤 namespace인지에 대한 comment를 명백히 남겨야 한다.

namespace object_oriented {
    namespace good_pratice_in{
        ...
    } // namespace good_pratice_in
} // namespace object_oriented

 

• "using namespace::사용하고자 하는 identifiers" 로 작성해야 한다.

그래야 어떤 namespace에서 어떤 identifier를 사용하는 것인지 명확해지기 때문이다.

 

 

namespace theory{
    void foo() { ... }
    void bar() { ... }
}

namespace practice{
    void foo() { ... }
    void bar() { ... }
}

using theory::foo();
using pratice::bar();

foo(); bar();;