3. Class

C1. 구현부와 선언부

Cpp에서 클래스를 구현할 때에는 구현부(.cpp)와 선언부(.h)를 다른 파일로 작성한다.

#include "Person.h"

int main()
{
    Person p1;
    p1.SetPerson("홍길동",20,true);
    p1.ShowPerson();

    return 0;
}

/*	Person.h	*/

//여러번 include 되는걸 방지하기 위한 전처리문이다.
#ifndef PROJECT_PERSON_H // 보통 '영어_대문자_H' 로 이름을 짓는다.
#define PROJECT_PERSON_H

class Person
{
    private: // 접근 제한자(비공개)
        char* m_name;
        int m_age = 0; // c++11 부터는 기본값 설정(생성자가 없을 때)도 가능하다.
        bool m_gender;
        
    public: //접근 제한자(공개)
        Person(); // 디폴트 생성자
        ~Person(); //소멸자
        void SetPerson(char* name, int age, bool gender); 
        
    	//함수도 public 선언 가능
        void ShowPerson();
};

#endif // ifndef 종료

 

참고로 구현부(.cpp)에서는 꼭 한 클래스로 내용을 적을 필요는 없다.

따로 나눠서 Class:: 으로 메서드 하나하나 따로 적어줘도 된다.

/*	 Person.cpp 	*/

#include "Person.h" // 선언부를 include 한다.

Person::Person(){
}
 
Person::~Person(){
    // delete[] 배열이름
}
 
void Person::SetPerson(char* name, int age, bool gender){
    this->m_name = name; // 참고로 지역변수의 이름이 다르다면 this를 생략해도 된다.
    this->m_age = age;
    this->m_gender = gender;
}
 
void Person::ShowPerson(){
    printf("%s, %d, ", this->m_name, this->m_age);
    
    if(this->m_gender == true)
        printf("남성\n");
    else
        pring("여성\n);
}

 

2. 클래스 객체 생성

Class c; 와 Class*c = new Class(); 의 차이

다른 언어를 하다오면 헷갈릴 수도 있는데, Cpp에서는 클래스를 사용하는데 new 키워드가 필요없다.

일반 자료형처럼 인스턴스를 생성해주면 된다. 이는 일반 자료형처럼 스택 메모리에 할당된다.

일반 자료형과 마찬가지로 변수의 생성범위(Scope)를 벗어나게되면 자동으로 메모리에서 할당 해제된다.

MyClass name; // 할당완료.
name.method() // 바로 사용

 

그럼에도 불구하고 new 키워드가 존재하는 이유는, 포인터를 사용한 동적할당에 사용된다.

메모리를 동적할당 할 경우 자바처럼 힙 메모리에 저장되고 new 연산자에 의해 생성자가 자동으로 호출된다.

어찌보면 당연한 기능인 것 같지만, 기존의 malloc을 사용하는 C언어에서는 클래스가 없으니 이런 기능도 없었다.

Student *kim;
kim = new Student();
kim->showData(); // 포인터를 이용해 클래스 접근 (->)

여기서 개같은 CPP의 장점. 우리가 직접 메모리를 관리하는 언어라는 걸 상기시켜준다.

할당된 힙 메모리를 할당해제(delete, free) 시켜주지 않으면 메모리는 계속해서 남아있게된다.

물론 최근의 GCC에는 가비지 컬렉터가 설치되어있어서 어느정도는 해결해주긴하지만 표준으로 제공해주는 언어의 기능이 아니므로 메모리 누수방지를 위해 직접 관리해주는 것이 좋다.

 

3. 생성자 오버라이딩

class Rectangle {
private: // 명시하지않으면 기본값은 private입니다.
    int length;
    int breadth;

public:
    Rectangle() { // 생성자
        length = 0;
        breadth = 0;
    }

    Rectangle(int l, int b) { // 생성자 오버라이딩
        length = l;
        breadth = b;
    }
    ~Rectangle(){ // 소멸자
        cout << "Destructor";
    }
};

 

3-1 생성자 위임

기존의 생성자를 재사용 하고 싶다면, new_Init { old_Init() } 처럼 직접 호출하지말고 아래와 같이 사용하자.

Class_init() { 
    // Code A 
} 

Class_init(int value) : Class_init() {// 다른 생성자를 위임한다. 
    // Code B
    // 여기에 Class_init()를 직접 호출하는 건 권장하는 방법이 아니다.
}

 

4. 소멸자

객체가 소멸될 때 자동으로 실행되는 클래스의 멤버 함수이다.

기본 자료형 값이면 크게 필요 없지만, 동적메모리나 데이터베이스 등 리소스를 관리하기에 편하다.

참고로 C언어에서는 free() 를 사용했다면, CPP에서는 delete 라는 키워드가 제공된다.

delete를 선언하게되면 해당 클래스나 자료형의 소멸자가 호출된다.

class MyArray {
private:
    int* Array;
    int Length;

public:
    MyArray(int length) { // 생성자
        this->Array = new int[static_cast<size_t>(length)]{};
        this->Length = length;
    }

    ~MyArray(){ // 소멸자
        delete[] Array; 
        // 메모리가 그룹 형식(리스트)이라면 delete[] 키워드를 사용하자.
    }
};

 

5. 클래스 멤버 초기화

CPP에서는 클래스 초기화를 할 때도 메모리를 아끼는 방법이 존재한다.

참고로 int x = 5; 를 int x { 5 }; 로 초기화 해도 된다. 이는 여러 멤버를 동시에 초기화 할 때 사용한다.

#include <iostream>

class Rectangle {
private:
    double m_Length = 1.0; // 또는 m_Length { 1.0 };
    double m_Width = 1.0;

public:
    Rectangle(double length, double width) : m_Length(length), m_Width(width){
        // 기본값을 사용하지 않는 초기화. + 이렇게하면 메모리를 더 아낄 수 있다.
    }

    Rectangle(double length) : m_Length(length){
        // m_Length 변수는 값이 초기화된다. // m_Width 변수는 기본값 1.0
    }
};

int main() {
    int x = {3};
    Rectangle y{ 2.0, 3.0}; // length = 2 , width = 3
    Rectangle z{2.0}; // length =2 , width = 기본값 (기본값을 안적었다면 쓰레기값)
    return 0;
}

 

6. Class Chaining

클래스의 this 포인터를 응용하면 Number.Add(5).Add(5).Mul(6) 이런식의 구현도 가능하다.

class Calc {
private: 
    int m_Value = 0;
    
public: 
    Calc& Add(int value) {
        m_Value += value; return *this; 
        // 헷갈리지말자. this 자체는 4바이트 포인터 주소값이다.
        // Calc 클래스를 반환할려면 값(*this)을 반환해야 한다
    } 
    
    Calc& Sub(int value) {
        m_Value -= value; return *this; 
    }
    
    Calc& Mul(int value) {
        m_Value *= value; return *this; 
    }
    
    int GetValue() { return m_Value; }
}; // 세미콜론 까먹지 말자.

int main() { 
    Calc calc; 
    calc.Add(5).Sub(3).Mul(4); 
    cout << calc.GetValue() << endl; // (+5-3)*4 = 8 
    return 0; 
}

 

7. Template Method

CPP에서 다양한 자료형에 대한 오버로딩을 구현하고 싶을 때 사용하는 방법이다.

아래와 같이 오버로딩을 구현했다고 쳤을 때

int sum(int a, int b){
    return a + b;
}
double sum(double a, double b){
    return a + b;
}

 

템플릿 메서드를 사용하면 이렇게 만들 수 있다.

// typename T 과 class T 제공 //

template <typename T>
T sum(T a, T b){ // sum<int>(a,b) 처럼 사용
    return a + b;
}

template <class T1, class T2>
void printAll(T1 a, T2 b){ 
	// printAll(m1,m2) 처럼 사용
    // 클래스의 경우 컴파일러가 자료형을 판단 가능하기에 생략가능.
	
    cout << "T1 : " << a << endl;
    cout << "T2 : " << b << endl;
    cout << "T1 + T2 : " << a + b << endl;
}

 

7-1 메서드가 자료형에 따라 다르게 동작 하는경우

해당 함수의 템플릿 원형을 선언 한 후, 밑에 구현부를 template<> 로 따로 적어주면 된다.

template <class T> // 원형
T sum(T a, T b){
   return a + b;
}
 
template<>
char * sum<char*> (char* s1, char* s2){ // char형
   char * str= "[char *]문자열은 더할 수 없습니다."; 
   cout << "s1 : " << s1 << endl;
   cout << "s2 : " << s2 << endl;
   return str; 
}
   
template<>
const char * sum<const char*> (const char * s1,const char *s2){ // const char 형
   char * str= "[const char *]문자열은 더할 수 없습니다.";
   cout << "const s1 : " << s1 << endl;
   cout << "const s2 : " << s2 << endl;
   return str; 
}
 
template<>
string sum<string>(string s1, string s2){ // string 형
   string str = "[string]문자열은 더할 수 없습니다.";
   cout << "string s1 : " << s1 << endl;
   cout << "string s2 : " << s2 << endl; 
   return str;
}

 

7-2 클래스에서 템플릿 메서드 사용

내부에서 사용할 때는 똑같이 사용하면 되고, 외부에 메서드별로 따로 구현할땐 각각 적어줘야 한다.

template <class T> // 클래스 내부에서 템플릿 사용
class Person{
private:
    string name;
    T height;
public:
    Person(string name, T height):name(name), height(height){}
 
    void printAll(){
        cout << "name : " << name << endl;
        cout << "number : " << height << endl;
    };
 
    void setName(string name){
        this->name = name;
    }
    void setNumber(T height){
        this->height = height;
    }
};

//클래스 외부에서 해당 메서드를 구현할 때 (헤더파일 분리)

template <class T>
class Person{

private:
    string name;
    T height;
public:
    Person(string name, T height);
    void printAll();
    void setName(string name);
    void setNumber(T height);
}; // 선언부 끝 (.h)


 //구현부 시작 (.cpp)
template <class T> // :: 처럼, 각 메서드마다 새롭게 적어주어야 함.
Person<T>::Person(string name, T height):name(name), height(height){}
 
template <class T>
void Person<T>::printAll(){
    cout << "name : " << name << endl;
    cout << "number : " << height << endl;
};
// ... 이하 생략