[C++] 객체 지향

객체지향의 근간이 되는 언어. 기본 단위를 객체로 한다.

추상화, 캡슐화, 다형성, 상속

상속과 다형성을 사용해 재사용성을 높임으로써 코드를 줄일 수 있음.

객체: Object. 사물을 나타내는 추상적인 개념.

절차형 프로그래밍: 기능 단위 ⇒ 함수

객체지향 프로그래밍: 기능 단위 ⇒ 객체(클래스. 변수+함수)

 

📌클래스(Class)

연관이 있는 데이터와 그 데이터를 다루는 함수를 하나로 묶어 놓은 추상적 데이터형(사용자 정의 타입). 멤버 변수와 멤버 함수를 가진다.

생성자, 소멸자(C#, Java, JavaScript에서는 사용하지 않음), 멤버 변수, 메서드.

 

객체 생성

스택 메모리에서 객체를 생성하는 방법: 변수 선언

 

void exampleFunction() {
    TV myTV;  // 스택 메모리에 생성
    myTV.power(true);
    // myTV는 함수 블록이 끝나면 자동으로 파괴됨
}

 

 

힙 메모리에서 객체를 생성하는 방법: 해당 자료형의 포인터에 new 연산자로 객체 생성 후 참조

 

void exampleFunction() {
    TV* myTV = new TV();  // 힙 메모리에 생성
    myTV->power(true);
    delete myTV;  // 메모리 해제
}

 

 

new 연산자는 객체를 힙 메모리에 동적으로 생성하고 해당 객체의 주소를 반환한다. 포인터 변수로 참조할 수 있다.

delete 로 객체 메모리를 해제해야 한다.

 

 

접근 제어자(접근 지정자)

클래스 생성 시 접근 제한자를 지정할 수 있다. private protected public

private 자기 자신을 제외한 모든 외부에서 접근할 수 없음.

public 공개(제한 없음)

protected 상속 관계에서 사용할 수 있음. 외부에서 접근할 수 없음.

접근 제어자를 생략하면 기본으로 private 이 된다.

변수를 외부에서 접근할 수 없도록 제한하면, 외부에서 데이터로 접근할 수 있는 인터페이스를 만들어야한다.

 

#include <iostream>

class MyClass{

private:
		int a;
public:
		int b;
		
	void setA(int a) {
		this->a = a;
	}

	int getA() {
		return this->a;
	}
}

void main(){
	
		MyClass m;
		
		m.a = 10; // 빌드 에러: 멤버 MyClass::a에 액세스할 수 없습니다.
		m.b = 10;
		
		m.setA(10);

		std::cout << m.getA() << std::endl; // 10
	
}

 

 

함수 선언부과 정의부를 분리할 수 있다.

 

 

class MyClass {

    private:
            int a;
            int b;

    public:
            void setA(int a);
    };

    void MyClass::setA(int a) {
            this->a = a;
    }

    void main() {

            MyClass m;
            m.setA(10);

}

 

 

 

 

생성자(Constructor)

객체 생성 시 멤버 변수에 초기값을 넣어주는 함수. 멤버 변수의 초기화를 담당하는 기능일뿐 값을 반환할 필요가 없기 때문에 리턴 타입은 지정하지 않으며(void도 쓰지 않는다.) 함수 이름은 클래스 이름과 동일하다. 객체 생성시 기본 생성자가 자동으로 호출된다.

매개변수가 없는 기본 생성자의 경우 객체 선언 시에 자동으로 호출된다.

생성자에 매개변수를 지정할 수 있다. 즉, 생성자를 오버로딩 할수 있다.

 

#include <iostream>

class MyClass{

private:
		int a;
		int b;
public:
		MyClass(){
			this->a = 1;
			this->b = 2;
		}
		
		MyClass(int a, int b){
			this->a = a;
			this->b = b;
		}
		
		void getA(){
				return this->a;
		}
		
		void getB(){
				return this->b;
		}

}

void main(){
		MyClass m1;
		
		std::cout << "m1.a = " << m1.getA() << std::endl;
		
		MyClass m2 = MyClass(10, 20);
		
		std::cout << "m2.a = " << m2.getA() << std::endl;
		
}

1
10

 

 

 

기본 생성자(Default Constructor)

매개변수도 중괄호 내부도 없는 생성자. 생성자를 단 하나도 선언하지 않으면 매개변수와 내부가 비어있는 생성자가 자동으로 생성된다.

 

 

소멸자(Destructor)

객체 지향 언어에는 소멸자가 반드시 존재한다. 단, 가비지 컬렉터가 존재하는 언어의 경우 소멸자의 행위를 가비지 컬렉터가 실행한다.

함수 이름은 클래스 이름 앞에 ~ 를 붙여 선언한다. 객체가 파괴될 때 자동으로 호출된다. 생성자와 달리 오버로딩할 수 없다. (단 한 개만 선언할 수 있다. )

• 스택 메모리는 First In Last Out 구조로 나중에 생성된 객체가 먼저 소멸된다.

 

#include <iostream>

class MyClass{

private:
    int a;
    int b;
public:
    MyClass(){
        this->a = 1;
        this->b = 2;
    }

    ~MyClass(){
        std::cout << "bye!" << std::endl;
    }

    void getA(){
            return this->a;
    }

}

void main(){
    MyClass m1;

    std::cout << "m1.a = " << m1.getA() << std::endl;
		
}

 

1
bye!

 

 

class와 struct

C언어에는 접근제한자가 존재하지 않는다. C++에서는 struct에도 접근제한자를 적용할 수 있지만, 객체를 만들기 위한 개념인 클래스를 사용하는 것이 권장된다.

struct 와 class 는 비슷하지만 기본 접근 제어에서 차이가 있음.

struct 는 기본적으로 public 접근 제어를 제공한다. 데이터 중심으로 설계할 때 유용하다.

class 는 기본적으로 private 접근 제어를 제공한다. 데이터 보호 및 객체 지향 설계(캡슐화)에 적합하다.

둘 다 다중 상속을 지원하지만 class 를 사용하는 것이 일반적이다.

 

struct MyStruct {
    int x;  // 기본적으로 public
};

 

class MyClass {
    int x;  // 기본적으로 private
};

 

 

객체(Object)

실세계에 존재하거나 추상적인 개념.

 

객체? 인스턴스?

객체를 속성과 기능으로 나누어 선언한 클래스로부터 프로그램 내에서 사용 가능하도록 메모리에 생성한 것을 인스턴스라고 한다.

자바의 경우 객체 변수는 모두 객체의 주소를 가진 객체 포인터지만, C++의 경우 int 등의 기본 자료형처럼 객체를 직접 가지고 있는 변수이므로, 변수는 객체 그 자체로 볼 수 있다. 예를 들어 객체 mp1 이 있고 객체 mp2 가 있을 때, mp2 에 mp1 를 대입하면 주소를 복사하는 것이 아니라 객체 자체가 복사되므로(깊은 복사), 두 객체는 각각 다른 객체다.

 

MousePoint mp1 = MousePoint(10, 20); // 혹은 MousePoint mp1(10, 20);
MousePoint mp2 = MousePoint(100, 200);

mp1 = mp2
mp1.setX(999);

cout <<"mp1.x :" << mp1.getX() << endl;
cout <<"mp2.x :" << mp2.getX() << endl;

 

mp1.x : 999
mp2.x :10

 

 

 

 

만약 mp1 과 mp2 가 같은 객체를 참조(얕은 복사)하고 있었다면 mp1.setX(999); 이후로는 mp1 의 x 와 mp2 의 x 모두 999가 되어야 한다.

그러나 두 객체는 다른 객체이기 때문에, 출력해보면 각각의 값이 나오는 것을 알 수 있다.

 

 

 

객체 배열

사용자 정의 자료형(클래스)으로 생성된 것을 객체(인스턴스)라고 할 때, 다수의 객체를 다루기 위한 배열. 다수의 객체를 한 번에 다루고 싶을 때 그 객체들을 배열에 담은 것이 객체 배열이다.

객체 배열의 객체도 생성자를 호출할 수 있다.

 

#include <iostream>

using namespace std;

class MousePoint {

private : 
	int x, y;

public :
	MousePoint(int x, int y) {
		this->x = x;
		this->y = y;
	}

	void setXY(int x, int y) {
		this->x = x;
		this->y = y;
	}

	int getX() {
		return this->x;
	}

	int getY() {
		return this->y;
	}
};

void main() {

	MousePoint mpArr[3] = { MousePoint(10, 20), MousePoint(30, 40), MousePoint(50, 60) };

	for (int i = 0; i < sizeof(mpArr) / sizeof(mpArr[0]); i++) {
		cout << "[" << i + 1 << "] x: " << mpArr[i].getX() << ", y: " << mpArr[i].getY() << endl;
	}

}

 

[1] x: 10, y: 20
[2] x: 30, y: 40
[3] x: 50, y: 60

 

 

 

 

객체 포인터

객체의 주소값을 저장하기 위한 변수. 객체를 간접 참조하기 위해 사용한다.

자바의 모든 객체 변수는 객체 포인터다.

	MousePoint ms(10, 20);
	MousePoint* msPtr;

	msPtr = &ms;

	cout << msPtr->getX() << endl;

 

 

new 연산자를 사용해 동적 메모리 할당을 할 경우 객체가 힙 메모리에 올라가게 되는데, 이를 참조하기 위한 변수는 스택에 있기 때문에 객체 포인터를 사용한다.

 

MousePoint* msPtr = new MousePoint();

 

 

위에서 자바의 객체 변수는 모두 객체 포인터라고 했다. 자바는 포인터 개념이 없기 때문에 * 포인터를 생략한다.

 

 

 

this 포인터

멤버 함수를 호출한 객체 자기 자신을 가리키는 포인터. 하나의 클래스로 생성된 객체가 여러 개 존재할 때, 멤버 함수를 호출한 객체가 어떤 객체인지 주소를 전달해준다.

즉, 멤버 함수의 인수로 객체(인스턴스)의 주소가 전달된다. 멤버 함수를 정의할 때, 컴파일러는 객체 포인터를 하나 추가한다.

 

void SetID(int id){
   this->id = id;
}

 

 

위 멤버 함수의 정의는 컴파일러에 의해 다음과 같이 변환된다.

void SetId(MyClass* const this, int id){
		this->id = id;		
}

 

 

모든 멤버함수는 컴파일러에 의해 함수가 호출된 객체(인스턴스)를 가리키는 this 포인터를 가진다.

this 포인터로 자기 자신의 포인터를 반환하도록 함수를 작성하면 메서드 체이닝을 사용할 수 있다.

 

MyClass& SetId(int id){
		this->id = id;
		return this*;
}

MyClass& SetName(std::string name){
		this->name = name;
		return this*;
}

 

void main(){
		MyClass c = MyClass();
		c.SetId(1).SetName("새로운이름");
}

 

 

전달 인자가 객체인 함수(Call by value)

인자로 사용자 정의 타입의 변수를 받아올 경우 객체 포인터가 아닌 객체 자체를 복사해서 받아온다.

call by value로 객체를 복사해서 새로 가져오는 것. 자바와 달리 주소를 가져오지 않는다. 자바는 call by reference.

 

void SetRect(MousePoint mp1, MousePoint mp2) {
	cout << "[함수 내 mp1]" << mp1.getX() << " ," << mp1.getY() << endl;
	cout << "[함수 내 mp2]" << mp2.getX() << " ," << mp2.getY() << endl;

	mp1.setXY(1000, 2000);
	cout << "[변경 후 mp1]" << mp1.getX() << " ," << mp1.getY() << endl;
}

 

[함수 내 mp1]10 ,20
[함수 내 mp2]100 ,200
[변경 후 mp1]1000 ,2000
[함수 호출 후]10 ,20

 

 

객체를 복사해서 넘겨주었기 때문에,함수 내부의 mp1 과 메인 함수의 mp1 은 다른 메모리를 가진다. 즉, 다른 주소이기 때문에 함수 내부에서 mp1 을 변경했더라도 메인 함수의 mp1 은 영향을 받지 않는다.

 

 

 

전달 인자가 객체 주소인 함수(Call by reference)

`사용자정의타입&` 로 객체의 주소값을 전달할 수 있다. 별칭을 설정하는 것과 같다고 생각하자.

 

void CopyObject(MousePoint& mp1, MousePoint& mp2) {

	cout << "void CopyObject() -----------------" << endl;
	
	cout << "[mp1]" << mp1.getX() << ", " << mp1.getY() << endl;
	cout << "[mp2]" << mp2.getX() << ", " << mp2.getY() << endl;

	mp1 = mp2;

	mp1.setXY(12, 24);
	cout << "mp1.setXY(12, 24); ----------------------------" << endl;

	cout << "[mp1]" << mp1.getX() << ", " << mp1.getY() << endl;
	cout << "[mp2]" << mp2.getX() << ", " << mp2.getY() << endl;

	cout << "mp1 = mp2; ----------------------------" << endl;
	mp1 = mp2;

	cout << "[mp1]" << mp1.getX() << ", " << mp1.getY() << endl;
	cout << "[mp2]" << mp2.getX() << ", " << mp2.getY() << endl;

	mp2.setXY(1200, 2400);
	cout << "mp2.setXY(1200, 2400); ----------------------------" << endl;

	cout << "[mp1]" << mp1.getX() << ", " << mp1.getY() << endl;
	cout << "[mp2]" << mp2.getX() << ", " << mp2.getY() << endl;

	cout << "----------------------------" << endl;

}

 

	MousePoint mp1(10, 20);
	MousePoint mp2(100, 200);

	//SetRect(mp1, mp2);
	CopyObject(mp1, mp2);

	cout << "[함수 호출 후]" << mp1.getX() << ", " << mp1.getY() << endl;
	cout << "[함수 호출 후]" << mp2.getX() << ", " << mp2.getY() << endl;

 

void CopyObject() -----------------
[mp1]10, 20
[mp2]100, 200
mp1.setXY(12, 24); ----------------------------
[mp1]12, 24
[mp2]100, 200
mp1 = mp2; ----------------------------
[mp1]100, 200
[mp2]100, 200
mp2.setXY(1200, 2400); ----------------------------
[mp1]100, 200
[mp2]1200, 2400
----------------------------
[함수 호출 후]100, 200
[함수 호출 후]1200, 2400

 

 

 

 

그러나 코드를 확인해보면 mp1 = mp2 라고 대입했을 때, 자바처럼 얕은 복사로 같은 객체를 참조하는 것이 아니라, 객체의 값만을 복사해주고 여전히 객체 자신의 주소값을 가진다. 즉, mp1 = mp2 라고 대입을 하더라도 포인터가 아니기 때문에 같은 주소를 가지지 않는다.

별칭을 설정하는 것과 같다고 생각하자!!! 참조로 넘겨주더라도 포인터처럼 주소값을 가진 변수가 아니다. 객체 변수다.

• 이후 new 연산자를 사용해서 객체를 생성하게 될 경우에는 변수는 스택, 객체는 힙 메모리에 생성되기 때문에 무조건 객체를 포인터로 참조해야한다. new 연산자는 힙메모리에 객체를 생성하고 그 객체 주소를 참조하는 포인터를 반환한다.
•  

const 함수

사전 ⇒ constant : 상수(常數, constant)란 수식에서 변하지 않는 값을 뜻한다. 이것은 변하는 값 변수와 반대이다. // 위키백과 함수에서 멤버 변수를 변경하지 못하도록 제한하는 읽기 전용 함수. 함수 시그니처에 const 를 붙여 선언한다. const void MyFunction(int a)

const 함수 내에서 값을 변경하는 다른 멤버 함수를 호출할 수 없다.

 

const 변수

초기화된 이후로 멤버 변수를 변경할 수 없도록 제어함. const MousePoint mp1(10, 20); 이후 mp1 의 멤버 변수를 변경하려하거나, mp1 = mp2; 처럼 또 다른 객체를 대입하려할 경우 오류가 발생한다.

const 변수에서는 const 함수만 호출할 수 있다. 그 함수가 읽기 전용이더라도, const 함수가 아닌 함수를 호출할 수 없다.

 

static 멤버 변수

전역 변수의 문제점: 클래스 내부 뿐 아니라 다른 클래스에서도 접근 가능하다. 객체 지향 철학에 위배된다.

ex) 고객명, 고객 예금 잔액은 별도로 관리되지만 이자율은 공통으로 가진다.

객체마다 고유로 가지는 멤버 속성이 아니라, 같은 값을 공유해야 할 때 전역 변수의 성질이 필요한데, 전역 변수로 선언할 경우 객체 지향의 철학에 위배되므로 멤버 변수와 전역 변수의 성질을 모두 가진 static 변수로 선언한다.

static 변수와 전역 변수는 데이터 영역에서 관리된다.

스택: 함수 호출 시 메모리 할당.

힙: 사용자(개발자)가 malloc 또는 new 연산자로 메모리를 할당하는 영역. 해제 시까지 사라지지 않는다.

 

초기화

#include <iostream>

using namespace std;

class Deposit {
public : 
	Deposit() {
	}

	void bankBalance() {
		balance = balance + (balance * interestRate);
	}

	double getBalance() {
		return this->balance;
	}

private : 
	char* name;
	double balance;
	static double interestRate;
};

double Deposit::interestRate = 0.0;

 

 

영역 결정 연산자 :: 를 사용하여 해당 변수를 초기화해준다.

static 멤버 변수는 클래스의 모든 인스턴스가 공유하는 변수로, 클래스의 모든 객체가 동일한 값을 참조하게 된다. 이를 초기화하려면 클래스 외부에서 별도로 초기화해야 한다.

 

 

변경

public:
	static void setInterestRate(double) {
		Deposit::interestRate = 0.05;
	}

 

객체마다 가지는 멤버 변수가 아니므로, 클래스를 통해 참조해서 변경한다.

 

 

 

const는 const끼리, static은 static끼리!

static 멤버 함수 내에서 일반 변수 또는 함수를 사용할 수 없다.

static은 클래스 선언 시 이미 데이터 영역에 올라오기 때문에 객체를 생성하지 않더라도 접근할 수 있지만, 객체 내 일반 멤버 변수는 객체가 생성된 뒤에 접근할 수 있다. static 멤버 함수를 사용하는 시점에서 객체가 생성되었는지 아닌지 알 수 없으므로 일반 멤버 변수 또는 함수를 참조하지 않는 것이 좋다.

static 멤버 함수가 아니더라도 static 멤버 변수에 접근할 수 있지만, 논리적으로 공용 변수이기 때문에 클래스를 통해 접근하는 것이 옳으므로 함수를 static으로 선언하는 것이 좋다.

 

	Deposit kim, lee, park;

	kim.setInterestRate(0.55); // 가능하지만 논리적으로 옳지 않음
	Deposit::setInterestRate(0.55);

 

 

static 멤버 변수는 객체마다 생성되는 것이 아니라 하나의 변수를 공용으로 사용하기 때문에 this 키워드를 사용할 수 없다.

 

friend

클래스 내에서 다른 클래스를 friend 로 선언하면, 선언된 해당 클래스가 본인의 클래스에 어떤 멤버든 접근이 가능하게 된다.(접근 제한자를 무시한다.)

friend는 일방적 관계이기 때문에 선언을 받은 쪽만 상대에게 접근할 수 있고, 쌍방으로 접근하려면 쌍방으로 선언되어야 한다.

다른 객체 지향 언어에서는 없는 개념이다.

 

#include <iostream>

using namespace std;

class FriendDeposit {

public:
	FriendDeposit(Deposit d) {
		interestRate = d.interestRate;
	}

	double interestRate;

};

class Deposit {
public : 

	friend class FriendDeposit;

	Deposit() {
		Deposit::nCount++;
		cout << "[nCount]"  << Deposit::nCount << endl;
			}

	~Deposit() {
		Deposit::nCount--;
		cout << "[nCount]" << Deposit::nCount << endl;
	}

	double getBalance() {
		return this->balance;
	}

	static void setInterestRate(double interestRate) {
		Deposit::interestRate = interestRate;
	}

	static double getInterestRate() {
		return Deposit::interestRate;
	}

private : 
	char* name;
	double balance;
	static double interestRate;
	static int nCount;
};

 

 

📌오버로딩(Overloading)

이름이 같지만 전달 인자의 개수나 타입이 다른 메서드를 정의하는 것. ex) 생성자 오버로딩

반환 타입은 관계가 없음. 시그니처가 모두 동일하지만 반환 타입이 다른 경우는 오버로딩이 아니다.

C언어에서는 불가능하다. (C언어는 함수를 이름으로 호출하기 때문이다. C++에서는 매개변수도 함께 사용하여 호출한다.)

 

📌추상화(Abstraction)

핵심적인 기능 또는 개념을 간추려놓은 것. 진돗개, 삽살개, 치와와가 있을 때, 개과라고 추상화할 수 있다. 개, 고양이, 여우가 있을 때, 네발동물 또는 포유류로 추상화할 수 있다.

사물의 특성을 정리하여 필드와 메소드로 정리하는 것이 중요함.

개: 눈, 코, 입, 귀, 다리 / 짖다(), 먹다(), 달리다()

 

📌상속(Inheritance)

멤버 변수와 함수를 모두 물려받는 것. 이미 정의되어 있는 변수와 기능을 또 작성할 필요 없이, 상속 받아 재정의하여 사용할 수 있음. 추상화(일반화)되어있는 부모를 물려받아 사용함으로써 코드의 중복을 줄일 수 있다. 부모 클래스로 올라갈수록 추상적이 되며, 자식 클래스로 내려갈수록 구체적이 된다.

자식 클래스 생성 또는 소멸 시 부모 클래스의 생성자, 소멸자를 호출한다. (생성자: 부모 클래스 생성자 → 자식 클래스 생성자) (소멸자: 자식 클래스 소멸자 → 부모 클래스 소멸자)

 

 

✨다형성(Polymorphism)

사전: 같은 종의 생물이면서도 어떤 형태나 성질이 다양하게 나타나는 현상. 하나의 객체를 다른 자료형의 변수로 참조하여 다양한 결과를 얻어낼 수 있는 성질. 클래스가 상속 관계에 있을 때 나타나는 다채로운 성질.

 

참조형 캐스팅(업캐스팅/다운캐스팅)

사용할 수 있는 멤버의 개수를 조절함. 스마트 티비가 있을 때, 일반 리모컨과 스마트 리모컨으로 조종하는 것과 비슷함.

업캐스팅(Upcasting)

자식 클래스가 부모 클래스 타입으로 형변환되는 것. 캐스팅 연산자 () 를 생략할 수 있음. 자식 클래스 멤버 변수에 접근을 제한함.

다운캐스팅(Downcasting)

부모 클래스가 자식 클래스 타입으로 형변환되는 것. 연산자를 생략할 수 없다. 부모 클래스로 업캐스팅된 변수를 자식 클래스로 복구하여 제한 받았던 필드와 기능을 회복하기 위해 사용한다.

 

✨오버라이딩(Overriding)

상속 받은 부모 클래스의 메서드를 재정의하는 것. 기존의 것을 덮어 쓴다.

#include <iostream>

using namespace std;

int Plus(int a, int b) {
	return a + b;
}

int Plus(int a, int b, int c) {
	return a + b + c;
}

double Plus(double a, double b) {
	return a + b;
}

int main() {

	int a = 1;
	int b = 2;
	int c = 3;

	double d = 1.1;
	double e = 2.2;

	cout << Plus(a, b) << endl;
	cout << Plus(a, b, c) << endl;
	cout << Plus(d, e) << endl;

	return 0;
}

3
6
3.3

 

 

 

📌캡슐화(Encapsulation)

데이터가 변질되는 것을 막기 위해 속성과 행위를 하나로 묶어 외부로부터 내부를 은닉함. 인터페이스(Getter, Setter)를 통해 올바르게 접근할 수 있도록 제어한다. 자바에서는 private protected 키워드를 통해 구현할 수 있음.

정보 은닉과 캡슐화가 같은 개념이 아니라, 정보 은닉 기법 중의 하나가 캡슐화임.

상속을 통한 타입 은닉도 할 수 있음. ⇒ 자식 객체의 타입을 부모 타입으로 형변환하여 구체적인 자식 객체의 타입을 은닉함.(다형성)

추상화된 결과를 하나의 클래스에 포함시켜 스스로를 보호하는 것을 캡슐화라고 함.

C++에서는 접근제한자를 지정하여 데이터의 직접 접근을 제한할 수 있다.

 

 

📌영역 결정 연산자(::)

다음과 같이 같은 이름으로 전역 변수와 지역 변수를 선언했을 때, 일반적인 방법으로 변수를 사용하면 전역변수를 사용할 수 없다.

#include <iostream>

using namespace std;

// 전역 변수
int nTemp = 20;

int main() {

	// 지역 변수
	int nTemp = 10;

	cout << "nTemp의 값은 " << nTemp << "입니다." << endl;

	return 0;
}

nTemp의 값은 10입니다.

 

 

 

전역 변수를 사용하기 위해서는 영역 지정 연산자 :: 를 사용해야한다.

 

cout << "nTemp의 값은 " << ::nTemp << "입니다." << endl;

nTemp의 값은 20입니다.

 

 

영역 지정 연산자 :: 앞에 명칭 공간이 지정되어 있지 않으면 전역 공간의 변수 또는 함수를 참조한다.

 

 

📌명칭 공간/이름 공간(namespace)

식별자 사이의 이름 충돌을 막기 위한 장치.

다음과 같이 매개변수의 개수가 동일한 경우 오버로딩이 아니기 때문에, 메인 함수 내에서 func() 를 호출할 때 어떤 함수를 호출할지 모호하므로 빌드 오류가 발생한다.

 

#include <iostream>

void func() {

	std::cout << "A학급 주성이" << std::endl;
}

void func() {

	std::cout << "B학급 주성이" << std::endl;
}

int main() {

	func();

	return 0;
}

// 빌드 에러! void func(void) 함수에 이미 본문이 있습니다.

 

 

하나의 파일에서 이런 상황이 발생한다면 함수 이름을 변경하면 되지만, 다른 개발자가 다른 파일에서 같은 이름으로 함수를 작성한다면 함수 이름을 변경하는 것은 현실적으로 불가능하다. 이를 방지하기 위해 명칭 공간(namespace)를 사용한다.

 

#include <iostream>

namespace a {
	void func() {
		std::cout << "A학급 주성이" << std::endl;
	}
}

namespace b {
	void func() {
		std::cout << "B학급 주성이" << std::endl;
	}
}

int main() {

	a::func();
	b::func();

	return 0;
}

 

A학급 주성이
B학급 주성이

 

 

 

 

 

이때, 다른 파일로 분리해서 작성한다면 main 함수에 a.cpp 와 b.cpp 를 포함시켜야 한다.

// a.cpp
#include <iostream>

namespace a {

	void func() {
		std::cout << "A학급 주성이" << std::endl;
	}
	
}

// b.cpp
#include <iostream>

namespace b {

	void func() {
		std::cout << "B학급 주성이" << std::endl;
	}

}

 

 

 

두 파일을 메인 함수에 포함시키기 위해 헤더파일을 작성한다.

#pragma once

#ifndef A_H
#define A_H

namespace a {
	void func();
}

#endif // !A_H

 

#pragma once

#ifndef B_H
#define B_H

namespace b {
	void func();
}

#endif // !B_H

 

// main.cpp

#include "a.h"
#include "b.h"

int main() {

	a::func();
	b::func();

	return 0;
}

 

 

 

Java에서 인터페이스와 실제 구현 파일을 구분하는 것과 비슷하다.

ex) ProductRepository ProductRepositoryImpl

 

 

 

📌매개변수의 기본값

함수 작성 시 매개변수에 기본값을 입력해두면 호출 시 인자를 생략할 수 있다.

 

#include <iostream>

using namespace std;

void func(int a = 10, int  b = 20) {
	cout << "a = " << a << ", b = " << b << endl;
}

int main() {

	func();
	func(500);
	func(1, 2);
	

	return 0;
}

 

 

 

📌인라인 함수(Inline Function)

함수에 작성한 코드 라인 자체가 호출부에 포함된다.

일반적으로 함수를 호출하면 그 호출부를 기억했다가 함수로 가서 코드를 모두 실행한 뒤 다시 호출부로 돌아오게 된다. 만약 함수를 100번 호출한다면, 호출부에서 함수로 100번 오가야 한다.

이때 컴파일러에게 함수 호출 오버헤드를 줄이기 위해 인라인 함수를 사용할 수 있다.

인라인 함수의 경우 호출이 일어나는 위치가 함수 코드 자체로 대체되기 때문에, 함수 실행 속도를 향상시킬 수 있다.

단, 코드 크기가 증가할 수 있다는 단점이 있으므로 코드 크기가 작고 기능이 단순하고(코드가 짧고) 자주 호출되는 함수인 경우만 사용한다.

 

#include <iostream>

using namespace std;

void inline func() {
	cout << "This is Inline Func" << endl;
}

int main() {

	func();
	
	return 0;
}

 

 

📌동적 메모리 할당

C언어에서는 malloc realloc calloc free 를 사용해서 동적 메모리를 할당했다. C++에서는 new delete 두 키워드를 사용한다.

new 연산자는 힙 메모리에 값이 할당되고 메모리 주소를 반환한다.

 

int* ptr = new int(9999);
cout << *ptr << endl; // 9999

 

📌STL(Standard Template Library)

표준 템플릿 라이브러리. 자료구조(컨테이너, 이터레이터, 알고리즘)를 모아놓은 라이브러리.

컨테이너(자료구조), 반복자(iterator), 알고리즘, 수치

컨테이너(Container)

Java의 컬렉션과 유사한 개념으로 데이터의 집합을 저장하고 관리하는데 사용한다.

• 시퀀스 컨테이너 (Sequence Containers)
  • vector 동적 배열로, 크기가 자동으로 조정됩니다. 인덱스를 통해 접근할 수 있으며, 효율적인 끝에 요소 추가/제거를 지원합니다.
  • deque 양쪽 끝에서 빠르게 삽입/삭제가 가능한 덱(더블 엔디드 큐)입니다.
  • list 양방향 연결 리스트로, 임의의 위치에서의 삽입과 삭제가 효율적입니다.
  • array 고정 크기의 배열입니다. std::array는 크기가 컴파일 타임에 결정됩니다.
• 연관 컨테이너 (Associative Containers)
  • set 고유한 요소들을 정렬된 상태로 저장합니다.
  • map 키-값 쌍을 저장하며, 키를 통해 값을 빠르게 조회할 수 있습니다.
  • multiset 중복을 허용하는 정렬된 집합입니다.
  • multimap 중복된 키를 허용하는 키-값 쌍의 집합입니다.
• 비순차 컨테이너 (Unordered Containers)
  • unordered_set 해시 기반의 집합으로, 요소들은 정렬되지 않으며, 빠른 조회를 제공합니다.
  • unordered_map 해시 기반의 키-값 쌍 저장소로, 빠른 조회를 지원합니다.
  • unordered_multiset 해시 기반의 중복을 허용하는 집합입니다.
  • unordered_multimap 해시 기반의 중복된 키를 허용하는 키-값 쌍의 집합입니다.
• 기타
  • stack: LIFO(Last In First Out) 방식의 컨테이너 어댑터입니다.
  • queue: FIFO(First In First Out) 방식의 컨테이너 어댑터입니다.
  • priority_queue: 우선순위가 있는 큐로, 가장 높은 우선순위를 가진 요소를 우선적으로 꺼냅니다.

C++에서는 데이터 출력 포맷(서식 문자. ex) %d)을 지정할 필요가 없다. 입출력 연산자 << >> 가 오버로딩 되어있기 때문이다.