gsi

// 프로세스 찾기
#include <tlhelp32.h>
bool GetProcessModule(DWORD dwPID, char* sProcessName);

bool ProcessFind(char* strProcessName)
{
    HANDLE         hProcessSnap = NULL;
    BOOL           bRet      = FALSE;
    PROCESSENTRY32 pe32      = {0};

    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hProcessSnap == (HANDLE)-1)
        return false;

    pe32.dwSize = sizeof(PROCESSENTRY32);

    //프로세스가 메모리상에 있으면 첫번째 프로세스를 얻는다
    if (Process32First(hProcessSnap, &pe32))
    {
        BOOL          bCurrent = FALSE;
        MODULEENTRY32 me32       = {0};

        do
        {
            bCurrent = GetProcessModule(pe32.th32ProcessID,strProcessName);
            if(bCurrent)
            {
                HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
                if(hProcess)
                {
                    // 이 주석을 없애면 프로세스를 죽이는것도 가능하다.
                    //if(TerminateProcess(hProcess, 0))
                    //{
                    //    unsigned long nCode; //프로세스 종료 상태
                    //    GetExitCodeProcess(hProcess, &nCode);
                    //}
                    //printf("process exit\n");
                    CloseHandle(hProcess);
                    return true;
                }
            }
        }
        while (Process32Next(hProcessSnap, &pe32)); //다음 프로세스의 정보를 구하여 있으면 루프를 돈다.
    }
    CloseHandle (hProcessSnap);
    return false;
}

bool GetProcessModule(DWORD dwPID, char* sProcessName)
{
    HANDLE        hModuleSnap = NULL;
    MODULEENTRY32 me32        = {0};
    hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);

    if (hModuleSnap == (HANDLE)-1)
        return (FALSE);

    me32.dwSize = sizeof(MODULEENTRY32);

//해당 프로세스의 모듈리스트를 루프로 돌려서 프로세스이름과 동일하면
//true를 리턴한다.

    if(Module32First(hModuleSnap, &me32))
    {
        do
        {
            printf("process name : %s\n", me32.szModule);

   if( strcmp(me32.szModule, sProcessName) == 0 )
   {
    CloseHandle (hModuleSnap);
    return true;
   }
            //if(me32.szModule == sProcessName)
            //{
            //    CloseHandle (hModuleSnap);
            //    return true;
            //}

        }
        while(Module32Next(hModuleSnap, &me32));
    }

    CloseHandle (hModuleSnap);
    return false;
}

----------------- 사용할때 -------------------
 // 런처가 돌고 있는지를 판단한다. (제가 한건 해당 프로세스가 돌고 있는지를 찾는 코드로 재사용 했음)
 if( ProcessFind("CruiseLauncher.exe") == false )
 {
  MessageBox(NULL, "CruiseLauncher가 실행중이지 않습니다.", "오류", MB_OK);
  exit(0);
 }

/*  file Main.cpp
 *
 *  This program is an adaptation of the code Rex Jaeschke showed in
 *  Listing 4 of his Nov 2005 C/C++ User's Journal article entitled
 *  "C++/CLI Threading: Part II".  I changed it from C++/CLI (managed)
 *  code to standard C++.
 *
 *  One hassle is the fact that C++ must employ a free (C) function
 *  or a static class member function as the thread entry function.
 *
 *  This program must be compiled with a multi-threaded C run-time
 *  (/MT for LIBCMT.LIB or /MTd for LIBCMTD.LIB).
 *
 *                                      John Kopplin  7/2006
 */

#include <stdio.h>
#include <windows.h>          // for HANDLE
#include <process.h>          // for _beginthread()

static bool interlocked = false;    // change this to fix the problem

const int maxCount = 100000000;
static LONG value = 0;              // under Windows Server 2003 you
                                    // could use LONGLONG here

unsigned __stdcall TMain(void* arg)
{
    if ( interlocked )
    {
      for ( int i = 1; i <= maxCount; i++ )
      {
        InterlockedIncrement(&value); // under Windows Server 2003 you
                                      // could use InterlockedIncrement64() here
      }
    }
    else
    {
      for ( int i = 1; i <= maxCount; i++ )
      {
        ++value;
      }
    }

    return 3;  // thread exit code
}

int main()
{
    // In this program we create 3 threads and request that their
    // entry-point-function be the TMain() function which is a
    // free (C) function and hence causes no problems for
    // _beginthreadex()

   
    HANDLE   hth1;
    unsigned  uiThread1ID;

    hth1 = (HANDLE)_beginthreadex( NULL,         // security
                                   0,            // stack size
                                   TMain,        // entry-point-function
                                   NULL,         // arg list
                                   CREATE_SUSPENDED,  // so we can later call ResumeThread()
                                   &uiThread1ID );

    if ( hth1 == 0 )
        printf("Failed to create thread 1\n");

    DWORD   dwExitCode;

    GetExitCodeThread( hth1, &dwExitCode );  // should be STILL_ACTIVE = 0x00000103 = 259
    printf( "initial thread 1 exit code = %u\n", dwExitCode );

    HANDLE   hth2;
    unsigned  uiThread2ID;

    hth2 = (HANDLE)_beginthreadex( NULL,         // security
                                   0,            // stack size
                                   TMain,        // entry-point-function
                                   NULL,         // arg list
                                   CREATE_SUSPENDED,  // so we can later call ResumeThread()
                                   &uiThread2ID );

    if ( hth2 == 0 )
        printf("Failed to create thread 2\n");

    GetExitCodeThread( hth2, &dwExitCode );  // should be STILL_ACTIVE = 0x00000103 = 259
    printf( "initial thread 2 exit code = %u\n", dwExitCode );

    HANDLE   hth3;
    unsigned  uiThread3ID;

    hth3 = (HANDLE)_beginthreadex( NULL,         // security
                                   0,            // stack size
                                   TMain,        // entry-point-function
                                   NULL,         // arg list
                                   CREATE_SUSPENDED,  // so we can later call ResumeThread()
                                   &uiThread3ID );

    if ( hth3 == 0 )
        printf("Failed to create thread 3\n");

    GetExitCodeThread( hth3, &dwExitCode );  // should be STILL_ACTIVE = 0x00000103 = 259
    printf( "initial thread 3 exit code = %u\n", dwExitCode );

    // If we hadn't specified CREATE_SUSPENDED in the call to _beginthreadex()
    // we wouldn't now need to call ResumeThread().

    ResumeThread( hth1 );   // Jaeschke's   // t1->Start();
    ResumeThread( hth2 );   // Jaeschke's   // t2->Start();
    ResumeThread( hth3 );   // Jaeschke's   // t3->Start();

    // In C++ the process terminates when the primary thread exits
    // and when the process terminates all its threads are then terminated.
    // Hence if you comment out the following waits, the non-primary
    // threads will never get a chance to run.

    WaitForSingleObject( hth1, INFINITE );  // Jaeschke's t1->Join()
    WaitForSingleObject( hth2, INFINITE );  // Jaeschke's t2->Join()
    WaitForSingleObject( hth3, INFINITE );  // Jaeschke's t3->Join()

    GetExitCodeThread( hth1, &dwExitCode );
    printf( "thread 1 exited with code %u\n", dwExitCode );

    GetExitCodeThread( hth2, &dwExitCode );
    printf( "thread 2 exited with code %u\n", dwExitCode );

    GetExitCodeThread( hth3, &dwExitCode );
    printf( "thread 3 exited with code %u\n", dwExitCode );

    printf( "After %d operations, value = %d\n", 3 * maxCount, value );
                                         // under Windows Server 2003 you
                                         // could use %I64d

    // The handle returned by _beginthreadex() has to be closed
    // by the caller of _beginthreadex().

    CloseHandle( hth1 );
    CloseHandle( hth2 );
    CloseHandle( hth3 );

    printf("Primary thread terminating.\n");
}

여러개의 객체를 생성하는 코드를 아래와 같이 일반적으로 사용합니다.

class Shape {};
class Line_ : public Shape  { public: Line_()   { printf("create Line\n");  } };
class Polygon_ : public Shape { public: Polygon_()  { printf("create Polygon\n"); } };
class Circle_ : public Shape  { public: Circle_()  { printf("create Circle\n"); } };

namespace DrawingType
{
 const int
  LINE = 1,
  POLYGON = 2,
  CIRCLE = 3;
};

Shape* Load( int drawingType )
{
 Shape* p;

 switch( drawingType )
 {
  using namespace DrawingType;
 case LINE:
  {
   p = new Line_();
  }
  break;

 case POLYGON:
  {
   p = new Polygon_();
  }
  break;

 case CIRCLE:
  {
   p = new Circle_();
  }
  break;
 }

 return p;
}

사용은 아래와 같이
 Shape* p;

 p = Load( DrawingType::LINE );
 delete p;
 p = Load( DrawingType::POLYGON );
 delete p;
 p = Load( DrawingType::CIRCLE );
 delete p;

하지만 이런 코드의 경우 객체의 추가로 인한 오버헤드가 커지게 됩니다.
그럼 이런 경우 어떻게 조금더 최적화가 가능해질것인가를 생각해 보면 아래와 같이 될 수 있습니다.

//
class ShapeFactory
{
 ShapeFactory() {}

public:
 typedef Shape* (*CreateShapeCallback)();

 static ShapeFactory& GetInstance()
 {
  static ShapeFactory sf;
  return sf;
 }

private:
 typedef std::map< int, CreateShapeCallback > CallbackMap;

public:
 bool RegisterShape( int ShapeId, CreateShapeCallback CreateFn )
 {
  return callbacks_.insert(
   CallbackMap::value_type( ShapeId, CreateFn ) ).second;
 }

 bool UnRegisterShape( int ShapeId )
 {
  return callbacks_.erase( ShapeId ) == 1;
 }

 Shape* CreateShape( int ShapeId )
 {
  CallbackMap::const_iterator I = callbacks_.find( ShapeId );
  if( I == callbacks_.end() )
   return NULL;

  return (I->second)();
 }

private:
 CallbackMap callbacks_;
};

namespace
{
 Shape* CreateLine()
 {
  return new Line_;
 }

 Shape* CreatePolygon()
 {
  return new Polygon_;
 }

 Shape* CreateCircle()
 {
  return new Circle_;
 }
 };

// 사용할때

 // 객체 레지스트리에 등록
 ShapeFactory::GetInstance().RegisterShape( DrawingType::LINE, CreateLine );
 ShapeFactory::GetInstance().RegisterShape( DrawingType::POLYGON, CreatePolygon );
 ShapeFactory::GetInstance().RegisterShape( DrawingType::CIRCLE, CreateCircle );

 p = ShapeFactory::GetInstance().CreateShape( DrawingType::LINE );
 delete p;
 p = ShapeFactory::GetInstance().CreateShape( DrawingType::POLYGON );
 delete p;
 p = ShapeFactory::GetInstance().CreateShape( DrawingType::CIRCLE );
 delete p;

객체를 레지스트리에 등록하고
사용하게 됩니다.

이때 더 나아간다면 템플릿을 사용해서 예외 처리를 조금더 기능적으로 해줄 수 있습니다.

template< class T1, class T2 >
class Test
{
};

이런 클래스가 있다고 합시다.
우리는 이 클래스가 두개의 템플릿 인자를 받아 들인다는 걸 알고 있습니다.

Test< Ca, Cb > A;
A a;

이런 식이 되는 거죠.

그렇다면 저희가 작업 할때 Test 라는 템플릿 클래스를 놓고 특정 타입에 대해서
특화 되게 구현하고 싶은 경우가 있을거예요.

template< class T1, class T2 >
class Test {};

template <>
class Test< CT, CU > {};

이렇게 두개의 같은 클래스이지만 하나는 CT, CU의 명시적으로 특화된 클래스가 또 하나 존재를 하게 되면 만약 코딩을 통해서 CT, CU가 들어 오게 되면 아래의 클래스가 동작 되게 되는거죠.

바로 이게 부분 특화 입니다.

이때 부분적으로 특화를 하고 싶다면 아래와 같은 클래스를 하나 추가 하면 되요

template < class T1 >
class Test< T1, CU > {};

앞의 T1은 모든 객체를 다 받아 들이고 뒤의 CU는 명시적으로 선언을 해놨어요.
이게 바로 부분 특화라는 거죠 ^^

하나더 해볼까요?.

Button 이라는 클래스가 있다고 합시다. 모든 Button과 CU에 대해서 특화 시키고자 한다면...

template < class T1 >
class Test< Button<T1>, CU > {};

이렇게 하면 되죠 ^^

템플릿의 장점은 참 많네요..

ps. 지적 및 조언 및 질문 해주시면 고맙겠습니다.

제목이 참 아리송 합니다. ^^
하지만 내용을 읽고 나면 이해가 될거예요..

이전의 포스트 를 우선 보시고 이 내용을 꼭 보셔야 합니다.

우선 이전의 내용을 한번 짚어 보면...

단위 전략을 통해서 객체 생성에 new, malloc를 선택적으로 해줄 수 있다는 거죠.

typedef WidgetManager< OpNewCreator<CTest> > MyWidgetMgr;
MyWidgetMgr a;

이런 코드를 사용해서 CTest를 특화 되게 구현할 수 있게 되는거죠.
즉, CTest 의 객체를 new, malloc를 선택해서 처리가 가능하다는 말이 됩니다.

그런데 이때 고민이 좀 됩니다.
뭐냐 하면 내부에서

CTest* p = CreationPolicy().Create( p2 );

이 코드를 사용했어요. CTest 를 특화 했기 때문에 CTest만을 사용하게 되는거예요.

난 다른 객체들도 메니져 안에서 다 관리 해주고 할려고 하면 에러가 나서 안되는거죠.

그래서 이 포스트의 주제가 나옵니다.
기본 선언은 비슷하게 구현하되 내부에서 다른 객체를 생성하는 것도 가능하게 말이죠.

우선 아래의 코드를 한번 보고 해요.

template < class T >
struct OpNewCreator
... 생략

template < class T >
struct MallocCreator
... 생략

template < template < class > class CP >
class CTestMgr : public CP<CTest>
{
public:
 CTestMgr()
 {
  CTest2* ptest2 = CP<CTest2>().Create();
 }
 ~CTestMgr() {}
};

위의 코드를 보면 이런 코드가 보입니다.
template < template < class > class CP >
이게 바로 템플릿 템플릿 인자를 통한 단위전략의 중요한 부분이라고 보여 집니다.

즉 이렇게 해서 CP<CTest> 라고 명시적으로 적어 주게 되면 아래와 같은 코드를 통해서 메니져를
처리할 수 있습니다.

typedef CTestMgr< OpNewCreator > MyTestMgr;

원래는 OpNewCreator 에 다른 인자를 더 넣어 주어야 하지만 명시적으로 처리가 되었기 때문에
추가를 해줄 필요가 없게 됩니다.

이렇게 하고 나면...

바로 아래와 같이 내부에서 다른 객체를 사용할 수 있게 됩니다.

CTest2* ptest2 = CP<CTest2>().Create();

어때요?.. CP의 단위 전략을 사용하면서 내가 원하는 다른 객체를 적용할 수 가 있게 됩니다.

Tip.
여기서 보시면 CP에 CTestMgr를 연결할 수도 있게 되요.
CTestMgr* p = CP<CTestMgr>().Create(); 이렇게요.

이건 나중에 템플릿을 여러개로 사용하면서 현재 클래스를 체크를 해준다거나 하는
여러가지 기능을 처리 하는 부분에서 또 설명이 나오네요..

오늘 내용은 여기 까지 ^^

ps. 지적 및 조언 및 질문 해주시면 고맙겠습니다.