결론적으론 둘다 결과는 139 가 된다

반복문 횟수가 많긴 하지만 시간에 있어서 약간 차이를 보인다

http://pdw1208.tistory.com/entry/pragma-pack

#include <stdio.h>

struct test{
  int iNum;
  char A;
  short B;
  char C;
};

void main()
{
  struct test B;
  
  B.iNum = 1000;
  printf("구조체의 크기는 %d\n", sizeof(B));
  
}

void main()
{
  int A = 100;
  struct test B;

  B.iNum = 1000;

  printf("구조체의 크기는 %d\n", sizeof(B));
} 

#pragma pack(push, 1) 이나 (1) 을 선언해 메모리를 1바이트 최적화를 시킨다 그렇게되

면 구조체의 크기는 선언된 변수의 자료형의 크기만큼의 구조체를 가진다 

구조체선언 다음에  #pragma pack(pop) 이나 (4) 선언해 다시 4바이트 최적화를 해준다  

32비트 CPU에서는 4바이트(32비트)의 단위로 데이터를 처리하는 것이 가장 빠르게 때문이다  즉 

#pragma pack(1) 또는 (push ,1) 이라고 선언해놓고 원래대로 돌려놓지 않는다면 속도저하의 문제가 생

길 수 있다

각변수는 메모리상에서 그림과 같이 공간을 차지한다   
 

마지막 128 전까지는 vc 어떤 버전이든 고정된 바이트를 제공한다

마지막 __m128은 부동소수 4개를 합쳐놓은 타입으로 SIMD 방식으로 벡터곱생등을 수행할 때 사용될 수 있다

std::cout<<sizeof(__int8)<<std::endl;

std::cout<<sizeof(__int16)<<std::endl;

std::cout<<sizeof(__int32)<<std::endl;

std::cout<<sizeof(__int64)<<std::endl;

std::cout<<sizeof(__m128)<<std::endl;

http://sonic.tistory.com/8

class에서 다중 상속을 받게 될 경우 그 부모의 함수를 호출하는데 부모 클래스의 이름이 필요하다.

이때 해당 클래스의 이름을 적지 않아도 __super 라는 키워드를 이용해 부모클래스를 찾아 해당 

함수를 호출하도록 할 수 있다. 아래는 MSDN에 수록된 __super 의 사용 예다.

http://blog.naver.com/dkfqkeorkfl/120187637909

Scott Meyers의 effective c++ 항목 30번은 inline에 관하여 이야기합니다. 

주제는 간단합니다.

"inline 키워드를 사용하기 위해서는 최대한 따져가며 사용해야만 한다."

이 주제에 대하여 자세히 읽어보면 아래와 같은 이야기를 합니다.

Scott Meyers "이야기가 나왔으니 말인데, 생성자와 소멸자는 인라인하기에 그리 좋지 않은 함수입니다"

생성자와 소멸자 내부를 컴파일러 어떻게 만들어내는지 알수 없을 뿐더러 혹여라도 코드의 길이에 막대한 영향을 끼칠 우려가 있기 때문입니다. 생성자와 소멸자는 자주 호출되는 함수중 하나로 암묵적인 객체까지 모두 포함되면 코드의 길이가 천문학적으로 늘어날 가능성이 존재합니다. 때문에 생성자와 소멸자에는 inline을 사용하지 말라고 권고하는 것이죠.

http://santacop.tistory.com/62

기존의 C++ enum은 다음과 같은 문제가 있었다.

http://kyruie.tistory.com/90

Windows memory code에서 쓰이는 값들
   - 0xABABABAB : HeapAlloc으로 할당받은 메모리 바로 뒤의 가드 영역(no man's land)에 들어가는 값⁴
   - 0xABADCAFE : 메모리 해제중에 잘못된 포인터를 잡아내기 위해 집어넣는 초기값⁵
   - 0xBAADF00D : HeapAlloc이나 LMEM_FIXED flag를 준 LocalAlloc로 할당받은 메모리에 들어가는 초기값⁶
   - 0xFEEEFEEE : HeapFree()하고 난 뒤 해당 메모리 영역에 들어가는 값

      0xfeeefeee

http://kaludin.egloos.com/2547365

추상클래스를 상속받아 인스턴스를 만들때는 자식클래스 어딘가에선 추상클래스의 모든함수=0; 을 실질적으로 자식에서 정의하는것이 좋다

빈 함수일지라도..

class objectBase_sjh{

public :

virtual ~objectBase_sjh()=0;

virtual HRESULT renderGeoMatricalNormal()=0;

};

objectBase_sjh::~objectBase_sjh()

{

}

class objectCommon_sjh : public objectBase_sjh{

protected:

typedef std::vector<TEXTUREINFO_SJH> vecTextureInfo_sjh;

objectCommon_sjh(){}

public :

};

class xFileObject_sjh : public objectCommon_sjh{

public :

public :

xFileObject_sjh(){}

~xFileObject_sjh(){}

explicit xFileObject_sjh( LPDIRECT3DDEVICE9 pD3dDevice,  

std::wstring xFileName=_T(""), 

std::wstring textureName=_T(""), 

const std::wstring& directoryPath=_T("images/")   ) {  }

public :

virtual HRESULT renderGeoMatricalNormal(){ return S_OK; }                                //이 함수를 지우면 에러가 발생한다, 추상클래스의 함수가 실제 정의되지 않게됨으로

};

typedef boost::shared_ptr<xFileObject_sjh> spXFile_sjh;

int main()

{

LPDIRECT3DDEVICE9 _pD3dDevice;

spXFile_sjh( 인자값 ) );

return 0;

}

http://mskyt.tistory.com/54

[1장] C++ 기본
 - explicit 생성자
 - 복사생성자 (copy constructor)
 - 복사 대입 연산자 (copy assignment operator)
 - 함수 인자로 전달될 때는 복사 생성자가 불림

항목1.  C++는 언어들의 연합체
 C + 객체지향 + 템플릿 + STL

항목2. define 대신 const, enum, inline 사용
 - 매크로 대신 상수 사용
 - 문자열일 경우 const를 앞뒤로 (상수포인터)
 - 클래스 상수 static const 사용 (구현파일에 따로 정의 필요)
 - 매크로 함수대신 inline template 함수 사용

항목3. 낌새만 보이면 const
 - const char *p : 상수 데이터
 - char *const p : 상수 포인터
 - const vector::iterator   vs  vector::const_iterator
 - 상수 멤버 함수 : 해당 객체의 논리적인 상태를 바꾸지 않겠다고 약속한 함수. const가 있고 없고에 따라 오버로딩 가능 (상수객체에 대한 함수를 따로 정의)
 - 비트수준의 상수석 vs 논리적 상수성 (사용자가 알아챌수 없으면 된다) : 논리적 상수성 파악은 힘들고, mutable 키워드로 const에서도 변수 변경 가능
 - 상수함수 비상수함수 코드 중복 - 비상수 함수가 상수 함수를 호출하도록
  const 떼어내기 :  const_cast<char&>(static_cast<const T&>(*this)[position])

항목4. 객체 초기화
 - 대입과 초기화는 다르다
 - 멤버 초기화 리스트로 복사 생성자 호출
 - 상수&참조자 변수 반드시 초기화
 - 기본클래스가 파생클래스보다 먼저 초기화됨
 - 멤버변수는 초기화 리스트 순서에 상관없이 선언된 순서로 초기화
 - 정적 객체(전역객체, 네임스페이스 전역 객체, 클래스 정적 변수, 함수내 정적 변수, 파일내 정적변수)의 초기화에 주의
     - 번역 단위 : 컴파일을 통해 하나의 오브젝트 파일을 만드는데 바탕이 되는 소스코드
     - 두개이상의 번역단위에서 비지역 정적 객체의 초기화 순서는 정해지지 않음 : 싱글턴 패턴 또는 참조자 반환 함수 사용


[2장] 생성자, 소멸자, 대입 연산자
항목5. 컴파일러 자동 생성(implicit) 함수들
 - 복사생성자, 복사대입연산자, 소멸자 자동생성
 - implicit 복사생성자는 각 멤버변수 복사생성
 - implicit 복사대입연산자도 각 멤버변수 복사대입
 - 참조자는 원래 자신이 참조하던 것과 다른 객체 참조 불가능

항목6. 컴파일러 자동생성 함수 금지시키기
 - 복사생성자, 복사대입생성자를 private로 선언
 - 프렌드 클래스도 안되게 : 선언만 하고 정의는 안함
 - 컴파일타임에 막고싶다면 uncopyable 클래스를 만듬

항목7. 다형성을 가진 기본 클래스는 소멸자를 가상 소멸자로
 - 팩토리 함수로 동적 할당된 객체를 쓰면, 지울때 기본클래스 포인터로 접근되고, 비가상소멸자이면 기본클래스 소멸자가 호출됨
 - 가상함수를 하나라도 가졌으면 가상 소멸자를 사용
 - 가상함수가 C++에선 클래스에 별도 자료구조 추가됨 : 실행중에 알기위해서 vptr(가상함수테이블 포인터), vtbl(가상함수 테이블) 
 - std::string, STL 컨테이너들은 비가상 소멸자

항목8. 예외가 소멸자를 떠나지 못하도록
 - vector가 소멸되다가 두번째 원소 소멸중 예외 : 미정의 동작
 - 방법1 : catch 하여 abort를 호출
 - 방법2 : 예외무시
 - 인터페이스를 분리. 안하더라도 리소스 관리하게 만들고 로그남기기

항목9. 객체 생성, 소멸시에는 가상 함수 호출 호출하지 않는다
 - 생성, 소멸자가 실행되는 동안에는 완전히 기본클래스로 보고 동작. 가상 함수더라도 기본 클래스 함수가 실행된다.

항목10. 대입연산자는 *this의 참조자를 반환하게 하자
 - A=B=C 처럼 대입연산자가 사슬처럼 얽히도록

항목11. 대입연산시에는 자기대입에 대한 처리가 빠지지 않도록
 - 중복참조(aliasing)
 - 일치성 검사(identity test)
 - 대개 예외에 안전하게 작성하면 자기대입에도 안전해진다
 - 복사후 맞바꾸기 기법 - reference copy 후 swap, pass by value로 받고 swap

항목12. 객체의 모든 부분을 빠짐없이 복사하자
 - 모든 멤버함수와 상속한 기본 클래스 복사를 빼먹지 말라
 - 복사 생성자와 복사 대입 연산자가 코드 중복되는 듯하지만,  대입연산자에서 복사생성자 호출 또는 그 역은 불가능

[3장] 자원관리
항목13. 자원 관리에는 객체가 그만
 - 팩토리 함수 : 클래스 객체를 동적할당하고 포인터 반환 해제는 호출한 쪽에서
 - 해제하기전 return이 되거나 예외가 발생하면 해제 안됨
 - 자원해제를 소멸자가 맡도록
 - 자원 관리 객체 : 자원 획득 즉시 초기화 (RAII-Resource Acquisition Is Initialization), 소멸자로 자원 해제
 - std::auto_ptr<T> : 스마트 포인터
     - 어떤 객체를 가리키는 auto_ptr의 개수가 여러개면 큰일 : 복사 생성자 및 대입연산자에서 피연산자를 null로 바꿔버림

http://blog.naver.com/wonjinho81?Redirect=Log&logNo=90162829555

순수 가상 함수가 하나도 없는 클래스를 추상 클래스로 만들고 싶을때에는 소멸자를 순수 가상 함수로 만든다.

당연한 얘기겠지만 하위 클래스의 소멸자가 호출된후 기반클래스 소멸자도 호출이 되므로

순수 가상 소멸자의 정의를 반드시 해줘야한다.

class MyClass {

  MyClass ();

  virtual ~MyClass () = 0;

};

MyClass::~MyClass() {}

순수 가상함수란? 추상 클래스를정의할때의 추상 클래스로부터 파생한 클래스가 무엇이건

그 함수만은 반드시 구현해야 한다는 것을 알려주는 것이라고 볼 수 있겠다..

추상 클래스를 상속받아서 파생클래스를 만들경우를 생각해보자

예를들어 전기제품에는 "전원을 켜다 power_on" 이라는 동작이 있을 것이다.

전기제품은 어디까지나 "전기를 사용하는 제품" 이라는 실체가 없는 개념적인 단어이기에

이를 추상클래스로 사용할 것이며 TV와 플레이 스테이션은 이를 상속받아 전원을 넣고 무엇을 할 것인가에 

대한 동작을 구현 하면 된다.

또한 추상클래스로 하려면 클래스가 가진 함수중 하나라도 순수 가상함수로써 정의하면 된다.

(추상 클래스와 인터페이스를 헷갈리는 경우가 많은데, 추상클래스는 일반 멤버, 함수, 순수가상함수등을 

모두 포함한 클래스를 말하며 인터페이스는 모두 순수가상함수로 이루어진것을 말한다)

// AbstractElectronics *pElectronic = new AbstractElectronics();가 되지 않는것은

power_on() 이라는 동작이 구체적으로 정의되어 있지 않기 때문이다.

순서가 이미 결정되어거나 기본동작이 이미 있는 것을 추상화 한다고 생각해보자

예를들어 칼(날붙이류)를 생각해보자.

칼은 "자르다" 라는 동작이 있다.

잘드는 나이프도 식칼도 투핸디드소드도 마찬가지일것이다.(이들을 통틀어 "칼"이라고 부를 뿐..)

여기서도 마찬가지로 "칼" 이란것은 개념으로 칼의 실체는 존재하지 않는다.

"칼"의 실체 자체는 식칼이나 투핸디드소드를 말한다.

따라서 "칼"이란 추상화한것이라고 할 수 있다

구현하면 다음과 같다.

칼의 기본동작인 자르다 cut은 추상클래스에서 의미 구체적으로 정의되어 있다.

그러나 소스코드에서와 같이 이대로는 추상클래스인 Cutlery까지 인스턴스화할수 있다.

순수가상함수가 없기 때문에 추상클래스로써의 기능을 하고 있지 않아서 이다.

이 동작은 원래의 의도가 아니다.

이럴때 순수가상소멸자를 사용한다.

순수가상함수가 존재하는것을 컴파일러에에게 알려줌으로써 이 클래스는 추상클래스로써의  역할을 하는 것이다.

그냥 소멸자에 평소 순수가상함수처럼 만들듯이 사용하면 된다.

추상 클래스를 상속한 파생클래스에서는 순수 가상함수 내부를 구현해야 하는데.

소멸자는 모든 클래스에서 반드시 정의해야 하므로( 또는 정의 되어 있으므로 (기본 소멸자)), 

추상클래스로 역할이 필요할때에 적합하다고 할 수 있다.

만일 전기제품에서 power_on을 순수가상함수로 정의하고선 추상 클래스에서 내부를 구현한 경우에는

파생 클래스에서 상속 받은 함수를 호출 하는 것도 가능하고

power_on 자체가 순수가상함수이기에 의 AbstractElectronics  인스턴스화를 하지 못하도록 방지하는것도 할 수 있다.

그림이 영 없으니...

class A{

public :

float x,y,z;

A(){

x=3;

y=5;

z=7;

}

operator float*(){

return &x;

}

 // 이부분의 주석만 제거하면 operator float*() 가 아닌 float& operator [] 으로 수행된다, 컴파일러마다 다른지는 확인 않함

/*float& operator [](int index)

{

return *((&x)+index);

}*/

};

int main()

{

A ai;

std::cout<<ai[0];            결과는 3  5  7

return 0;

}

http://www.synch3d.com/wiki/moin/moin.cgi/template?action=LikePages

함수 템플릿

//template <class T> void Swap(T &a, T &b) // class와 typename에 의미의 차이는 없다. 
template <typename T> void Swap(T &a, T &b)  
{ 
 T t; t=a; a=b; b=t; 
} 

헤더와 소스로 분리하기

// swap.h 
template <typename T> void Swap( T&a, T&b); 
template <> void Swap<float>(float&a, float&b); // 이건 명시적 특수화, 확장되어 사용되는것을 미리 선언. export 키워드 없이 분리하는 법 
template <> void Swap<int>(int &a,int &b); // 이것도 마찬가지 
... 

 
// swap.cpp 
#include "swap.h" 
 
template <> void Swap<int>(int&a, int&b) // 이놈의 특수화된 템플릿 함수 
{ 
        int t; 
        t=a;a=b;b=t; 
} 
 
 
template <> void Swap<float>(float&a, float&b) // 이놈의 특수화된 템플릿 함수 
{ 
        float t; 
        t=a;a=b;b=t; 
} 

키의 상태를 확인하는

GetAsyncKeyState, GetKeyState

우선은 GetAsyncKeyState API에 대해 알아보기 전에 API의 원형을 먼저 살펴봅시다!

반환값은 SHORT형이고, 첫번째 인수로는 가상 키코드가 오며, 우리가 만약 VK_UP을 넘겨주면, 방향키 중 위를 가르키는 키가 눌려있나 눌려있지 않나 확인할 수 있습니다. (키가 눌려진 상태에서는 최상위 비트(0x8000)이 1이 되며,  처음 입력되었을 때는 0x8001 비트가 1이 됩니다.)

(가상 키코드 목록을 보고싶으신 분들은 아래의 MSDN를 방문하셔서 참고하세요.)

MSDN: http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx

GetAsyncKeyState의 반환값은 아래와같이 4가지로 나뉩니다. 

이전에 누른 적이 없고 호출 시점에서 눌린 상태, 즉 키가 눌려진 시점에서 0x8000을 반환합니다. 만약 이전에도 누른 적이 있고 호출 시점에서도 눌렸으면 0x8001을 반환합니다. 이전에 키를 눌렀으면 0x0001을 반환하고, 눌리지 않았다면 0x0000을 반환합니다. 혹시, GetAsyncKeyState(VK_UP) & 0x8000 이런 코드를 보신적이 있으신가요? 0x8000과 GetAsyncKeyState 반환값을 AND 연산하는 이유는 정확한 시점에서 키의 상태를 확인하기 위함입니다. 만약에 키를 눌러 GetAsyncKeyState 함수가 0x8000을 반환한다면 이를 0x8000으로 AND 연산하여 키가 눌렸을때는 0x8000이 나옵니다. 그러나 눌려진 적이 있으면 GetAsyncKeyState 함수는 0x0001을 반환한다고 했었습니다. 0x0001에다 0x8000을 AND 연산하게되면 0이 나오게 됩니다. (만약에 AND 연산하지 않았을 경우에는 눌러진 적이 있는 상태도 참이 되어 동작을 수행할 것입니다.)

이제 GetAsyncKeyState API 함수를 이용해서, 방향키(상하좌우)가 입력됨에 따라 그 방향으로 @가 그려지는 프로그램을 간단히 만들어보도록 합시다.

결과:

컴파일 후 프로그램을 실행시키시면 방향키 입력에 따라 @가 움직입니다. 이번에는 GetKeyState API 함수를 살펴보도록 합시다. 다음은 GetKeyState API 함수의 원형입니다.

GetKeyState도 반환되는 값은 SHORT형이며, 첫번째 인수도 가상 키코드가 옵니다. "그럼, GetKeyState와 GetAsyncKeyState은 똑같은게 아닌가요?"라는 궁금증이 생겨나시는 분들도 계실텐데, GetKeyState는 메세지 큐에 저장된 메시지에 따라 반환되는 값이 다릅니다. 만약에 우리가 A 키를 눌렀다는 메세지가 메세지 큐에 남아 처리되지 않을때 있을때, 키가 눌렸다고 출력될 것입니다. 반대로 GetAsyncKeyState는 메세지 큐와 상관없이 입력되는 순간 즉각적으로 읽어들여 동작합니다. GetKeyState 함수는 해당 키가 눌렸으면 음수값(0xffffff80, 0xffffff81)을 반환하고, 아닐 경우에는 0을 반환합니다. 이것 역시 이전에 누른적이 있고, 호출 시점에서는 누르지 않았다면 계속 1로 남습니다.

이번에는 GetKeyState API 함수를 이용해서 @를 움직이는 프로그램을 만들어 보도록 합시다.

결과:

http://narusakura.tistory.com/196

포인터와 같다. 하지만 포인터는 포인터변수 4바이트를 차지하고 참조는 사용하지 않는다.

참조의 단점 : 초기화할 때 들어간 값은 변하지 않는다.

참조는 const 속성을 가진다. 변경불가! 

연산자오버로딩 기본코드

연산자오버로딩 main

(상속+연산자오버로딩)main

#include <iostream.h> main() {    int i;    i = 12;   cout << "12 -> 8진수 : " << oct << i << endl;   cout << "12 -> 10진수 : " << dec << i << endl;   cout << "12 -> 16진수 : " << hex << i << endl;   return 0; }

#include <iostream.h> #include <iomanip.h> main() {   double d;   d = 12.345;    cout << setw(15) << "hello!" << endl;  cout << setw(15) << setfill('-') << "hello!" << endl;  cout << setprecision(3) << d << endl;  return 0; }

http://blog.naver.com/xogml_blog/130144674709

인라인 함수란 무엇인가 ? 

우선 일반 함수를 알아보면, 일반 함수는 우선 매개변수를 스택에 집어넣고, 함수를 호출한다. 다시말하면

//int x86     *.cpp

int add(int a, int b) { return a + b; } 이러한 코드는

int main(void) {

add(1, 2);

return 0;

}

//int x86     *.asm

push 2

push 1

call ?add@@YAHHH@Z ; add1

add esp, 8

mov DWORD PTR _n1$[ebp], eax

이런식으로 호출된다.

또한 여기에는 적지않았지만 리턴값을 위한 스택 push, pop도 있고 라턴후 스택정리를 위한 pop도 있다..

이러한 함수 호출은 스택에 접근 하기 떄문에, 다시말하면 메모리에 접근하기 때문에 속도 저하가 생길수 있다.

이러한 스택접근, 즉 메모리 접근을 피하는 방법은 무엇이 있을까? 에서 나온 한편의 해결책이 인라인 함수이다.

위의 내용을 자세히 보려면 [calling convention] 을 보면 된다.

원리 ?

기계어를 통채로 치환한다. 즉 함수 호출없이 코드를 가져다 붙인다. ㅋ 그래서 스택접근이 없기 떄문에 메모리 접근이

없고 결국 속도면에서 이득을 얻을수 있다.

사용 ?

inline returnType functionName(argument) {

//routine...

}

ex)

//main.cpp

inline int add(int a, int b) {

return a + b;

}

int main(void) {

add(1, 2);

return 0;

}

이런식으로 사용하면 된다. 이와같이 인라인 함수를 사용해서 컴파일 하게 되면

//main.cpp

mov eax, 1

add eax, 2

mov DWORD PTR _n2$[ebp], eax

어셈 코드가 위와같이 나오게 된다. 즉 push, pop가 없으므로 성능에 향상이 있다.

문제점 1. 코드의 길이가 길어진다 ?

직관적으로 보면 메서드의 기계어를 통채로 때어다가 붙이기 때문에, 목적코드가 길어질수 있다....

라고 Effective C++이라는 책에 나오고 있지만, 오히려 목적코드를 작게 해줄수도 있다고 적혀잇다. 비교해보자

a) 일반 함수를 사용할경우 : 매개변수 push + 복귀주소 eip push + 함수호출 call

b) 인라인 함수 사용할경우 : 함수의 목적코드가 통째로 와서 붙음.

정리하면 함수의 크기가 "매개변수 push + 복귀주소 eip push + 함수호출 call" 보다 클경우 목적 코드의 길이가 길어지고

작을경우에는 오히려 목적 코드의 길이가 작아진다.

따라서 함수가 복잡할경우에는 인라인 함수의 사용을 줄여야 한다. 하지만 단순한 함수일경우 무조건 인라인이다.

문제점 2. 디버깅이 어렵다.

당연한 이야기이다. 함수 모듈화의 장점은 재활용성과 더불어 코드 가독성에 있다. 하지만 call-return 구조를 포기하되 성능을

택하였으므로 코드가 보기 어려워지고 결과적으로 디버깅이 어렵게 된다.

더불어 vs에서는 최적화 옵션때문에 release 일때만 인라인으로 처리하고(어셈을 만들고), debug 모드일경우에는 일반 함수로 처리. 

문제점 3. inline 함수는 Internal Linkage 이다.

다시말해 인라인 함수는 내부연결이다. 더 나가기전에 internal linkage에 대해 알아보면

a. Internal Linkage 

- 영역의 심볼(전역변수, 함수)이 자신을 선언한 컴파일 단위(파일)에서만 사용 가능.

-> static 전역변수, inline 함수, function template, 매크로

-> C++ 문법의 const 

b. External Linkage

- 영역의 심볼이 프로젝트 내의 모든 컴파일 단위에서 사용 가능

-> 일반 전역변수, 일반 함수

-> C 문법의 const

※ 단 C++문법의 const도 C의 const처럼 External Linkage로 쓸수 있다는 밥법이 있다.

※ 단 C++문법의 const도 C의 const처럼 External Linkage로 쓸수 있는 방법이 있다

즉 inline 함수는 내부 연결의 속성을 갖기 때문에 이런것이 불가능 하다.

//add.cpp

inline int add(int a, int b) {

return a + b;

}

//main.cpp

inline int add(int a, int b);

int main(void) {

add(1, 2);

return 0;

}

다시말해 add.cpp 에서 작성한 인라인 add함수는 자신의 컴파일 단위, 다시말해 add.cpp에서만 효력한다. 그렇다면 어떻게 해야 할까?

해법은 헤더파일, 즉 헤더파일에 인라인 함수의 선언과 구현을 다 해주고 여러 파일들에서 이 헤더를 추가하여 사용하면 된다.

문제점 4. 인라인 함수를 함수포인터로 사용 ?

볼것도 없이 우선 해보자

//main.cpp

inline int add(int a, int b) {

return a + b;

}

int main(void) {

int (*pAdd)(int, int) = &add;

pAdd(1, 2);

return 0;

}

이 코드의 목적코드를 보자. 과연 함수포인터르 받은 인라인 함수가 사용 되었을까 ? 

; 5    : int main(void) {

push ebp

mov ebp, esp

push ecx

; 6    :  int(*pAdd)(int, int) = &add;

mov DWORD PTR _pAdd$[ebp], OFFSET ?add@@YAHHH@Z ; add

; 7    :  pAdd(1, 2);

push 2

push 1

call DWORD PTR _pAdd$[ebp]

add esp, 8

; 8    :  return 0;

어 사용 안됬다. 다시말해서 인라인 함수를 함수포인터로 받을수는 있지만, 함수 포인터로 사용하면 일반 함수처럼 사용된다.

뭔상관이야 ? 할수도 있는데 이런 경우를 생각해보자.

누구나 c언어를 배울때 stdlib의 퀵소트를 사용해본적이 있을것이다. 

void qsort(void * base, size_t num, size_t size, int(* comparator)(const void *, const void *));

여기서 세번째 함수로 넘겨주는것이 함수포인터이다. C언어에서 

1. 변하지 않은 전체 알고리즘과, 변해야 하는 정책을 분리하는 것이 좋다.

2. C에서는 변하는 것을 함수 인자화, 즉 함수 포인터로 표현하면 된다.

퀵소트의 알고리즘을 보면 선택된 인자 두개를 비교하는 루틴이 있다는것을 알것이다. 이 루틴에 따라서 오름차순, 내림차순이

결정되는데, 즉 무지막지하게 저 comparator가 호출되는것이다.

간혹가다 "아 이 comparator가 많이 호출되고 단순한 함수니까 inline으로 만들자" 라는 사람이 있을텐데...

이쯤되면 눈치 챘을것이다. 함수포인터는 inline으로 사용될수 없다.

그럼 해결책은 ? 아쉽게도 C언어 에서는 없다....

단 C++에서는 함수객체라는 이름으로 해결방안이 있다. 

http://bravedog.blog.me/100005576789

http://www.soenlab.com/

3DMP engines

3D그래픽스 물리 수학, 프로그래밍 GPU Shader 게임엔진 알고리즘 디자인패턴 matlab etc..

#include <string>

namespace st=std;

st::string str;

처럼 사용할 수 있다 이렇게 쓰면 별 쓸모없어보이지만 아래처럼 네임스페이스가 여러개 포함될때 유용하게 쓰일 수 있다

namespace fs = boost::filesystem;

http://saelly.tistory.com/128

Link : http://kldp.org/node/26526

// korText.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <iostream>
#include <string>
#include <fstream>

using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{
wstring aa = L"abcde 입니다.";
wfstream filestr;

filestr.imbue(locale( "korean" ) ); // 이게 중요
filestr.open (L"C:\test.txt", wfstream::in | wfstream::out | wfstream::app);
filestr.write(aa.c_str(), static_cast<streamsize>(aa.length()));
filestr.close();

return 0;
}

http://blog.naver.com/elastica/50045305787

윈도우즈 프로그램을 개발하다 보면 날짜 및 시간 관련 처리가 필요한 경우가 많습니다.

특정 날짜 기준으로 어느 시간이 경과한 이후에 로그 파일을 지운다거나

특정 날짜에 프로그램을 실행 시킨다거나 또는 두 시간 사이의 차이점을 알아보고자 할때도

있구요..  다양한 요구 사항이 나올 수 있습니다.

위와 같은 요구사항에 적용될 수 있는 시간 및 날짜 관련 Tip 에 대해 정리해 보았습니다. 

1> 현재 시간 알아오기

아래의 두가지 코드 예제를 보시기 바랍니다.

첫번째 CTime::GetCurrentTime() 이 현재의 정확한 시간을 가지고 오는 함수 입니다.

CTime now1 = CTime::GetCurrentTime(); (O)

아래에 사용된 GetCurrentTime API 는 GetTickCount 로 대체 되었으며

시스템이 시작된 이후 경과돤 시간을 밀리세컨드로 리턴해 주는 함수입니다.

CTime now2  = GetCurrentTime(); (X)

CString 의 Format 을 통해 좀더 자세히 알아보겠습니다.

지금 시간이 3월 4일 오후 16:23 분 경입니다.

CTime::GetCurrentTime 을 사용했을 경우 정확한 현재 시간을 가져옴을 볼 수 있습니다.

*예제코드

CTime now1 = CTime::GetCurrentTime();

CTime now2  = GetCurrentTime();

 
 CString strTime1;
 
 strTime1.Format(_T("%04d-%02d-%02d %02d:%02d:%02d"),now1.GetYear(), now1.GetMonth(),now1.GetDay(),now1.GetHour(), now1.GetMinute(),now1.GetSecond());

 CString strTime2;

 strTime2.Format(_T("%04d-%02d-%02d %02d:%02d:%02d"),now2.GetYear(), now2.GetMonth(),now2.GetDay(),now2.GetHour(), now2.GetMinute(),now2.GetSecond());