# Class

일반적으로 c++의 클래스는 구조체보다 더 효과적인 문법이다. 구조체와 클래스는 거의 흡사하게 동작하지만, **클래스에서는 내부적으로 함수 등을 포함**할 수 있다.

클래스는 상속 개념을 프로그래밍에서 그대로 이용할 수 있다는 점에서 객체 지향 프로그래밍(OOP)을 가증하도록 해주는 기본단위이다.

### 구조체

```cpp
#include <iostream>
#include <string>

using namespace std;

struct student{
    string name;
    int score;
};
int main(){
    struct student a;
    a.name = "테스트";
    a.score = 90;

    cout << a.name << " : "<< a.score << endl;  
    return 0;
}
```

### 객체 지향 프로그래밍의 특징

객체 지향 프로그래밍은 다음과 같은 특징때문에 소스코드를 보다 간결하고 생산성 높게 만들어준다.

* 추상화(Abstract)
* 캡슐화(Encapsulation)
* 상속성(Inheritance)
* 정보 은닉(Data Hiding)
* 다형성(Polymorphism)

[_자바-객체지향프로그래밍_](https://dh00023.gitbooks.io/java/%EB%AC%B8%EB%B2%95/java06.html)_에서 더 자세히 관련 특징을 볼 수 있다._

```cpp
class Student {
// 멤버 변수는 속성(property)라고 부른다.
private:
    string name;
    int score;
// 객체의 외부에서 접근할 수 있는
public:
    // 생성자
    Student(string n, int s){ 
        name = n;
        score = s;
    }
    // 멤버 함수(Method)
    void show(){
        cout << name << " : " << score << endl;
    }
};
```

C++ 클래스를 활용해 만든 변수를 instance라고 한다.

```cpp
int main(){
	// s1이 인스턴스
	Student s1 = Student("test", 100);
}
```

기본적으로 하나의 클래스에서 생성된 인스턴스는 서로 독립된 메모리 영역에 멤버 변수가 저장되고, 관리된다. 다만 멤버 함수는 모든 인스턴스가 공유한다는 점에서, 함수 내에서 인스턴스를 구분할 필요가 있다. c++ `this` 포인터는 포인터 자료형으로, 상수라는 점에서 값을 변경할 수 없다.

```cpp
class Student {
// 내부적인 객체
private:
    string name;
    int englishScore;
    int mathScore;
    int getSum() { return englishScore + mathScore;}
// 객체의 외부에서 접근할 수 있는
public:
    // 생성자
    Student(string name, int englishScore, int mathScore){ 
        // 자기 자신의 멤버 변수에 접근하기 위해서는 this 사용
        this->name = name;
        this->englishScore = englishScore;
        this->mathScore = mathScore;
    }
    void show(){
        cout << name << " : " << getSum() << endl;
    }
};
```

### 접근 한정자

* public : 클래스, 멤버 등을 외부로 공개한다. 해당 객체를 사용하는 어떤 곳에서도 접근할 수 있다.
* private : 클래스, 멤버 등을 내부에서만 활용한다. 외부에서 해당 객체에 접근할 수 없다.

클래스는 기본 멤버를 private 형태로 간주한다.(`private:`를 제외하면 멤버는 자동으로 private 문법을 따름) 반대로 구조체는 기본적으로 멤버를 public으로 간주한다.

### 생성자(Constructure)

생성자를 이용해 객체를 생성함과 동시에 멤버 변수를 초기화할 수 있다. 생성자는 특별한 메소드로, **클래스의 이름과 동일한 이름의 메소드로 구현**된다. 생성자는 반환 값이 없으며, 여러번 정의되어 다양한 방법으로 객체를 초기화할 수 있다.

c++에서는 별도로 생성자를 구현하지 않으면 기본 생성자(Default Constructor)가 사용된다. 기본 생성자는 매개변수를 가지지 않으며, 멤버 변수는 0, NULL등의 값으로 초기화 된다.

Copy Constructor(복사 생성자)는 다른 인스턴스의 참조를 인수로 받아 그 참조를 이용해 자신의 인스턴스를 초기화할 수 있다. Deep Copy를 이용해 만들어진 인스턴스는 기존의 인스턴스와 다른 메모리 공간에 할당되어 독립적이다.

* 얕은 복사

```cpp
Student(string name, int englishScore, int mathScore) : name(name), englishScore(englishScore), mathScore(mathScore) { }
```

다음과 같이 생성자를 한줄로 줄여서 쓸 수 있다.

* 깊은 복사

```cpp
// 또 다른 Student 인스턴스를 매개변수로 받아서 초기화할 수 있다.
Student(const Student& other){
	name = other.name;
	englishScore = other.englishScore;
	mathScore = other.mathScore;
}
```

```cpp
int main(){
	Student s1 = new Student("test", 100, 20);
	Student s2 = Student(*s1);
}
```

### 소멸자(Destructor)

소멸자는 객체의 수명이 끝났을 때 객체를 제거하기 위한 목적으로 사용된다. 객체의 수명이 끝났을 때 자동으로 컴파일러가 소멸자 함수를 호출한다.

소멸자도 클래스의 이름과 동일하며 물결 기호(`~`)를 이용해 정의할 수 있다.

```cpp
~Student(){
	cout << " 객체가 소멸되었습니다. " << endl;
}
```

```cpp
int main(){
		Student* student1 = new Student("dahye", 100,100);
    student1->show();

    Student student2 = Student(*student1);
    student2.show();
    delete student1; // 동적할당을 이용한 인스턴스만 성공적으로 소멸한다.
    // delete student2  동적할당을 이용하지 않은 인스턴스는 소멸시킬 수 없다.(자동소멸)
}
```

### 상속(Inheritance)

자식 클래스가 부모 클래스의 속성을 그대로 물려 받아 사용할 수 있다. 상속을 활용해 소스코드의 재사용성을 늘릴 수 있다. 자식 클래스는 파생 클래스(Derived Class)라고도 불리며, 부모 클래스의 모든 속성을 물려 받는다. `:`을 활용해 부모클래스와 연결될 수 있다.

```cpp
class Person {
private:
	string name;
public:
	Person( string name ): name(name) { }
	string getName(){
		return name;
	}
	void showName(){
		cout << "이름 : "<< getName() << endl;
	}
};
```

```cpp
class Student : Person{
private:
	int studentId;
public:
	// 생성자에서 name은 Person의 name을 상속받은 것
	Student(int studentId, string name) : Person(name) {
		this->studentId = studentId;
	}
	void show(){
		cout << "student id" << studentId << endl;
	}
};
```

자식 클래스의 인스턴스를 만들 대 가장 **먼저 부모 클래스의 생성자가 호출**된다. 자식클래스의 수명이 다했을 때는 자식 클래스의 소멸자가 먼저 호출된 후에 부모 클래스의 소멸자가 호출된다.

### 오버라이딩(Overriding)

부모 클래스에서 정의된 함수를 무시하고, 자식 클래스에서 동일한 이름의 함수를 재정의하는 문법. 오버라이딩을 적용한 함수의 원형은 기존의 함수와 동일한 매개변수를 전달 받는다.

```cpp
class Person {
private:
	string name;
public:
	Person( string name ): name(name) { }
	string getName(){
		return name;
	}
	void showName(){
		cout << "이름 : "<< getName() << endl;
	}
};
```

```cpp
class Student : Person{
private:
	int studentId;
public:
	// 생성자에서 name은 Person의 name을 상속받은 것
	Student(int studentId, string name) : Person(name) {
		this->studentId = studentId;
	}
	void show(){
		cout << "student id" << studentId << endl;
	}
	void showName(){
		cout << "student name : "<< getName() << endl;
	}
};
```

### 다중상속(Multipple Inheritance)

여러개의 클래스를 상속받는 것이다. 다중상속을 지원하지만 많이 사용되지는 않는다.

```cpp
class Student : Person, public Temp {
private:
	int studentId;
public:
	// 생성자에서 name은 Person의 name을 상속받은 것
	Student(int studentId, string name) : Person(name) {
		this->studentId = studentId;
	}
	void show(){
		cout << "student id" << studentId << endl;
	}
	void showName(){
		cout << "student name : "<< getName() << endl;
	}
};
```

* 여러 개의 부모 클래스에 동일한 멤버가 존재할 수 있다.
* 하나의 클래스를 의도치 않게 여러 번 상속받을 가능성이 있다.

### 오버로딩(Overloading)

동일한 이름의 멤버 함수를 다양한 방식으로 활용하기 위해서 오버로딩을 사용할 수 있다.

* 함수 오버로딩

```cpp
class Person {
private:
	string name;
public:
	// 생성자 오버로딩
	Person() { name = "테스트"; }
	Person( string name ) : name(name) { }

	void showName(){
		cout << name << endl;
	}

};
int main(void){
	Person person1;
	person1.showName(); // 테스트
	Person person2 = Person("테스트2");
	person2.showName(); //테스트2
}
```

* 연산자 오버로딩
  * 기존에 존재하는 연산자만 정의할 수 있다.
  * 멤버 연산자(`.`), 범위 지정 연산자(`::`) 등의 몇몇 연산자는 오버로딩 처리할 수 없다.
  * 피연산자의 개수 규칙 등 기본적인 연산자의 규칙을 따라야한다.
  * 오버로딩이 된 연산자의 피연산자 중 하나는 사용자 정의 자료형이어야만 한다.

```cpp
#include <iostream>
#include <string>

using namespace std;

class Person {
private: 
	string name;
public:
	Person() { name = "테스트"; }
	Person( string name ) : name(name) { }
	// 연산자 오버라이딩
	Person operator +(const Person& other) { return Person(name + " & "+ other.name);}
	
	void showName(){
		cout << name << endl;
	}	
};

int main(void){
	Person person1;
	Person person2("테스트2");
	Person result = person1 + person2;
	result.showName(); // 테스트 & 테스트2
}
```

### 캡슐화(Encapsulation)

캡슐화는 관련된 함수의 멤버들은 되도록 하나의 클래스에서 관리하는 것이다. 또한, 같이 실행되어야 하는 기능들도 하나의 클래스에 넣어서 응집된 기능을 가질 수 있도록 해야한다.

c++에서는 기본적으로 멤버 변수에 접근하기 위해서는 public 멤버 함수(getter)를 이용해야한다. 다만 특정한 객체의 멤버 함수가 아닌 경우에도 private 멤버에 접근해야 할 때가 있다. 이때 `friend` 키워드를 이용하면 특정한 객체의 모든 멤버에 접근할 수 있다.

```cpp
#include <iostream>
#include <string>

using namespace std;

class Student {
private:
	int studentId;
	string name;

public:
	Student(int studentId, string name) : studentId(studentId), name(name) { }
	// friend 키워드를 이용해 바로 student.name, other.name 과 같이 바로 접근할 수 있다.
	friend Student operator +(const Student &student, const Student &other) {
		return Student(student.studentId, student.name + " & " + other.name);
	}
	void showName() { cout << "이름: " << name << '\n'; }
};

int main(void) {
	Student student(1, "테스트");
	Student result = student + student;
	result.showName();
}
```

#### Friend Class

두 클래스가 서로 밀접한 연관성이 있으며, 상대방의 private에 접근해야 한다면 클래스 자체를 Friend로 선언할 수 있다.

```cpp
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <ctime>

using namespace std;

class Time {
    // friend class를 선언해주면 Date class에서 Time class 이용이 가능하다.
    friend class Date;
private:
    int hour, min, sec;
public:
    void setCurrentTime() {
        time_t currentTime =  time(NULL);
        struct tm *p = localtime(&currentTime);
        hour = p->tm_hour;
        min = p->tm_min;
        sec = p->tm_sec;
    }
};

class Data{
private:
    int year, month, day;
public:
    Date(int year, int month, int day) : year(year), month(month), day(day){ }
    // friend class이므로 바로 접근할 수 있다.
    void show(const Time &t) {
        cout << "지정된 날짜 : " << year << "년 " << month << "월 " << day << "일 " << '\n';
        cout << "지정된 날짜 : " << t.hour << ":" << t.min << ":" << t.sec << '\n';
    }
};

int main(void){
    Time time;
    time.setCurrentTime();
    Date date = Date(2019, 12, 22);
    date.show(time);
}
```

#### 정적 멤버

클래스에 포함되어있는 멤버이지만 모든 객체가 공유하는 멤버이다. 정적으로 선언된 멤버는 메모리 상에 오직 하나만 할당되어 관리된다. 정적멤버를 public 으로 선언하면 외부의 어떠한 클래스에서도 접근이 가능하며, 정적 멤버는 일반적으로 **싱글톤 패턴**등의 다양한 기능을 위해 사용된다.

```cpp
class Person {
private:
	string name;
public:
	// 정적 변수
	static int count;
	Person(string name) : name(name) {
		count ++;
	}
};

int Person::count = 0;

int main(void) {
	Person p1("테스트1");
	Person p2("테스트2");
	Person p3("테스트3");
	cout << Person::count << endl; // 3
}
```

#### 상수 멤버(Constant Member)

호출된 객체의 데이터를 변경할 수 없는 멤버

```cpp
class Person {
private:
	const int id;
	string name;
public:
	// 정적 변수
	static int count;
	Person(int id, string name) : id(id), name(name) {
		count ++;
	}
};

int Person::count = 0;

int main(void) {
	Person p1(1, "테스트1");
	Person p2(2, "테스트2");
	Person p3(3, "테스트3");
	cout << Person::count << endl; // 3
}
```

### 다형성(Polymorphism)

여러 개의 서로 다른 객체가 동일한 기능을 서로 다른 방법으로 처리할 수 있는 기능을 의미. 예를 들어 게임에서 칼, 대포, 총은 '공격'이라는 동일한 기능을 수행할 수 있다.

추상클래스(Abstract Class)로 동일한 기능을 구현하면 효과적으로 설계할 수 있다.

C++ 컴파일러는 포인터 변수가 가리키고 있는 변수의 타입을 기준으로 함수를 호출하지 않고, 포인터의 타입을 기준으로 함수를 호출한다. 즉, A라는 객체를 가리키는 포인터 변수는 A객체의 멤버 함수만을 호출할 수 있다.

```cpp
class A{
public:
    void show() {
        cout << "A class" << endl;
    }
};

class B : public A{
public:
    void show() {
        cout << "B class" << endl;
    }
};

int main(void){
    A* p;
    A a;
    B b;
    p = &a;
    p->show(); // A class
    p = &b;
    p->show(); // A class
}
```

p라는 포인터가 A객체의 타입을 가리키기 때문에 A class의 show()를 호출하는 것을 볼 수 있다. 이러한 것을 정적 바인딩이라고 한다.

#### 동적바인딩(Dynamic Binding)

C++는 특정한 함수를 호출할 때 해당 함수의 루틴이 기록된 메모리 주소를 찾아야한다. 특정한 함수를 호출하는 소스코드에서 실제로 함수가 정의된 메모리 공간을 찾기 위해서는 Binding 과정이 필요하다.

일반적으로 함수의 호출은 컴파일 시기에 고정된 메모리 주소를 이용한다. 이러한 방식을 정적 바인딩(Static Binding)이라고 한다. 일반적인 멤버 함수는 모두 이러한 정적 바인딩을 사용한다.

다만 가상 함수는 프로그램이 실행될 때 객체를 결정하는 점에서 컴파일 시간에 객체를 특정할 수 없다. 가상함수는 실행 시간 때 올바른 함수가 실행될 수 있도록 동적바인딩을 사용한다.

```cpp
class A{
public:
    virtual void show() {
        cout << "A class" << endl;
    }
};

class B : public A{
public:
    virtual void show() {
        cout << "B class" << endl;
    }
};

int main(void){
    A* p;
    A a;
    B b;
    p = &a;
    p->show(); // A class
    p = &b;
    p->show(); // B class
}
```

#### 가상함수

컴파일러는 가상 함수 테이블(Virtual Function Table)을 이용해 가상 함수를 다루게 되는데, 컴파일러는 각각의 객체마다 가상 함수 테이블을 가리키는 포인터를 저장하기 위한 멤버를 저장한다.

가상 함수를 호출하면 가상 함수 테이블에 접근하여 자신이 필요한 함수의 주소를 찾아 호출하게 된다. 이러한 과정은 **동적 바인딩**을 통해 이루어지므로 컴퓨팅 리소스를 소모하게된다.

즉, 자식 클래스가 재정의할 가능성이 있는 멤버 함수들은 가상 함수로 선언하는 것이 좋다.

* 가상 클래스의 소멸자

상속 관계가 잇으면서, 동시에 메모리 해제를 해야하는 경우에는 부모 클래스의 소멸자를 가상함수로 선언해야한다. 부모 포인터로 객체를 삭제하면 부모 클래스의 소멸자가 호출되기 때문이다.

* 순수 가상 함수(Pure Virtual Function) : 자식 클래스에서 반드시 재정의를 해주어야하는 함수이다. 일반적으로 순수 가상 함수는 부모 클래스에서 함수 동작을 정의하지 않으며, 자식 클래스에서 반드시 정의해야 사용할 수 있다. `=0` 키워드를 붙여서 선언할 수 있다.

```cpp
class A{
public:
    // 순수 가상 함수
    virtual void show()=0 {
        cout << "A class" << endl;
    }
};

class B : public A{
public:
    virtual void show() {
        cout << "B class" << endl;
    }
};

int main(void){
    A* p;
    B b;
    p = &b;
    p->show();
}
```

#### 추상클래스

즉, 추상클래스란 하나 이상의 순수 가상 함수를 포함하는 클래스를 의미한다. 자식 클래스는 추상 클래스를 상속 받은 이후에 반드시 순수 가상 함수를 모두 오버라이딩 해야 비로소 해당 객체를 사용할 수 있다.

### 템플릿

Template을 이용하여 Generic Programming을 사용할 수 있다.

> generic programming은 데이터 형식에 의존하지 않고, 하나의 값이 여러 다른 데이터 타입들을 가질 수 있는 기술에 중점을 두어 재사용성을 높일 수 있는 프로그래밍 방식

Template은 매개변수의 타입에 따라서 함수 및 클래스를 손쉽게 사용할 수 있도록 해준다. Template을 사용하면 타입마다 별도의 함수나 클래스를 만들지 않고, 다양한 타입에서 동작할 수 있는 단 하나의 객체를 정의할 수 있다.

```cpp
// template 선언
template <typename T>
```

#### 함수 템플릿(Function Template)

Function Template은 각각의 자료형에 대해 처음으로 호출될 때, c++ 컴파일러는 해당 타입의 인스턴스를 생성하게 된다. (string type이 들어오면 string type의 함수 인스턴스를 생성)

* 명시적 특수화(Explicit Specialization)

함수 템플릿은 특정한 타입에 대해 명시적 특수화 기능을 제공한다. 이러한 명시적 특수화를 이용하면, 특정한 타입에 대해서 특수한 기능을 정의할 수 있다. 컴파일러는 호출된 함수에 대응하는 특수화된 정의를 발견한 이후에는 해당 정의만을 사용한다. (효과적으로 메모리를 이용)

```cpp
#include <iostream>
#include <string>

using namespace std;

// template 선언
template <typename T>
// 따로 타입을 선언하지 않는다.
// template을 사용해 자료형에 제한 받지 않고 함수를 구현할 수 있다.
void change(T& a, T& b){
    T temp;
    temp = a;
    a = b;
    b = temp;
}

// 명시적 특수화
template <> void change<int>(int& a, int& b){
    cout << "정수형 데이터를 교체" << endl;
    int temp;
    temp = a;
    a=b;
    b=temp;
}
int main(void){
    int a = 6;
    int b = 8;

    cout << a << ':' << b << endl;
    swap(a,b);
    cout << a << ':' << b << endl;
}
```

#### 클래스 템플릿

클래스를 일반화하기 위해서 Class Template을 사용할 수 있다. Class Template을 사용하면 자료형에 따라서 다르게 동작하는 클래스 집합을 만들 수 있다.

```cpp
template <typename T>
class Data{
private:
    T data;
public:
    Data(T data) : data(data) { }
    void setData(T data){ this->data = data; }
    T getData() { return data; }
};
int main(void){
    Data<int> data1(1);
    Data<string> data2("test");
    cout << data1.getData() << data2.getData() << endl;
}
```

* default template arguments

```cpp
template <typename T = int>
```

### Smart Pointer

힙 영역에 동적 할당(`new`)된 메모리를 해제하기 위해서는 `delete` 키워드를 사용하는데, 메모리를 해제해주지 않으면 힙 공간에 계속해서 존재하기 때문에 메모리 누수(Memory Leak)가 발생할 수 있다. 이를 방지하기위한 수단으로 포인터처럼 동작하는 class template인 스마트 포인터(Smart Pointer)를 사용할 수 있다. 스마트 포인터를 이용하면 메모리 누수를 더 효과적으로 방지할 수 있어 컴퓨터 시스템의 안정성을 높일 수 있다.

> Java, C#, python 등등에서는 garbage collector가 쓰이지 않는 객체들을 수거하는 역할을 한다.

기본적으로는 `new` 키워드로 특정한 메모리 주소를 가리키도록 초기화 한 후 스마트 포인터에 해당 포인터를 넣어서 사용할 수 있다. 스마트 포인터는 수명을 다했을 때 `delete` 키워드를 이용해 할당된 메모리들을 자동으로 해제하는 기능을 수행한다.

* unique\_ptr : 하나의 스마트 포인터가 특정한 객체를 처리할 수 있도록 한다. 특정한 객체의 소유권을 가지고 있을때만 소멸자가 객체를 삭제할 수 있다.

```cpp
    unique_ptr<int> p1(new int(10));
    unique_ptr<int> p2;

    cout << "p1 "<< p1 <<  " p2 " << p2 << '\n';
    cout << "p1 "<< *p1 << '\n'; //p1 10
    p2 = move(p1); // 소유권 이전
    cout << "p1 "<< p1 <<  " p2 " << p2 << '\n';
    p2.reset(); // 메모리 할당 해제
    cout << "p1 "<< p1 <<  " p2 " << p2 << '\n';
    // p1 0x7f7f7fc02750 p2 0x0
		// p1 0x0 p2 0x7f7f7fc02750
		// p1 0x0 p2 0x0
```

* shared\_ptr : 특정한 객체를 참조하는 스마트 포인터가 총 몇개인지를 참조, 특정한 객체를 새로운 스마트 포인터가 참조할 때마다 참조 횟수(Reference Count)가 1씩 증가, 각 스마트 포인터의 수명이 다할 때마다 1씩 감소한다. 결과적으로 참조 횟수가 0이 되면 delete키워드를 이용해 메모리에서 데이터를 자동으로 할당 해제한다.

```cpp
int* arr = new int[10];
    arr[8] = 100;
    shared_ptr<int> p1(arr);
    cout << p1.use_count() << '\n'; // 1
    shared_ptr<int> p2(p1);
    cout << p1.use_count() << '\n'; // 2
    shared_ptr<int> p3=p2;
    cout << p1.use_count() << '\n'; // 3

    p1.reset();
    p2.reset();
    cout << p1.use_count() << '\n'; // 0
    p3.reset();
```

* weak\_ptr : 하나 이상의 shared\_ptr 인스턴스가 소유하는 객체에 대한 접근할 수 있다. 하지만 해당 객체의 소유자의 수에는 포함되지 않는다.

```cpp
    int* arr = new int(1);
    shared_ptr<int> sp1(arr);
    weak_ptr<int> wp = sp1; // wp는 참조 횟수 계산에서 제외됨.

    cout << sp1.use_count() << '\n'; // 1
    cout << wp.use_count() << '\n';  // 1

    if(true){
        shared_ptr<int> spw = wp.lock(); // shared_ptr point 반환
        cout << sp1.use_count() << '\n'; // 2
        cout << wp.use_count() << '\n';	 // 2
    }
    // scope를 벗어나므로 sp2 해제
    cout << sp1.use_count() << '\n';    // 1
    cout << wp.use_count() << '\n';     // 1
```
