티스토리 뷰

190705-2
 

교육을 받으면서 노트필기 했던 내용을 날것 그대로 업로드합니다.


 
 
new 는 기본적으로 동기화가 되어있다.
 
전용 힙의 장점
  1. 한꺼번에 할당하고 제거할 수 있다.
  2. 동기화가 필요없다. (내 쓰레드 에서만 사용한다. 속도가 빠르다.)
 
#include <iostream>
#include <Windows.h>
 
using namespace std;
 
template <typename T>
class List
{
private:
    struct Node
    {
        T data;
        Node*next;
        Node*prev;
    public:
        Node(T d):data(d),prev(0),next(0){}
    };
private:
    HANDLE hHeap; // 힙의 핸들
    bool bDefaultHeap; // 기본힙 or 사용자힙
 
    Node*head;
    Node*tail;
    Node*cur;
private:
    List(const List& );
    const List& operator=(const List&);
    Node* AllocNode(const T& data)
    {
        Node* p = (Node*) HeapAlloc( // * OS의 함수 (new와 같은함수)
            hHeap, // 힙의 핸들
            HEAP_NO_SERIALIZE, // 이 리스트는 단 하나의 쓰레드가 사용한다!! + HEAP_ZERO_MEMORY
            // 동기화를 하지 않겠다. 속도가 빠르다.
            sizeof(Node)
            );
        p->next = p->prev = NULL;
        p->data = data;
 
        return p;
    }
    void _Initialize()
    {
        head = AllocNode(T());
        tail = AllocNode(T());
        head->next = tail;
        tail->prev = head;
    }
    void _Destroy()
    {
        if( bDefaultHeap )
        {
            Node*p=head;
            while(p != NULL)
            {
                Node*pp = p;
                p=p->next;
                HeapFree(hHeap,
                    0, // 이미 HeapCreate()에서 HEAP_NO_SERIALIZE 지정하여 생략함.
                    pp // 해제할 메모리 주소
                    );
            }
        }
    }
public:
    List(HANDLE hh=0):hHeap(hh),bDefaultHeap(false),head(0),tail(0),cur(0)
    {
        if( hHeap == NULL )
        {
            hHeap = GetProcessHeap(); // default heap의 핸들을 얻는 함수
            bDefaultHeap = true;
        }
 
        _Initialize();
    }
    ~List()
    {
        _Destroy();
    }
    void AddBack(T data)
    {
        Node*n = AllocNode(data);
        Node*pp = tail->prev;
        pp->next = n;
        n->prev = pp;
        n->next = tail;
        tail->prev = n;
    }
    void AddFront(T data)
    {
        Node*n = AllocNode(data);
        Node*hn = head->next;
        head->next = n;
        hn->prev = n;
        n->next = hn;
        n->prev = head;
    }
public:
    class Iterator
    {
        Node*cur;
    public:
        Iterator(Node*c=0):cur(c){}
        bool operator!=(const Iterator&arg)const
        {
            return cur != arg.cur ? true:false;
        }
        const Iterator operator++()
        {
            cur = cur->next;
            return *this;
        }
        T& operator*()
        {
            return cur->data;
        }
        T* operator->()
        {
            return &cur->data;
        }
        friend class::List;
    };
public:
    Iterator Begin()const
    {
        return Iterator(head->next);
    }
    Iterator End()const
    {
        return Iterator(tail);
    }
};
 
void main()
{
    List<int> lt;
 
    lt.AddBack(10);
    lt.AddBack(20);
    lt.AddBack(30);
    lt.AddBack(40);
    lt.AddBack(50);
 
    for(List<int>::Iterator iter= lt.Begin(); iter != lt.End(); ++iter)
        cout << *iter << " ";
    cout << endl;
    
    ////////////////////////////////////////
    List<int> lt2;
    lt2.AddBack(100);
    lt2.AddBack(200);
    lt2.AddBack(300);
 
    for(List<int>::Iterator iter= lt2.Begin(); iter != lt2.End(); ++iter)
        cout << *iter << " ";
    cout << endl;
}
 
사용자힙
#include <iostream>
#include <Windows.h>
 
using namespace std;
 
template <typename T>
class List
{
private:
    struct Node
    {
        T data;
        Node*next;
        Node*prev;
    public:
        Node(T d):data(d),prev(0),next(0){}
    };
private:
    HANDLE hHeap; // 힙의 핸들
    bool bDefaultHeap; // 기본힙 or 사용자힙
 
    Node*head;
    Node*tail;
    Node*cur;
private:
    List(const List& );
    const List& operator=(const List&);
    Node* AllocNode(const T& data)
    {
        Node* p = (Node*) HeapAlloc(
            hHeap,
            HEAP_NO_SERIALIZE, // 이 리스트는 단 하나의 쓰레드가 사용한다!! + HEAP_ZERO_MEMORY
            sizeof(Node)
            );
        p->next = p->prev = NULL;
        p->data = data;
 
        return p;
    }
    void _Initialize()
    {
        head = AllocNode(T());
        tail = AllocNode(T());
        head->next = tail;
        tail->prev = head;
    }
    void _Destroy()
    {
        if( bDefaultHeap )
        {
            Node*p=head;
            while(p != NULL)
            {
                Node*pp = p;
                p=p->next;
                HeapFree(hHeap,
                    0, // 이미 HeapCreate()에서 HEAP_NO_SERIALIZE 지정하여 생략함.
                    pp // 해제할 메모리 주소
                    );
            }
        }
        else
            HeapDestroy(hHeap); // 사용자 힙이라면 한방에 삭제가능하다.
    }
public:
    List(HANDLE hh=0):hHeap(hh),bDefaultHeap(false),head(0),tail(0),cur(0)
    {
        if( hHeap == NULL )
        {
            hHeap = GetProcessHeap();
            bDefaultHeap = true;
        }
        _Initialize();
    }
    ~List()
    {
        _Destroy();
    }
    void AddBack(T data)
    {
        Node*n = AllocNode(data);
        Node*pp = tail->prev;
        pp->next = n;
        n->prev = pp;
        n->next = tail;
        tail->prev = n;
    }
    void AddFront(T data)
    {
        Node*n = AllocNode(data);
        Node*hn = head->next;
        head->next = n;
        hn->prev = n;
        n->next = hn;
        n->prev = head;
    }
public:
    class Iterator
    {
        Node*cur;
    public:
        Iterator(Node*c=0):cur(c){}
        bool operator!=(const Iterator&arg)const
        {
            return cur != arg.cur ? true:false;
        }
        const Iterator operator++()
        {
            cur = cur->next;
            return *this;
        }
        T& operator*()
        {
            return cur->data;
        }
        T* operator->()
        {
            return &cur->data;
        }
        friend class::List;
    };
public:
    Iterator Begin()const
    {
        return Iterator(head->next);
    }
    Iterator End()const
    {
        return Iterator(tail);
    }
};
 
void main()
{
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo); //시스템의 정보를 얻음
    int pageSize = sysinfo.dwPageSize; //프로그램 os마다 가상 메모리에 페이징을 하는 크기 (4~8k 정도)
 
    HANDLE hHeap = HeapCreate( // 사용자 힙을 생성
        HEAP_NO_SERIALIZE, //옵션 동기화하지 않겠다.
        pageSize*10, // 초기크기: 최대크기에 지정한 메모리 크기 중에서 초기에 할당할(COMMIT) 메모리 크기
        pageSize*1000 //최대크기: 페이지 크기만큼 RESERVE로 0이면 자동 크기가 증가하는 힙 생성
        );
 
    List<int> lt(hHeap); //lt는 사용자 힙을 사용함.
 
    lt.AddBack(10);
    lt.AddBack(20);
    lt.AddBack(30);
    lt.AddBack(40);
    lt.AddBack(50);
 
    for(List<int>::Iterator iter= lt.Begin(); iter != lt.End(); ++iter)
        cout << *iter << " ";
    cout << endl;
    
    ////////////////////////////////////////
    List<int> lt2; //lt2는 기본힙을 사용함.
    lt2.AddBack(100);
    lt2.AddBack(200);
    lt2.AddBack(300);
 
    for(List<int>::Iterator iter= lt2.Begin(); iter != lt2.End(); ++iter)
        cout << *iter << " ";
    cout << endl;
}
댓글
댓글쓰기 폼
네이버 이웃추가
«   2019/10   »
    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    
글 보관함