수안이의 컴퓨터 연구실

쓰레드 풀은 연결/종료가 자주일어나는 웹서버와 같은 바쁜 서버에게 있어서 효율적인 클라이언트 연결 처리를 위해서 사용하는 프로그래밍 기법이다. 이번에는 쓰레드풀을 이용한 어플리케이션 제작방법에 대해서 알아보도록 하겠다.


1절. Thread Pooling
1.1절. Thread Pooling 이란
1.1.1절. Thread Pool의 구현방식
1.1.2절. 구현 프로세스
1.2절. 예제
2절. 결론

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

1절. Thread Pooling
1.1절. Thread Pooling 이란
pool 의 사전적인 뜻을 찾아보면 연못, 저수지, 수영장 풀 등 "무엇을 담아놓는" 의 뜻을 가진다. 이대로 해석하자면 Thread Pooling 이란 쓰레드를 담아 놓는 용기(메모리가 될것이다) 를 뜻하며, 프로그래밍 측면에서 해석하자면, "미리 쓰레드를 할당시켜 놓는기법" 을 뜻한다.

그렇다면 쓰레드를 미리 할당시켜 놓는 이유에 대해서 생각해보자, 지금까지 이 사이트에서 다루었던 쓰레드프로그래밍 기법은 기본적으로 fork 방식과 매우 비슷하며, 쓰레드를 생성시켜야 될 필요가 있을때 pthread_create(3)등의 함수를 이용하여 새로운 작업쓰레드를 생성시키는 방식을 사용했다. 보통 쓰레드프로그래밍은 네트웍 프로그래밍시 주로 사용됨으로 accept(2) 로 연결을 기다리다가 연결이 만들어지면 accept 에서 넘어온 소켓 지시자를 인자로 하는 쓰레드를 생성했다.

이러한 방식 - 요청이 있을때 쓰레드를 생성시키는 - 의 쓰레드 프로그래밍기법은 대부분의 작업을 처리하기에 충분히 효율적이며, 빠르긴하지만 클라이언트로 부터의 연결과 종료가 매우 바쁘게 일어나는 서버의 경우, 계속적으로 쓰레드를 생성하고 종료해야 하는 비용을 무시할수 없게 된다. 쓰레드가 비록 fork()에 비해서 생성과 소멸시에 훨씬 적은 비용을 소모한다고는 하지만, 이건 어디까지나 상대적인 것으로 실상은 꽤 많은 시간과 비용을 소비하는 작업이다. 특히 Linux 에서의 Pthread 의 경우 clone(2)를 이용한 구현임으로 더욱더 많은 비용을 소비하게 된다.

Thread Pooling 은 이러한 반복적인 쓰레드의 생성/소멸에 의한 비효율적인 측면을 없애고자 하는 목적으로 만들어진 프로그래밍 기법이다.


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

1.1.1절. Thread Pool의 구현방식
개념적으로 보자면 Thread Pool 을 구성하는건 매우 간단하다. 생성하고자 하는 크기만큼 ptread_create() 함수를 돌리면 되기 때문이다.

하지만 이건 어디까지나 개념적인 것으로 대부분의 경우 각각의 쓰레드를 스케쥴링 해주어야 함으로, 때에 따라서는 구현을 위해서 매우 복잡한 프로그래밍 기법을 동원해야 할때도 있다. 간단히 웹 서버를 Thread Pool 로 구현한다고 가정을 해보자 - 보통 웹서버는 HTTP 의 특성상 연결과/종료가 빈번하게 일어 남으로 쓰레드풀을 사용할경우 많은 이익을 얻을수 있다 -, 만약 100 개의 Thread 를 미리 생성시켰고, 각각의 Thread 는 하나의 클라이언트 연결을 처리한다고 가정했을때, main 쓰레드는 accept(2) 를 통해서 클라이언트를 받아들였을때, accept() 로 만들어진 소켓 지정번호를 미리 만들어진 100 개의 쓰레드중 "놀고" 있는 쓰레드에게 넘겨주어야 할것이다. 그러기 위해서는 main 쓰레드에서 각각의 쓰레드 상태를 유지해서 적당한 쓰레드에게 파일지정자를 넘겨줘야 할것이다.

그나마 위의 경우는 하나의 쓰레드가 하나의 연결을 처리함으로 어렵지 않게 구현하겠지만, 만약 100개의 쓰레드가 있고, 거기에 각각의 쓰레드가 10개 씩의 클라이언트 연결을 처리하도록 구성한다면, 거기에다가 적당한 로드밸런싱 기능 까지 포함시키고자 한다면, 구현이 꽤 복잡해 질수도 있다.






위는 Thread Pool 의 대략적인 구현상태를 그림? 으로 나타낸 것이다. Thread Pool 에 들어있는 각각의 쓰레드를 관리하기 위해서는 필수적으로 각각의 쓰레드의 상태를 가지고 있는 Schedul 자료구조 를 가지고 있어야한다. 그래야만 MAIN THREAD 에서 쓰레드 상태를 확인해서 적당한 쓰레드로 작업분배가 가능할것이기 때문이다. - 실제 Linux 커널도 각각의 task 의 스케쥴링을 위해서 task 구조체를 유지한다. -


1.1.2절. 구현 프로세스
이제 구현방식에 대한 밑그림이 나왔으니, 실제로 구현을 위한 프로세스를 만들어 보도록 하자. 프로세스는 슈도코드로 구성을 하도록 하겠다. 네트웍 서버 작성을 기준으로 하겠다.

스케쥴관련 자료구조 {   현재 연결된 클라이언트수   현재 처리해야될 클라이언트 소켓지시자   쓰레드풀에 만들어진 쓰레드 상태 : 쓰레드풀 크기만큼의 배열   {       0 이면 휴식상태       1 이면 작업상태       처리중인 소켓지시자   } }; main 함수시작 {    아규먼트로 몇개의 쓰레드를 생성할지를 받음    while(쓰레드 생성수만큼)    {        pthread_create 를 이용해서 쓰레드 생성        // 통신쓰레드 함수        {            WAIT:            main 쓰레드가 깨우길 기다린다.            만약 main 쓰레드로 부터 깨움이 있다면              {                스케쥴 자료구조->현재 처리해야될 소켓지시자 를 읽어온다.                스케쥴 자료구조->자신의 상태를 1로 세팅한다.                  스케쥴 자료구조->처리중인 소켓지시자를 세팅한다.                while(1)                {                    클라이언트와 통신한다.                    만약 에러가 발생하면                    {                        스케쥴 자료구조->처리중인 소켓지시자를 0으로 세팅                          스케쥴 자료구조->자신의 상태를 0으로 세팅                        스케쥴 자료구조->현재 연결된 클라이언트수 --;                        goto WAIT:                    }                }            }        }    }    // main 쓰레드    while(1)    {        만약 accept 를 통해서 연결이 발생한다면        {            스케쥴관련 자료구조->현재연결된 클라이언트수가 MAX 를 초과하지 않았다면            {                스케쥴관련 자료구조->현재연결된 클라이언트수 ++;                스케쥴관련 자료구조->현재처리해야될 클라이언트 소켓지시자 = accept();                스케줄관련 자료구조->쓰레드풀에 만들어진 쓰레드상태 가 0인                  쓰레드를 찾아서 해당 쓰레드를 깨운다.              }            그렇지 않고 초과했을경우            {                클랑리언트에게 에러메시지를 전송한다.            }        }    } }

구현은 구현하는 프로그래머가 상황에 따라서 선택하기 나름이긴 하지만 보통은 위의 방법을 기본으로 해서, 약간의 변경을 가하는 정도가 될것이다. 위의 슈도코드를 보면 main 쓰레드에서 accept 를 받으면 휴식상태에 있는 쓰레드를 깨운다고 되어있는데, 이때 깨우기 위해서는 쓰레드 조건변수를 사용하면 될것이다.

그렇다면 스케쥴관련 자료구조는 어떻게 구현하는게 쉬운방법인지 생각해보도록 하자. 구현하는 방법은 프로그래머 맘이겠지만, 필자가 구현하고자 한다면 multimap 을 이용해서 구현할것이다. 이 자료구조는 아마 다음과 같을것이다.

// 쓰레드 정보 구조체 struct ph {   int sockfd;    // 처리중인 소켓지정번호   int index_num; // 쓰레드의 인덱스 번호 }; // 쓰레드 구조체 MAP multimap<int, struct ph> phinfo; struct schedul_info {    int client_num;      // 총 연결중인 클라이언트수    int current_sockfd;  // 가장최근에 연결된 소켓지정번호    phinfo mphinfo;      // 쓰레드 구조체 map }

멀티맵의 key 는 쓰레드의 활성화 여부로 1 혹은 0이 된다. 그리고 value 는 해당 쓰레드 정보가 될것이다. 이렇게 멀티맵으로 만든이유는 간단하다. 멀티맵은 정렬연관 컨테이너 임으로 key 를 기준으로 자동적으로 정렬이 될것이다. 만약 첫번째 쓰레드가 처리중(1)로 변경되었다면 이 원소는 multimap 의 가장 뒤로 정렬이 될것이다. 그럼으로 우리는 클라이언트의 수가 총연결가능한 클라이언트수(Thread Pool 에 생성된 쓰레드수) 를 초과하지 않는한 phinfo.begin() 으로 가져온 쓰레드는 휴식상태(0) 이라는걸 믿을수 있게 된다. 다시 말해서 복잡해서 쓰레드상태가 0인지 1인지 처음부터 검사할 필요가 없다는 뜻이다.  
  1 2 3 4 5 6 7    99 100  : 쓰레드 번호
+-+-+-+-+-+-+-+---+-+-+
|0|0|0|0|0|0|0|...|0|0|
+-+-+-+-+-+-+-+---+-+-+

--> 연결이 들어왔다면
1 2 3 4 5 6 7    99 100  : 쓰레드 번호
+-+-+-+-+-+-+-+---+-+-+
|1|0|0|0|0|0|0|...|0|0|
+-+-+-+-+-+-+-+---+-+-+
|                   |  
+----------->-------+
가장 뒤로 자동으로 sort 됨

--> Sort 후
2 3 4 5 6 7 8   100 1 : 쓰레드 번호
+-+-+-+-+-+-+-+---+-+-+
|0|0|0|0|0|0|0|...|0|1|
+-+-+-+-+-+-+-+---+-+-+

--> 클라이언트가 99개가 접속해 있을경우
+-+-+-+-+-+-+-+---+-+-+
|0|1|1|1|1|1|1|...|1|1|
+-+-+-+-+-+-+-+---+-+-+

그럼으로 begin() 을 사용하게 될경우
언제나 휴식상태에 있는 쓰레드를 가져올수 있음
                               

사실 multimap 을 쓴다면 굳이 "현재 연결된 클라이언트 수" 를 유지하기 위해서 별도의 변수를 둘 필요가 없을것이다. multimap 에서 제공하는 count() 를 이용해서 key 가 "1" 인 요소의 수를 구하면 되기 때문이다. 만약 multimp 의 begin() 값이 1 이라면 MAX 클라이언트가 가득찼다는걸 의미할것이다.

물론 multimap 의 경우 기본적으로 key 값의 수정은 허용하지 않기 때문에 0 을 1로 변경할경우 실제로는 0 을 가지는 요소를 삭제하고, 1을 가지는 새로운 요소를 삽입하는 방식을 취해야 할것이다. 마찬가지로 클라이언트가 종료해서 1을 0으로 변경할때에도 삭제/인서트를 해야할것이다. Value(값) 는 그대로 복사해서 삭제/인서트를 해야 한다.

이 방법이 번거롭다면, 그냥 배열을 쓰거나 혹은 다른 어떤 자료구조를 쓰더라도 전혀 관계없기는 하다. 그건 자기의 기호에 맞게 선택해서 사용하면 될문제이다.


1.2절. 예제
지금까지 Thread POOL 의 구현방법에 대해서 알아봤으니, 간단하게 구현해 보도록 하겠다. 이 코드는 지극히 기능구현에만 신경쓴 코드이다. 에러처리와 몇군데 뮤텍스잠금처리는 각자의 재량에 맡기겠다.

예제 : pool_echo.cc
#include <map> #include <iostream> #include <pthread.h> #include <unistd.h> #include <stdlib.h> #include <time.h> #include <sys/socket.h> #include <sys/stat.h> #include <signal.h> #include <arpa/inet.h> #include <sys/un.h> #include <stdio.h> #include <stdlib.h> #include <string.h> // 최대 쓰레드 POOL 크기 #define MAX_THREAD_POOL 256 using namespace std; // 전역 쓰레드 구조체 typedef struct _ph {    int sockfd;    // 현재 사용중인 소켓 fd    int index_num; // 인덱스 번호 } ph; // 전역쓰레드 구조체로써 // 현재 쓰레드 상황을 파악함 struct schedul_info {    int client_num;       // 현재 연결된 클라이언트수    int current_sockfd;   // 가장최근에 만들어진 소켓지시자    multimap<int, ph> phinfo; }; // 각 쓰레드별 조건변수 pthread_cond_t *mycond; // 쓰레드 동기화를 위한 조건변수 pthread_cond_t async_cond = PTHREAD_COND_INITIALIZER; // 각 쓰레드별 조건변수의 크리티컬세션 지정을 위한 // 뮤텍스 pthread_mutex_t mutex_lock= PTHREAD_MUTEX_INITIALIZER; // 쓰레드 동기화용 조건변수의 크리티컬세션 지정을 위한 // 뮤텍스 pthread_mutex_t async_mutex = PTHREAD_MUTEX_INITIALIZER; // 클라이언트와의 통신용 쓰레드 void *thread_func(void *data); // 현재 클라이언트 상태 모니터용 쓰레드 // 한마디로 디버깅용 void *mon_thread(void *data); schedul_info s_info; // 메인 함수 int main(int argc, char **argv) {    int i;    ph myph;    int status;    int pool_size = atoi(argv[2]);    pthread_t p_thread;    struct sockaddr_in clientaddr, serveraddr;    int server_sockfd;    int client_sockfd;    int client_len;        // 풀사이즈 검사    if ((pool_size < 0) || (pool_size > MAX_THREAD_POOL))    {            cout << "Pool size Error" << endl;        exit(0);        }    // Make Socket    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)    {        perror("error : ");        exit(0);    }    // Bind    bzero(&serveraddr, sizeof(serveraddr));    serveraddr.sin_family = AF_INET;    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);    serveraddr.sin_port = htons(atoi(argv[1]));    if (bind (server_sockfd, (struct sockaddr *)&serveraddr,                        sizeof(serveraddr)) == -1)    {        perror("bind error : ");        exit(0);    }    // Listen    if (listen(server_sockfd, 5) == -1)    {        perror("listen error : ");        exit(0);    }    // 쓰레드 갯수만큼 조건변수 생성    mycond     = (pthread_cond_t *)malloc(sizeof(pthread_cond_t)*pool_size);    // 쓰레드 전역변수 초기화    s_info.client_num = 0;    s_info.current_sockfd = 0;    // 쓰레드 POOL 새성    for (i = 0; i < pool_size; i++)    {        memset((void *)&myph, 0x00, sizeof(myph));        myph.index_num = i;        s_info.phinfo.insert(pair<int, ph>(0, myph));        // 조건변수를 이용해서 쓰레드간 동기화를 실시한다.        pthread_mutex_lock(&async_mutex);        if (pthread_create(&p_thread, NULL, thread_func, (void *)&i) < 0)        {            perror("thread Create error : ");            exit(0);            }            pthread_cond_wait(&async_cond, &async_mutex);        pthread_mutex_unlock(&async_mutex);    }    // 디버깅용 쓰레드 생성    pthread_create(&p_thread, NULL, mon_thread, (void *)NULL);    // MAIN THREAD accept wait    client_len = sizeof(clientaddr);    // 클라이언트 ACCEPT 처리를 위한    // MAIN 쓰레드    while(1)    {        multimap<int, ph>::iterator mi;        client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr,                                        (socklen_t *)&client_len);        if (client_sockfd > 0)        {            // 만약 쓰레드풀이 가득찼다면 클라이언트 연결을            // 종료시킨다.            mi = s_info.phinfo.begin();            if (mi->first == 1)            {                //error message send to client_sockfd                cout << "SOCKET IS FULL" << endl;                    close(client_sockfd);            }            // 그렇지 않다면 연결을 받아들이고            // 클라이언트 전역 변수를 세팅한다.            // 세팅후 해당 처리쓰레드에게 시그널을 보내어서            // 처리하게 한다.            else            {                ph tmpph;                int psockfd;                int pindex_num;                s_info.current_sockfd = client_sockfd;                tmpph.sockfd = client_sockfd;                tmpph.index_num = mi->second.index_num;                s_info.phinfo.erase(mi);                    s_info.phinfo.insert(pair<int, ph>(1,tmpph));                s_info.client_num ++;                cout << "SEND SIGNAL " << mi->second.index_num << endl;                    pthread_cond_signal(&mycond[mi->second.index_num]);                }        }        else        {            cout << "ACCEPT ERROR " << endl;            }    }    pthread_join(p_thread, (void **)status); } void *thread_func(void *data) {    char buf[255];    int mysocket;    int mynum = *((int *)data);    multimap<int, ph>::iterator mi;    // 쓰레드 동기화용 조건변수    pthread_mutex_lock(&async_mutex);    pthread_cond_signal(&async_cond);    pthread_mutex_unlock(&async_mutex);    cout << "Thread create " << mynum << endl;    while(1)    {        // MAIN 쓰레드로 부터 신호를 기다린다.        // 신호가 도착하면 쓰레드 전역변수로 부터        // 현재 처리해야할 소켓지정값을 가져온다.        pthread_mutex_lock(&mutex_lock);        pthread_cond_wait(&mycond[mynum], &mutex_lock);        mysocket = s_info.current_sockfd;        pthread_mutex_unlock(&mutex_lock);        memset(buf, 0x00, 255);            // 데이타를 처리한다.        // 만약 quit 문자열을 만나면        // 쓰레드 전역변수를 세팅한다음 연결종료 한다.        while(1)        {            read(mysocket, buf, 255);            if (strstr(buf, "quit") == NULL)            {                write(mysocket, buf, 255);            }            else            {                mi = s_info.phinfo.begin();                while(mi != s_info.phinfo.end())                {                    cout << "search " << mi->second.index_num << endl;                    if (mi->second.index_num == mynum)                    {                        ph tmpph;                        tmpph.index_num = mynum;                        tmpph.sockfd = 0;                        s_info.phinfo.erase(mi);                        s_info.phinfo.insert(pair<int, ph>(0, tmpph));                        s_info.client_num --;                        close(mysocket);                        break;                    }                    mi ++;                }                break;            }            memset(buf, 0x00, 255);            }    } } void *mon_thread(void *data) {    cout << "moniter thread" << endl;    while(1)    {        sleep(10);        multimap<int, ph>::iterator mi;        mi = s_info.phinfo.begin();        cout << "size " << s_info.phinfo.size() << endl;        while(mi != s_info.phinfo.end())        {            cout << mi->first << " : " << mi->second.index_num                 << " : " << mi->second.sockfd << endl;            mi ++;        }    } }

이 프로그램은 2개의 인자를 받아들이며, 클라이언트의 입력을 되돌려주는 일을한다 (echo 서버). 첫번째 인자는 서비스할 PORT 번호이고, 두번째 인자는 쓰레드 생성갯수이다. 프로그램은 인자의 정보를 이용해서 PORT 를 열고 클라이언트를 받아들인다. 클라이언트가 연결하면, Thread Pool 에 남는 공간이 있는지를 확인하고, 남는 공간이 있다면 클라이언트와 통신하게 된다.

단지 쓰레드를 미리 생성시키고 나서, 이것을 스케쥴링하기 위한 코드가 몇줄 추가되었을 뿐 특별히 복잡한 코드는 아닐거라고 생각된다.


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

2절. 결론
이상 간단한 쓰레드 풀의 작성요령에 대해서 알아보았다. 위에서 설명했듯이 쓰레드 풀이란 개념적인 요소에 가까움으로 어떻게 구현할지는 상황에 따라서 매우 달라지게 되며, 위의 예제는 그러한 여러가지 상황중 가장 기본적인 상황을 예로 해서 만들어진 것이다. 어쨋든 위의 예제를 충분히 이해한다면 다른 상황으로의 응용역시 별 어려움없을 것이라고 생각된다.

쓰레드 풀은 보통 매우 효율적인 성능을 보장해주는 어플리케이션의 작성을 위해서 사용되어짐으로, 가능한한 빠른 쓰레드간 전환이 가능하도록 고민해서 코딩을 해야 한다. 위의 경우 쓰레드간 전환을 위해서 multimap 을 사용하고 있는데, accept 가 들어왔을경우 해당 클라이언트에 대한 쓰레드 할당은 매우 빠르다고 볼수 있을것이다. 그러나 종료할경우에는 multimap 의 첫번째 원소부터 마지막번 원소까지 search 해야 한다. 이것은 매우 비효율적임으로 개선할 여지가 있다. 가장 간단하게 생각할수 있는 것은 multimap 의 key 값이 1인 원소내에서만 검색하는 것이다. 우리는 쓰레드 풀의 크기와 현재 연결된 클라이언트의 수를 알고 있음으로, multimap 의 몇번째 요소부터 key 값이 1인지를 계산해 낼수 있기 때문이다. 이렇게 할경우 약간의 시간단축효과를 기대할수 있을것이다.    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|0|0|0|0|0|0|0|0|1|1|1|1|1|1|1|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
                 |             |
                 +-------------+
                     15 - 8
               

이 시간단축효과는 연결된 클라이언트의 수가 전체 POOL 사이즈에 비례해서 작을 수록 커질것이다.

나머지 방법은 각자 고민을 해보기 바란다. 아마 전혀 다른 자료구조를 사용할수도 있을것이다.


출처 : http://joinc.co.kr/modules.php?name=new ··· 3Dnested

Visual C++ 개념: C/C++ 프로그램 빌드

시간 중심의 코드 성능 향상을 위한 팁
빠른 코드를 작성하려면 해당 응용 프로그램의 모든 측면을 이해하고 시스템과 상호 작용하는 방법을 이해해야 합니다. 이 항목에서는 시간 중심의 코드 부분 성능을 향상시킬 수 있는 코딩 기법을 설명합니다.

요컨대, 시간 중심의 코드 성능을 향상시키려면 다음 사항을 알고 있어야 합니다.

프로그램에서 속도가 빨라야 하는 부분
코드의 크기와 속도
새로운 기능 사용에 따른 비용
작업 수행에 필요한 최소 작업
코드의 성능에 대한 정보는 성능 모니터(perfmon.exe)를 사용하여 얻을 수 있습니다.

캐시 적종 및 페이지 폴트
정렬 및 검색
MFC 및 클래스 라이브러리
공유 라이브러리
힙
스레드
작은 작업 집합
캐시 누락 및 페이지 폴트

프로그램 명령어 및 데이터를 찾아 보조 저장 장치로 이동하는 페이지 폴트뿐만 아니라 내부 및 외부 캐시에 대한 누락된 캐시 적중은 프로그램 성능을 저하시킵니다.

CPU 캐시 적중은 10–20 클럭 주기가 소요될 수 있습니다. 외장 캐시 적중은 20–40 클럭 주기가 소요될 수 있습니다. 프로세서가 초 당 5억개의 명령어를 처리하고 페이지 폴트 1회 당 2밀리초의 시간이 걸린다고 가정할 때 페이지 폴트는 100만 클럭 주기가 소요될 수 있습니다. 따라서 누락된 캐시 적중 및 페이지 폴트 횟수를 줄이는 코드를 작성하면 프로그램 실행 성능이 향상됩니다.

프로그램의 속도가 느린 이유 중 하나는 필요 이상으로 페이지 폴트가 많거나 캐시가 누락되기 때문입니다. 이러한 문제를 방지하려면 참조 집약성이 좋은 데이터 구조를 사용하는 것이 중요합니다. 참조 집약성이란 관련된 항목을 함께 두어 참조하기 쉽도록 하는 것을 의미합니다. 보기 좋은 데이터 구조라도 참조 집약성이 미약하면 속도가 느릴 수 있고 그 반대인 경우도 있습니다. 두 가지 예를 들겠습니다.

항목을 검색하거나 목록의 끝까지 이동할 때 건너 뛴 각 연결마다 캐시가 누락되거나 페이지 폴트가 발생할 수 있기 때문에 동적으로 할당된 연결 리스트는 프로그램 성능을 저하시킬 수 있습니다. 간단한 배열을 기초로 목록을 구현하면 캐싱은 더 좋아지고 페이지 폴트는 줄어들기 때문에 실제로 속도는 더 빨라질 수 있습니다. 배열의 크기가 커지기는 더 어려울 것이라는 사실을 감안하더라도 속도는 여전히 더 빠를 것입니다.
동적으로 할당된 연결 리스트를 사용하는 해시 테이블은 성능을 저하시킬 수 있습니다. 확장되는 경우 동적으로 할당된 연결 리스트를 사용하여 내용을 저장하는 해시 테이블의 성능은 그보다 상당히 더 떨어질 것입니다. 실제로 최종 분석에서는 상황에 따라 배열을 통한 단순한 선행 검색이 실제로 더 빠를 수 있습니다. "폐쇄형 해시"라는 배열 기반 해시 테이블은 종종 간과되긴 하지만, 성능이 뛰어난 구현 방법입니다.
정렬 및 검색
정렬은 일반적인 많은 작업에 비해 시간이 많이 소모됩니다. 불필요한 속도 저하를 방지하는 가장 좋은 방법은, 작업을 빨리 수행해야 하는 시간에는 정렬을 수행하지 않는 것입니다. 다음과 같은 방법을 사용할 수 있습니다.

작업을 빨리 수행해야 하는 시간이 지난 후에 정렬을 수행합니다.
작업을 빨리 수행해야 하는 시간 이전에 미리 데이터를 정렬합니다.
반드시 정렬해야 하는 데이터 부분만 정렬합니다.
경우에 따라서는 목록을 정렬된 순서로 빌드할 수 있습니다. 정렬된 순서로 데이터를 삽입해야 할 경우 참조 집약성이 떨어지는 더 복잡한 데이터 구조를 사용하게 되면 캐시 누락과 페이지 폴트가 발생할 수 있으므로 주의해야 합니다. 모든 경우에 적용할 수 있는 방법은 없습니다. 여러 방법을 사용해 보고 차이점을 평가해 보십시오.

다음은 정렬에 관한 몇 가지 일반적인 팁입니다.

스톡 정렬을 사용하여 버그를 최소화합니다.
정렬의 복잡성을 줄이기 위한 사전 작업을 하면 도움이 됩니다. 데이터를 한 번 전달하여 비교를 단순화하고 정렬을 O(n log n)에서 O(n)으로 줄이면 결과가 확실하게 미리 나타납니다.
실행하려고 하는 데이터와 정렬 알고리즘의 참조 집약성을 고려합니다.
검색은 정렬보다 사용할 수 있는 방법이 적습니다. 검색에서 시간이 중요한 경우에는 이진 검색이나 해시 테이블 조회가 가장 좋은 방법이지만 정렬의 경우와 마찬가지로 집약성을 염두에 두어야 합니다. 작은 배열을 통한 선형 검색은 페이지 폴트나 캐시 누락을 초래하는 포인터가 많은 데이터 구조를 통한 이진 검색보다 더 빠를 수 있습니다.

MFC 및 클래스 라이브러리
MFC(Microsoft Foundation Classes)를 사용하면 코드를 작성하는 일이 매우 간단해질 수 있습니다. 시간 중심 코드를 작성할 때는 일부 클래스에 내재하는 오버헤드를 주의해야 합니다. 시간 중심 코드에서 사용하는 MFC 코드를 검토하여 성능 요구 사항에 맞는지 확인하십시오. 다음은 반드시 알고 있어야 하는 MFC 클래스 및 함수 목록입니다.

CString MFC는 C 런타임 라이브러리를 호출하여 CString에 메모리를 동적으로 할당합니다. 일반적으로 Cstring은 동적으로 할당된 다른 문자열만큼 효율적이며, 동적으로 할당된 모든 문자열과 마찬가지로 동적 할당 및 해제에 따르는 오버헤드를 지닙니다. 스택에서의 간단한 char 배열을 사용하면 같은 작업을 더 빨리 수행할 수 있습니다. 상수 문자열을 저장하려면 Cstring을 사용하지 말고 const char *를 대신 사용합니다. CString 개체를 사용하여 수행하는 모든 작업에는 약간의 오버헤드가 따릅니다. 런타임 라이브러리인 문자열 함수를 사용하는 것이 더 빠를 수 있습니다.
CArray CArray는 일반 배열과는 달리 융통성을 제공하지만 프로그램에 융통성이 필요하지 않을 수도 있습니다. 배열의 구체적인 한계를 알면 대신 전역 고정 배열을 사용할 수 있습니다. Carray를 사용하는 경우에는 CArray::SetSize를 사용하여 크기를 설정하고, 재할당이 필요할 경우 Carray를 몇 개 요소만큼씩 증가시킬지를 지정하십시오. 이 값을 지정하지 않고 요소를 추가하면 배열이 자주 재할당되고 복사될 수 있는데, 이는 비효율적이며 메모리가 단편화될 수 있습니다. 또한 항목을 배열에 삽입하면 Carray는 다음 항목을 메모리로 이동시켜 배열의 크기가 커질 수 있습니다. 이로 인해 캐시 누락과 페이지 폴트가 발생할 수 있습니다. MFC에서 사용하는 코드를 검토하면 시나리오와 관려된 더 구체적인 코드를 작성하여 성능을 향상시킬 수 있습니다. 예를 들어, Carray는 템플릿이므로 특정 형식에 Carray 특수화를 제공할 수 있습니다.
CList CList는 이중 연결 리스트이므로 리스트의 맨 위, 맨 아래 및 알려진 위치(POSITION)에서 요소를 삽입하는 작업의 속도는 매우 빠릅니다. 요소를 값 또는 인덱스로 조회하려면 순차 검색이 필요하지만 리스트가 길면 오래 걸릴 수 있습니다. 코드에 이중 연결 리스트가 필요하지 않은 경우에는 Clist 사용을 다시 고려할 수 있습니다. 단일 연결 리스트를 사용하면 모든 작업에 대한 추가 포인터와 해당 포인터에 대한 메모리를 업데이트하는 오버헤드가 줄어듭니다. 추가로 사용되는 메모리 양은 얼마 안되지만 캐시 누락이나 페이지 폴트의 또 다른 원인이 됩니다.
IsKindOf 이 함수는 많은 호출을 생성하고 서로 다른 데이터 영역의 많은 메모리에 액세스할 수 있으므로 참조 집약성이 떨어지게 됩니다. 디버그 빌드(예: ASSERT 호출)에는 유용하지만 릴리스 빌드에서는 사용하지 않는 것이 좋습니다.
PreTranslateMessage 창의 특정 트리에 여러 키보드 액셀러레이터 키가 필요하거나 메시지 펌프에 메시지 처리를 삽입해야 할 때 PreTranslateMessage를 사용합니다. PreTranslateMessage는 MFC 디스패치 메시지를 변경합니다. PreTranslateMessage를 재정의하는 경우에는 필요한 수준에서만 재정의하십시오. 예를 들어, 특정 뷰의 하위 뷰로 전달되는 메시지에만 관심이 있다면 CMainFrame::PreTranslateMessage를 재정의할 필요가 없습니다. 대신 뷰 클래스의 PreTranslateMessage를 재정의하십시오.
창으로 보낸 메시지를 처리하려면 PreTranslateMessage를 사용하여 정상적인 디스패치 경로를 우회하지 마십시오. 정상적인 디스패치 경로를 우회하려면 창 프로시저와 MFC 메시지 맵을 사용하십시오.

OnIdle WM_KEYDOWN과 WM_KEYUP 이벤트 사이처럼 예상치 않은 시간에 유휴 이벤트가 발생할 수 있습니다. 코드를 트리거할 때는 타이머를 사용하는 것이 더 효율적인 방법일 수 있습니다. 거짓 메시지를 작성하거나 OnIdle 재정의에서 항상 TRUE를 반환하여 OnIdle이 강제로 반복 호출되지 않도록 하십시오. 이렇게 하면 스레드가 대기할 수 없게 됩니다. 이 경우에도 타이머나 별도의 스레드를 사용하는 것이 더 효율적일 수 있습니다.
공유 라이브러리
코드를 다시 사용하는 것이 바람직합니다. 그러나 다른 사람이 작성한 코드를 사용하려는 경우, 성능이 중요한 작업에 어떤 영향을 미치는지 정확히 알아야 합니다. 가장 좋은 방법은 소스 코드를 단계별로 실행하거나 PView 또는 성능 모니터 등의 도구를 사용하여 측정하는 것입니다.

힙
여러 개의 힙을 사용할 때는 신중해야 합니다. HeapCreate 및 HeapAlloc으로 만들어진 힙을 사용하여 관련된 할당 집합들을 관리한 다음 삭제할 수 있습니다. 너무 많은 메모리를 커밋하지 않도록 하십시오. 여러 힙을 사용하는 경우 처음에 커밋되는 메모리 양에 특히 주의하십시오.

여러 힙을 사용하는 대신 코드와 기본 힙 사이의 인터페이스에 대해 도우미 함수를 사용할 수 있습니다. 도우미 함수를 사용하면 응용 프로그램의 성능을 향상시킬 수 있는 사용자 지정 할당 전략을 쉽게 작성할 수 있습니다. 예를 들어, 작은 할당을 자주 수행하는 경우 기본 힙의 한 부분으로 할당을 지역화할 수 있습니다. 큰 블록의 메모리를 할당한 다음 도우미 함수를 사용하여 그 블록에서 다시 할당할 수 있습니다. 이 방법을 사용하면 기본 힙에서 할당이 이루어지므로 사용되지 않은 메모리를 지니는 추가 힙이 없어집니다.

그러나, 기본 힙을 사용하면 참조 집약성이 떨어지는 경우도 있습니다. 프로세스 뷰어, Spy++ 또는 성능 모니터를 사용하여 힙 간에 이동하는 개체의 영향을 측정하십시오.

힙을 측정하면 힙에 대한 모든 할당을 설명할 수 있습니다. C 런타임 디버그 힙 루틴을 검사점으로 사용하고 힙을 덤프합니다. Microsoft Excel 등의 스프레드시트 프로그램으로 결과를 읽어 오고 피벗 테이블을 사용하여 결과를 볼 수 있습니다. 할당의 전체 수, 크기 및 분포를 기록하고 작업 집합 크기와 비교하십시오. 관련 크기의 개체 클러스터링도 검토하십시오.

성능 카운터를 사용하여 메모리 사용을 모니터링할 수도 있습니다.

스레드
백그라운드 작업의 경우 이벤트 유휴 상태를 효율적으로 처리하는 것이 스레드를 사용하는 것보다 더 빠를 수 있습니다. 단일 스레드 프로그램에서는 참조 집약성을 이해하기가 더 쉽습니다.

가장 좋은 방법은 차단한 운영 체제 알림이 백그라운드 작업의 루트에 있는 경우에만 스레드를 사용하는 것입니다. 이러한 경우 이벤트에 대한 주 스레드를 차단하는 것이 비실용적이기 때문에 스레드를 사용하는 것이 가장 좋은 해결 방법입니다.

또한 스레드를 사용할 때는 통신 문제도 있습니다. 메시지 목록을 사용하거나 공유 메모리를 할당하여 사용하여 스레드 사이의 통신 연결을 관리해야 합니다. 통신 연결을 관리하려면 일반적으로 경쟁 상태와 교착 상태 문제를 방지하기 위해 동기화가 필요합니다. 이러한 복잡성 때문에 버그와 성능 문제가 발생하기 쉽습니다.

자세한 내용은 유휴 루프 처리 및 다중 스레딩을 참조하십시오.

작은 작업 집합
작업 집합의 크기가 작아질수록 참조 집약성은 더 좋아지고, 페이지 폴트는 줄어들며, 캐시 적중은 더 높아집니다. 프로세스 작업 집합은 운영 체제에서 참조 집약성을 측정하기 위해 직접 제공하는 가장 가까운 메트릭입니다.

작업 집합의 상한 및 하한을 설정하려면 SetProcessWorkingSetSize를 사용합니다.
작업 집합의 상한 및 하한을 구하려면 GetProcessWorkingSetSize를 사용합니다.
작업 집합의 크기를 보려면 Spy++를 사용합니다.

출처 : http://msdn.microsoft.com/library/kor/d ··· code.asp

Sep 28 2002 20:23 Written by www.taeyo.pe.kr


상태바위에 ProgressBar올리기 #2




안녕하세요?
이번것은 Progress 콘트롤이 작동할때 생기고 끝나면 사라지게 합니다.
약간은 복잡할수도 있습니다만.. 일단 따라해 보시구 궁금하면 물어주세요...앙


1. 우선 기본적인 MFC의 SDI골격을 갖춘 윈도우를 Wizard를 통해 만들고 나서...

2. 위저드에서 New Class를 통해 베이스클래스가 CStatusBarCtrl 인
우리가 만들 클래스 CMyStatusBar를 만듭니다.
이렇게하면 편하기 땜에 만드는 거지요..
잘 만들어졌지요?
근데 우리가 만들 클래스의 부모는 CStatusBarCtrl 잖아요..
이걸 CStatusBar로 다 바꿔주세요..
왜냐구요? 헤헤.. 지두 잘 몰라요.
어쩄거나 바꿔 주셔야합니다.
메뉴에서 EDIT인가에 Replace인가가 있죠?
우리가 만든 CMYStatusBar.h 와 CMyStatusBar.cpp 내에 있는
CStatusBarCtrl라는건 죄다 CStatusBar로 바꿔줍니다.
일일이 찾아서 해 줘도 되지만..그래도 Replace.

3. 그리고 난뒤 메인프레임의 헤더에 가 보면 CStatusBar m_wndStatusBar; 라는 부분이 있죠?
그걸 바꿔줍니다.
CMyStatusBar m_wndStatusBar; 로 이제 내가 만든클래스를 이용할수 있어요..
현재까지는 한게 없지요?
그냥 놔둬도 되는걸 왜 건드리는지??
하지만 이제부터입니다.
이제 상태바를 내 맘대로 조종할수 있대요..
내 클래스에 코딩함으로서 말이지요.

4. 내가 만든 클래스 안에 CProgressCtrl m_Prog;를 선언해줍니다.
왜냐구요?
상태바애 Progress콘트롤 올려야 하잖아요..

5. 자..이제 코딩. 역시 멤버함수를 하나 만듭니다.
이름은 DisplayProgress()으로..

void CMyStatusBar::DisplayProgress() { CRect rc; GetItemRect(0,rc); rc.left = rc.Width()/3; if(!m_Prog.Create(WS_CHILD|WS_VISIBLE,rc,this,IDW_PROGRESS)) { AfxMessageBox("실패"); return; } SetPaneText(0,"파일로딩중"); UpdateWindow(); m_Prog.SetRange(0,100); m_Prog.SetPos(20); for(int i=0;i<25;i++) { ::Sleep(500); m_Prog.SetPos(i*4); } m_Prog.DestroyWindow(); SetPaneText(0,"파일로드 완료"); }

설명 : IDW_PROGRESS는 역시 Resource Symbols에서 등록해주고..
어디서든 이 함수를 호출하면 상태바에 프로그레스가 생기고 동작하고 사라집니다.
메인프레임에서 호출하는게 좋겠죠? 상태바객체가 메인프레임에 있으니까...
m_wndStatusBar.DisplayProgress() 라고 하면 되겠죠?? 하하하

Sep 28 2002 20:14 Written by www.taeyo.pe.kr


상태바위에 ProgressBar올리기 #1


안녕하세요?


1. 먼저 CProgressCtrl m_wndProg; 를 선언한다.

2. 상태바에 Progress 콘트롤을 올리게 하는 함수를 만듭니다.
멤버함수를 추가한다는 것이지요.
이름은 InitProgress()로 합시다.

void CMainFrame::InitProgress() { if (!m_wndProg.Create(WS_CHILD|WS_VISIBLE, CRect(0,0,0,0), &m_wndStatusBar, ID_PROGRESS)) { AfxMessageBox("ProGress콘트롤 생성 실패!!"); } m_wndProg.SetRange(0,100); m_wndProg.SetPos(50); }

설명 : 위에서 ID_PROGRESS는 Resource Symbols에서 정의해주어야 한다.
progress 콘트롤의 범위와 위치는 일단 가정해준다. 눈으로 봐야하니까...

　

3. 자!! 그다음엔 메인프레임의 OnCreate()에서 위의 함수를 호출하면 됩니다.
그렇게 했는데 눈에 안보인다구요?? 당연하지요...
왜냐하면 윈도우의 사이즈가 변할떄마다 다시 그려줘야 하잖겠어요???
해서 메인프레임의 OnSize(UINT nType, int cx, int cy)에 맵핑해줍니다.

void CMainFrame::OnSize(UINT nType, int cx, int cy) { if (m_wndProg.m_hWnd) { CRect rc; m_wndStatusBar.GetItemRect(1,rc); m_wndProg.SetWindowPos(NULL, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER); } }

상태바의 rc를 얻어서 그 위에 Progress를 올립니다.
메인프레임의 사이즈가 변경될 때마다 말이지요...

Apr 08 2003 11:10 Written by sinalove (codenuri.com members)



다이얼로그 박스상의 특정 컨트롤의 색상을 변경하는 방법입니다.

이는 VB나 델파이에서는 아주 쉽게 할 수 있는 일이지만 다이얼로그 박스 클래스에서 좀 복잡합니다.
일단 다이얼로그 클래스의 WM_CTLCOLOR 메시지에 대한 처리 함수를 정의합니다.
그 안의 코드를 다음과 같이 변경합니다.
참고로 IDC_TEXTOUT은 색상을 변경하고자 하는 스태틱 컨트롤의 ID라고 하겠습니다.

HBRUSH CTifTestView::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) { HBRUSH hbr = CRecordView::OnCtlColor(pDC, pWnd, nCtlColor); if (pWnd->GetDlgCtrlID() == IDC_TEXTOUT) { pDC->SetTextColor(RGB(255, 0, 0)); // 빨강색으로 출력하고자할 경우에 사용한다. } return hbr; }

Nov 20 2002 10:28 Written by www.anygate.com


1. 무슨 얘기지?

대화상자는 사용자와 프로그램간의 상호 의사전달을 용이하게 하는 도구이다.
사용자의 명령을 처리하기 위해 적당한 정보를 알려주고 또 필요한 정보를 입력받는다.
이 과정에서 대화상자는 모든 정보를 스스로 생성하여 제시하지는 않는다.
대화상자 자체가 프로그램의 부수적인 기능일 뿐이므로
대부분의 정보는 메인 프로그램이 갖게된다.
따라서 대화상자를 호출하기 전에 대화상자에서 필요한 데이터를 전달해 주어야 한다.
(물론 그 데이터가 전역변수라면 상관이 없겠지만...)
여기서 하려는 얘기는 바로 그 전달 방법이다.


2. 가장 일반적인 방법

참고서적의 가장 흔한 주제가 대화상자이고 거기서 빈번하게 사용하는 코드는 다음과 같다.
많이 봤을테니 설명이 필요없겠죠?

CMyDlg dlg; dlg.m_data = myData1; // dialog box의 멤버변수에 직접 전달하는 경우. dlg.SetData( myData2 ); // dialog box의 멤버함수를 사용하는 경우. dlg.DoModal();

3. 생성자를 통해 전달하는 방법

이렇게 하면 더 간단하지 않을까?

CMyDlg dlg( myData1, myData2 ); // dialog box의 생성자에 데이터 전달. dlg.DoModal();

그러자면 클래스위저드가 생성해준 대화상자 클래스를 조금 수정해야 한다.

먼저 헤더파일의 클래스 선언중 생성자 원형을 다음과 같이 수정한다.
원래의 생성자는 지워도 되고 그대로 둔 채 새로운 생성자를 추가해도 된다.

class CMyDlg : public CDialog { public: CMyDlg( CWnd* pParent = NULL ); // 표준 생성자 CMyDlg( MYDATA1 myData1, MYDATA2 myData2 ); // 새로운 생성자 ... };

다음에 cpp 파일의 정의부분을 수정한다.
마찬가지로 기존의 생성자는 지워도 되고 그대로 둔 채 새로운 생성자함수를 추개해도 된다.
그대로 둘 경우엔 어떤 생성자를 사용해서 대화상자를 호출할 것인가는 프로그래머 맘대로다.

CMyDlg::CMyDlg( CWnd* pParent /*=NULL*/ ) : CDialog( CDbNewDlg::IDD, pParent ) { ... // 기존의 생성자 } CMyDlg::CMyDlg( MYDATA1 myData1, MYDATA2 myData2 ) : CDialog(CMyDlg::IDD, NULL) { ... // 새로운 생성자 }

위에서 MYDATA1, MYDATA2는 임의의 데이터형이다.
원래의 형태와 수정된 형태를 잘 비교해 보라.
생성자에 전달하는 인자의 데이터형과 갯수는 제한이 없다.
참, 생성자를 통해 전달된 인수는 생성자 함수 내에서만 유효하므로
생성자에서 대화상자의 적당한 멤버변수에 대입하여 저장해두어야 한다.
(엄청나게 당연한 거지만 왕초보를 위해 덧붙임.)

Nov 19 2002 14:23 Written by findit (codenuri.com member)


에구 제가 이런곳에 글을 올리게 될줄은 몰랐네요.
저는 전문가용 응용풀을 작업중입니다.
그러던중 아주 머리아픈 고민을하게 되었죠.
윈도우 스타일에 대한 고민입니다.

일반적인 윈도우 스타일이라하면,
타이틀바가 있고 메뉴와 툴바 그리고 상태바를 가지고 있으며,
일정한 뷰영역을 확보한 모양이 일반적입니다.

그런데 제가 생각한것은 타이틀바를 제거하고,
메뉴와 상태바도 제거된 즉,툴바와 뷰영역만 존재하는 스타일입니다.
또한 전체화면을 마치 DirectX 처럼 장악해야 하지요.
탭버튼에 의해 뒤쪽의 응용풀이 나오는건 상관없구요.
거참 이런 스타일에 메인프레임을 해보긴 첨이었습니다.
고민하던중 Visual C++ Programmer Bible(영진출판사) 에서 해결책을 찾아냈습니다.
혹시나해서 저와같은 분들에게 도움이 될까해서 이곳에 작업내용을 남깁니다.
뭐 그리 거창한 내용은 아니지만 필요한분에게 유익한 내용이 되길 바래봅니다.


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

1. 먼저 상태바를 제거하기 위해 아래부분을 주석처리한다.

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) { ........ /* if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT))) { TRACE0("Failed to create status bar\n"); return -1; // fail to create } */ .......

2. 다음 메뉴를 제거하기 위해 다음을 추가한다.

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) { .......... CMenu *pMenu = new CMenu; pMenu->Attach( cs.hMenu ); pMenu->DestroyMenu(); cs.hMenu = NULL; ........

3. 다음 윈도우 스타일을 새로이 갱신해 주기 위해
PreCreateWindow() 함수에 다음내용을 추가한다.

cs.style = WS_VISIBLE | WS_POPUP; cs.x = 0; cs.y = 0; cs.cx = GetSystemMetrics( SM_CXMAXTRACK ); cs.cy = GetSystemMetrics( SM_CYMAXTRACK );

이상의 내용을 조금만 손질해 주면 마치 DirectX 처럼 전체 화면을 장악하고
왠지 전문가 시스템같은 상단에 툴바와 덩그런 뷰영역이 화면을 가득채우는
그런 모양의 윈도우가 만들어 지게 됩니다.

헤헤 별거 아니지요 !!!!
암튼 삽질의 고통에서 조금이나 벗어나 디버그 창이 밝은 세상을 꿈꾸며 몇자 적어 올립니다.
모두들 즐프하세요 ... ㅎㅎ

Aug 30 2002 18:36   Written by codenuri.com



뷰에 컨트롤 그리기


1. 버튼 컨트롤

1) 뷰 클래스 헤더파일에 버튼을 위한 포인터를 하나 추가한다.

CButton *pButton;

2) 포인터를 만든 후, 버튼 객체를 new 연산자를 이용하여 객체를 생성한다.
OnInitialUpdate() 함수는 뷰가 생성된 후
윈도우에 그려지기 바로 직전에 호출되는 함수이다.
따라서 여기서 버튼의 초기화를 한다.
new 연산자는 필요하다면 생성자에 넣어도 된다.

void CMyCtrlView::OnInitialUpdate() { CView::OnInitialUpdate(); // TODO: Add your specialized code here and/or call the base class pButton = new CButton(); pButton->Create("Test Button", BS_DEFPUSHBUTTON, CRect(0,0,200,50), this, 100); }

3) 다음은 버튼을 화면에 나타나도록 OnDraw()에서 ShowWindow() 함수를 호출한다.

void CMyCtrlView::OnDraw(CDC* pDC) { CMyCtrlDoc* pDoc = GetDocument(); ASSERT_VALID(pDoc); // TODO: add draw code for native data here pButton->ShowWindow(SW_SHOW); }

4) 소멸자에서 pButton에 할당한 메모리를 없앤다.
물론 OnInitialUpdate() 함수에 delete 연산자를 넣어도 된다.

CMyCtrlView::~CMyCtrlView() { delete pButton; }

(참고.1) View에 Child 윈도우를 만들 때

우리는 종종 View에 버튼 이외에 다른 여러 컨트롤들을
추가시키게 될 상황이 발생할지 모른다.
이러한 컨트롤들은 View에서 호출되므로 View의 Child 윈도우가 되고
따라서 View는 이들 컨트롤의 부모 윈도우가 된다.
CButton 클래스의 Create() 함수를 유의해서 보면 알겠지만
부모 윈도우의 포인터를 필요로 하는 것을 알 수 있다.
따라서 Create() 함수를 만약 다음과 같이 생성자에서 선언해 버리면 에러를 유발하게 된다.

CMyCtrlView::CMyCtrlView() { pButton->Create("Test Button", BS_DEFPUSHBUTTON, CRect(0,0,200,50), this, 100); }

왜 그럴까?
this 라는 값은 view의 자신을 가리키는 포인터로 아직 그 값이 확정되지 않았기 때문이다.
따라서 this 라는 값은 OnInitialUpdate() 함수가 호출된 시점에서
결정되어 있기 때문에 OnInitialUpdate() 함수에 넣은 것이다.



(참고.2) 버튼 컨트롤의 Create() 함수의 인자에 대해

Create() 함수의 프로토타입은 다음과 같다.

BOOL Create(LPCTSTR lpszCaption, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);

lpszCaption : 버튼에 나타날 문자열
dwStyle : 버튼의 스타일
rect : 버튼이 나타날 위치
pParentWnd : 버튼이 나타나게 될 윈도우, 즉 부모 윈도우,
보통 호출할 때 this 라는 포인터를 넘겨준다.
nID : 이 버튼을 식별하는 아이디

두 번째 파라미터인 dwStyle은 버튼의 스타일을 나타내는 값으로 다음과 같은 값들을 가질 수 있다.

BS_CHECKBOX
- 네모난 사각형을 가진 체크 박스 모양이 된다.

BS_AUTOCHECKBOX
- 버튼의 모양이 체크박스 모양으로 나타난다.

BS_AUTORADIOBUTTON
- 버튼의 모양이 라디오 버튼 모양으로 나타난다.

BS_AUTO3STATE
- 버튼의 모양이 3가지 상태를 가지는 체크박스의 모양으로 나타난다.

BS_DEFPUSHBUTTON
- 가장 기본적인 버튼모양으로 마우스나 키보드로 누르면
눌림효과가 나타나는 버튼의 모양으로 만든다.
이 옵션은 다른 옵션을 선택하지 않았을 때 Default 옵션이 된다.

BS_GROUPBOX
- 사각형을 그리게 되는데, 이 사각형 안에 있는 다른 버튼들은 그룹화된다.

BS_LEFTTEXT
- 라디오 버튼이나 체크박스 스타일의 버튼을 만들 때
나타나게 될 텍스트가 라디오 버튼이나 체크박스의 왼쪽에 나오게 된다.

BS_OWNERDRAW
- 사용자 정의 버튼을 그릴 때 사용된다.
이 옵션을 선택하면 프레임워크가 DrawItem() 이란 멤버함수를 호출하여 주는데,
이 함수에서 사용자가 버튼의 모양을 정의해 주어야 한다.
(주의 : 이 스타일을 사용할 때는 CButton 클래스에서 유도된 CBitmapButton 클래스를 사용한다.)

BS_PUSHBUTTON
- 사용자가 버튼을 눌렀을 때 WM_COMMAND 메시지가 발생하도록 버튼을 만들어 준다.
WM_COMMAND 메시지가 발생한다는 것은 메뉴에 있는 어떤 기능과
동일한 역할을 하도록 할 때 필요한 기능이다.
예를 들면 툴바 버튼들이 그러하다.

BS_RADIOBUTTON
- 작은 원 모양의 라디오 버튼을 만드는데, 그 원 옆에는 텍스트가 표시된다.

BS_3STATE
- 체크박스와 같은 버튼을 만들지만 어둡게(dimmed) 되는 상태를 하나 더 갖는다.



(참고.3) 버튼으로부터의 메시지 처리

버튼의 상태를 알아낼 때 사용되는 멤버함수가 GetCheck() 이다.

int GetCheck() const;

리턴값 :

0 - 체크되지 않음
1 - 체크됨
2 - 상태가 결정되어 있지 않음 (3버튼 상태일 경우)

반대로 버튼의 상태를 강제적으로 결정해 주는 함수가 SetCheck() 이다.

void SetCheck(int nCheck);

인자 : nCheck

0 : 체크표시를 없애는 기능
1 : 체크표시를 함
2 : 3버튼 상태일 경우 결정을 하지않고 내버려두는 기능



2. 리스트 박스 컨트롤

1) 뷰 클래스 헤더파일에 버튼을 위한 포인터를 하나 추가한다.

CButton *pButton;


2) OnInitialUpdate() 함수 내용

void CMyCtrlView::OnInitialUpdate() { CView::OnInitialUpdate(); // TODO: Add your specialized code here and/or call the base class pListBox = new CListBox(); pListBox->Create(LBS_STANDARD, CRect(210, 0, 450, 200), this, 200); }

3) OnDraw()에서 ShowWindow() 함수를 호출

void CMyCtrlView::OnDraw(CDC* pDC) { CMyCtrlDoc* pDoc = GetDocument(); ASSERT_VALID(pDoc); // TODO: add draw code for native data here pListBox->ShowWindow(SW_SHOW); }

4) 소멸자에서 할당된 메모리 제거

CMyCtrlView::~CMyCtrlView() { delete pListBox; }

5) 리스트 박스에 새로운 항목을 입력하기 위해 메뉴에
ID_TEST_ADD_LSTBX 라는 ID의 항목을 새로 만들고
여기에 연결될 메시지를 다음과 같이 클래스 위저드를 사용하여 만든다.

void CMyCtrlView::OnTestAddLstbx() { // TODO: Add your command handler code here char *String[] = { "first string", "second string", "third string"}; for(int i=0; i<3; i++) { pListBox->AddString(String[i]); } }

6) 리스트 박스에서 사용자가 선택한 것을 얻어오는 작업을 해 보자.
여기서는 item을 마우스로 더블클릭하면 메시지 박스가 뜨도록 할 것이다.
다음은 뷰의 cpp 파일에 있는 메시지 맵 부분이다.

다음 한 줄을 추가한다.

IMPLEMENT_DYNCREATE(CMyCtrlView, CView) BEGIN_MESSAGE_MAP(CMyCtrlView, CView) //{{AFX_MSG_MAP(CMyCtrlView) ON_COMMAND(ID_TEST_ADD_LSTBX, OnTestAddLstbx) ON_LBN_DBLCLK(200, OnListBoxDK) // <---- 추가된 부분 //}}AFX_MSG_MAP // Standard printing commands ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint) ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint) ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview) END_MESSAGE_MAP()

7) 뷰의 헤더파일에 있는 다음 부분에 한 줄을 추가한다.

// Generated message map functions protected: //{{AFX_MSG(CMyCtrlView) afx_msg void OnTestAddLstbx(); afx_msg void OnListBoxDK(); // <---- 추가된 부분 //}}AFX_MSG DECLARE_MESSAGE_MAP() };

8) 추가한 메시지 맵에 연결되는 핸들러를 직접 만든다. 뷰의 cpp 파일에 추가.

void CMyCtrlView::OnListBoxDK() { char buffer[100]; int sel = pListBox->GetCurSel(); pListBox->GetText(sel, buffer); MessageBox(buffer); }

(참고.1) 리스트 박스 컨트롤의 Create() 함수의 인자에 대해

리스트 박스 컨트롤의 Create() 함수의 프로토 타입은 다음과 같다.

BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);

이 함수의 첫 번째 인자인 dwStyle은 리스트 박스의 스타일을 정의하는 부분이다.
다음은 가능한 스타일의 목록이다.

LBS_EXTENDEDSEL
- 사용자로 하여금 여러 개의 아이템을 동시에 선택할 수 있도록 해준다.

LBS_HASSTRINGS
- 사용자가 정의한 리스트 박스에서 리스트 박스의 아이템이 문자열로 되어있음을 나타낸다.
이렇게 함으로써 GetText() 멤버함수를 호출했을 때 문자열을 알아낼 수 있게 된다.

LBS_MULTICOLUMN
- 컬럼(column)이 여러개인 리스트 박스를 만든다.
리스트 박스의 각 컬럼은 SetColumnWidth() 멤버함수로 결정할 수 있다.

LBS_MULTIPLESEL
- 선택한 문자열이 토글되도록 한다.

LBS_NOINTEGERALHEIGHT
- 리스트 박스의 크기를 사용자가 제시한 크기와 동일하게 만든다.
왜냐하면 보통 윈도우에서 리스트 박스를 그릴 때
아이템이 완전히 나타나도록 크기를 조절하기 때문이다.

LBS_NOREDRAW
- 리스트 박스가 변화되었을 때 그 내용을 반영해 주지 않도록 한다.
이 스타일을 다시 바꾸고 싶다면 WM_SETREDRAW 메시지를 보내주면 된다.

LBS_NOTIFY
- 사용자가 리스트의 아이템을 클릭하거나 더블클릭했을 때
부모윈도우가 메시지를 받도록 해 준다.

LBS_OWNERDRAWFIXED
- 리스트 박스의 소유자가 그 내용을 그리도록 하는 옵션으로
모든 아이템은 동일한 높이를 가지고 있다.

LBS_OWNERDRAWVARIABLE
- 리스트 박스의 소유자가 그 내용을 그리도록 하는데
리스트박스의 아이템들은 서로 다른 높이를 가질 수 있도록 해 준다.

LBS_SORT
- 리스트 박스에 있는 스트링들을 알파벳으로 정렬할 수 있도록 해준다.

LBS_STANDARD
- 리스트 박스에 있는 스트링은 알파벳 순으로 정렬이 되고
부모 윈도우는 LBS_NOTIFY 스타일을 준 것처럼 메시지를 받게 된다.
보통 이 스타일을 많이 사용한다.

LBS_USETABSTOPS
- 리스트 박스가 Tab 문자를 인식하도록 해준다.

LBS_WANTKEYBOARDINPUT
- 리스트 박스의 소유자, 즉 호출하는 쪽이 WM_VKEYTOITEM
또는 WM_CHARTOITEM 메시지를 받도록 해준다.
이 스타일을 사용하는 리스트 박스가 입력 포커스를 가지고 있을 때
키보드 입력에 대해서 특별한 루틴을 수행할 수 있도록 해준다.

LBS_DISABLENOSCROLL
- 리스트 박스가 충분한 아이템을 가지고 있지 않을 때
리스트 박스 스크롤바가 작동하지 않도록 해준다.
이 스타일을 적용하지 않을 때는 스크롤바가
충분한 아이템을 가지고 있지 않을 때 숨겨지게 된다.



(참고.2) 위의 6번에서 사용가능한 메시지 핸들러 종류

Map Entry -> Function ProtoType

ON_LBN_DBLCLK( <id>, <memberFxn> ) -> afx_msg void memberFxn(); ON_LBN_ERRSPACE( <id>, <memberFxn> ) -> afx_msg void memberFxn(); ON_LBN_KILLFOCUS( <id>, <memberFxn> ) -> afx_msg void memberFxn(); ON_LBN_SELCHANGE( <id>, <memberFxn> ) -> afx_msg void memberFxn(); ON_LBN_SETFOCUS( <id>, <memberFxn> ) -> afx_msg void memberFxn();

Aug 29 2002 21:47 Written by codenuri.com




실행중 윈도우 스타일 바꾸기



1) 다음 그림을 참조하여 메인메뉴에 다음 항목을 추가한다.





2) 클래스 위저드를 사용하여 위의 추가된 두 항목에 대한 핸들러를 메인 프레임에 만든다.

다음은 그 내용이다.

void CMainFrame::OnStyleNosysmenu() { // 기존의 스타일 정보를 얻는다 long style = GetWindowLong(m_hWnd, GWL_STYLE); // 시스템 메뉴 속성을 없앤다 style &= ~WS_SYSMENU; // 변경된 스타일 반영 SetWindowLong(m_hWnd, GWL_STYLE, style); // 화면이 실제로 변경된 것을 반영하도록 한다 SendMessage(WM_NCPAINT, (WPARAM)1); } void CMainFrame::OnStyleSysmenu() { long style = GetWindowLong(m_hWnd, GWL_STYLE); style |= WS_SYSMENU; SetWindowLong(m_hWnd, GWL_STYLE, style); SendMessage(WM_NCPAINT, (WPARAM)1); }

Jun 14 2003 17:41 Written by Ramakrishna Talla (codeguru member)


이 기사는 Codeguru 의 Ramakrishna Talla 님이 작성하신 코드입니다.
제시된 예제 샘플은 비트맵 화일을 읽어들여 MFC 로
어떻게 디스플레이 할수 있는지를 보여줍니다.
이 코드는 아주 간단하며 몇라인이 되지 않습니다.
자 그럼 한번 따라해 보도록 하지요.


Step 1: Load the Image File
Call the following:

CString szFilename ("C:\\Talla\\yourimg.bmp"); HBITMAP hBmp = (HBITMAP)::LoadImage( NULL, szFilename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE|LR_CREATEDIBSECTION );

Step 2: Create a Bitmap Object and Attach It to the Object

CBitmap bmp; bmp.Attach(hBmp);

Step 3: Create a Memory DC and Select the BMP to It
You also need to store the old BMP pointer:

CClientDC dc(this); CDC bmDC; bmDC.CreateCompatibleDC(&dc); CBitmap *pOldbmp = bmDC.SelectObject(&bmp);

Step 4: Get the BMP Height and Width
Obtain this from CBitmap's GetBitmap function.

BITMAP bi; bmp.GetBitmap(&bi);

Step 5: Get the Block of Pixels from memoryDC to the Screen use CClientDC's BitBlt function.
Next, re-select the old BMP.

The complete code is as follows:

void AppView::OnButton() { CString szFilename("C:\\Talla\\yourimg.bmp"); HBITMAP hBmp = (HBITMAP)::LoadImage(NULL,szFilename, IMAGE_BITMAP,0,0, LR_LOADFROMFILE|LR_CREATEDIBSECTION); CBitmap bmp; bmp.Attach(hBmp); CClientDC dc(this); CDC bmDC; bmDC.CreateCompatibleDC(&dc); CBitmap *pOldbmp = bmDC.SelectObject(&bmp); BITMAP bi; bmp.GetBitmap(&bi); dc.BitBlt(0,0,bi.bmWidth,bi.bmHeight,&bmDC,0,0,SRCCOPY); bmDC.SelectObject(pOldbmp); }

자 아주 간단하지요 ?
뭐 크게 어려움이 없으리라 봅니다.