객체 지향 프로그래밍(Object-Oriented Programming, OOP) : 프로그래밍 패러다임의 하나로 프로그램을 객체들의 모임으로 보고 개발하는 것이다. 유연하고 변경이 용이하여 대규모 소프트웨어 개발에 많이 사용된다.

장점

* 유연하고 변경이 용이하다. (프로그램의 구조를 파악하기 쉬워 개발과 보수가 간편)

단점

* 지나치게 객체화 하는 것은 실제의 개념과 너무 달라서 이해하기가 쉽지 않아질 수 있다.

특성

* 크게 다음 네가지의 동작 과정이 있다.
  - 클래스(class) : 추상 자료형(빵틀)
  - 객체(object) : 추상 자료형의 인스턴스(빵틀을 통해 만들어진 빵)
  - 메소드(method) : 추상 자료형에 정의된 연산(빵을 자르는 명령)
  - 메시지(message) : 메소드의 호출(빵을 자르는 명령을 실행)
* 클래스는 정보은닉(Data Hiding)을 위해 캡슐화(Encapsulation)를 지향해야 한다.
  : 내부 구현내용은 보이지 않도록 하고 약속된 부분만을 보이도록 지정한다.
  => 새로운 클래스에서 약속되지 않은부분을 추측해서 개발 했을 경우 문제가 발생할 수 있다.
* 기존 클래스의 기능을 상속(Inheritance)받는다.
  : 하위 클래서에서는 기존 기능을 응용해 추가적인 요구사항을 개발할 수 있다.
  => 클래스간의 종속관계를 형성시켜 객체를 조직화할 수 있고 소스코드의 재사용성을 더해준다.
* 2개 이상의 클래스로부터 상속받을 수 있다.(다중상속)
  => 클래스의 상속관계에 혼란을 줄 수 있으므로 주의해야한다.
* 다형성(polymorphism)을 위해 다음과 같은 개념을 사용한다.
  : 객체의 메소드를 여러가지 개념으로 사용 되도록 할 수 있다.
  => 클래스의 상속관계에서 가상함수(Virtual Functions)를 사용
  => 메소드를 오버라이딩(Overriding - 같은 이름의 메소드가 여러 클래스에서 다른기능을 하는것)
     ※ 오버라이딩을 위해 순수가상함수(Pure Virtual Functions)를 정의한다.
     ※ 순수가상함수가 1개 이상 선언된 클래스를 추상클래스(Abstract Class)라 부른다.
  => 메소드를 오버로딩(Overloading - 같은 이름의 메소드가 인자의 갯수나 자료형에 따라서 다른 기능을 하는것)

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

using namespace std;

// Ex1> 클래스(Class)의 선언
class Dot
{
public:
	Dot();
	// Ex2> 생성자 Dot을 오버로딩(Overloading) 한다.
	Dot(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
	int x;
	int y;
	// Ex3> 가상함수(Virtual Functions)를 선언한다.
	virtual int Cal()
	{
		return this->x - y;
	}
	// Ex4> 일반 멤버함수를 선언한다.
	void NotVirtual()
	{
		cout << "DOT CALL\n";
	}
	// Ex5> 순수가상함수(Pure Virtual Functions)를 선언한다.
	virtual void PureVirtual() const = 0;
};

// Ex6> Dot 클래스를 상속(Inheritance) 받는다.
class DotA:public Dot
{
public:
	DotA();
	DotA(int x, int y);
	// virtual는 생략가능하다.
	virtual int Cal()
	{
		return this->x + this->y;
	}
	void NotVirtual()
	{
		cout << "DOTA CALL\n";
	}
	virtual void PureVirtual() const
	{
		cout << "DOTA CALL\n";
	}
};
DotA::DotA(int x, int y):Dot(x, y)
{
	cout << "SET DotA\n";
}

class DotB :public Dot
{
public:
	DotB();
	DotB(int x, int y);
	// virtual는 생략가능하다.
	virtual int Cal()
	{
		return this->x * this->y;
	}
	void NotVirtual()
	{
		cout << "DOTB CALL\n";
	}
	virtual void PureVirtual() const
	{
		cout << "DOTB CALL\n";
	}
};
DotB::DotB(int x, int y) :Dot(x, y)
{
	cout << "SET DotB\n";
}

int _tmain(int argc, _TCHAR* argv[])
{
	// 가상함수의 사용
	Dot* dot[2] = {};
	// Ex7> 객체 생성
	dot[0] = new DotA(100, 20);
	dot[1] = new DotB(100, 20);

	cout << "\n######## Virtual Functions ########\n";
	// 가상함수의 사용
	cout << "DotA Result : " << dot[0]->Cal() << "\n";
	cout << "DotB Result : " << dot[1]->Cal() << "\n";

	cout << "\n######## Member Functions ########\n";
	// 일반멤버함수의 사용
	dot[0]->NotVirtual();
	dot[1]->NotVirtual();

	cout << "\n######## Pure Virtual Functions ########\n";
	// 순수가상함수의 사용
	dot[0]->PureVirtual();
	dot[1]->PureVirtual();

	// Ex8> 추상클래스(Abstract Class) 생성
	// 순수가상함수"virtual void PureVirtual() const = 0;"를 선언하므로써 Dot은 추상클래스(Abstract Class)가 되었다.
	// 즉, 추상클래스는 말그대로 추상화된 클래스(구체화 되지않은 클래스)이기 때문에 상속받아 구현을 해야만 사용할 수 있다.
	// Error - 추상클래스를 상속받은 클래스를 생성하지 않고 그냥 생성하였다.
	// Dot dotTest = new Dot(100, 20);

	return 0;
}

Ex1> 클래스(Class) 선언
Ex2> 오버로딩(Overloading)
Ex3> 가상함수(Virtual Functions) 선언
Ex4> 멤버함수 선언
Ex5> 순수가상함수(Pure Virtual Functions) 선언
Ex6> 클래스 상속(Inheritance)
Ex7> 객체(object) 생성
Ex8> 추상클래스(Abstract Class) 생성