꿈 꾸는 누렁이

연산자 오버로딩

• 연산자 오버로딩

C++언어에서는 연산자의 오버로딩을 통해서 기존에 존재하던 연산자의 기본 기능 이외에 다른 기능을 추가할 수 있다.

먼저 15번 라인을 통해서 operator+ 라는 함수를 제공한다. 이 함수를 정의함으로써 연산자를 오버로딩한다. 29번 라인을 보면 operator+ 멤버 함수를 호출함으로써 a1의 멤버 변수 value의 값과 a2의 멤버 변수 value의 값을 더한 결과를 a3로 객체 복사를 통해서 전달하고 있음을 확인할 수 있다. 그런데 이러한 과정이 30번 라인에서도 똑같이 일어나고 있음을 알 수 있다. 즉, 정리해보자면 다음과 같음을 알 수 있다.

이는 객체 또한 기본 자료형 변수처럼 취급하고 각종 연산이 가능하도록 하려는 C++의 기본 철학이다. operator 키워드와 연산자를 묶어서 함수를 정의하면 함수의 이름(operator’연산자’)을 이용한 함수 호출은 물론 연산자만을 이용해도 operator’연산자’ 함수 호출로 바꾸어 준다.

• 연산자 오버로딩의 두 가지 방법

멤버 함수에 의한 연산자 오버로딩

위에서 제시한 예의 경우이다.

전역 함수에 의한 연산자 오버로딩

다음의 예를 통해 설명.

20번 라인에서 private 영역에 접근을 위해서 전역 함수를 friend 선언을 해 주었다. 그리고 22번 라인에서 + 연산자에 대해서 전역 함수 형태로 오버로딩 하였다. 이 함수를 이용해서 30번 라인에서 a1+a2는 operator+(a1,a2) 형태로 해석이 된다.

l  오버로딩이 가능한 / 불가능한 연산자의 종류

오버로딩 불가능 연산자

오버로딩 가능 연산자

• 연산자 오버로딩 주의사항

1.     본래의 의도를 벗어난 형태의 연산자 오버로딩은 좋지 않다.

2.     연산자의 우선순위와 결합성은 바뀌지 않는다.

3.     매개변수의 디폴트 값 설정이 불가능하다

4.     연산자의 순수 기능까지 빼앗을 수 없다.

• 단항 증감 연산자(선 증감 후 연산)의 오버로딩

operator++( ) 처럼 인자에 아무 것도 명시하지 않은 경우에는 선 증감 후 연산의 증감 연산자가 오버로딩 된다.

• 단항 증감 연산자(선 연산 후 증감)의 오버로딩

operator++(int)처럼 인자에 int 키워드를 넣어 명시하는 경우에는 선 연산 후 증감의 증감 연산자가 오버로딩 된다. 인자 전달의 int 의미는 아니라는 것. 이 때 int 키워드는 매개 변수의 가장 뒤에 넣는다.

21번 라인이나 30번 라인과 같이 Const를 이용하여 객체를 반환한 이유는 단순히 const A 타입은 returnObj 반환하기 때문에 const를 기재한 것이 아니라, 반환함으로써 생기는 임시 객체를 const 객체로 생성한다는 의미에서 const를 기재한 것임.

선 연산 후 증감에 대한 연산자의 경우 해당 연산이 존재하는 라인에서는 증가되지 않은 값을 출력해야 한다. 그리고 또한 그 값을 변경할 수도 없기 때문에 참조 값을 반환하지 않을 뿐 더러, 임시 객체를 const로 반환한다.

(a1++)++ 이 불가능한 이유

(a1++)++ -> (a1.operator++( ))++ -> (A형 const 임시객체)++ -> (A형 const 임시객체).operator++( )

이 과정에서 마지막 operator++( ) 호출이 불가능하다. 왜냐하면 const로 선언된 함수 내에서는 const 함수의 호출만을 허용하기 때문이다.

• 교환 법칙이 필요한 연산자의 오버로딩 ( * )

멤버 함수의 * 연산자 오버로딩에서, 이와 같은 경우는 멤버 함수의 연산자 오버로딩으로 설명이 가능하다.

a1 * 3; -> a1.operator*(3);

그러나, 아래와 같은 경우는 멤버 함수의 연산자 오버로딩으로 설명이 불가능하다

3 * a1; -> 3.operator*(a1);   -   ?

이러한 경우에는 전역 함수의 형태로 연산자 오버로딩을 진행해야 한다.

a1 * 3; -> operator*(a1, 3);
3 * a1; -> operator*(3, a1);

교환 법칙을 성립한 연산자 오버로딩의 예제이다.

• cout, cin, endl의 정체 ( >> 연산자의 오버로딩 )

정체는 위의 예와 같다. cout은 생성된 객체의 이름이었고, endl은 개행 기능을 하는 함수이다.

•  <<, >> 연산자의 오버로딩 ( 특별 자료형에 대한 cout과 cin의 구현 )

cout과 cin에 대해서 <<, >> 연산자 오버로딩을 하기 위해서는 전역 함수를 통한 오버로딩을 해야 한다. 왜냐하면 멤버 함수를 통하여 오버로딩을 하기 위해서는 ostream(객체 cout의 클래스) 클래스와 istream(객체 cin의 클래스) 클래스를 수정해야 하는데 그것은 불가능하기 때문이다.

• 대입 연산자의 오버로딩

대입 연산자 오버로딩은 복사 생성자와 그 성격이 매우 유사하다.

디폴트 대입 연산자 : 객체 간의 대입 연산

다음은 복사 생성자와 대입 연산자의 공통점이다.

다음은 복사 생성자와 대입 연산자의 유일한 차이점이다.

그러므로 객체 간의 대입 연산을 진행할 시에는 복사 연산자의 경우처럼 깊은 복사 문제에 대해서도 고려를 해야 한다

상속 관계에서의 대입 연산자 오버로딩

Derived 클래스를 통하여 디폴트 대입 연산이 진행되면 base 클래스의 대입 연산자까지 호출한다. 그러나 derived 클래스에서 대입 연산자를 정의해주면 명시적으로 base 클래스의 대입 연산자의 호출문을 삽입하지 않으면, base 클래스의 대입 연산자는 호출되지 않아서 base 클래스의 멤버 대 멤버 복사는 이루어지지 않는다.

대입 연산자 호출과 이니셜라이저의 효과

38번 라인처럼 이니셜라이저를 사용하면 선언과 동시에 초기화가 이뤄지는 형태로 바이너리 코드가 생성되기 때문에(A aaa=ref와 같은 효과) 58번 라인에서는 복사 생성자만 호출된다. 그러나 생성자의 몸체 부분에서 대입 연산을 통한 초기화를 진행하면, 선언과 초기화를 각각 별도의 문장에서 진행하는 형태로 바이너리 코드가 생성된다. 그렇기 때문에 50번 라인처럼 초기화를 진행하는 경우이기 때문에 60번 라인은 생성자 이외에 대입 연산자자 호출되는 것이다.

• 배열의 인덱스 연산자 오버로딩

C언어 및 C++언어의 배열은 배열 인덱스에 대한 검사를 하지 않는다. 그렇기 때문에 배열이름[범위를 넘어선 인덱스]의 경우를 허용한다. 이런 허용을 막는 배열 클래스를 만들어 볼 것이다. 배열의 역할을 하는 클래스.

위와 같이 만든 배열 클래스를 이용하여 배열 간의 대입을 이루어지게 하면 얕은 복사가 이루어지므로 깊은 복사가 이루어지도록 복사 생성자 및 대입 연산자를 수정할 수 있다. 그러나 배열은 저장소의 일종이고, 저장소에 저장된 데이터는 유일성이 보장되어야 하기 때문에 저장소의 복사는 불필요하거나 잘못된 일로 간주된다.

그러므로 다음과 같이 복사 생성자나 대입 연산자를 private 멤버로 둠으로써 복사와 대입을 차단한다.

• Const 함수의 오버로딩

위의 예제에서 문제는 showAllData 함수의 매개 변수로 const Array& ref 형태로 Array 객체를 받아들이는데 41번 라인에서 const화 되지 않은 함수 operator[] 가 호출된다. 그렇기 때문에 에러가 발생하는데 그렇다고 해서 operator[] 함수를 const화 할 수도 없는 노릇이다. 왜냐하면 배열에 저장이 불가능해지기 때문이다. 그렇기 때문에 const 선언 유무에 따른 함수 오버로딩을 통해 위의 문제를 해결해야 한다.

• new & delete 연산자의 오버로딩

new 연산자 오버로딩

위와 같은 문장에서 new 연산자가 오버로딩되어 있는 상태라면 어떻게 해석해야 하는가? 해석할 수 없다. 왜냐하면 오버로딩 된 new 연산자는 기본적으로 제공하는 new 연산자를 완벽 대체가 불가능하다.

기본 new 연산자의 기능

1.     메모리 공간의 할당

2.     생성자의 호출

3.     할당하고자 하는 자료형에 맞게 반환된 주소 값의 형 변환

기본 new 연산자의 기능 중 2번, 3번은 여전히 컴파일러가 맡게 되고, 1번의 기능인 메모리 공간의 할당만 오버로딩 할 수 있다.

위와 같은 형태로 오버로딩 된다. 출력 타입은 무조건 void * 형태이고, 매개 변수로 사이즈를 받을 수 있다.

오버로딩 된 new 연산자를 이용하여 위와 같이 할당을 하더라도 new 연산자가 반환하는 값은 operator new 함수가 반환하는 값이 아니고, 컴파일러에 의해서 적절히 형 변환이 된 값이다. 또한 생성자의 호출정보는 operator new 함수와 아무런 상관이 없다.

delete 연산자 오버로딩

위와 같은 형태로 delete 연산자를 오버로딩 한다.

new와 delete 연산자 오버로딩의 예

18번 라인과 24번 라인에서 static을 넣은 이유는 객체가 생성이 되기 전에 호출되어야 하기 때문이다.

new, delete 연산자를 이용하여 배열 할당 및 소멸을 할 경우에는 다음의 operator 함수가 호출된다.

• 포인터 연산자 오버로딩

아래의 예는 위의 포인터 관련 연산자를 구현한 예제이다.

40번 라인의 경우에는 객체의 참조 값에 대입이 이루어지고 있으니 대입 연산자가 호출되어 number 멤버 변수에 값이 저장되었고, 41번 라인에서는 Number*형 주소 값을 이용하여 -> 연산자(추가)를 이용하여 멤버 함수에 간접 접근을 통해 호출한다. 그리고 42번 라인은 객체의 참조 값을 이용하여 .연산자를 이용하여 멤버 함수에 직접 접근을 통해 호출한다. 위의 예처럼 main 함수에서 private 멤버의 값을 변경하는 연산은 좋지 못함.

• 스마트 포인터

스마트 포인터란 포인터의 역할을 하는 객체를 뜻한다.     

객체에 대해서 포인터 역할을 하는 객체이면서도 가리키는 객체에 대해서 delete 연산이 자동으로 이뤄졌다는 점에서 스마트 포인터이다. 위의 예는 아주 작은 기능의 스마트 포인터를 구현해 본 예이다.

• ( ) 연산자의 오버로딩

( ) 연산자를 오버로딩 하면 객체를 함수처럼 사용할 수 있다. 함수처럼 동작하는 클래스를 가리켜 펑터(Functor)라고 한다.

• 임시 객체로의 자동 형 변환과 형 변환 연산자

위의 예제에서 39번 라인에서 서로 다른 자료형 임에도 불구하고 대입 연산이 이루어 졌음을 확인할 수 있다.

num=30;
▽
num = Number(30); 임시 객체의 생성
▼
num.operator=(Number(30)); 임시 객체를 대상으로 하는 대입 연산자 호출

위와 같은 단계로 대입이 이루어짐. 이는 정리를 해보자면,

A형 객체가 와야 할 위치에 B형 데이터(또는 객체)가 왔을 경우, B형 데이터를 인자로 전달받는 A형 클래스의 생성자 호출을 통해서 A형 임시 객체를 생성한다.

즉, Number 객체가 와야 할 위치에 정수형 데이터가 왔기 때문에 정수형 데이터를 인자로 전달받는 Number 형 클래스의 생성자 호출을 통해 해당 정수형 데이터가 대입되어 있는 Number형 임시 객체를 생성한다.

그렇다면 반대로 Number형 객체를 정수형 데이터 타입으로 변경할 수 있는지 다음의 예제로 확인한다

23번 라인에서 int 형 변환 연산자 오버로딩이 이루어지고 있다. 형 변환 연산자는 반환 형을 명시하지 않는다. 그러나 return 문을 통해서 값의 반환은 가능하다.

46번 라인에서 먼저 num1의 int 형 변환 발생이 일어나고 그 결과 값을 3과 더한 뒤, 그 정수 값을 다시 num2에 대입하는 과정에서 num2의 생성자가 호출되어 임시 객체를 통한 대입 연산자가 호출되고 대입이 이루어진다.

함수 포인터와 void 포인터

• 함수 포인터

함수 또한 메모리 상에 바이너리 형태로 올라가 호출 시 실행이 되는데, 메모리 상에 저장된 함수의 주소 값을 저장하는 포인터 변수가 함수 포인터 변수이다.

배열의 이름이 배열의 시작 주소 값을 의미하듯이 함수의 이름 또한 함수가 저장된 메모리 공간의 시작 주소 값을 의미한다.

함수 이름의 포인터 형은 반환 타입과 매개변수의 선언을 통해 결정 짓도록 약속. 즉, 반환 타입과 매개변수의 선언이 일치하는 모든 함수들의 포인터 형은 모두 같다.

9번 라인과 10번 라인에서 볼 수 있듯이

반환 타입 (*포인터변수이름) (매개 변수) = 함수 이름

다음과 같은 형태로 함수 포인터 변수를 선언하고 함수의 주소를 받아서 12번, 13번 라인처럼 함수 포인터 변수를 통한 함수 호출이 가능하다.

• Void 형 포인터 ( 자료 형이 없는 포인터 )

다음과 같이 선언되는 포인터를 void 형 포인터 변수라고 한다.

Void 형 포인터는 어떤 변수의 주소 값이든 함수의 주소 값이든 상관 없이 ‘주소’ 값의 경우는 무엇이든 전부 담을 수 있다. 다음 예는 void * 변수에 다양한 주소 값을 저장하는 예를 나타낸 것이다.

단, void 형 포인터 p를 이용하여 참조를 하는 순간(=포인터 연산을 하는 순간) 컴파일 에러가 발생한다. 왜냐하면 void * 포인터는 포인터 연산 시 증감의 크기에 대한 정보가 단 한 부분도 없다. 즉, 해당 주소로부터 어느 범위까지 연산을 하여 참조를 해야하는지에 대한 정보가 없기 때문에 참조(포인터 연산)가 불가능하다.

void형 포인터는 주소 값을 저장하는 것에만 의미를 두고 포인터 형은 나중에 결정한 참조하는 경우에 유용하게 사용된다 -> 동적 메모리 할당

• Main 함수를 통한 인자 전달

위의 예제에서 argc는 파일 이름을 포함한 전달 되어온 인자의 수를 나타내고, argv는 더블 포인터 형태로 싱글 포인터 혹은 싱글 포인터 배열의 각 요소를 가리킨다. 즉, argv는 두 번째 결과에서 “./t”, “yoo”, “seung”, “ho”의 주소 값인 char * 타입을 가리키기 때문에 더블 포인터 형태이다.

다중 상속

• 다중 상속

위와 같은 상황을 다중 상속된 상황이다. 이러한 다중상속의 상황에서는 멤버 함수의 이름을 명확하게 구분 짓지 않으면 모호성이 발생하게 된다. 이런 경우에는 범위를 지정하여 멤버 함수를 호출하는 방법이 있다.

DeepDerived 클래스에서 DerivedLeft::func(); DerivedRight::func(); 또한, DeepDerived 클래스에서 Base 클래스의 멤버 함수를 호출할 때 DerivedLeft에 상속된 멤버를 호출해야 할지, DerivedRight에 상속된 멤버를 호출해야 할지 알 수 없는 경우가 발생한다. 이런 경우에는 가상 상속 개념을 이용한다.

위의 상황에서는 Base 클래스가 두 번 상속되게끔 되어 있다. 그러나 이 두 번 상속되는 다중 상속의 상황을 한 번 만 상속되도록 하는 문법이 가상 상속 개념이다. virtual 키워드를 이용하여 가상 상속을 적용하자.

위와 같은 방법을 적용하면 DeepDerived 클래스에서 Base 클래스의 멤버 함수를 호출할 때 DerivedLeft에 상속된 멤버를 호출해야 할지, DerivedRight에 상속된 멤버를 호출해야 할 지에 대한 문제는 자동으로 해결된다. 왜냐하면 Base 클래스가 딱 한 번 상속되기 때문이다. 그렇기 때문에 Base 클래스의 생성자도 한 번 실행되고, Base 클래스의 함수 또한 하나씩만 존재하게 된다.( 두 클래스에 걸쳐 있는 형태로 )

다차원 배열과 포인터의 관계

• 2차원 배열과 포인터의 잘못된 오해

정수형 2차원 배열의 배열 이름은 정수형 더블 포인터 형이라고 오해하고 2차원 배열의 이름을 매개 변수 혹은 변수로 주소 값을 받을 때 더블 포인터 변수로 받을 수 있다.

<2차원 배열과 포인터의 잘못된 관계>

더블 포인터로 받을 수 있는 것은 포인터 배열의 이름이다.

• 2차원 배열의 배열 이름의 포인터 형은?

먼저, 알아야 할 것은 arr과 arr[0]의 차이를 알아야 한다.

arr과 arr[0]은 2차원 배열의 첫 시작 주소를 가리키지만 차이점이 존재한다. sizeof 연산자를 이용하여 11번째 라인, 12번째 라인처럼 사이즈를 체크했을 때 arr은 배열의 전체 길이를 나타냈지만, arr[0]의 경우는 해당 행의 길이를 반환하였다.

그리고 다음으로는 배열 이름을 이용하여 포인터 연산을 행했을 때 어떤 연산 결과가 나타나는지 알아야한다.

2차원 배열 이름에 +1, +2 포인터 연산을 진행하였을 때 각 주소는 8씩 증가하는 것을 볼 수 있다.

이번에는 2차원 배열의 열에 해당하는 인덱스를 2에서 4로 변경한 후 포인터 연산을 진행했는데, 이 때 주소의 증가 폭은 16이 증가하였다.

두 경우를 잘 살펴보면 같은 정수형 2차원 배열 임에도 불구하고 포인터 연산의 증감 폭이 다르다. 포인터 연산 시 증감하는 폭을 결정하는 것은 2차원 배열에서 열의 길이에 따라서 달라짐을 알 수 있다.

두 가지 요인을 이용하여 최종 결론을 내리자면 먼저, 2차원 배열에서도 배열 이름을 통하여 배열 전체를 대표하고, 이 배열 이름을 통하여 포인터 연산을 행한다는 점과 같은 타입의 2차원 배열이라고 할지라도 배열 이름을 통하여 포인터 연산을 행할 때 증감의 차이는 열의 길이에 따라서 증감의 폭이 결정된다. 결국, 이 증감의 폭까지 같아야 비로소 같은 포인터 형이 된다는 점.

위의 결론을 토대로 7번 라인에서 알 수 있는 정보는 2차원 배열 이름(2차원 배열의 첫 주소)과 포인터 연산 시 증감하는 크기 그리고 자료 형을 알 수 있기 때문에 이를 반영하여 8번 라인처럼 2차원 배열을 받는 포인터 변수를 선언할 수 있다. pArr은 정수형 포인터 변수인데 포인터 연산 시 sizeof(int) x 열의 길이(4)만큼 증감하는 2차원 배열의 주소를 받는 포인터다 라고 해석하면 된다.

• 2차원 배열을 받는 포인터와 포인터 배열과 혼동하지 말 것.
• 2차원 배열을 함수의 인자로 전달하기

위와 같이 전달하고, 매개 변수는 두 형태 모두 허용한다.

• 2차원 배열에서 또한 arr[i]=*(arr+i) 방법이 적용된다.

멤버함수 가상함수의 동작 원리

• 가상함수

객체 포인터가 참조를 할 때, 포인터 연산의 기준으로 두는 것은 실제 가리키는 객체의 자료형이 아니라, 선언된 포인터의 자료형을 기준으로 한다. 그로 인해 포인터 변수의 자료형에 따라서 호출되는 함수의 종류가 달라진다.

이와 같은 상황을 발생하지 않도록 가상함수 라는 문법을 제공.

위 소스에서 포인터 변수의 자료형을 기준으로 판단하여 호출되는 함수를 결정하는 상황을 발생시킬 수 있는 오버라이딩 된 함수들이다. 이러한 오버라이딩 된 함수들을 "가상 함수"로 만듦으로써, 실제 가리키는 객체의 자료형을 기준으로 판단하여 호출 함수를 결정하게 만들 수 있다.

가상함수로 만드는 것은 위의 소스처럼 해당 함수 앞에 "virtual" 키워드를 붙임으로써 완성한다.

함수를 가상함수로 만들게 되면 이를 "오버라이딩 하는" 함수들 또한 virtual 키워드를 붙이지 않더라도 자동으로 가상 함수화 된다.

• 순수 가상함수, 추상 클래스

클래스 중에는 객체 생성을 목적으로 하지 않는 클래스가 존재한다. 상속을 위한 Base 클래스로서 존재하는 클래스들이 존재하는데, 이를 객체로 생성하게 되는 것은 개발자의 실수이다.

이러한 실수를 방지하기 위해 가상함수를 순수 가상함수로 선언하여 객체의 생성을 방지한다.

순수 가상함수란? 함수의 몸체가 정의되지 않은 함수를 말한다. 이를 포함한 클래스는 불완전한 클래스이기 때문에 객체를 생성하게 되면 컴파일 에러가 발생한다. 이러한 순수 가상함수가 멤버 함수로 포함된 불완전한 클래스를 추상 클래스라고 한다.

• 가상 소멸자

소멸자 또한 가상함수 선언이 된다. Base 클래스를 Derived 클래스가 상속하였을 때, Derived 클래스의 생성자를 호출하고 바디를 실행하기 이전에 Base 클래스 생성자를 호출한다. 이 두 생성자는 멤버 변수의 동적 할당을 수행한다고 가정한다! 이 때, 객체 포인터를 이용하여 객체를 할당하였다면 소멸자 또한 객체 포인터의 자료형을 기준으로 판단하여 경우에 따라서는 Derived 클래스의 소멸자가 실행되지 않을 수 있다.

이를 방지하기 위해서 소멸자에 virtual 키워드를 붙임으로써 해결한다.

• 다형성(polymorphism)

문장은 같은데 결과는 다른 것을 다형성이라고 한다. ( 동질이상, 열혈 C++ 참고 )
오버라이딩, 순수 가상함수 개념이 다형성에 해당한다. 이는 참조자(레퍼런스) 에서도 똑같이 적용된다.

• 멤버함수의 진실

멤버 변수는 객체 내에 존재한다. 그러나 사실, 멤버 함수는 객체 안에 존재하지 않는다. 멤버 함수는 사실, 메모리 한 공간에 위치하고, 해당 클래스로 선언되어 생성된 객체들이 이 한 공간에 위치한 멤버 함수들을 공유하는 형태로 존재한다.

• V-Table

위와 같은 두 클래스는 V Table이라는 가상 함수 테이블을 구성하게 된다. 객체 생성이 되지 않더라도 컴파일러에 의해 가상함수 테이블을 만든다.

위의 예제에 해당하는 가상 함수 테이블은 2개가 다음과 같은 형태로 구성이 된다.

유심히 살펴봐야 할 부분은 Derived 클래스의 테이블인데, 이 테이블에서는 상속을 받은 입장인대도 불구하고, Base::f1의 정보가 존재하지 않는다. 이는 오버라이딩 된 가상 함수의 정보는 존재하지 않고, 유도 클래스의 오버라이딩 한 가상 함수만이 존재한다.

상속과 다형성

• 객체 포인터를 통한 참조

위의 소스에서는 Base 클래스가 Derived 클래스를, DeepDerived 클래스가 Derived 클래스를 상속하고 있는 2단 상속이 이루어지고 있다. 위의 상황에서 다음과 같은 소스 코드는 에러 없이 실행이 가능하다.

정리를 해보자면, C++ 에서는 Base 클래스 형 포인터 변수는 Base 클래스의 객체 또는 Base 클래스를 직접적(Base 를 직접 상속) 혹은 간접적(Base를 상속한 Derived 클래스를 상속)으로 상속하는 모든 객체를 가리킬 수 있다.

왼쪽 위의 예제는 오른쪽 그림의 소스 코드에서 주석과 같이 실행이 된다.

위 소스와 결과에서 주목해야 할 여러 가지가 있다.

1. 상속 관계에서 Base 클래스 그리고 Derived 클래스들에 완전히 동일한 함수 (이름, 반환타입, 매개변수) 를 정의할 수 있다.
>> 이를 "Overriding" 이라고 하고, 오버라이딩 된 함수들 중 Base 혹은 이전 Derived 클래스의 함수들은 가장 마지막 Derived 클래스의 함수에 의해 가려진다.

2. 객체 포인터를 이용하여 멤버 함수 등을 호출할 때에는 실제 참조하고 있는 객체를 기준하는 것이 아니라, 객체 포인터의 자료형을 기준으로 한다.
>> 5번, 9번 줄에서 보았을 때, 5번 줄에서는 Base * 자료형이지만 실제로는 DeepDerived 객체를 가리킨다. 그러나 9번 줄에서 오버라이딩 된 함수 print()를 호출하였을 때, Base 클래스에 있는 함수를 호출한다. 이것이 증거이다.

포인터의 포인터

• 포인터의 포인터(의 포인터 의 … ) – 더블 포인터

포인터의 포인터는 포인터 변수를 가리키는 또 다른 포인터 변수를 뜻한다. 마찬가지로 포인터의 포인터의 포인터는 포인터 변수를 가리키는 또 다른 포인터 변수를 가리키는 또 다른 포인터 변수를 뜻한다.

포인터 변수는 종류와 상관 없이 주소 값을 저장하는 변수인데, 다만 더블 포인터와 일반 싱글 포인터의 차이점은 가리키는 대상이 또 다른 포인터 변수인지, 일반 변수인지의 차이이다.

위의 예는 일반 변수, 싱글 포인터, 더블 포인터의 사용 예와 세 변수 간의 관계를 값으로 나타낸 예이다.

먼저, 7번 라인에서 일반 정수형 변수를 선언, 그 주소 값을 8번 라인에서 포인터 변수에 저장한다. 그리고 다시 그 포인터 변수의 주소 값을 9번 라인의 더블 포인터를 선언하고 저장한다. 다음은 11번 라인 ~ 13번 라인의 출력에 대한 결과를 나타내었다.

위의 실행 결과에서 첫 번째 결과 라인에서의 일반 정수형 변수의 주소 값을 출력 하였고, 이 주소 값을 두 번째결과 라인에서 싱글 포인터 변수에 값으로 대입되어 싱글 포인터 변수 pNum이 일반 변수 number를 가리키고 있는 형태를 이루었다. 그리고 마찬가지로 두 번째 결과 라인에서 싱글 포인터 변수의 주소 값을 출력 하였고, 이 주소 값을 세 번째 결과 라인에서 더블 포인터 변수에 값으로 대입되어 더블 포인터 변수 dpNum이 싱글 포인터 변수 pNum을 가리키는 형태를 이루고 있다.

두 번째 실행 결과 라인에서 * (애스터리스크) 연산자를 이용하여 pNum이 값으로 가지고 있는 주소에 접근하여 값을 출력한다.(가리키는 변수의 값을 출력) 세 번째 실행 결과 라인에서 **(더블 애스터리스크)를 이용하여 더블 포인터가 가지고 있는 싱글 포인터 주소에 접근하고 또 그 싱글 포인터가 가지고 있는 주소에 접근하여 값을 출력한다.(가리키고 가리키는 변수의 값을 출력)

사실, 참조의 더블 포인터(**)는 *(*더블 포인터 변수) 에서 소괄호가 생략된 형태이다.

• 포인터 배열의 포인터 형

8번 라인에서 정수형 포인터 타입 배열을 선언하여 n1과 n2의 주소 값을 배열의 각 요소에 대입하였다. 1차원 배열 이름의 포인터 형을 배열 이름이 가리키는 요소의 자료형을 고려하여 결정하듯이 1차원 포인터 배열 이름의 포인터 형 또한 배열 이름이 가리키는 요소의 자료형을 고려하면 된다. 11번 라인에서 배열 이름과 배열의 첫 번째 요소의 주소 값을 출력했는데 그 결과는 배열 이름 arr과 arr 배열의 첫 번째 요소의 주소가 일치했다. 이 때 배열 이름은 int * 형의 요소를 가리킨다. 즉 1차원 포인터 배열의 배열 이름은 더블 포인터 상수라고 할 수 있겠다. 그렇기 때문에 9번 라인에서 더블 포인터 변수에 배열 이름 arr을 아무런 처리 없이 대입하더라도 문제 없이 대입이 된다. 이어서 12번 라인에서 더블 포인터 변수를 이용하여 더블 포인터 연산을 통하여 포인터 배열의 각 요소에 접근하여 값을 출력하는 예제이다.

• 이중 포인터 이상의 다중 포인터 변수

다중 포인터 또한 더블 포인터와 완전히 같다.

• 포인터의 필요성

1.     자료구조를 위함.

2.     함수 내에서 함수 외부에 선언된 변수에 접근하는 방법을 제시.

상속

• 상속 들어가기 전에 앞서

상속이란? (열혈 C++, 윤성우) "기존에 정의해 놓은 클래스를 재활용을 하기 위한 목적으로 만들어진 문법" 이라고 한다.

그러나, 이는 과거에 상속을 바라봤던 관점이라고 한다. 그렇다면 상속을 어떤 관점으로 봐야 하고, 왜 필요한지 이해할 필요가 있다고 생각한다.

• 상속이 필요한 이유

객체지향 언어에서는 데이터적인 성격이 강한 데이터 클래스와 그 데이터 클래스를 이용하여 어떤 여러 기능들의 처리를 담당하는 컨트롤 클래스(혹은 핸들러 클래스)가 필요하다.

하나의 주제 및 테마에 대한 데이터 클래스 + 해당 데이터 클래스에 맞는 컨트롤 클래스

그런데 상속이라는 어떤 개념을 사용하지 않은 상태에서 비슷한 주제에 대한 다른 데이터 클래스를 추가하게 된다면 그 데이터 클래스에 대한 기능을 수행할 수 있도록 기존 컨트롤 클래스 모두를 갱신해야 한다. 이는 대공사가 아닐 수가 없다.

 -> 시시각각 변하는 여러 요구로 인한 변경에 대응하는 프로그램의 유연성과 기능을 추가함으로써 프로그램이 확장되는 확장성이 부족하다고 표현한다.

"탈 것"을 주제로 예를 들어 보았을 때,

1) 상속을 사용하지 않을 경우

기차 클래스  / 기차 기능을 수행하는 컨트롤 클래스

이렇게 구성하고 기차를 운영하는 프로그램을 작성했는데, 어느 날 비행기를 추가한다고 한다. 이런 경우에는

기차 클래스 / 비행기 클래스

기차 기능 수행 컨트롤 클래스 / 비행기 기능 수행 컨트롤 클래스

혹은

기차 클래스 / 비행기 클래스

기차 기능, 비행기 기능 수행 컨트롤 클래스

이렇게 대대적인 공사가 필요하다.

2) 상속을 사용하는 경우

비행기, 기차 등의 최소한의 공통점을 이용한 부모 클래스 / 컨트롤 클래스
▽
(상속)
▽
비행기, 기차, 자동차 등..

기차 클래스 외에 다른 클래스가 추가되는 경우에는 추가한 후 상속하고, 간단한 수정만 하게 되면 컨트롤 클래스까지 추가 수정하는 대대적인 공사를 막을 수 있다.

• 상속

간단하게 자식이 부모로부터 재산을 물려받는 행위를 상속이라고 하는데 객체지향 프로그래밍 언어에서는 재산 뿐만 아니라 행동 및 성격, 사상 등의 모든 것이 상속의 대상이 된다!

부모 ------ (상속) ------> 자식
키, 재산, 집 문서(데이터적인 성격)
하는 일, 습관적인 행동(기능적인 성격)

위 소스에서는 child 클래스가 parent 클래스를 상속받고 부모가 물려준 money 값을 출력하는 예제 소스이다. child 클래스 내에서 50번 줄의 함수 호출은 parent 클래스의 함수를 호출하고 있다. 이는 child 가 parent 를 상속받았기 때문에 가능한 호출이다. 상속은 34번 줄과 같이 " : 접근제한 상속_대상_클래스 " 형식으로 이루어진다.

그리고 57번 줄과 같이 child 클래스만 이용하여 선언했지만 parents 클래스를 상속받기 때문에 parents 클래스에 해당하는 생성자 호출 및 초기화 또한 child 클래스가 담당해야 한다. 관련 부분이 40번 줄, 이니셜라이저를 통하여 부모 클래스의 생성자가 호출되고 있음을 알 수 있다. 이니셜라이저를 통한 초기화이기 때문에 parent 클래스의 생성자는 child 생성자 보다도 앞서 본체까지 모두 실행되고 그 뒤에 child 생성자의 본체가 실행된다.

-> 이는 정말 당연하게도 부모가 존재해야 자식에게 상속을 할 수 있는 것처럼 부모가 먼저 객체화 되어야 자식 또한 상속받은 상태로 객체화 할 수 있기 때문이다.

• 상속 시 부모 클래스의 private 영역 접근

위의 예제에서 child 클래스가 parent 클래스를 상속받은 경우, child 클래스 내에서 parent 클래스의(부모 클래스) private 영역을 직접 접근이 가능한가가 문제이다.

위의 경우는 불가능하다. 아무리 상속을 받았다고 하더라도 부모 클래스의 private 영역은 자식 클래스에서도 직접 접근이 불가능하다. 이렇게 상속 관계에서 또한 정보 은닉 개념이 지켜진다.

private 영역은 부모의 사생활 영역이라고 생각하면 된다. 부모의 뇌라고 생각하고, 자식이 부모의 뇌까지 상속받아서 무슨 생각을 하는지 알 수 있는 것은 아니지 않은가!

• 상속 설정된 객체를 생성 시, 생성자 / 소멸자 호출 순서

생성자 호출 순서 : 부모 클래스 생성자 body 호출 -> 자식 클래스 생성자 body 호출
소멸자 호출 순서 : 자식 클래스 소멸자 호출 -> 부모 클래스 소멸자 호출

이러한 호출 순서는 당연한 것이다. 왜냐하면 객체 생성 시 부모 클래스 객체가 먼저 생성이 되어야 다음으로 생성되는 자식 객체에게 상속될 수 있기 때문이다.

소멸자의 호출은 생성자의 호출 순서에 반대이다!

지역변수의 호출 순서와는 무관하다. 지역 변수는 기본적으로 스택 구조에 담기기 때문에 LIFO 순서로 메모리 공간에서 해체되므로 이에 맞는 생성자/소멸자 호출이 이뤄진다.

• protected 접근 제어 지시자

접근 제어 지시자 정리

private   : 외부에서 이 영역에는 접근 불가하며, 상속 관계에서의 derived 클래스에서도 또한 접근이 불가능하다. 오직 해당 클래스의 멤버 함수를 통한 접근(내부 접근)만 허용
protected : 외부에서 이 영역에는 접근 불가하나 private와 다른 점은 상속 관계에서 derived 클래스에서 이 영역에 직접 접근이 가능하다.
public　　: 외부, 내부, 상속 관계에서의 모든 접근을 허용함.

• 세 가지 상속 형태

상속하는 방법에는 3가지 형태가 존재한다. public, private, protected 상속이 존재한다. 하지만 이러한 세 가지 상속들은 Base 클래스의 접근 제어 지시자와 함께 관련이 있기 때문에 함께 보아야한다.

Base 클래스의 접근 제어 지시자 + 세 가지 중 하나에 해당하는 상속 형태

이것이 결정하는 것은 바로!! 상속을 완료하였을 때, Base 클래스가 Derived 클래스에서 어떤 접근 권한으로 갱신되는지를 결정한다.

위의 표는 일반적으로 설명에 쓰이는 표. 이 포스팅에서는 조금 다른 방법으로 정리해보았다.

1.     먼저 상속의 형태 쪽을 훌라후프와 같은 원이라고 생각하자! 범위가 넓을 수록 큰 원이 된다.

public 상속은 제일 큰 원  / protected 상속은 중간 크기 원 / private 상속은 가장 작은 원

2.     그리고 Base 클래스 또한 원이라고 생각하는데 이 원을 1번에서 생각한 원에 떨어트려본다.

3.     크기가 같은 경우는 쏙 빠져 나온다고 생각하자,

EX)

- public 상속의 원에 public 멤버를 넣게 되면 public 접근 제어 권한으로 갱신되어 상속!

- private 상속의 원에 public 멤버를 넣게 되면 private 원 크기만큼만 잘려서 나오므로 private 접근 제어 권한으로 갱신되어 상속!

- Base 클래스에서 private 멤버인 경우는 부모의 사생활이기 때문에 무슨 짓을 해도 외부 접근 / 상속 관계의 derived 클래스에서의 접근 모두 허용하지 않고 내부 접근만 허용하므로 접근 불가.

이 두 상속 관계의 클래스가 상속이 완료된 모습을 보게 된다면 (정확한 형태는 본인도 잘 모르겠으나 핵심만 확인하기)

이러한 식으로 권한이 재 결정된다. 이는 외부 혹은 Derived 클래스를 다시 상속받으려고 하는 클래스의 입장에서 바라보았을 때의 권한이 된다. Base 클래스 만을 바라보면 Base 클래스 권한 그대로 유지하고 봐야 한다.

• 상속을 고민할 때, 따져 봐야 할 조건

IS-A 조건 과 HAS-A 조건

IS-A 조건 :
a는 b의 일종이다 라는 말이 성립할 경우, b를 Base 클래스로, a를 Derived 클래스로 정의.

HAS-A 조건 :
a가 b 를 소유한다 라는 말이 성립할 경우, b를 Base 클래스로, a를 Derived 클래스로 정의
-> 그러나 HAS-A 조건은 상속이 아닌 소유의 관계로 풀면 된다. a의 멤버로 b를 선언하여 표현.

const, friend, static 키워드

• const 객체

위와 같이 객체에 const 키워드를 선언하게 되면 이 객체를 대상으로는 const 멤버 함수만을 호출할 수 있다. 왜냐하면 const 키워드는 기본적으로 데이터 변경을 허용하지 않음을 의미하기 때문이다.

• 함수 오버로딩의 조건 : const

함수 오버로딩이 성립하기 위해서는 함수의 이름과 매개 변수 정보(자료형, 수) 등이 필요했는데 거기에 더해서 const 여부 또한 오버로딩의 조건이 될 수 있다.

• 클래스와 friend 선언

aBoy, bGirl이라는 두 클래스가 있을 때, aBoy 클래스가 bGirl 클래스를 friend 선언하게 되면 bGirl 클래스는 aBoy 클래스의 private 영역까지 직접 접근이 가능하다. 그러나 aBoy 클래스는 bGirl 클래스의 private 영역에 접근이 불가능하다 왜냐하면 aBoy 클래스 측에서만 bGirl 클래스를 friend로 인정했지만 bGirl 클래스는 aBoy 클래스를 friend로 인정하지 않았기 때문이다.

다음은 위의 상황을 나타내는 예제 코드이다.

전역 함수와 클래스 멤버 함수를 대상으로도 friend 선언이 가능하다. 함수를 friend 선언하게 되면 friend 선언된 함수들은 해당 클래스의 private 영역에 접근이 가능하다.

위의 예에서 특이한 점은 8번 라인처럼 B가 클래스 이름임을 선언해야 먼저 나오는 클래스 A에서 B가 무엇인지 식별을 할 수 있다. 그리고 friend로 선언된 함수들은 선언과 정의를 분리해줘야 하는 것 같다. (확인필요)

• static 키워드

C언어 에서의 static 키워드

c언어에서의 static 키워드는 다음과 같은 의미를 지님.

1.     전역 변수 필드에 선언되었을 때
-> 선언된 파일 내에서만 참조를 허용

2.     함수 내에 선언되었을 때 
-> 메모리의 데이터 영역에 딱 한 번 생성과 동시에 초기화 되어 저장되며, 함수 내에서 그대로 지역적인 성격을 가지고 있지만, 함수가 종료되어도 소멸되지 않는다. 

C++ 에서의 static 키워드

static 멤버 변수 ( = 클래스 변수 )

c++ 에서도 지니는 성질은 같다. static 멤버 변수로 활용을 하는데, 클래스 변수라고 한다.

위와 같이 5번 줄에서 클래스 내부에서 static 선언을 이용하여 생성한 변수를 클래스 변수 및 static 멤버 변수라고 하는데, 이는 일반 클래스의 멤버 변수와 같이 객체가 생성될 때마다 생성되는 것이 아니다.

해당 클래스의 객체가 생성되든지 안되든지 생성 여부와 상관없이 프로그램이 시작되면 메모리 공간에 독립적으로 딱 하나만 할당되어서 공유되는 변수이다! (생성과 소멸의 시기가 전역 변수와 동일!)

객체가 생성되지 않았을 때에도 메모리 공간에 할당되어 있다는 이야기는 static 멤버는 객체에 종속되어 있는 변수가 아니라 외부에 존재하는 변수라는 이야기다.

단, 클래스 내부에 선언하여 멤버처럼 사용할 수 있는 이유는 객체에게 멤버 변수처럼 접근할 수 있는 권한만 부여되었기 때문임.

private: / public : 영역으로 나뉘는 것은 static 멤버를 해당 객체 내애서만 쓸 것인지, 외부에서도 클래스 이름 및 객체 이름을 통해 접근 가능하게 할 것인지를 나타낸다.

10번 라인처럼 초기화 방법이 따로 존재하는데, C++에서는 자바처럼 클래스 내에서 초기화 하는 방식을 지원하지 않기 때문에 생성자 및 멤버함수를 통해서 초기화 시키는 방법이 있다. 그러나 이 생성자를 이용하여 초기화하는 방법을 사용할 경우, 객체가 생성되어 생성자가 실행될 때마다 static 멤버 변수가 초기화 되기 때문에 이 방법을 사용해서는 안 된다. 10번 라인과 같이 초기화를 시켜준다.

static 멤버 함수

static 멤버 함수 또한 static 멤버 변수와 같이 특성이 그대로 적용된다. 다만, 객체의 멤버로 존재하지 않기 때문에 다음과 같은 코드는 에러가 발생한다.

9번 줄에서 에러가 발생하는 이유는 static 멤버 함수는 실제로 객체의 멤버가 아니다. 소속 객체가 없기 때문에 9번 줄에서 지정된 number 는 어느 객체의 number 인지 알 수 있는 길이 없다. 그렇기 때문에 에러가 난다

-> 결국 static 멤버 함수 내에서는 static 멤버 변수, static 멤버 함수만 호출 가능하다.

c언어에서처럼 전역 변수를 이용한 카운팅 등을 static 멤버들을 활용하여 대체할 수 있다.

const static 멤버

const static 멤버는 static 멤버의 특성을 유지한 채 const 화 되어 값을 항상 일정하게 유지하기 때문에 다음과 같은 코드가 허용이 된다.

• mutable 키워드

mutable 키워드를 사용하여 멤버 변수에 선언하게 되면 const화된 함수 내에서 멤버에 대한 값의 변경을 예외적으로 허용하겠다 라는 의미를 지닌다!

다차원 배열

• 다차원 배열

2차원 이상의 배열을 의미한다. 논리적으로 1차원 배열을 1차원의 형태(선), 2차원 배열은 2차원의 형태(평면), 3차원 배열은 3차원의 형태(직육면체)를 띤다. 4차원 및 그 이상의 차원은 문법적으로 허용하고 있으나, 불필요하고, 이해하기도 어려운 형태의 배열이다.

아래와 같이 1차원, 2차원, 3차원 배열을 논리적으로 표현한다.

<길이가 10인 1차원 배열>

<행과 열의 길이가 각각 5인 2차원 배열>

<행과 열 그리고 높이의 길이가 각각 3인 3차원 배열>

• 2차원 배열

2차원 배열을 다음과 같이 선언한다.

Type 배열이름[행(세로길이)][열(가로길이)];

아래는 선언의 예와 구조를 나타냄.

<2행 4열인 2차원 정수형 배열 arr1>

<3행 5열인 2차원 정수형 배열 arr2>

이렇게 선언한 변수는 인덱스를 활용한 접근을 다음과 같이 접근한다.

배열 이름[원하는 행 인덱스][원하는 열 인덱스] = 값;
배열 이름[원하는 행 인덱스][원하는 열 인덱스]

그 이전에 인덱스에 대한 분포는 다음과 같이 이루어져 있다.

원하는 인덱스에 값을 대입 및 원하는 인덱스의 값을 출력하는 예이다.

2차원 배열의 메모리 상의 할당 형태

2차원 배열도 사실은 메모리 상에 1차원 배열의 형태로 존재한다. 메모리의 물리 구조적으로 1차원의 형태로 이루어져 있기 때문이다. 다음의 예는 2차원 배열의 메모리 상 할당된 형태를 보인다.

2차원 배열의 초기화

일반적으로 초기화 할 경우, 행 단위로 중괄호로 구분하고 각 행에 대해서 열 단위로 값을 채워 초기화 해준다. 단, 열에 대해서 초기화 값을 생략할 경우 0으로 자동 초기화가 이루어진다. 다음은 관련 예이다.

위와 같이 행과 열을 맞추어 초기화하는 것이 보통이지만,

위와 같이 열에 대해서 초기화 값을 생략할 경우 0으로 자동 초기화가 이루어진다. 두 예제는 같은 값으로 초기화가 이루어진다.

다음과 같이 1차원 배열 초기화 형태로 초기화가 이루어질 수 있다. 왜냐하면 2차원 배열은 사실 1차원 배열 구조로 메모리 상에 적재되기 때문이다. 중요한 것은 초기화될 때 명시된 초기화 값들은 메모리 상의 인덱스 순서대로 값이 대입된다.

배열의 크기를 알려주지 않고 초기화 값들을 통해서 자동으로 계산하여 초기화 하는 방법 또한 존재한다.

단, 위와 같이 행과 열 모두 생략할 경우 2x3인지, 3x2인지, 0을 생략한 경우까지 봐야 하는지 사람의 입장에서도 알 수 없기 때문에 행과 열 인덱스를 모두 생략할 수 없다. 2차원 배열에서 인덱스를 생략할 때는 행만 생략 가능하고, 열은 꼭 제시해야만 한다.

위 예제의 경우에는 행만 생략한 경우로 제시한 열을 토대로 행을 자동 계산하여 2x3 형태의 2차원 배열을 생성한다.

• 3차원 배열

3차원 배열은 여러 개의 2차원 배열이 모여 있는 형태로 이해 가능하며, 3차원은 논리적인 구조 상에서 3차원이고, 물리적인 메모리 상에서는 1차원의 형태로 할당되어 인덱스가 구성된다.