struct ST_OBB // OBB구조체
{
     D3DXVECTOR3 vCenterPos; // 상자 중앙의 좌표
     D3DXVECTOR3 vAxisDir[3]; //상자에 평행한 세 축의 단위벡터
     float  fAxisLen[3]; // 상자의 평행한 세 축의 길이 fAxisLen[n]은 vAxisDir[n]에 각각 대응한다.
};

 // ST_OBB 구조체 두개의 포인터를 각각 인자로 받아, 두 OBB의 충돌 여부를 체크하는 함수

// 충돌 시 TRUE리턴, 충돌하지 않으면 FALSE 리턴

BOOL CheckOBBCollision( ST_OBB* Box1, ST_OBB* Box2 )
{
     double c[3][3];
     double absC[3][3];
     double d[3];

     double r0, r1, r;
     int i;

     const double cutoff = 0.999999;
     bool existsParallelPair = false;

     D3DXVECTOR3 diff = Box1->vCenterPos - Box2->vCenterPos;

     for( i = 0 ; i < 3 ; ++i )
     {
          c[0][i] = D3DXVec3Dot( &Box1->vAxisDir[0], &Box2->vAxisDir[i] );
          absC[0][i] = abs( c[0][i] );
          if( absC[0][i] > cutoff )
               existsParallelPair = true;
     }
     d[0] = D3DXVec3Dot( &diff, &Box1->vAxisDir[0] );
     r = abs( d[0] );
     r0 = Box1->fAxisLen[0];
     r1 = Box2->fAxisLen[0] * absC[0][0] + Box2->fAxisLen[1] * absC[0][1] + Box2->fAxisLen[2] * absC[0][2];

     if( r > r0 + r1 )
          return FALSE;

     for( i = 0 ; i < 3 ; ++i )
     {
          c[1][i] = D3DXVec3Dot( &Box1->vAxisDir[1], &Box2->vAxisDir[i] );
          absC[1][i] = abs( c[1][i] );
          if( absC[1][i] > cutoff )
               existsParallelPair = true;
     }
     d[1] = D3DXVec3Dot( &diff, &Box1->vAxisDir[1] );
     r = abs( d[1] );
     r0 = Box1->fAxisLen[1];
     r1 = Box2->fAxisLen[0] * absC[1][0] + Box2->fAxisLen[1] * absC[1][1] + Box2->fAxisLen[2] * absC[1][2];

     if( r > r0 + r1 )
          return FALSE;

     for( i = 0 ; i < 3 ; ++i )
     {
          c[2][i] = D3DXVec3Dot( &Box1->vAxisDir[2], &Box2->vAxisDir[i] );
          absC[2][i] = abs( c[2][i] );
          if( absC[2][i] > cutoff )
               existsParallelPair = true;
     }
     d[2] = D3DXVec3Dot( &diff, &Box1->vAxisDir[2] );
     r = abs( d[2] );
     r0 = Box1->fAxisLen[2];
     r1 = Box2->fAxisLen[0] * absC[2][0] + Box2->fAxisLen[1] * absC[2][1] + Box2->fAxisLen[2] * absC[2][2];

     if( r > r0 + r1 )
          return FALSE;

     r = abs( D3DXVec3Dot( &diff, &Box2->vAxisDir[0] ) );
     r0 = Box1->fAxisLen[0] * absC[0][0] + Box1->fAxisLen[1] * absC[1][0] + Box1->fAxisLen[2] * absC[2][0];
     r1 = Box2->fAxisLen[0];

     if( r > r0 + r1 )
          return FALSE;

     r = abs( D3DXVec3Dot( &diff, &Box2->vAxisDir[1] ) );
     r0 = Box1->fAxisLen[0] * absC[0][1] + Box1->fAxisLen[1] * absC[1][1] + Box1->fAxisLen[2] * absC[2][1];
     r1 = Box2->fAxisLen[1];

     if( r > r0 + r1 )
          return FALSE;

     r = abs( D3DXVec3Dot( &diff, &Box2->vAxisDir[2] ) );
     r0 = Box1->fAxisLen[0] * absC[0][2] + Box1->fAxisLen[1] * absC[1][2] + Box1->fAxisLen[2] * absC[2][2];
     r1 = Box2->fAxisLen[2];

     if( r > r0 + r1 )
          return FALSE;

     if( existsParallelPair == true )
          return TRUE;

     r = abs( d[2]*c[1][0] - d[1]*c[2][0] );
     r0 = Box1->fAxisLen[1] * absC[2][0] + Box1->fAxisLen[2] * absC[1][0];
     r1 = Box2->fAxisLen[1] * absC[0][2] + Box2->fAxisLen[2] * absC[0][1];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[2]*c[1][1] - d[1]*c[2][1] );
     r0 = Box1->fAxisLen[1] * absC[2][1] + Box1->fAxisLen[2] * absC[1][1];
     r1 = Box2->fAxisLen[0] * absC[0][2] + Box2->fAxisLen[2] * absC[0][0];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[2]*c[1][2] - d[1]*c[2][2] );
     r0 = Box1->fAxisLen[1] * absC[2][2] + Box1->fAxisLen[2] * absC[1][2];
     r1 = Box2->fAxisLen[0] * absC[0][1] + Box2->fAxisLen[1] * absC[0][0];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[0]*c[2][0] - d[2]*c[0][0] );
     r0 = Box1->fAxisLen[0] * absC[2][0] + Box1->fAxisLen[2] * absC[0][0];
     r1 = Box2->fAxisLen[1] * absC[1][2] + Box2->fAxisLen[2] * absC[1][1];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[0]*c[2][1] - d[2]*c[0][1] );
     r0 = Box1->fAxisLen[0] * absC[2][1] + Box1->fAxisLen[2] * absC[0][1];
     r1 = Box2->fAxisLen[0] * absC[1][2] + Box2->fAxisLen[2] * absC[1][0];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[0]*c[2][2] - d[2]*c[0][2] );
     r0 = Box1->fAxisLen[0] * absC[2][2] + Box1->fAxisLen[2] * absC[0][2];
     r1 = Box2->fAxisLen[0] * absC[1][1] + Box2->fAxisLen[1] * absC[1][0];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[1]*c[0][0] - d[0]*c[1][0] );
     r0 = Box1->fAxisLen[0] * absC[1][0] + Box1->fAxisLen[1] * absC[0][0];
     r1 = Box2->fAxisLen[1] * absC[2][2] + Box2->fAxisLen[2] * absC[2][1];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[1]*c[0][1] - d[0]*c[1][1] );
     r0 = Box1->fAxisLen[0] * absC[1][1] + Box1->fAxisLen[1] * absC[0][1];
     r1 = Box2->fAxisLen[0] * absC[2][2] + Box2->fAxisLen[2] * absC[2][0];
     if( r > r0 + r1 )
          return FALSE;

     r = abs( d[1]*c[0][2] - d[0]*c[1][2] );
     r0 = Box1->fAxisLen[0] * absC[1][2] + Box1->fAxisLen[1] * absC[0][2];
     r1 = Box2->fAxisLen[0] * absC[2][1] + Box2->fAxisLen[1] * absC[2][0];
     if( r > r0 + r1 )
          return FALSE;

     return TRUE;
}

간편성

일단 간편성이란, XML의 단순한 문법과 형식을 뜻합니다. Tagging과 tree구조라는 것만 잘 알면 XML구조의 전부를 이해했다고도 할 수 있지요. 그리고 XML파일은 텍스트 형식이기 때문에 컴파일도 필요하지 않은 아주 간편한 언어입니다.

호환성

유니코드로 작성되는 텍스트 형식이기 때문에, XML문서는 호환성도 매우 좋습니다. XML문서는 유니코드를 인식하는 모든 운영 체제 상에서 호환성 있는 문서가 됩니다.

확장성

확장성은 HTML언어와 비교하면 쉽게 이해하실 수 있습니다. HTML의 경우 정해져 있는 tag외의 다른 tag를 우리가 정의할 수 없습니다. 하지만 XML은 메타 언어이기 때문에 얼마든지 새로운 tag를 정의해서 사용할 수 있지요. 이것이 XML의 확장성입니다.

누구나 알 수 있는 Context 정보

XML문서는 data와 meta-data가 tag형식으로 동시에 저장됩니다. 따라서 누구나 쉽게 data와 meta-data를 구분할 수 있고, 따라서 쉽게 이해할 수 있는 구조를 가지고 있지요.

내용과 표현의 분리

또한 XML 문서 자체는 데이터의 표현을 어떤 식으로 할지 컨트롤 하지 않습니다. XML 문서가 다루는 것은 오직 데이터내용의 구조화이지요. 우리는 XSL같은 또 다른 언어를 사용하여 XML문서의 data를 표현하게 됩니다. 즉, data의 내용과 표현이 완전히 분리되어 있기 때문에 우리는 data를 좀더 쉽게 다룰 수 있게 됩니다.

데이터의 비교와 연산이 간편

Tree구조인 XML 문서는 데이터 검색 시에 비교, 연산 과정이 간단하기 때문에 원하는 결과를 더욱 빨리 얻게 할 수 있습니다.

네, 하지만 아직도 그리 와 닫지는 않을 겁니다. 왜냐하면 여러분이 실제로 XML을 많이 써보지 않았기 때문이죠. 그럼 한번 고수들의 경험담을 들어볼까요? 사실 저도 XML을 거의 써보지 않았기 때문에 인터넷에서 몇 가지를 퍼왔습니다.

단점

관리는 편해도
직접열어서볼때 난해한것도 있지
구조가 플밍에 맞춰져있어서
트리형태로 저장되니
직접 에디팅하기엔 좀 무리지
데이터 + 구조 = xml
덕분에 용량커지고 내부 텍스트 복잡도가 올라가서 데이터량이 많아지면 사람이 직접보기엔 힘듬

용량이 크다.

class AA 
{
public:
 virtual void Jaeho() = 0;  순수가상 함수
};

class A : public AA
{
public:
 virtual void Jaeho()  가상함수
 {
  printf ("나는 재호야\n");
 }
};

class B : public AA
{
public:
 virtual void Jaeho()
 {
  printf ("나는 진호야\n");
 }
};

int main()
{
 AA* jaeho = new A();
 AA* jinho = new B();
 AA* jjj = new B();

 jaeho->Jaeho();
 jinho->Jaeho();
 jjj->Jaeho();
 return 0;
}

순수 가상함수는 상속 받은 자식들이 꼭 정의해서 써먹어야 할때 써먹음 인터페이스같이 사용

가상함수는 오버라이드개념 자기에 맡게 내용 정의하면 됨

사용 예 )

액션일 경우

기본 baseaction이라는 클래스를 만들어

onStart() =0

onEnd()=0

onUpdate()=0

이런식으로 액션의 시작 끝 업데이트 순수 가상 함수를 만들어 놓은다

그다음 죽는액션 이동액션 공격액션등 baseaction을 상속 받아

onstart등 액션마다 다른 행동 할것을 코딩하면 된다.

# 일자: 2009-12-05 일곱째날

# 강좌: C# Programing

# 주제: 상속 기법(Overload, Override, Interface)

<Lecture>

1. OOP 구조

   객체1 - 객체2 - 객체3

   ☞ 각 객체는 구별, 존재, 고유역할 

2. OOP 작성순서

   0) 클래스(분류,구분) 작성

   1) 객체 형성

   2) 객체간 상호작용 시킴

3. OOP을 위한 선수학습

   1) 클래스 작성법

       (1) 기본적

   6) Interface ☞ 부모가 어떤 행동을 할지 몽땅 구체적으론 몰르는 것만 있는 경우

      (1) 의미

           ① interface

map 이 뭐길래 그럴까? perl에서 hash 배열인가? 하는것 아는 사람이 있을지 모르겠지만..

배열의 첨자가 숫자가 아닌 키워드로 인식하는것이다. 숫자가 들어가더라도 그것이 크기와는

상관없고 단지 키값만 되는것이다.

즉 키워드와 키워드가 매칭시킬수 있다는것이 map의 큰 장점이다.

map<string, info> data; 라고 선언을 한다면

data["seeper"]; data["abcd"]; 라는 표현이가능해진다.

map<int, info> data; 라고 선언을 한다면

data[3]; data[5]; ,등의 표현도 가능해진다.

여기서 data[4]를 선언하기전까지 data[4]는 존재하지 않는다.

물론 iterator를 이용해서 전체를 찾아볼수도 있다.

또한 key를 찾는 key를 만들어서 두가지의 인덱스로 데이터를 찾게 할수도 있을것이다.

활용범위는 config값이나 resource manager 등에서 쓸수 있다.

서버쪽에서는 아마도 로그인정보를 이렇게 관리하는것도 괜찮을것 같다.

(이 경우는 좀더 고민하긴 해야한다. 동접이 몇명이냐에 따라 또 달라질것이다.)

머리만 잘쓰면 map의 활용범위는 많을것 같다. ^^

그리고 STL은 포인터의 구조보다 일반적인 스트럭쳐나 단일 타입을 위해서

설계되었다. 물론 포인터를 사용할수 있지만 new와 delete는 개발자의 몫이된다.

따라서 메모리 누수가 일어날 확률이 높다.

특별한 경우가 아니고는 포인터를 사용하지 않는 것이 좋다.

프로그램 실행 중에 일어나는 에러를 말한다.

예를 들어서 동적할당 된 오브젝트가 있는데 프로그램 돌아가는 도중

그 오브젝트의 함수를 실행하게 되는데 그 때 그 오브젝트가 비어 있으면

에러가 발생하게 된다. 이런 상황이 런타임 에러이다

http://blog.naver.com/0bloodwind0/20127908176

여기에 설명 잘되어 있음!!!

출처 : http://blog.naver.com/anjindago?Redirect=Log&logNo=150119261447

빅오 표기법이란?

어떤 하나의 함수의 복잡도를 정의하는 데 즐겨 사용하는 것.
간단히 말하자면 알고리즘이 처리할 자료집합의 크기가 성장함에 따라 알고리즘의 효율이
어떻게 변화하는지를 대략적이나마 추정하는 하나의 함수라고 정의 할 수 있다.


알고리즘의 복잡도를 표현하는 데 흔히 쓰이는 함수들이 몇 가지 있는데,
복잡도의 낮은 것부터 높은 순으로 나열해보자면
(상수), (log₂n), (n), (nlog₂n), n², n³, 2ⁿ 이라고 한다.


O(c)
빅 O 표기에서 c는 상수를 뜻한다.
상수 함수의 그래프는 항상 수평을 유지한다. 이는 알고리즘의 수행에 걸리는 시간이 자료집합의 크기에
상관없이 항상 동일하다는 뜻이다. 대체로 이런 함수들이 가장 빠른 것으로 간주된다.


O(log₂n)
로그 기반의 알고리즘은 자료의 크기에 의존적인 알고리즘들 중에서는 가장 효율적인 것으로 간주된다.
즉, 데이터가 추가되면 될수록 효율이 좋아지는 녀석이다.


O(n)
선형 함수라 불리며, 어떠한 알고리즘이 1000개의 항목을 20초안에 처리한다면, 2000개의 항목은
40초에 처리하게되는 자료의 크기와 직접적인 관계를 갖는 함수이다.


O(nlog₂n)
이 함수는 일반적인 정렬 알고리즘이 가져야 할 최소한의 복잡도로 간주된다.


O(n²)
자료가 증가함에 따라 급격히 커지기 때문에 대부분의 과제들에 비해 비효율적이라고 간주된다.
예를들어 1000개의 항목을 처리하는데 20초가 걸렸다면 2000개의 항목을 처리하기위해선 80초의
시간이 소요된다. 항목의 갯수가 2배증가하면 시간은 4배가 증가하는 셈이다.
일반적으로 어떤 알고리즘이 O(n²)이라면 일단 다른 알고리즘을 찾아보는 것이 더 낫다. (최대한 쓰지말자)
전형적인 예는  for 루프 안에 다른 for 루프가 내포된 형태이다.


O(n³)
1000개의 항목을 처리하는데 20초라면 2000개는 160초(8배)
위의 것보다 더 최악... 그냥 쓰지말자


O(2ⁿ )
흔히 기수 2 지수 함수라 부르며 항목 개수가 1 증가할 때마다 함수는 2배가 된다.
매우 비효율적이므로 피해야하는 알고리즘이다.


여러가지 복잡도들의 비교