728x90
300x250

[자료구조(Data Structure)] - 6. Linked Queue

 

1. Linked Queue 동작 로직

 

a. 삽입(push)

 

b. 인출(pop)

 

 

2. Linked Queue ADT

 

 abstract interface Queue{

       abstract void Push( Object x );

       abstract Object pop();

       abstract boolean isEmpty();

 }

 

 Queue Interface ADT

 

 

 
class LinkedNode{
        private Object data;
        private LinkedNode next;
 
        public void setData(Object x)
        {
             this.data = x;
        }


       public void setNext(LinkedNode node)
       {
             this.next = node;
       }

       public Object getData()
       {
            return this.data;
       }

       public LinkedNode getNext()
       {
            return this.next;
       }
}

LinkedNode ADT

 

3. 코드 구현

 

 

 abstract interface Queue{

       abstract void Push( Object x );

       abstract Object pop();

       abstract boolean isEmpty();

 }

 class LinkedNode{
        private Object data;
        private LinkedNode next;
 
        public void setData(Object x)
        {
             this.data = x;
        }


       public void setNext(LinkedNode node)
       {
             this.next = node;
       }

       public Object getData()
       {
            return this.data;
       }

       public LinkedNode getNext()
       {
            return this.next;
       }
}

 class LinkedQueue implements Queue{

          private LinkedNode front;
          private LinkedNode rear;
 
          public LinkedQueue(){
                 this.front = null;
                 this.rear = null;
          }
 
          public void push(Object x){
  
                 LinkedNode newNode = new LinkedNode();

                 newNode.setData( x );
                 newNode.setNext( null );

              

                 if( isEmpty() )
                 {
                       this.front = newNode;
                       this.rear = newNode;  
                 }
                 else{
                       this.rear.setNext ( newNode );
                       this.rear = newNode;
                 }

          }

 

          public Object pop(){
   
                 if ( isEmpty() )
                       return null;
  
                 Object data = front.getData();
   
                 LinkedNode prevnode = front;
                 front = front.getNext();
 
                 prevnode = null;
                 return data;
         }

 

         public Object peak(){
  
                if ( isEmpty() )
                        return null;
                else
                        return front;

         }

 

         public boolean isEmpty(){
  
                if(front == null)
                        return true;
                else
                        return false;  

          }
 
          public void viewOfAll()
          {
                LinkedNode current = this.front;
  
                System.out.println("출력 ---------");
 
                while ( current != null )
                {
                         System.out.println( current.getData() );
                         current = current.getNext();
                 }

           }

 }

 
public class LinkedQueueProgram{
 
         public static void main(String args[])
         {
                 LinkedQueue queue = new LinkedQueue();
                 queue.push("1번");
                 queue.push("2번");
                 queue.push("3번");
                 queue.viewOfAll();

 

                 queue.pop(); 
                 queue.viewOfAll();
 
                 queue.push("1번");
                 queue.viewOfAll();

         }
}

 LinkedQueueProgram.java

 

 

반응형
728x90
300x250
[자료구조(Data Structure)] - 5. Circular Queue with Array

 

먼저 환형 큐 with 배열을 소개하면, 여러분들 원으로 된 시계 잘 아신가요??

 

1. 잔머리 굴려보기

 

 

실제로는 원이 아닙니다. 배열 index가 마치 회전하는 듯한 연상이 이해하는 데 도움이 되기 때문에 그려 놓은 겁니다.

예를 들어 저기 원이 Size가 4개인데, 회전하는 데 있어서 회전을 균일하게 잡아줄 공간이 필요합니다.

 

저 원이 예를 들어 Size가 4라고 하면, 실제로 사용가능한 공간은 Size 3입니다.

 

잉여공간 1개를 부여하지 않으면, rear index가 기존에 있는 데이터를 하나 잡아 먹게 됩니다.

(이 부분은 여러분들이 한번 아래의 코드를 수정해서 생각해보시기 바랍니다.)

(또는 종이로 한번 그려보시기 바랍니다.)

 

갑자기 설명하는데, 잔 테크닉 먼저 이야기해서 난해하셨을 것 같습니다.

다시 기본 원리에 대해 소개 해드리겠습니다.

 

2. 기본 원리는?

 

먼저 동작 원리를 구현한 결과입니다. (파워포인트로 그리기엔 솔직히 귀찮고 힘든 일입니다.)

대신 코드 동작으로 똑같이 표현해드리겠습니다.

 

먼저 Queue 자료 구조의 ADT형을 이해하기에 앞서 용어를 이해하기 쉽게 설명해드리고 ADT를 설명해드리겠습니다.

push (어떤 책에선 enqueue( datatype x ) ), pop (어떤 책에선 dequeue ( ) )라고 표기합니다.

 

 abstract interface Queue{

      abstract void push ( Object x ) ;

      abstract Object pop ( ) ;

      abstract boolean isEmpty ( );

      abstract Object peak ( ) ;

 }

 Queue의 ADT

 

큐(Singly Queue), 환형 큐(Circular Queue)나, 연결 큐(Linked Queue) 등 기본 ADT는 이걸로 사용합니다.

이건 Stack ADT나 동일합니다. (소개하지 않아서 언급은 여기서 ~ 끝)

 public class ArrayQueue implements Queue{

 

      private int front;

      private int rear;

      private int count;

      private int queuesize;

     

      private Object[] itemArray;

 

      public ArrayQueue()

      {

               this.front = 0;

               this.rear = 0;

               this.count = 0;

               this.queueSize = 10;

               this.itemArray = new Object [ this.queueSize ];

      }

 } 

 배열 큐 - Circular Queue 구현 - 기본 Instance Variable, Constructor


Push(삽입) 원리

 

 rear = ( rear + 1 ) % n

 itemArray[rear] = x ;

 

Pop(인출) 원리

 

 front = ( front + 1 ) % n

 Object data = itemArray ( front );

 

 

3. 코드로 한번 실험해보세요.

 

 
abstract interface Queue{
 
        abstract boolean isEmpty();
        abstract void push(Object x);
        abstract Object pop();
        abstract Object peak(); 
}

 

class ArrayQueue implements Queue{

         private int front;
         private int rear;
         private int count;
         private int queueSize;
         private int increment;
         private Object[] itemArray;
 
         public ArrayQueue( )
         {
                 this.front = 0;
                 this.rear = 0;
                 this.count = 0;
                 this.increment = 5;
                 this.queueSize = 5;

                 itemArray = new Object[queueSize];
          }

 

          private void queueFull()
          {
  
                 int prevQueueSize = queueSize;
                 queueSize += increment ;
  
                 Object[] prevItemArr = itemArray.clone();
                 itemArray = new Object[queueSize];
  
                 int i = 0;

                 while( i < prevQueueSize )
                 {
                         itemArray[i] = prevItemArr[front];
                         front = (front + 1) % prevQueueSize;
   
                         i++;
                 }

 

                 front = 0;
                 rear = count;
        }
 
        public boolean isEmpty(){
                 return (count == 0) ? true : false ;
        }

        public void push(Object x){
  
                 if ( ( count + 1 ) ==  queueSize )
                        queueFull();

 

                 rear = ( rear + 1 ) % queueSize;
                 itemArray[ rear ] = x;
  
                 count++;

        }

 

        public Object pop(){

                if( isEmpty() )
                       return null;
  
                front = (front + 1) % queueSize;
                Object item = itemArray[front];
                itemArray[front] = null;
  
                count--;

                return item;
         }
 
          public Object peak(){
  
               if( isEmpty() )
                       return null;
               else
                       return itemArray[front];

          }

 

           public void viewOfAll( String label )
           {
                   System.out.println ( "\n\n[" + label + "]/-----실험결과" );
    
                   for ( Object x : itemArray )
                  {
                            System.out.println ( x );   

                   }

            }

 

             public int getCount()
             {
                     return this.count;
             }
 }

 

 public class QueueProgram{

             public static void main(String args[])
             { 

                     ArrayQueue queue = new ArrayQueue();
  
                     queue.push("1번");
                     queue.push("2번");
                     queue.push("3번");
                     queue.push("4번");
                     queue.viewOfAll("1번");

 

                     queue.pop();
                     queue.viewOfAll("2번");

 

                     queue.push("5번");
                     queue.viewOfAll("3번");

 

                     queue.push("6번");
                     queue.viewOfAll("4번");

 

                     queue.pop();
                     queue.viewOfAll("5번");


                     queue.pop();
                     queue.viewOfAll("6번");

 

                     queue.push("7번");
                     queue.viewOfAll("7번");

 

                     queue.push("8번");
                     queue.viewOfAll("8번");

 

                     queue.pop();
                     queue.viewOfAll("9번");

 

                     queue.pop();
                     queue.viewOfAll("11번");

 

                     queue.push("9번");
                     queue.viewOfAll("12번");

 

                     queue.push("10번");
                     queue.viewOfAll("13번");

 

                     queue.push("11번");
                     queue.viewOfAll("14번");

 

                     queue.push("12번");
                     queue.viewOfAll("15번");
 
         }

}

 QueueProgram.java

 

반응형
728x90
300x250

[자료구조(Data Structure)] - 4. Circular Linked List - Java

 

작년에 배운 자료구조 복습 겸 다시 짜봤습니다.

LinkedList Class 내에 headnode와 firstnode를 보통은 두고 짜는 데 한번 rootnode 하나만 두고 대신 length(정수형)을 추가하여 구현해봤습니다.

 

전체 로직은 이렇습니다.

 

 

/*      
       Data Structure Circular Linked List - rootnode만 이용
       2015. 4. 25
       James
*/ 

 

class Node

{
        private Object data;
        private Node prev;
        private Node next;

 

        // Getter
        public Object getdata()
        {
             return this.data;
        }

        public Node getprev()
        {
             return this.prev;
        }

        public Node getnext()
        { 
             return this.next;
        }
 

        // Setter
        public void setdata(Object data)
       {
             this.data = data;
       }

       public void setprev(Node prev)
       {
             this.prev = prev;
       }

       public void setnext(Node next)
       {
             this.next = next;
       }


class LinkedList{

       private Node headnode;
       private long length;
 
       public LinkedList(){
              this.headnode = null;
              this.length = 0;
       }

       public void insert(Object data)
       {
              Node createnode = new Node();  

              createnode.setdata(data);
              createnode.setprev( createnode );
              createnode.setnext( createnode );
  
              if ( this.headnode == null )
              {
                       this.headnode = createnode;
              }
              else
              { 
                      Node firstnode = this.headnode.getnext();   
   
                      // 현재 기억하고 있는 이전 노드 설정
                      createnode.setprev ( this.headnode );

                      // 맨 마지막 노드 처음 위치 지정
                      createnode.setnext ( firstnode );

                      // 현재 노드 -> node 삽입 (Next)
                      this.headnode.setnext( createnode );
   
                      // 현재 노드 -> 다음 노드로 이동
                      this.headnode = this.headnode.getnext();

                      // 맨 처음 노드 마지막 위치 지정
                      firstnode.setprev( this.headnode );
              }

              this.length++;
  
 }
 
 public void remove(Object data)
 {
             Node currentnode = this.headnode.getnext();
             boolean check = false;  

             long cnt = 0;  
  
             // 데이터 검색
             while ( cnt < length )
             {
                       if( currentnode.getdata() == data)
                       {    
                               check = true;
                               break;
                       }

                       currentnode = currentnode.getnext();
   
                       cnt++;
             }

 

              // 3가지 기준 (맨 처음 자료, 중간 자료, 맨 마지막 자료)
              if ( check == true )
              {
                      Node firstnode = this.headnode.getnext();
                      Node lastnode = this.headnode;
  
                      // 맨 처음 자료
                      if ( currentnode == firstnode )
                      { 
                                // 다음 주소가 firstnode와 일치시
                                if ( this.headnode.getnext ( ) == firstnode ){

                                        Node prevnode = firstnode.getprev();
                                        Node nextnode = firstnode.getnext();
     
                                        firstnode = nextnode;
                                        firstnode.setprev ( prevnode ) ;
                                        this.headnode.setnext ( firstnode ) ;
                               }
                               else
                                        this.headnode = this.headnode.getnext ( ) ; 
                      }

 

                     // 중간 자료 판별
                     if ( currentnode != firstnode && currentnode != lastnode )
                     {
                               Node prevnode = currentnode.getprev ( ) ;
                               Node nextnode = currentnode.getnext ( ) ;

                               currentnode = prevnode ;
                               currentnode.setnext ( nextnode ) ;
                               nextnode.setprev ( prevnode ); 
                     }

 

                      // 마지막 자료 판별
                      if ( currentnode == lastnode && this.headnode != null )
                      {
                               Node prevnode = currentnode.getprev ( ) ;

                        
                               prevnode.setnext ( firstnode ) ;
                               firstnode.setprev ( prevnode ) ;
     
                               currentnode = null ;

                               this.headnode = prevnode;
                      }
 
                      this.length--;

                }  

        }
  
        public void view()
        {
                  Node currentnode = this.headnode.getnext();
    
                  long cnt = 1;

                  while ( cnt <= length )
                  {
                           System.out.println( "번호:" + cnt + ", Data:" + currentnode.getdata() ) ;
   
                           currentnode = currentnode.getprev() ;
                           cnt++;
                  } 
         }
 
         public long getlength()
         {
                  return this.length;
         }

 

          public Node getnode()
          {
                  return this.headnode;
          }

}

 

public class Ds{

         public static void main(String args[])
        {
             LinkedList list = new LinkedList();

             list.insert("야호1"); 
             list.view();

             list.remove("야호1");
             System.out.println( list.getlength() ) ;
             list.view();
       }

 Ds.java

 

반응형
728x90
300x250

[Java] Deep Copy & Shallow Copy

 

1. 개념(Concept)


 

2. 소스 코드

 

class Account implements Cloneable{

        private String accnum;
        private int balance;

 

        public void setNum(String accnum)
        {
             this.accnum = accnum;  
        }

        public String getNum()
       {
            return this.accnum;
       }
 

         
       protected Object clone()
       {

 

               try{
                    Account account = (Account)super.clone();
                    return account;
               }
              catch(CloneNotSupportedException e)
              {
                   e.printStackTrace();
              }
              return null;
       } 

}

 

Source) Account.java

 

public class Program
{

      public static void deepcopy()
     {
              Account source = new Account();
              source.setNum("111");

 
             Account target = (Account)source.clone(); // clone()은 Overliding으로 구현.
  
              System.out.println( "소스원본:" + source.getNum() );
              System.out.println( "대상-깊은 복사:" + target.getNum() );

 

              System.out.println( "원본값 계좌번호 변경 333\n" );


              source.setNum("333");


              System.out.println( "소스원본:" + source.getNum() );
              System.out.println( "대상-깊은 복사:" + target.getNum() + "\n" );
       }


       public static void shallowcopy()
       {
              Account source = new Account();
           source.setNum("111");

 

              Account target = source;
  
              System.out.println( "소스원본:" + source.getNum() );
              System.out.println( "대상-얇은 복사:" + target.getNum() );

 

              System.out.println( "원본값 계좌번호 변경 333\n" );
              source.setNum("333");


              System.out.println( "소스원본:" + source.getNum() );
              System.out.println( "대상-얇은 복사:" + target.getNum() + "\n" );
       }

 

       public static void main(String args[])
       { 
              System.out.println("--- 1.깊은 복사------------------");
           deepcopy();

 

              System.out.println("--- 2.얇은 복사------------------");
            shallowcopy();
       }

}

 

 

 

Main Source) Program.java

 

3. 동작 결과

 

 


이해가 되었으면 합니다.^^

 

[첨부(Attachment)]

Sample-copy.zip

 

반응형
728x90
300x250

[Java] IceCream - Class 구현

 

아이스크림 클래스를 작성하였습니다.
이해를 돕기 위해서 작성하였습니다.

 


interface IceCream{
     abstract void use();
     abstract void destroy();
}

class Bar implements IceCream{
 
      public void use(){
           System.out.println("맛있는 막대바 아이스크림 섭취");
      }
 
      public void destroy()
      { 
           System.out.println("다 먹음(막대바)"); 
      }
}

 

class Cone implements IceCream{
 
      public void use()
      {
           System.out.println("맛있는 콘 타입 아이스크림 섭취");
      }
 
      public void destroy(){
           System.out.println("다 먹음(콘 타입)");
      }
}

public class Output {
 
     public static void main(String args[])
     {
           Bar iceCreamBar = new Bar();
           Cone iceCreamCone = new Cone();
  
           iceCreamBar.use();
           iceCreamCone.use();
  
           iceCreamBar.destroy();
           iceCreamCone.destroy();
     }

 아이스크림을 추상화함. - Output.java

 

(아이스크림 바, 아이스크림 콘)을 먹을 때 공통적으로 할 수 있는 일

두 가지로 생각해봄.

-> 먹는다(use)

-> 버린다(destroy)

반응형
728x90
300x250
[PC활용] uTorrent - Torrent 토렌트 파일(Seed) 배포하기

 

.torrent 파일은 많이 이용해보셨을 겁니다.

이번에는 사람들에게 배포하는 방법을 소개하도록 하겠습니다. 

 

 

(uTorrent 3.4.2)

 

최신 버전인 uTorrent 3.4.2을 기준으로 소개하도록 하겠습니다.

 


1. 새 토렌트 만들기

 

 

 

 빨강색으로 친 아이콘을 클릭합니다. (새 토렌트 만들기)

 


2. 파일 선택 / 폴더 선택

 

 

 

 새 토렌트 만들기 -> 파일 추가

                           -> 폴더 추가

 

 

 

 

 곰돌이.mp3를 선택하겠습니다. (예제)

 

 


3. 만들기

 

 

 결론은 만들기를 클릭하면, .torrent파일이 생성됩니다.

 

 

 

 

 토렌트 파일은 .torrent을 저장(S)을 클릭하면 실제 파일을 생성할 수 있습니다.

 


4. 배포 중 (정상 배포가 될 수 있는 상태인지 확인해보기)

 

 

 

 파일 배포를 위한 상태가 되었는지 확인해보시기 바랍니다.

 

 

 

 

 아까 만든 파일을 배포하면, 파일을 배포할 수 있게 됩니다.

 

 
반응형
728x90
300x250

[MFC] 윈도우 프로그래밍 기초 - 트리 컨트롤

 

이번에는 트리 컨트롤에 대해서 소개하고자 합니다.

 

위의 그림에서 빨간색으로 표기된 구조가 Tree Control의 한 예입니다.

이런 구조는 많이 익숙하실거라고 생각됩니다.

 


1. CTreeCtrl 클래스

 

1-a. 멤버 함수

 * InsertItem

 HTREEITEM InsertItem( LPCTSTR lpszItem, HTREEITEM hParent = TVI_ROOT , HTREEITEM hInsertAfter = TVI_LAST ) ;

 

 -> lpszItem : 아이템에 표시할 문자열 주소

 -> hParent : 추가되어 있는 부모 아이템의 헨들 -> TVI_ROOT는 루트 아이템으로 기본 값 지정되어 있음.

 

     (궁금하신 분들은 자료 정의나 구글링 해보세요.)

 -> hInsertAfter : 새로운 아이템이 어떤 아이템의 뒤에 삽입될 것인지를 지정

 *> Return Value : 추가된 아이템의 헨들(HTREEITEM 반환), 실패시 NULL

 

 기존에 리스트 컨트롤 강의에선 InsertItem 이런 거에 담는 개념이었는데,

 이 원형은 HTREEITEM이라는 형태로 반환하여 뿌리 구축 단위로 동작함. (직접 코드 짜보면 이해함)

 

 * DeleteItem 

 BOOL DeleteItem ( HTREEITEM hItem ) ;

 -> hItem : 삭제할 트리 아이템의 헨들

 -> Return Value : 성공시 TRUE, 실패시 FALSE;

 * DeleteAllItems

 BOOL DeleteAllItems( ) ;

 

 -> 트리 컨트롤의 모든 아이템들을 전체 삭제함.

 

 -> Return Value : 성공시 TRUE, 실패시 FALSE

 * GetParentItem

 HTREEITEM GetParentItem( HTREEITEM hItem ) const;

 

 -> hItem : 부모 아이템을 찾고자 하는 트리 아이템의 핸들 (쉽게 말하면 부모 아이템을 가져온다고 이해하는 게 정신적으로 편함)

 -> Return Value : 부모 아이템의 핸들, 실패시 NULL

 

 * GetItemText

 CString GetItemText ( HTREEITEM hItem ) const ;

 

 -> hItem : 텍스트를 획득하고자 하는 트리 아이템의 핸들

 -> Return Value : 트리 아이템의 텍스트

 


1-b. 트리 컨트롤(Tree Control)의 Primative Attribute (주요 속성)

 

 

 

주요 속성이라고 지정하긴 제목을 말하긴 했는데, 트리를 운영하는 데 가장 중요한 요소라서 이렇게 불렀으니깐

쉽게 생각하시기 바랍니다. 잊어버리셔도 됩니다. 동물적으로 찾아서 보실 수 있으면 됩니다.

 

 트리 컨트롤 속성

 설명

 Check Boxes

 아이템에 체크박스를 표시하기 위한 속성

 Has Buttons

 서브 아이템이 있는 경우,

 해당 아이템에 [+], [-] 버튼을 표시하기 위한 속성

 (옵션??이 더 맞는 말인거 같음)

 Has Lines

 아이템 간의 연결 관계를 라인을 사용하여 표현하기 위한 속성

 -> 제 블로그에도 사실 보면 트리 라인있습니다.

     모르시면 메뉴 보셔도 됩니다.

 Lines At Root

 루트 아이템에도 라인을 표시하기 위한 속성.

 Single Expand

 확장되는 아이템을 하나로 지정하기 위한 속성.

 True로 설정하면 하나의 아이템을 확장했을 때 다른 확장 아이템은 축소한다.

 Tract Select

 트래킹 표시를 지정하기 위한 속성

 True로 설정하면 마우스 포인터가 위치된 아이템에 밑줄이 표시된다.

 

 


2. 결과물

 

 

 

 

 

 

 

 

 


3. 실습

 

a. 레이아웃 디자인

 

컨트롤 이름 

 범주(T)

 매개 변수(N)

 비고

 IDC_TREE1

 Control

 m_yourtree

 

 IDC_EDIT1

 해당 없음

 해당 없음

 해당 없음

 

IDC_TREE1의 리소스 속성

Has Buttons, Has Lines, Single Expand, Lines At Root (True)로 해주기

 

 

 

 


4. 코드 구현

 

// CMyTreeDlg 메시지 처리기

BOOL CMyTreeDlg::OnInitDialog()

 

//         (중략~~~~~)

 

         // TODO: 여기에 추가 초기화 작업을 추가합니다.

         HTREEITEM root_branch = m_yourtree.InsertItem(_T("지사"));
         HTREEITEM root_headoffice = m_yourtree.InsertItem(_T("본사"));

         HTREEITEM child_b_china = m_yourtree.InsertItem(_T("중국"), root_branch);
         HTREEITEM child_b_gumi = m_yourtree.InsertItem(_T("한국"), root_branch);

         HTREEITEM child_h_seoul = m_yourtree.InsertItem(_T("서울"), root_headoffice);
         HTREEITEM child_b_c_bejing = m_yourtree.InsertItem(_T("베이징"), child_b_china);

         // this->m_yourtree.InsertItem

 

//         (중략~~~~~)

 

}

 OnInitDialog

 

 

void CMyTreeDlg::OnTvnSelchangedTree1(NMHDR *pNMHDR, LRESULT *pResult)
{
 LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);  // 자동 생성된 부분임.

 

          // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
          HTREEITEM hItemRoot;
          HTREEITEM hItemParent;
          HTREEITEM hItemCur;

 

          CString strRoot;
          CString strParent;
          CString strCur;

          CString strTxt;

 

          hItemCur = pNMTreeView->itemNew.hItem;
          hItemParent = this->m_yourtree.GetParentItem( hItemCur );
          hItemRoot = this->m_yourtree.GetParentItem( hItemParent );

 

          strRoot = m_yourtree.GetItemText(hItemRoot);
          strParent = m_yourtree.GetItemText(hItemParent);
          strCur = m_yourtree.GetItemText(hItemCur);
 
          strTxt.Append(_T("/") + strRoot);
          strTxt.Append(_T("/") + strParent);
          strTxt.Append(_T("/") + strCur);
 
          ::SetDlgItemText( this->m_hWnd, IDC_EDIT1, strTxt );

 

 

           *pResult = 0;      // 자동 생성된 부분임.

 

 OnTvnSelchangedTree1 ( ) -> 마우스로 클릭해서 생성한 함수 원형
 -> (쉽게 말하면, 트리 선택시 동작 구현)

 

 

 

 

 

 

[첨부(Attachment)]

MyTree.zip

 

 

반응형
728x90
300x250
[MFC] 윈도우 프로그래밍 기초 - List Control

 

이번 글은 직접 List Control을 구현해보는 것이 기본 목표입니다.

 

개념은 기본 멤버함수 몇 개 소개하는 것으로 시작하겠습니다.

 

1. CListCtrl 클래스의 멤버함수

 

 * InsertColumn

 

 int InsertColumn ( int nCol,

                           LPCTSTR lpszColumnHeading,

                           int nFormat = LVCFMT_LEFT,

                           int nWidth = -1,

                           int nSubItem = -1 );

 

-> nCol : 컬럼 헤더의 인덱스 값

-> lpszColumnHeading : 컬럼 헤더에 표시할 문자열

-> nFormat : 컬럼 헤더에 표시할 문자열의 정렬방식을 지정하며, 다음의 값들을 지정하여 사용가능.

-> Return 값 : 컬럼 추가에 성공하면 컬럼의 인덱스를 반환하며, 실패하면 -1을 반환한다.

 

 포멧 값

 정렬 방식

 LVCFMT_RIGHT

 오른쪽 정렬

 LVCFMT_LEFT

 왼쪽 정렬

 LVCFMT_CENTER

 중앙 정렬

 

-> nWidth : 컬럼 헤더의 너비

-> nSubItem : 연관된 하위 항목의 인덱스

-> Return 값 : 컬럼 추가에 성공하면 컬럼의 인덱스를 반환하며, 실패하면 -1을 반환한다.

 

 * DeleteColumn

 BOOL DeleteColumn ( int nCol ) ;

 

 -> nCol : 삭제하고자 하는 컬럼의 인덱스

 -> Return 값 : 삭제에 실패하면 0 (FALSE)을, 성공하면 1 (TRUE)을 반환한다.

 * InsertItem

 int InsertItem ( const LVITEM* pItem ) ;

 

-> pItem : 리스트 컨트롤에 등록할 LVITEM 구조체 포인터

-> Return 값 : 성공 시 추가된 아이템의 인덱스, 실패 시 -1

 * SetItemText

 BOOL SetItemText ( int nItem, int nSubItem, LPCTSTR lpszText ) ;

 

-> nItem : 아이템 인덱스

-> nSubItem : 서브 아이템 인덱스

-> lpszText : 출력할 텍스트 변수의 포인터

-> Return 값 : 실패시 0(FALSE), 성공시 1(TRUE) 반환 

 * GetItemText

 CString GetItemText ( int nItem, int nSubItem ) const

 

-> nItem : 아이템 인덱스

-> nSubItem : 서브 아이템 인덱스

-> Return 값 : 지정한 아이템 또는 서브 아이템의 문자열

 * DeleteItem

 BOOL DeleteItem ( int nItem );

 

-> nItem : 아이템 인덱스

-> Return 값 : 성공시 TRUE(1), 실패시 FALSE

 * DeleteAllItems

 BOOL DeleteAllItems( );

 

-> Return 값 : 성공시 TRUE, 실패시 FALSE

 

2. 결과물

 

 

 

 

3. 레이아웃

 

List Control에 변수를 만들어 줍니다.

 

 컨트롤 이름

 범주(T)

 변수 이름(N)

 비고

 List Control

 Control

 m_ListView

 

 

 

 

ListControl 속성의 View를 Report로 바꿔줍니다.

 

 

4. 코드

 

 

 BOOL CListControlDlg::OnInitDialog(){

 

           (중략)

            // TODO: 여기에 추가 초기화 작업을 추가합니다.

           m_ListView.InsertColumn(0, _T("번호"), NULL, 50);
           m_ListView.InsertColumn(1, _T("이름"), NULL, 150);
           m_ListView.InsertColumn(2, _T("비고"), NULL, 50);

 

           // LVITEM - 삽입 데이터 보관 장소
           LVITEM firstitem = { 0 } ;  LVITEM seconditem = { 0 } ;


           firstitem.mask = LVIF_TEXT;
           firstitem.iItem = 0;

 

           seconditem.mask = LVIF_TEXT;
           seconditem.iItem = 0;

 

           // 데이터 삽입 - Firstitem
           m_ListView.InsertItem(&firstitem);

 

           // 데이터 값 넣기 - Firstitem
           m_ListView.SetItemText(0, 0, _T("1번"));
           m_ListView.SetItemText(0, 1, _T("도도1-1"));
           m_ListView.SetItemText(0, 2, _T("도도1-2"));

 

            // 데이터 삽입 - Seconditem
           m_ListView.InsertItem(&seconditem);
 
           // 데이터 값 넣기 - Seconditem
          m_ListView.SetItemText(0, 0, _T("2번"));
          m_ListView.SetItemText(0, 1, _T("도도2-1"));
          m_ListView.SetItemText(0, 2, _T("도도2-2"));

        

          UpdateData(FALSE);

 

          return TRUE;  // 포커스를 컨트롤에 설정하지 않으면 TRUE를 반환합니다.
}

 dlg.cpp 파일 내 코드

 

 

반응형

+ Recent posts