2016. 11. 30. 13:51

[C++] Swap 함수! Template를 이용해서 구현해보자!

프로그래밍/Language

안녕하세요. 게임개발자 놀이터입니다.


이번 포스팅에선 C++로 Swap 함수를 짜보려고합니다.


흔히 Swap 함수를 짠다고 하면 자료형 int에 한애 대부분 이렇게 짤것입니다.


1
2
3
4
5
6
void Swap(int *a, int *b)
{
    int temp = *b;
    *b = *a;
    *a = temp;
}
cs


int형에 한에 정말 간단하고 편한 방법이지요.


main에서는 다음과 같이 사용할것입니다.

1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
 
    int a =10;
    int b =50;
 
    cout<<"*** Swap 함수 실행 전 2개의 값 : "<<a<<" , "<<b<<" ***"<<endl;
    Swap(&a,&b);
    cout<<"*** Swap 함수 실행 후 2개의 값 : "<<a<<" , "<<b<<" ***"<<endl;
 
    return 0;
}
cs


실행 결과는 다음과 같겠죠??


하지만 여기서 Swap을 숨겨저 포인터 인자인지를 모른다면..??


한번쯤은 이렇게 쓰고 싶어질것입니다.


1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
 
    int a =10;
    int b =50;
 
    cout<<"*** Swap 함수 실행 전 2개의 값 : "<<a<<" , "<<b<<" ***"<<endl;
    Swap(a,b);
    cout<<"*** Swap 함수 실행 후 2개의 값 : "<<a<<" , "<<b<<" ***"<<endl;
 
    return 0;
}
cs


그럼 Swap 함수는 이렇게 고쳐야 할꺼애요.


1
2
3
4
5
6
void Swap(int &a, int &b)
{
    int temp = b;
    b = a;
    a = temp;
}
cs


어느게 더 좋아 보이나요??


뭐.. 사용자에 다를테니.. 자세한 의견댓글로 남겨주시면 감사하겠습니다..


하지만 위의 방식은 int자료형에 한정되어있다는점이 아쉽죠.


char는? float는?


그럼 그때마다 함수를 계속 새로 만들어야 할까요?


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void Swap(int &a, int &b)
{
    int temp = b;
    b = a;
    a = temp;
}
 
void Swap(float &a, float &b)
{
    float temp = b;
    b = a;
    a = temp;
}
 
void Swap(char &a, char &b)
{
    char temp = b;
    b = a;
    a = temp;
}

cs


이렇게 말이죠..? 너무 비효율적이죠. Swap이란 이름을 가진 함수는 뭐든간에 2개의 자리 또는 서로 교체 한다는 뜻일텐데 말이죠.


그래서 Template를 이용합니다.


1
2
3
4
5
6
7
template<typename T>
void Swap(T &a, T &b)
{
    T temp = b;
    b = a;
    a = temp;
}

cs


이러면 어떤가요? 이렇게 하면 어떤 자료형이라도 Swap이 가능합니다.


밑은 풀소스입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
 
using namespace std;
 
template<typename T>
void Swap(T &a, T &b)
{
    T temp = b;
    b = a;
    a = temp;
}
 
 
int main()
{
 
    int a =10;
    int b =50;
 
    cout<<"*** Swap 함수 실행 전 2개의 값 : "<<a<<" , "<<b<<" ***"<<endl;
    Swap(a,b);
    cout<<"*** Swap 함수 실행 후 2개의 값 : "<<a<<" , "<<b<<" ***"<<endl;
 
    return 0;
}
cs


감사합니다.


저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C#] C++에서 사용하는 typedef , C#에서 사용할 수 없을까?  (0) 2016.12.12
[C++] Inline 함수에 대하여!  (0) 2016.12.05
[C++] friend, 프렌드? 친구? 넌 무엇이냐.  (0) 2016.11.30
[C++] 출력시 소수점 자리 조절  (0) 2016.11.28
[C++] const에 대하여  (0) 2016.07.28
Posted by 시리시안
2016. 11. 30. 11:57

[C++] friend, 프렌드? 친구? 넌 무엇이냐.

프로그래밍/Language

안녕하세요. 게임개발자 놀이터 입니다.

오늘은 C++에서 자주 쓰이지 않는! (개인적인 기준입니다..! 전 지금까지 써본적이 없었어요) friend에 대해서 정리 해볼까 합니다.


먼저 friend의 뜻을 생각해볼까요? 제목에도 적어놨지만 [친구]라는 뜻을 가지고 있습니다. C++에서 friend를 선언하면 친구 관계가 되는 거랍니다.  클래스끼리 말이죠. 그것도 굉장히 [친한 친구]! 베스트프렌드! 라고 생각하시면 이해가 좀 쉬울꺼애요.


모두가 그런건 아니겠지만, 여기선 이렇게 생각해봅시다. 

'나는 내 친한친구에게 나의 모든걸 보여줘도 괜찮아.'

'내 친구에게는 숨기는게 없어'

라는 뜻으로 friend를 생각하면 됩니다.


즉, A클래스가 B클래스를 friend로 지정한다면 B클래스는 A클래스의 private 멤버나 함수까지 접근이 가능합니다.

여기서 B클래스도 A클래스를 friend로 지정한다면 서로간의 private멤버나 함수까지 접근이 가능합니다.

(물론 B클래스는 A클래스를 friend로 지정 안할수도있습니다. (일방적인 사랑) )


선언 방법은 클래스 내부에 friend 로 선언해주면 되는데 이때 위치는 private, protected, public 어디든 상관 없습니다.


1
2
3
4
5
6
7
8
9
10
11
12
class A
{
    // 어디든 상관 없다! 
private:
    friend B;
 
protected:
    friend B;
 
public:
    friend B;
}
cs


위 코드처럼 firend는 어디에 선언되든 상관없습니다. ( 위 코드에선 A클래스가 선언되기전 B클래스를 알고있다고 생각합시다.)


그럼 직접적인 사용 예를 한번 보겠습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<iostream>
 
using namespace std;
 
class B;
 
class A
{
 
private:
    int value;
public:
    A(int data)
    {
        value = data;
    }
    friend B;
};
 
class B
{
public:
    void fb(A a){
        cout<<"*** B클래스 public 함수 ***"<<endl;
        cout<<"*** A클래스 priavte int value에 접근 : "<<a.value<<" ***"<<endl;
    }
};
 
int main()
{
    A a(10);
 
    B b;
 
    b.fb(a);
 
    return 0;
}
cs


위 코드에서 25번째줄을 봅시다.

인자로 받아온 클래스 A의 value값에 접근하고있습니다.

value값은 private라 일반적으로는 절대 접근 할 수 없습니다.


하지만 friend가 이를 가능하게 만들어 줍니다.


실행 결과는 다음과 같습니다.


즉 friend로 선언 받은 이상 A클래스의 모든걸 접근할 수 있다는 것입니다.


이처럼 friend는 언뜻보면 아무런 이상 없고 정말 편해 보이지만, 이 friend는 객체지향의 핵심중 하나인 '정보 은닉'을 깨부수는 행위를 일으키게 됩니다.


어떤 클래스라도 private에 넣어둔 이유가 분명이 있을텐데, 이를 무시하고 접근해서 원한다면, 수정을 해버릴수도 있죠.


그래서 전 friend를 써본적이 없습니다..


이상으로 friend관련 글을 이만 마칩니다.


감사합니다.




저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] Inline 함수에 대하여!  (0) 2016.12.05
[C++] Swap 함수! Template를 이용해서 구현해보자!  (0) 2016.11.30
[C++] 출력시 소수점 자리 조절  (0) 2016.11.28
[C++] const에 대하여  (0) 2016.07.28
[C++] C++에서의 캐스팅(cast)  (0) 2016.07.27
Posted by 시리시안
2016. 11. 28. 17:45

[C++] 출력시 소수점 자리 조절

프로그래밍/Language

안녕하세요. 게임 개발자 놀이터입니다. 정말 오랜만에 포스팅하는데요..

갑자기 제가 float를 C++로 소수점을 출력할일이 생겼는데.. 순간.. 기억이..! 나질않아서..!!! 이렇게 정리하려고합니다.


앞으로도 이런 이슈가 생기면 대부분 정리해두려고합니다.


먼저 cout이 가지고있는 presision을 사용하면 됩니다.


먼저 일반적인 코드와 실행결과입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
 
using namespace std;
 
int main()
{
    float f = 3.141592f;
 
    cout<<f;
 
    return 0;
}


위의 코드를 실행하게 되면 출력결과는 다음과 같습니다.

꼭 직접 해보시기 바랍니다.



그럼 cout이 가지고있는 presision을 사용해보도록 하겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
 
using namespace std;
 
int main()
{
    cout.precision(7);
 
    float f = 3.141592f;
 
    cout<<f;
 
    return 0;
}
cs

위처럼 입력 하고 출력하면.


정상적으로 나오는걸 확인 하실수있습니다!



+ 숫자를 크게하면 소숫점은 다르수가 나오게 됩니다.


왜 그럴까요..?




저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] Swap 함수! Template를 이용해서 구현해보자!  (0) 2016.11.30
[C++] friend, 프렌드? 친구? 넌 무엇이냐.  (0) 2016.11.30
[C++] const에 대하여  (0) 2016.07.28
[C++] C++에서의 캐스팅(cast)  (0) 2016.07.27
[C++] Virtual 소멸자를 사용해야 하는 이유  (2) 2016.04.20
Posted by 시리시안
2016. 7. 28. 10:11

[C++] const에 대하여

프로그래밍/Language

const ( 상수 )


많이 들어봤으나, 사용하는 사람은 자주 사용하고, 사용하지 않는 사람들은 자주 사용하지 않을것입니다.


상수 (constant)는 값을 '절대로' 바꿀 수 없다. 라는 특징을 가지고 있습니다.

또한 정의시 무조껀 값을 지정해주어야 합니다.


const ( 자료 타입 ) ( 상수 명 ) = ( 상수 값 );


1
2
3
4
5
6
#include <iostream>
 
int main()
{
    const int c = 10; 
}
cs


이런식으로 말이죠.


하지만 const의 위치는 여러군데에 붙을 수 있답니다.


1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
 
int main()
{
    int a = 10;
    
    const int * c1 = &a;     
    int * const c2 = &a; 
 
 
}
cs


위와 같은 코드를 보시면, c1과 c2의 차이점을 아시겠나요?


간단하게 생각하면 어떤게 상수화가 되는지를 생각하면 됩니다.


c1의 경우 정수형 포인터가 됩니다. 즉 c1의 메모리 주소를 변경이 가능하지만, 메모리에 있는 값을 변경하지 못하게 합니다.


하지만 c2는 상수형 포인터가 됩니다. c2의 메모리주소는 상수화 되어서 변경이 불가능하지만, 메모리에 있는 값은 변경이 가능하게 됩니다.


즉 이런 대입이 가능합니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int main()
{
    int a = 10;
    
    const int * c1 = &a;     
    int * const c2 = &a; 
    
    int b = 20;
    
    c1 = &b;
    c2 = 100;
 
}
cs


이 의외에 대입을 하면 에러가 나니, 직접 해보시기 바랍니다.



Complite const 와 Runtime const


C++에서 const에는 2가지의 종류가 있습니다.


바로 컴파일 상수와 런타임 상수 입니다.


어떤 차이 냐면 아래 소스를 보시면 됩니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
 
int main()
{
    int m_1 = 10;
    int array01[m_1];  // error.
 
    const int m_2 = 10;
    int array02[m_2];  // ok..
 
    const int m_3 = s1;
    int array03[m_3];   // error.
}
cs


위 소스 에서 가운데 있는 array02를 제외하곤 전부 에러가 발생합니다.


이유가 뭘까요?


먼저 array01은 배열의 크기가 변수이기때문에 에러가납니다.


반대로 array02는 상수이기때문에 가능하지요. 하지만,


array03은 상수를 넣었는데 왜 에러가 날까요?


이는 array02에 쓰이는 m_2는 컴파일 상수이며, array03에 쓰이는 m_3는 런타임 상수이기 때문입니다.


실제로 코드를 보시면 m_3는 프로그램이 실행되어 배열 생성까지 도달할때 m_3에 대입되는 s1의 값을 모릅니다.


위 코드는 간단해서 생각만으로도 값을 알아낼 수 있지만, 좀더 복잡한 코드가 된다면 눈으로도 알아낼 수 없을것입니다.


이런 컴파일 상수와 런타임 상수과 확실하게 나눠진다면 정말 편할텐데 말이죠.


(PS. C++11에서는 이를 해결 할 수 있는 constexpr 이 있습니다. 참고하세요.)



const 위치에 따른 쓰임 변화


const는 정말 여러 위치에 놓일 수 있습니다.


변수 선언 시 : [const] 자료형타입 [ const ] 포인터 [const] 변수명

함수 선언 시 : [const] 자료형타입 [ const ] 포인터 [const] 함수명(매개변수...) [const { }


함수 변수를 생각하면 총 7군데나 되네요.. 많아라..


겹치는곳을 생각하면 총 4가지입니다. 걱정마시죠!


그럼 먼저 다시 짚고 가야할 부분이 있습니다.


const(상수화)가 되면 값 변경이 불가능하다.


그럼 이제 찾아야 할 점을 '어디서' 또는 '어떤게' 값 변경이 안되는가 입니다.



그럼 몸풀기로 생각을 해봅시다.


const int * * a;

int *const * a;

int * * const a;


이렇게 3개의 변수가 각각 다른 위치에 const를 달고 있습니다. 이 3개를 구분지어 볼까요?


먼저 '어디서', '어떤게' 영향을 받았나가 중요합니다.


그럼 제일 크게 const를 기반으로 자료형과 변수명을 나눌수있습니다.


(const int) * * a;

(int *const) * a;

(int **) const a;


위 처럼 나눠서 보면 더 쉬울까요?


첫번째 (const int) * * a; 은 상수화된 int의 이중포인터 라는 것입니다.

즉 해석하면 가능과같습니다.

const int x =10;

const int * y = &x;

이때 &x 가 const int ** 라고 형입니다.

즉, (const int) * * a; 에선 알맹이 값인 a가 상수처리 되는것이죠.


다시 말하면

a (값변경가능 = 주솟값)

*a (값 변경가능 = 주솟값)

**a (값 병경 불가능 , 상수)

입니다.


2번쨰 (int *const) * a; 은 int*이 가지고 있는 주솟값 즉 *를 상수화 시킨겁니다.


가리키는 방향을 상수화 한거죠.


간단하죠?


3번쨰는 (int **) const a;

int **형 자체가 상수화가 된겁니다.


즉 처음으로 가리키는 주솟값이 상수화가 된것이지요.


함수도 비슷합니다. 하지만 마지막으로 함수 맨뒤에 붙는 const는 함수 내부 내용을 상수화 하겠다는 뜻입니다. 즉, 함수 내부에서는 값을 변화시키는 행위를 일절 하지 못하게 막는다는 소리입니다.


감사합니다



저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] friend, 프렌드? 친구? 넌 무엇이냐.  (0) 2016.11.30
[C++] 출력시 소수점 자리 조절  (0) 2016.11.28
[C++] C++에서의 캐스팅(cast)  (0) 2016.07.27
[C++] Virtual 소멸자를 사용해야 하는 이유  (2) 2016.04.20
[C++]오버로딩(Overloading)과 오버라이딩(Overriding)의 예제와 설명  (0) 2016.04.14
Posted by 시리시안
2016. 7. 27. 12:49

[C++] C++에서의 캐스팅(cast)

프로그래밍/Language



C++ 캐스팅(cast)에는 총 4가지 종류가 있습니다.


바로


static_cast

reinterpret_cast

const_cast

dynamic_cast 

입니다.


각각 무슨 기능을 하는지 알아 보자면


 

 static_cast


명시적 형 변환을 위한 캐스트 연산자

 reinterpret_cast


무조건 적으로 변환한다.(강제 변환)  ( reinterpret 다시 해석하다, 새로 해석하다.) 메모리 단위로 분해하여 재조립합니다. 굉장히 위험한 방법입니다.

 const_cast

 

const 즉 상수성을 제거 할때 사용됩니다.

 dynamic_cast 

 

RTTI( Run Time Type Information )를 위한 캐스팅 입니다.


하지만, 굳이 귀찮게 위의 방법을 써야하는 이유가 뭘까요?


저희가 C언어 쓸때는 그냥 (Type) 으로 캐스팅 연산을 했었습니다.


다음과 같은 경우를 봅시다.


1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
 
int main()
{
 
    int m_4byte = 0;
    double* m_pointer = (double*)&n;
    *m_pointer = 1.23;
 
    return -1;
}
cs


무엇이 문제 인지 보이시나요?


위와 같은 방법을 사용하면 어떻게 될까요?


에러가 납니다.  직접 VS를 열어서 빌드해보세요.


그럼 다음 경우를 보겠습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
 
int main()
{
 
    
    const int c_int = 50;
    int * p_int = (int*)&c_int;
    *p_int = 100;
 
    cout << c_int << endl;
 
    cout << *p_int << endl;
 
    return -1;
}
cs

다음과 같이 코드를 작성 한 후 실행하면 어떤 결과가 나올까요?
---------------------------
50
100
---------------------------
이 나오게 됩니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
 
int main()
{
 
    
    int value = 50;
    const int c_int = value;
    int * p_int = (int*)&c_int;
    *p_int = 100;
 
    cout << c_int << endl;
 
    cout << *p_int << endl;
 
    return -1;
}
cs


하지만 다음과 같이 코드를 작성 한 후 실행 하게되면

-------------------------
100
100
-------------------------


이 나오게 됩니다.


이는 const의 값이 결정되는 시점에 따라 달라집니다만, 그건 나중에 const에 관련 글을 적을때 적도록 하겠습니다.


이 2개의 코드로 알아야 하는것은 C에서 지원하는 cast 방식은, 불안전 하다는 것입니다.


2개의 코드 다 에러를 나타내지 않습니다. 하지만 비정상적인 결과를 출력하죠.


과연 이게 올바른 걸까요?


그럼 static_cast로 변경을 해봅시다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int main()
{
    int value = 50;
    const int c_int = value;
    int * p_int = static_cast<int*>(&c_int);
    *p_int = 100;
 
    cout << c_int << endl;
 
    cout << *p_int << endl;
 
    return -1;
}

cs


컴파일러는 const 또는 다른 형식 한정자로 캐스팅 할수없습니다. 라며 에러를 띄우고 빌드를 하지 않습니다.

불안전 하기 때문이죠.


만약 const값을 변하게 하려는 의도가 있다면, const_cast를 사용해야 할것입니다.


그렇기에 안정하고 정상적인 캐스팅을 위하면 C++에서는 기본적으로 명시적캐스팅인 static_cast를 사용하도록 합시다.


다음은 reinterpret_cast 입니다.


reinterpret_cast는 제가 위에 이렇게 적어 놨을겁니다.


무조건 적으로 변환한다.(강제 변환)  ( reinterpret 다시 해석하다, 새로 해석하다.) 메모리 단위로 분해하여 재조립합니다. 굉장히 위험한 방법입니다.


여기서 중요하게 보셔야 할 부분은 '메모리' 단위 입니다.


메모리 단위란 무엇일까요?


그럼 이 코드를 자세히 봅시다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
class A {public : int a;};
class B {public : int b;};
 
class C : public A, public B
{
    int c;
};
 
int main()
{
    C c;
    return -1;
}
cs


위의 코드에서 class C는 class A와 B를 다중 상속 받은 상태입니다. 그리고 A와 B는 각각 4byte짜리의 int를 가지고 있죠.

그럼 C를 선언 하는 순간 메모리는 어떻게 잡힐까요?


Class C

 Class A

 int a;

 4 Byte

 Class B

 int b;

 4 Byte

 C클래스 멤버

 int c;

 4 Byte


다음과 같이 구조를 가질껍니다.


그럼 위와 같은 메모리 구조를 가졌을때 아래와 같이 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
class A {public : int a;};
class B {public : int b;};
 
class C : public A, public B
{
    int c;
};
 
int main()
{
    C c;
    A* p_a = &c;
 
    cout << &c << end;    
    cout << p_a << end;
 
    return -1;
}
cs


코드를 작성 한후 실행하면 2개의 결과 값은 똑같이 나올겁니다.


하지만 이 코드를 어떨까요?



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
class A {public : int a;};
class B {public : int b;};
 
class C : public A, public B
{
    int c;
};
 
int main()
{
    C c;
    B* p_b = &c;
 
    cout << &c << end;    
    cout << p_b << end;
 
    return -1;
}
cs


C클래스가 부모인 B클래스로 암시적 캐스팅이 된 형태 입니다.


실행 하면 결과는


------------------------------------

&c의 주소값

&c의 주소값 + 4byte 

------------------------------------


암시적 변환으로 메모리의 주소값이 바뀌었습니다.


물론 자식 -> 부모 변환이라 static_cast를 사용하셔도 됩니다.


하지만 reinterpret_cast를 사용하면 어떻게 될까요?


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
class A {public : int a;};
class B {public : int b;};
 
class C : public A, public B
{
    int c;
};
 
int main()
{
    C c;
    B* p_b = reinterpret_cast<B*>(&c);
 
    cout << &c << end;    
    cout << p_b << end;
 
    return -1;
}
cs

놀랍게도 2개의 출력값이 같은 주솟값을 가지게 됩니다.


메모리 단위로 분해해서 재 생성 하기 때문이죠.


이와 같은 방법을 전 아직 어디서 잘 사용해야 할지 모르겠습니다. ( 나중에 알게되면 꼭 수정하겠습니다. ) 


하지만 저기서 p_b가 가진 멤버변수인 b를 수정하게 되면 A클래스가 가진 a가 수정이 된답니다.




Class C

 Class A

 int a;

 4 Byte

 Class B

 int b;

 4 Byte

 C클래스 멤버

 int c;

 4 Byte


위와 같은 구조가 

Class C

 Class B

 int b;

 4 Byte

 Class C

 int c;

 4 Byte


 ( )

 (4 Byte )


이렇게 조립 되었을뿐 메모리 주소를 변하지 않았기 때문이죠.


전 처음 이 사실을 알았을때는 정말 신기했습니다.  잘만 사용하면 메모리 단위로 잘 쪼개서 사용 할 수 있기 때문이죠.



마지막으로 dynamic_cast입니다.


dynamic_cast는 RTTI(Runtime Type Information)를 위한 캐스팅이라고 제가 위에 적었는데요.


런타임에 상속 계츨 관계를 가로지르거나 다운 캐스팅시 사용되는 캐스팅 연산자 라고 생각하시면 편합니다.


즉, 부모가 자식으로 캐스팅이 될 수 없는데, 런타임중 판단으로 가능하게 된다는거죠.


단 dynamic_cast는 다형성을 띄지 않은 객체간의 변환은 불가능하며, 컴파일이 에러를 낸답니다.


즉 다형성을 가지려면 클래스간 virtual 멤버 함수가 있어야 합니다.


코드로 표현하면 다음과 같습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;
 
class A {
public: 
    int a; 
 
    virtual void test(){}
};
 
class C : public A
{
    int c;
    virtual void test(){}
};
int main()
{
    C c;
    A* pA = &c; 
    C* c2 = dynamic_cast<C*>(pA);
    
    return -1;
}
cs


하지만 저 dynamic_cast가 올바르지 않았을경우는 null값을 반환하니 주의 하시기 바랍니다.


읽어주셔서 감사합니다

저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] 출력시 소수점 자리 조절  (0) 2016.11.28
[C++] const에 대하여  (0) 2016.07.28
[C++] Virtual 소멸자를 사용해야 하는 이유  (2) 2016.04.20
[C++]오버로딩(Overloading)과 오버라이딩(Overriding)의 예제와 설명  (0) 2016.04.14
[C++] 인터페이스(Interface) 예제  (0) 2016.04.14
Posted by 시리시안
2016. 7. 27. 10:16

코드 이쁘게 올리는 방법

프로그래밍/기타

안녕하세요. 게임개발자놀이터 입니다.


오늘은 코드를 이쁘게 올리는 방법에 대해서 알려드리려고합니다.


제 블로그의 글들은 다 이 방법을 사용하고 있습니다.


http://colorscripter.com/


위 주소로 들어가시게 되면



다음과 같은 창이 뜨는데, 위에 언어 : 자동(text) 로 되어있는 부분을 자신에게 알맞은 내용으로 변경합니다.


그후 글 작성후 하단의 클립보드에 복사를 누른후 붙여넣으시면 됩니다.


참 간단하죠?




클립 보드에 복사를 누르신후..


1
2
3
4
5
6
7
8
9
10
11
//이렇게 작성하시고
//붙여 넣으면 됩니다
 
 
#include<stdio.h>
 
int main()
{
 
    return -1;
}
cs

붙여 넣으시면 위와 같이 나오게 됩니다.



감사합니다

저작자표시 비영리 변경금지

'프로그래밍 > 기타' 카테고리의 다른 글

아컴호러 PC게임 제작기 -2-  (0) 2017.04.01
아컴호러 PC게임 제작기 - 1 -  (0) 2017.04.01
로컬라이징을 위한 엑셀로 XML만들기.  (0) 2016.03.03
망하는 제품의 흔한 개발 과정  (0) 2016.02.23
안드로이드 스튜디오 사용시 참고할만한 라이브러리 모음  (0) 2016.02.22
Posted by 시리시안
2016. 4. 20. 13:23

[C++] Virtual 소멸자를 사용해야 하는 이유

프로그래밍/Language


저희가 상속을 사용하여 클래스를 구성할때 최상위 부모 소멸자에는 꼭 Virtual을 넣어 주어야 합니다.

그 이유가 뭘까요?

이유를 알기위해선 상속을 받은 클래스의 생성과 소멸의 순서를 알아야합니다.

생성을 할경우 부모클래스의 생성자부터 호출되며 차례로 자식의 생성자를 호출하게 됩니다.

반대로 소멸자는 자식클래스의 소멸자를 먼저 호출하고 부모클래스의 소멸자가 호출됩니다.

이렇게 생각하면 아무런 문제없습니다. 

단, 우리가 비교적 자주 상속을 사용하여 선언할경우 부모클래스의 포인터로 자식클래스를 정의하여 사용하게 될것입니다.

이경우, 부모클래스로부터 자식 클래스를 호출할때 가상 함수로 정의되지 않은 자식 클래스의 오버라이딩된 함수를 호출하면 주체가 선언된 인자형이 부모이기 때문에 부모클래스의 멤버함수가 호출됩니다.

이렇게 생각했을때 소멸자 또한 오버라이딩된 멤버함수라 볼 수 있기 때문에, 만약에 부모 포인터로 객체를 삭제하면 부모클래스의 소멸자가 호출되며 정의된 자식의 나머지 공간의 메모리 만큼 누수되어 버립니다.

따라서 소멸자를 가상 함수로 선언하지 않으면 자식클래스의 소멸자가 결코 호출되지 않습니다. 

virtual을 사용하였다면 이것은 자식클래스에서 재정의 될 수 있음을 명시 하기 때문에 포인터의 종류와 상관없이 자식 클래스의 멤버함수가 호출되게 답니다. 즉, 자식 클래스의 소멸자가 호출되고 부모 클래스의 소멸자가 호출되게 됩니다.

따라서 상속관계를 이용하였고 소멸자에서 리소스를 해제해야 한다면 반드시 소멸자를 가상함수로 선언해주어야 합니다.

예제 코드
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
using namespace std;
 
class classA
{
    public:
      classA(){  cout << "A 생성" << endl;}
       virtual ~classA(){  cout << "~A 소멸" << endl;}
};
 
class classB : public classA
{
    public:
      classB(){cout << "B 생성"<< endl;}
      ~classB(){cout << "~B 소멸" << endl;}
};
 
 
int main()
{
  cout << "== 소멸자 테스트 시작 ==" << endl;
  classB *B = new classB;
  classA *A = B;
  delete A;
  return 0;
}
cs



실행 결과는 다음과 같습니다


ClassA에서 소멸자에 virtual을 사용하지 않았을 경우

===================================================================

START

A

B

~A

===================================================================


ClassA에서 소멸자에 virtual을 사용했을 경우

===================================================================

START

A

B

~B

~A

===================================================================


저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] const에 대하여  (0) 2016.07.28
[C++] C++에서의 캐스팅(cast)  (0) 2016.07.27
[C++]오버로딩(Overloading)과 오버라이딩(Overriding)의 예제와 설명  (0) 2016.04.14
[C++] 인터페이스(Interface) 예제  (0) 2016.04.14
[C#/C++] 인터페이스(Interface)의 정의 및 사용법  (0) 2016.04.14
Posted by 시리시안
2016. 4. 14. 11:09

[C++]오버로딩(Overloading)과 오버라이딩(Overriding)의 예제와 설명

프로그래밍/Language

오버라이딩(Overriding)


※ 오버라이딩은 함수의 재정의를 말합니다.

※ 상속받은 자식 클래스에서 부모 클래스의 멤버 함수를 재정의 하는것을 말합니다.


오버로딩(Overloading)


※ 오버로딩은 함수의 중복 선언을 말합니다.

※ 같은 함수에서 인수만 다르면 얼마든지 정의할 수 있습니다.



===============================================

오버라이딩의 예


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
class _Parent{
public:
    void Something()
    {
        cout << "_Parent Shomthing Function" << endl;
    }
};
 
//자식클래스01
class _Children:public pitching
{
};
 
//자식클래스02
class _OtherChildren:public pitching
{
public:
    //함수 재정의(오버라이딩)
    void Something()
    {
        cout << "_OtherChildren Shomthing Function" << endl;
    }
};
 
void main()
{
    //_Children 객체생성 후 함수호출
    _Children *Children = NULL;
    Children->Something();
 
    //_OtherChildren 객체 생성 후 함수호출
    _OtherChildren *OtherChildren=NULL;
    OtherChildren->Something();
}
 
cs


위 함수의 결과가 어떻게 나올까요?


결과는

-----------------------------------------------

_Parent Shomthing Function

_OtherChildren Shomthing Function

-----------------------------------------------


이렇게 나온답니다.

이유는 Children객체는 상속받은 부모의 함수를 실행하지만, OtherChildren은 클래스내에서 재 정의한 함수를 호출하기 때문입니다.


이처럼 부모와 똑같은 함수명, 파라미터를 가지고 자식클래스에서 새롭게 정의하여 사용하는것을 오버라이딩이라고합니다.


===============================================


오버 로딩의 예


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
class Overload{
    public void Something()
    {
        cout << "Shomthing() Function" << endl;
    }
    public void Something(int _cnt,int _cnt)
    {
        cout << "Shomthing(int _cnt,int _cnt) Function" << endl;
    }
    public void Something(double _num)
    {
        cout << "Shomthing(double _num) Function" << endl;
    }
}
 
void main() {
        Overload ob = new Over();
        ob.Something(1,2);
        ob.Something(3);
}
cs


출력결과는

-----------------------------------------------

Shomthing() Function

Shomthing(int _cnt,int _cnt) Function

Shomthing(double _num) Function

-----------------------------------------------


입니다.

이유는 함수의 인자가 다르기 때문입니다. 각각의 맞는 인자로 알아서 호출된답니다.

이처럼 같은 함수내에서 인자로 구분되어 정의하는것을 오버로딩 이라고 합니다.



저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] C++에서의 캐스팅(cast)  (0) 2016.07.27
[C++] Virtual 소멸자를 사용해야 하는 이유  (2) 2016.04.20
[C++] 인터페이스(Interface) 예제  (0) 2016.04.14
[C#/C++] 인터페이스(Interface)의 정의 및 사용법  (0) 2016.04.14
파일 입출력에 대하여  (0) 2016.02.25
Posted by 시리시안
2016. 4. 14. 10:46

[C++] 인터페이스(Interface) 예제

프로그래밍/Language
밑의 코드처럼 선언하시면 됩니다.
상속받아 사용할 때는 소멸자를 꼭 포함 시켜야 한다는점을 잊지마세요~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "stdafx.h"
#include <iostream>
 
class _IRef{
public:
    virtual ~_IRef(){}
    virtual void _Update() = 0;
};
 
class Node : public _IRef{
public:
    ~Node(){}
    void _Update(){ std::cout << "Node Update" << std::endl; }
};
 
class user{
public:
    void Something(_IRef* Ir){ Ir->_Update(); }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
    Node* c = new Node;
    user u;
    u.Something(c);
 
    return 0;
}
 
 
 
cs



저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++] Virtual 소멸자를 사용해야 하는 이유  (2) 2016.04.20
[C++]오버로딩(Overloading)과 오버라이딩(Overriding)의 예제와 설명  (0) 2016.04.14
[C#/C++] 인터페이스(Interface)의 정의 및 사용법  (0) 2016.04.14
파일 입출력에 대하여  (0) 2016.02.25
구조체에 대하여  (0) 2016.02.25
Posted by 시리시안
2016. 4. 14. 10:39

[C#/C++] 인터페이스(Interface)의 정의 및 사용법

프로그래밍/Language

인터페이스(Interface)란 컴퓨터 용어에서 많이 등장합니다.

대표적으로 User Interface 입니다. 줄여서 UI라고 자주 부릅니다.

Interface를 어원을 찾아보면 Inter(중간) + face(맞대고 있다)입니다. 즉, 어느 중간 사이에서 맞대고 있는 부분을 의미를 가집니다.

User Interface, UI란 사용자 그러니까 플레이어와 컴퓨터 '중간' 사이에서 '맞대고 있어' 일어나는 상호작용을 매개하는 것을 말합니다.


지금부터 설명할 객체 지향 언어에서도 인터페이스란 객체와 객체 '중간' 사이에서 '맞대고 있어' 일어나는 사이에서 상호 작용의 매개로 쓰인답니다.


Java에서는 Interface라는 키워드를 통해서 Interface를 바로 생성할 수 있습니다.

interface로 할 수 있는 일이 무엇이냐 하면 클래스의 기본적인 틀을 제공하면서 다른 객체 사이에서의 '중간' 매개 역할도 담당한다는 것입니다.

그럼 자바를 이용해서 직접 인터페이스를 선언해 봅시다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public interface Book{    //여기서 I는 인터페이스의 i입니다.
    private String _author;    //작가
    private String _title;    //제목
    private String _text;    //본문
    public void Show_Information(){
    }
}
public class Cartoon implements Book{
    //_author와 _title, _text에 접근 할 수 있음
    public void Show_Information(){
        // 꼭 구현해야함
    }
}
public class Novel implements Book{
    //_author와 _title, _text에 접근 할 수 있음
    public void Show_Information(){
        // 꼭 구현해야함
    }
}
cs


이처럼 인터페이스 선언하고 클래스를 선언할 수 있습니다.

이경우는 즉 Book 클래스가 인터페이스 클래스가 된것입니다.

즉 다음과 같이 사용 할 수 있습니다.


1
2
3
4
5
6
7
void main(){
    Book mCartoon = new Cartoon();
    mCartoon.Show_Information();//만화책 정보
    Book mNovel = new Novel();
    mNovel.Show_Information();//소설책 정보
}
 
cs


즉, 이렇게 Book이라는 클래스 하나로, Cartoon과 Novel을 선언하여 공통된 함수를 불러서 관리 할수있습니다.

손쉽게 표현하면 위처럼 사용하는게 아니라,


1
2
3
4
5
6
7
8
9
 
 
void main(){
    Book[] mBooks = new Book[2];
    mBooks[0] = new Cartoon();
    mBooks[1] = new Novel();
    for(int i=0; i<2; ++i)
        mBooks[i].Show_Information();//책정보 
}
cs


이처럼 한가지의 클래스로 묶어서 사용할 수 있습니다.


사용 용도 및 방법은 무궁무진합니다.


게임에서 적이 가진 모든 총알을 _IBullet 이라 선언하고 관리해도 되고, 모든 오브젝트를 _IObject 라고 하여 관리해도됩니다.

이 모든걸 다합쳐서 _IRef 로 인터페이스 선언하여 관리하면 정말 간단하겠죠?



C++에서 선언법은 다음과 같습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "stdafx.h"
#include <iostream>
 
class _IRef{
public:
    virtual ~_IRef(){}
    virtual void _Update() = 0;
};
 
class Node : public _IRef{
public:
    ~Node(){}
    void _Update(){ std::cout << "Node Update" << std::endl; }
};
 
class user{
public:
    void Something(_IRef* Ir){ Ir->_Update(); }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
    Node* c = new Node;
    user u;
    u.Something(c);
 
    return 0;
}
 
 
 
cs






저작자표시 비영리 변경금지

'프로그래밍 > Language' 카테고리의 다른 글

[C++]오버로딩(Overloading)과 오버라이딩(Overriding)의 예제와 설명  (0) 2016.04.14
[C++] 인터페이스(Interface) 예제  (0) 2016.04.14
파일 입출력에 대하여  (0) 2016.02.25
구조체에 대하여  (0) 2016.02.25
try, throw, catch 를 이용한 예외 처리 방법  (0) 2016.02.23
Posted by 시리시안

티스토리툴바