C++ About const and static.

C++ About const and static.

1.C++ Initialization List of Constructor

Apple::Apple()
{
	price = 508;

	coord_x = coord_y = 0;

	amount = 10;

	origin = U.S.A;
}

생성자 이름 뒤에 : price(500), coord_x(0), coord_y(0), amount(10), origin(U.S.A) {}로 오는 것을 초기화 리스트 (initializer list) 라고 부르며, 

생성자 호출과 동시에 멤버 변수들을 초기화해주게 된다. 

Apple::Apple(int x, int y) : coord_x(x), coord_y(y), price(500),
	amount(10), origin(U.S.A) {}

coord_x 는 x 로 초기화 되고, origin 는 U.S.A 로 초기화 되게 된다. 멤버 초기화 리스트의 일반적인 꼴은 아래 형식. (생성자 이름) : var1 ( arg1 ), var2 ( arg2) { } 여기서 var 들은 클래스의 멤버 변수들을 지칭하고, arg 는 그 멤버 변수들을 무엇으로 초기화 할 지 지칭하는 역할을 한다. var1 과 arg1 의 이름이 같아도 된다.

Apple::Apple(int coord_x, int coord_y) : coord_x(coord_x), coord_y(coord_y), price(500),
	amount(10), origin(U.S.A) {}

위 소스 코드처럼 정상적으로 작동한다. 왜냐하면 coord_x ( coord_x ) 에서 바깥쪽의 coord_x 는 무조건 멤버 변수를 지칭하게 되는데, 이 경우 coord_x 를 지칭하는 것이고, 괄호 안의 coord_x 는 원칙상 Apple이 인자로 받은 coord_x 를 우선적으로 지칭하는 것이기 때문이다. 따라서 실제로 인자로 받은 coord_x 가 클래스의 멤버 변수 coord_x 를 초기화 하게 된다.

Apple::Apple(int coord_x, int coord_y)
{
	coord_x = coord_x;
	coord_y = coord_y;
	price = 500;
	amount = 10;
	origin = U.S.A;
}

위 소스 코드처럼 컴파일러가 두 coord_x 모두 인자로 받은 coord_x 로 구분해서 오류가 난다. 굳이 초기화 리스트를 사용해야 되는 이유를 알아본다.

Apple::Apple() =================================Q
{
	price = 500;
	coord_x = coord_y = 0;
	amount = 10;
	origin = U.S.A;
}
===================================W
Apple::Apple() : price(500), coord_x(0), coord_y(0),
	amount(10), origin(U.S.A) {}

일단 Q코드나 W코드는 하는 일이 똑같아 보인다. 하지만 약간의 차이가 있다. 왜냐하면, 초기화 리스트를 사용한 버전의 경우 '생성과 초기화를 동시에' 하게 된다. 반면에 초기화 리스트를 사용하지 않는다면 '생성을 먼저 하고 그 다음에 대입' 을 수행하게 된다. 쉽게 말하면 초기화 리스트를 사용하는 것은 int a = 10;이라 하는 것과 같고, 예전 버전의 생성자를 사용하는 것은 int a; a = 10;이라 하는 것과 동일하다. 만약에 int 가 대신에 클래스라면, 전자의 경우 '복사 생성자' 가 호출되는데, 후자의 경우 '디폴트 생성자' 가 호출된 뒤 대입이 수행된다. 흠.... 후자가 조금 더 하는 작업이 많게 보인다. 따라서 초기화 리스트를 사용하는 것이 조금 더 효율적인 행동이라는 사실을 알 수 있다. 그 뿐만 아니라, 반드시 '생성과 동시에 초기화 되어야 하는 것들' 이 몇 가지 있다. 대표적으로 레퍼런스와 상수가 있다. 일단 상수와 레퍼런스들은 모두 생성과 동시에 초기화가 되어야 한다.

const int a;
a = 3;

int& ref; 
ref = c; 

위 소스 코드는 컴파일 오류가 뜬다. 따라서 클래스 내부에 레퍼런스 변수나 상수를 넣고 싶다면, 

이들을 생성자에서 무조건 초기화 리스트를 사용해서 초기화 시켜주어야만 한다. Ex)

Apple::Apple() : price(500), coord_x(0), coord_y(0), =====================Q
	amount(10), origin(U.S.A) {}
====================================================
Apple apple1 (2, 3);===================================================W
	Apple apple2 (3, 5);

	apple1.show_status();
	apple2.show_status();
======================================================
	cout << endl << "apple 1 를 apple2 로 교체! " << endl; ==========================E
	apple2.be_changed(apple1.change());

생성자에서 초기화 리스트를 도입해서 Q와 같이, amount를 생성과 동시에 초기화 할 수 있도록 한다. 따라서 상수인 amount 를 10 로 초기화 할 수 있고, 이 값은 영원히 바뀌지 않게 된다. W와 같이 Marine 의 객체들 (apple1, apple2) 를 생성하면서 생성자 오버로딩에 따라 Apple(int x, int y) 가 호출되는데, 이를 통해 각각 (2,3) 과 (3,5) 에 위치해 있는 사과를 만들 수 있게 된다. 그리고, show_status 를 호출해 보면 제대로 정의 되어 있다는 사실을 알 수 있다. 마찬가지로 E 소스코드를 보면 Apple들이 서로 교체되는 과정도 잘 실행되고 있음을 알 수 있다. 위 소스코드들에서 봤듯이 중요한 값들을 상수로 처리하는 것은 매우 편리하다. 다른 사용자가 이 소스코드를 사용하면서 실수로 apple 의 amount 를 변경하는 명령을 집어 넣더라고 컴파일 오류가 발생하기 때문에 프로그램을 실행해서 지루한 디버깅 과정을 거쳐서 알아 내는 것 보다 훨씬 효율적으로 오류를 발견할 수 있다.

2.C++ static variable

이번에는 여태까지 만들어지는 총 Apple 의 수를 알아내기 위해 코드를 만들어본다.

많은 방법이 있지만 가장 단순한 두 방식을 생각해본다면

1. 어떠한 배열에 Apple 을 보관해 놓고, 생성된 Apple의 개수를 모두 센다.

2. 어떤 변수를 만들어서 Apple 의 생성시에 1 을 추가하고, 소멸시에 1 을 뺀다.

첫 번째 방법의 경우, 따로 크기가 자유자재로 변할 수 있는 배열을 따로 만들어야 하는 문제점이 있고, 두번째의 같은 경우 만일 어떠한 함수 내에서 이런 변수를 정의하였다면 다른 함수에서도 그 값을 이용하기 위해 인자로 계속 전달해야 하는 번거로움이 있다. 물론 전역 변수로 만들면 되지 않겠냐고 물을 수 도 있지만, 전역 변수의 경우 프로젝트의 크기가 커질 수록 사용자의 실수로 인해 서로 겹쳐서 오류가 날 가능성이 높기에 반드시

필요한 경우가 아니면 사용을 하지 않는다. cf) 실제로 꼭 필요한 경우가 아니면 전역변수는 사용 X.

하지만 C++ 에서는 간단하게 해결 할 수 있는 기능을 제공하고 있다. 마치 전역 변수 같지만 클래스 하나에만 종속되는 변수, 바로 static 멤버 변수다. 예전에 C에서 어떠한 함수의 static 변수가 지역 변수들 처럼 함수가 종료될 때 소멸되는 것이 아니라 프로그램이 종료될 때 소멸되는 것 처럼,

어떤 클래스의 static 멤버 변수의 경우, 멤버 변수들 처럼, 객체가 소멸될 때 소멸되는 것이 아닌, 프로그램이 종료될 때 소멸되는 것이다. 

또한, static 멤버 변수의 경우, 클래스의 모든 객체들이 '공유' 하는 변수로써 각 객체 별로 따로 존재하는 멤버 변수들과는 달리 모든 객체들이 '하나의' static 멤버 변수를 사용하게 된다.

static int total_apple_num; =====================Q
=========================
int Apple::total_apple_num = 0; ===================W
=========================
class Apple ================================E
{
	static int total_apple_num = 0;
==========================
class Apple ================================R
{
	const static int x = 0;

먼저 Q 코드와 같이 클래스 static 변수를 정의한다. 모든 전역 및 static 변수들은 정의와 동시에 값이 자동으로 0으로 초기화 되기 때문에 이 경우 굳이 따로 초기화하지 않아도 되지만, 클래스 static 변수들의 경우 W방법으로 초기화 한다. 간혹 누군가 클래스 내부에서 E와 같이 초기화 해도 되지 않냐고 묻는 경우가 있는데, 멤버 변수들을 W 같이 초기화 시키지 못하는 것처럼 static 변수 역시 클래스 내부에서 E처럼 초기화 하는 것은 불가능하다. 가능한 유일한 경우는 const static 변수 일 때만 가능한데, 실제로 R 같이 쓸 수 있다. 실제로 total_apple_sum 이 잘 작동하고 있는지 살펴보자 .클래스의 편한 점이 

생성자와 소멸자를 제공한다는 점인데, 덕분에 Apple이 생성될 때, 그리고 소멸될 때 굳이 처리하지 않고도, 생성자와 소멸자 안에 total_apple_num 을 조작하는 문장을 넣어주면 편하게 처리할 수 있다.

Apple::Apple() : price(500), coord_x(0), coord_y(0),  ============Q
	amount(5), origin(U.S.A) { total_apple_num ++;}

Apple::Apple(int x, int y) : coord_x(x), coord_y(y), price(500),
	amount(5), origin(U.S.A) { total_apple_num ++; }

Apple::Apple(int x, int y, int amount) : coord_x(x), coord_y(y), price(500),
	amount(amount), origin(U.S.A) { total_apple_num ++; }
==================================================
~Apple() { total_apple_num --;}  ============W
=====================================
Apple apple1 (2, 3, 5); ========================E
apple1.show_status();
Apple apple2 (3, 5, 10);
apple2.show_status();
============================================
void create_apple() ========================R
{
	Apple apple3(10, 10, 4);
	apple3.show_status();
}
===========================================
cout << endl << "사과 1를 사과 2 로 교체! " << endl; ============T
	apple2.be_changed(apple1.change());
	apple1.show_status();

그 결과 Q로 각 생성자 호출 시에 total_apple_num 을 1 씩 증가시키는 문장을 넣고, 소멸 될때는 W 코드에 1감소시키는 문장을 넣었다. 따라서 E를 실행하면 실제로 총 Apple 의 수가 1, 2 늘어나는 것을 확인할 수 있고, 그 다음에 create_apple 을 실행하였을 때 R에 apple3 을 생성함으로써 총 apple 의 수가 3 이 됨을 확인할 수 있는데, apple3 은 create_apple 의 지역 객체이기 때문에 create_apple 이 종료될 때 소멸되게 된다. 따라서 다시 main 함수로 돌아와서 T에서 총 사과의 갯수를 표시할 때 2 명으로 나오게 된다. 그런데 클래스 안에 static 변수만 만들 수 있는 것이 아니다. 클래스 안에는 static 함수도 정의할 수 있는데, static 변수가 어떠한 객체에 종속되는 것이 아니라, 그냥 클래스 자체에 딱 1 개 존재하는 것인 것처럼, static 함수 역시 어떤 특정 객체에 종속되는 것이 아니라 클래스 전체에 딱 1 개 존재하는 함수다. 즉, static 이 아닌 멤버 함수들의 경우 객체를 만들어야지만 각 멤버 함수들을 호출할 수 있지만 static 함수의 경우, 객체가 없어도 그냥 클래스 자체에서 호출할 수 있게 된다.

Apple::show_total_marine(); ==========Q
----------------------------------
void Apple::show_total_apple() =====================W
{
	cout << amount << endl; // mount 는 멤버 변수
	cout << "전체 사과 갯수 : " << total_apple_num << endl;
}

static 함수는 앞에서 이야기 한 것과 같이, 어떤 객체에 종속되는 것이 아니라 클래스에 종속되는 것으로, 따라서 이를 호출하는 방법도 (객체).(멤버 함수) 가 아니라, Q와 같이 (클래스)::(static 함수) 형식으로 호출하게 된다. 왜냐하면 어떠한 객체도 이 함수를 소유하고 있지 않기 때문이다. 그러하기에, static 함수 내에서는 클래스의 static 변수 만을 이용할 수 밖에 없다. 만일 static 함수 내에서 W처럼 그냥 클래스의 멤버 변수들을 이용한다면 amount가 누구의 amount인지 아무도 모르는 상황이 발생한다. 즉, 어떤 객체의 amount인지 static 변수인 show_total_apple() 은 알 수 없다. 왜냐하면 계속 말해왔듯이 어떤 객체에도 속해이지 않기 때문이다.

3. C++ this

Apple& Apple::be_changed(int amount again)  ============Q

{

	price -= amount again;

	if(price <= 0)

		origin = true;
	
      return *this; 

}
-----------------------------------------
Apple& Apple::be_changed(int amount again) ================W
{

	this->price -= amount again;

	if(this->price<= 0)

		this->is_can not eat = true;

	return *this; 
}

일단 this 라는 것이 C++ 언어 차원에서 정의되어 있는 키워드 인데, 이는 객체 자신을 가리키는 포인터의 역할을 한다. 즉, 이 멤버 함수를 호출하는 객체 자신을 가리킨다. 따라서, 실제로 Q의 내용은 W과 동일한 의미가 된다. cf)(구조체 포인터 변수에서 -> 를 이용해서 구조체 원소들에 접근) 실제로 모든 멤버 함수 내에서는 this 키워드가 정의되어 있으며 클래스 안에서 정의된 함수 중에서 this 키워드가 없는 함수는 오직 static 함수 뿐이다. 그러면 이제 Apple& 을 리턴한다는 말이 도대체 뭔 소리일까?. 레퍼런스라는 것이 어떤 변수의 다른 별명이라고 했다. 그런데, 그 별명을 리턴한다니, 잘 이해가 안 된다. '레퍼런스를 리턴하는 함수' 에 대해 알아보기 위해 글을 계속 읽어나가자.

4.C++ Functions that return references

int& access_x() { return x; } =================Q
int get_x() { return x;}
---------------------------------------------
int& c = a.access_x(); ======================W
	c = 4;
	a.show_x();
----------------------------------------
int &c = x; // 여기서 x 는 a 의 x ==================E
-------------------------------------------
int d = a.access_x(); ======================R
	d = 3;
	a.show_x();

일단 위 클래스 A 는 아래와 같이 int 와 int 의 레퍼런스를 리턴하는 두 개의 함수를 가지고 있다. access_x 는 x 의 레퍼런스를 리턴하게 되고, get_x 는 x 의 '값' 을 리턴하게 되지요. 실제로 이들이 어떻게 작동하는지 살펴보도록 하겠다. 여기서 레퍼런스 c 는 x 의 레퍼런스, 즉 'x 의 별명'을 받았다. 따라서, c 는 x 의 별명으로 탄생하게 되는 것이다. 레퍼런스를 리턴하는 함수는 그 함수 부분을 원래의 변수로 치환했다고 생각해도 상관이 없다. 다시 말해서 E와 동일한 말이다. 따라서 c 의 값을 바꾸는 것은 a 의 x 의 값을 바꾸는 것과 동일한 의미이므로 (c 는 단순히 x 에 다른 이름을 붙여준 것일뿐) show_x 를 실행 시에 x 의 값이 5 에서 4 로 바뀌었음을 알 수 있다. 계속 이어가자. 이번에는 int& 가 아닌 그냥 int 변수에 'x 의 별명' 을 전달하였다. 만일 d 가 int& 였다면 x 의 별명을 받아서 d 역시 또 다른 x 의 별명이 되겠지만, d 가 그냥 int 변수 이므로, 값의 복사가 일어나 d 에는 x 의 값이 들어가게 된다. 그리고 d 는 x 의 별명이 아닌 또 다른 독립적인 변수 이기에, d = 3; 을 해도 x 의 값은 바뀌지 않은 채, 그냥 4 가 출력되게 된다.

int& e = a.get_x();
e = 2;
a.show_x();

위 소스 코드를 컴파일하면 오류가 발생한다.그 이유는 레퍼런스가 아닌 타입을 리턴하는 경우는 '값' 의 복사가 이루어지기 때문에 임시 객체가 생성되는데, 임시객체의 레퍼런스를 가질 수 없기 때문이다. cf) 임시객체는 문장이 끝나게 되면 소멸된다. get_x 의 리턴으로 인해 임시로 '복사생성' 된 int 는 a.get_x() 부분을 대체한다,

int &e = x' ===============Q
-----------------------
int f = a.get_x(); ===============W
	f = 1;
	a.show_x(); 
-----------------------
a.access_x() = 3; ======================E
-----------------------
a.x = 3; =======================R
-----------------------
a.get_x() = 3; =====================T

x' 은 문장이 끝날 때 자동으로 소멸되는 임시 객체 이기 때문에 레퍼런스를 만들 수 없다. 레퍼런스를 만들었다고 해도 '이미 존재하지 않는 것에 대한 별명' 이 되므로 이 레퍼런스에 접근하는 것은 오류다. 이러한 이유로 int 를 리턴하는 a.get_x 에 대해서는 레퍼런스를 만들 수 없다. cf) int& 는 좌측값에 대한 레퍼런스 이고, a.get_x() 는 우측값 이기 때문에 레퍼런스를 만들 수 없다. 마지막으로 W코드는 익히 보왔던 것 처럼, 임시로 생성된 int 변수 (위 그림에서는 x' ) 이 f 에 복사되는데, 역시 f = 1 한 것이 실제 객체 a 의 x 에게는 아무런 영향을 끼칠 수 없다. 웃긴 건 E가 잘 작동한다는 점인데, 앞에서도 말했지만 '레퍼런스를 리턴하는 함수는 그 함수 부분을 리턴하는 원래 변수로 치환해도 된다' 라는 말이 명확히 들어맞는다. 즉, E은 결국 R과 동일한 말이 된다. 그 에 반면, T는 역시 오류가 나게 되는데, 왜냐하면 a.get_x() 는 get_x() 가 리턴하면서 생성되는 임시 객체 (x') 으로 치환되며 임시객체에 대입을 하게 되는 모순적인 상황이 발생하게 된다. 다시 한 번 Apple 예제를 살펴보자.

Apple& Apple::be_changed(int amount again)
{

	this->price -= amount again;

	if(this->price <= 0)

		this->is_can not eat = true;

	return *this; 
}

위 소스 코드 경우 be_changed 함수는 Apple& 타입을 리턴하게 되는데, 위 경우, *this 를 리턴하게 된다. 앞에서도 말했지만 this가 지금 이 함수를 호출한 객체를 가리키는 것이다. 그렇기 때문에 *this 는 그 객체 자신을 의미하게 된다. 따라서 apple2.be_changed(apple1.change()).be_changed(apple1.change()); 문장의 경우, 먼저 apple2.be_changed(apple1.change()) 이 먼저 실행되고 리턴되는 것이 다시 apple2 이므로 그 다음에 또 한 번 apple2.be_changed(apple1.change()) 가 실행된다고 생각할 수 있다. 만약에 be_changed 함수의 리턴 타입이 Apple& 이 아니라 그냥 Apple이라고 해보자. 즉, 만일 be_changed 함수가 아래와 같이 바뀌었다고 가정한다면,

Apple Apple::be_changed(int amount again)
{
	this->price -= amount again;

	if(this->price<= 0)

		this->is_can not eat = true;

	return *this; 
}

위 소스 코드 바뀐 함수를 가지고 apple2.be_changed(apple1.change()).be_changed(apple1.change());를 실행해보면 apple2 는 실제로 두 번 공격이 아닌 1 번 공격으로 감소한 price만을 보인다. (즉 40 이 아닌 45 로 나옴) 이는 앞에서도 설명했듯이 리턴타입이Apple이므로, 임시 객체 Apple를 생성해서, *this 의 내용으로 복사가 되고 (즉, Apple의 복사 생성자 호출) 이 임시 객체에 대한 be_changed 함수가 호출되게 되는 것이다. 따라서 결국 두 번째 be_changed 는 apple2 가 아닌 임시 객체에 대해 호출되는 것이므로 결국 apple2 는 apple1 의 공격을 1 번만 받게 된다.

5.C++ const function

int attack() const ; // 데미지를 리턴. ============Q
---------------------------
(기존의 함수의 정의) const; ==============W
---------------------------
int Apple::change() const =================E
{
	return amount;
}

일단 상수 함수는 Q형태로 선언을 하게 된다. 그리고 함수의 정의 역시 const 키워드를 꼭 넣어주어야 하는데, W형태처럼 말이다. 그렇게 하였으면 E change 함수는 '상수 멤버 함수' 로 정의된 것이다. 상수 함수로 이 함수를 정의함으로써, 이 함수는 다른 변수의 값을 바꾸지 않는 함수라고 명시 시킬 수 있다. 당연하게도, 상수 함수 내에서는 객체들의 '읽기' 만이 수행되며, 상수 함수 내에서 호출 할 수 있는 함수로는 다른 상수 함수 밖에 없다. 사실 많은 경우 클래스를 설계할 때, 멤버 변수들은 모두 private 에 넣고, 이 변수들의 값에 접근하는 방법으로 get_x 함수 처럼 함수를 public 에 넣어 이 함수를 이용해 값을 리턴받는 형식을 많이 사용한다. 이렇게 하면 멤버 변수들을 private 에 넣음으로써 함부로 변수에 접근하는 것을 막고, 또 그 값은 자유롭게 구할 수 있게 된다.