Từ 1 tới 4 trên tổng số 4 kết quả

Đề tài: Xử lý stack trong lập trình Visual C++

  1. #1
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Talking Xử lý stack trong lập trình Visual C++

    Anh em xem hộ con nay của mình viết stack sao khi test với popStack toàn ra kết quả sai

    Header File : stdafx.h
    Visual C++ Code:
    1.  
    2. #pragma once
    3.  
    4. #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
    5. #include <stdio.h>
    6. #include <tchar.h>
    7.  
    8. typedef struct node
    9. {
    10.     void* dataPtr;
    11.     struct node* link;
    12. } STACK_NODE;
    13.  
    14. typedef struct
    15. {
    16.     int count;
    17.     STACK_NODE* top;
    18. } STACK;
    19.  
    20. void showMenu(void);
    21.  
    22. STACK* createStack(void);
    23. bool pushStack(STACK* stack, void* dataInPtr);
    24. void* popStack(STACK* stack);
    25. void* stackTop(STACK* stack);
    26. bool emptyStack(STACK* stack);
    27. bool fullStack(STACK* stack);
    28. int stackCount(STACK* stack);
    29. STACK* destroyStack(STACK* stack);

    Cấu trúc header File : stdafx.cpp
    Visual C++ Code:
    1.  
    2.  
    3. #include "stdafx.h"
    4. #include <malloc.h>
    5. #include <stdio.h>
    6. // createStack()
    7. STACK* createStack(void)
    8. {
    9.     STACK* stack;
    10.  
    11.     stack = (STACK*)malloc(sizeof(STACK));
    12.     if(stack)
    13.     {
    14.         stack->count=0;
    15.         stack->top=NULL;
    16.     }
    17.     return stack;
    18. }
    19.  
    20. // pushStack
    21. bool pushStack(STACK* stack, void* dataInPtr)
    22. {
    23.     STACK_NODE* newPtr;
    24.     newPtr = (STACK_NODE*)malloc(sizeof(STACK_NODE));
    25.     if(!newPtr)
    26.         return false;
    27.    
    28.     newPtr->dataPtr=dataInPtr;
    29.     newPtr->link=stack->top;
    30.     stack->top=newPtr;
    31.  
    32.     (stack->count)++;
    33.     return true;
    34. }
    35.  
    36. // popStack
    37. void* popStack(STACK* stack)
    38. {
    39.     void* dataOutPtr;
    40.     STACK_NODE* temp;
    41.  
    42.     if(stack->count==0)
    43.         dataOutPtr=NULL;
    44.     else
    45.     {
    46.         temp=stack->top;
    47.         dataOutPtr=stack->top->dataPtr;
    48.         stack->top=stack->top->link;
    49.         free(temp);
    50.         (stack->count)--;
    51.     }
    52.     return dataOutPtr;
    53. }
    54.  
    55. // stackTop
    56. void* stackTop(STACK* stack)
    57. {
    58.     if(stack->count==0)
    59.         return NULL;
    60.     else return stack->top->dataPtr;
    61. }
    62.  
    63. // emptyStack
    64. bool emptyStack(STACK* stack)
    65. {
    66.     return (stack->count==0);
    67. }
    68.  
    69. // fullStack
    70. bool fullStack(STACK* stack)
    71. {
    72.     STACK_NODE* temp;
    73.  
    74.     if((temp=(STACK_NODE*)malloc(sizeof(*(stack->top)))))
    75.     {
    76.         free(temp);
    77.         return false;
    78.     }
    79.    
    80.     return true;
    81. }
    82.  
    83. // stackCount
    84. int stackCount(STACK* stack)
    85. {
    86.     return stack->count;
    87. }
    88.  
    89. // destroyStack
    90. STACK* destroyStack(STACK* stack)
    91. {
    92.     STACK_NODE* temp;
    93.  
    94.     if(stack)
    95.     {
    96.         while(stack->top!=NULL)
    97.         {
    98.             free(stack->top->dataPtr);
    99.  
    100.             temp=stack->top;
    101.             stack->top=stack->top->link;
    102.             free(temp);
    103.         }
    104.  
    105.         free(stack);
    106.     }
    107.  
    108.     return NULL;
    109. }
    110.  
    111. // showMenu(void)
    112. void showMenu(void)
    113. {
    114.     printf("================STACK MENU================\n");
    115.     printf(" A. Push data into stack\n");
    116.     printf(" B. Pop and print data\n");
    117.     printf(" C. Print data at top of stack\n");
    118.     printf(" D. Print entire stack ( top of base )\n");
    119.     printf(" E. Print stack status : Empty\n");
    120.     printf(" F. Print stack status : Full\n");
    121.     printf(" G. Print number of elements in stack\n");
    122.     printf(" H. Destroy stack and quit\n");
    123.     printf("==========================================\n");
    124. }

    Main File : Stack_Application.cpp
    Visual C++ Code:
    1. // Stack_Application.cpp : Defines the entry point for the console application.
    2. //
    3.  
    4. /* Preprocessor */
    5. #include <stdio.h>
    6. #include "stdafx.h"
    7. #include <malloc.h>
    8. #include <conio.h>
    9.  
    10. /* Main() Unicode */
    11. int _tmain(int argc, _TCHAR* argv[])
    12. {
    13.     /* Variables Declaration */
    14.     int* dataPtr;
    15.     char key=NULL;
    16.     int inNum, cntStack;
    17.     STACK* stack;
    18.  
    19.     stack=createStack(); // Create Stack First
    20.    
    21.     showMenu(); // Show Menu
    22.  
    23.     do {
    24.     /* Get Input Command */
    25.     printf("->Enter command :");
    26.     key = _getch();
    27.    
    28.     switch(key)
    29.     {
    30.         /* Push Data Into Stack */
    31.         case 'a':
    32.         case 'A': // fine
    33.             printf("\nCommand<A> ");
    34.             printf("::Input data <integer> : ");
    35.             scanf_s("%d",&inNum);
    36.             dataPtr = &inNum;
    37.             if (!pushStack(stack,dataPtr))
    38.                 printf("::Out of memory ! \n");
    39.             break;
    40.         /* Pop Data Out Of Stack */
    41.         case 'b':
    42.         case 'B':
    43.             printf("\nCommand<B> ");
    44.             dataPtr = (int*)popStack(stack);
    45.             if ( dataPtr != NULL )
    46.                 printf("::Output data : %d\n",*dataPtr);
    47.             else printf("::Data Empty .\n");
    48.  
    49.             break;
    50.         /* Get Top Of The Stack */
    51.         case 'c':
    52.         case 'C':
    53.             printf("\nCommand<C> ");
    54.             if ((dataPtr = (int*)stackTop(stack)) != NULL )
    55.                 printf("::Top data : %d\n", *dataPtr);
    56.             else printf("::No such a data ! \n");
    57.             break;
    58.         /* Get Entire Data From Stack */
    59.         case 'd':
    60.         case 'D':
    61.             printf("\nCommand<D> ");
    62.             dataPtr = (int*)popStack(stack);
    63.             if ( dataPtr == NULL )
    64.                 printf("::No data .");
    65.             else {
    66.                 printf("::Entire data :");
    67.                 while ( dataPtr != NULL )
    68.                     {
    69.                     printf(" %d",*dataPtr);
    70.                     dataPtr = (int*)popStack(stack);
    71.                     }
    72.                 printf("\n");
    73.                 }
    74.             break;
    75.         /* Check Empty Stack */
    76.         case 'e':
    77.         case 'E': // fine
    78.             printf("\nCommand<E> ");
    79.             if(emptyStack(stack))
    80.                 printf("::Stack Status : Empty\n");
    81.             else printf("::Stack Status : No empty .\n");
    82.             break;
    83.         /* Check Empty Stack */
    84.         case 'f':
    85.         case 'F': // fine
    86.             printf("\nCommand<F> ");
    87.             if(fullStack(stack))
    88.                 printf("::Stack Status : Full\n");
    89.             else printf("::Stack Status : No Full .\n");
    90.             break;
    91.         /* Check Number Of Elements In Stack */
    92.         case 'g':
    93.         case 'G': // fine
    94.             printf("\nCommand<G> ");
    95.             cntStack = stackCount(stack);
    96.             printf("::Elements in stack : %d\n",cntStack);
    97.             break;
    98.         /* Destroy Stack */
    99.         case 'h':
    100.         case 'H': // fine
    101.             printf("\nCommand<H> ");
    102.             printf("\n");
    103.             destroyStack(stack);
    104.             break;
    105.        
    106.         default : // fine
    107.             printf("\nInvalid Command ! Please Input Command Again...");
    108.             break;
    109.         }  
    110.  
    111.     } while ( key != 'h' && key != 'H');
    112.  
    113.     return 0;
    114. }

    Bài này pete viết để thể hiện ứng dụng của stack qua các hàm thôi.
    Mọi người check xem khi mình test cứ qua hàm popStack nó đưa ra mỗi giá trị Top còn giá trị sau kô ra.
    Còn Cái in ra giá trị toàn stack ngoài cách pop ra còn có cách nào hay hơn ko ?
    Bài này viết trên môi trường VC++ 2k5 Pro .
    Có gì mọi người vào góp ý cho vui !
    None!

  2. #2
    Ngày gia nhập
    07 2006
    Bài viết
    121

    Đề nghị muốn test phải viết mục đích các hàm của cậu là gì ?
    Ý nghĩa các tham số truyền vào. Và giá trị ra là gì? ý nghĩa của giá trị đầu ra.
    Đã được chỉnh sửa lần cuối bởi shinichi_haha : 09-04-2007 lúc 08:39 PM.

    OoShinHaoO

  3. #3
    Ngày gia nhập
    11 2006
    Bài viết
    75

    Visual C++ Code:
    1. //This is a new version of pushStack
    2. bool pushStack(STACK* stack, void* dataInPtr)
    3. {
    4.     STACK_NODE* newPtr;
    5.     newPtr = (STACK_NODE*)malloc(sizeof(STACK_NODE));
    6.  
    7.     if(!newPtr)
    8.         return false;
    9.        
    10.     int newData = *((int*) dataInPtr); //We assume that dataInPtr points to an integer number
    11.     newPtr->dataPtr = malloc(sizeof(int)); //Make a new room for storing this number's value
    12.                                            //(NOT STORE ITS ADDRESS AS YOUR PREVIOUS VERSION
    13.                                            //THROUGH A POINTER ASSIGNMENT)
    14.     *((int*)(newPtr->dataPtr)) = newData; //Saving value...
    15.      
    16.     newPtr->link=stack->top;
    17.     stack->top=newPtr;
    18.  
    19.     (stack->count)++;
    20.     return true;
    21. }

    You wrote:
    Mọi người check xem khi mình test cứ qua hàm popStack nó đưa ra mỗi giá trị Top còn giá trị sau kô ra.

    This concerning with your source code:
    Visual C++ Code:
    1. ...
    2. int *dataPtr;
    3. int inNum;
    4. ...
    5. /* Push Data Into Stack */
    6.         case 'a':
    7.         case 'A': // fine
    8.             printf("\nCommand<A> ");
    9.             printf("::Input data <integer> : ");
    10.             scanf("%d",&inNum);
    11.             dataPtr = &inNum; //dataPtr always points to inNum.
    12.            
    13.             if (!pushStack(stack,dataPtr))
    14.             //This will make a new node in stack, but node->dataPtr                      
    15.             //will points to inNum's address only because you doesn't allocate
    16.             //memory for storing the new value of inNum. The assignment
    17.             //"node->dataPtr = dataPtr" means "let node->dataPtr & dataPtr point
    18.             //"to the same variable" not "let node->dataPtr handle a COPY of data which
    19.             //"dataPtr holds".
    20.                                            
    21.                 printf("::Out of memory ! \n");
    22.             break;
    23.             //Now, every node->dataPtr in your stack points to inNum
    24.             //so there is only one choice for your popStack.
    25.             //That's why you can not retrieve another value as you expect
    26.             //and values displayed on screen are the lastest value of inNum

    In addition, I think you should modify the file stdafx.h as below:

    Visual C++ Code:
    1. #pragma once
    2. #ifndef _STDAFX_INCLUDED
    3. #define _STDAFX_INCLUDED
    4. #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
    5. #include <stdio.h>
    6. #include <tchar.h>
    7. #include <malloc.h>
    8. #include <conio.h>
    9. ...
    10. #endif

    This will allow you to save many keystrokes because you have to type "#include stdafx.h" only in stdafx.cpp & stack_application.cpp. Thus including other header files is unnecessary.

    Visual C++ Code:
    1. //stack_appilcation.cpp
    2. #include "stdafx.h"
    3. //nothing changed

    and

    Visual C++ Code:
    1. //stdafx.cpp
    2. #include "stdafx.h"
    3. //nothing changed, except your pushStack function

    Refer to C++ STL and Boost::any if you want to store anything in a container (instead of using void pointer).
    Have fun!
    Đã được chỉnh sửa lần cuối bởi ilovecplusplus : 10-04-2007 lúc 04:54 AM.
    Our dreams are young and we both know they take us where we want to go...

  4. #4
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Thanks...I corrected it ^^
    None!

Các đề tài tương tự

  1. Bài tập C++ copy noi dung tu stack S sang stack D
    Gửi bởi thaodn_chuprong trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 12
    Bài viết cuối: 18-10-2012, 11:45 PM
  2. Cấu trúc dữ liệu Chuyển các phần tử từ stack này sang stack kia như thế nào?
    Gửi bởi rukawa1184 trong diễn đàn Thắc mắc CTDL & Giải thuật
    Trả lời: 9
    Bài viết cuối: 06-12-2011, 06:52 PM
  3. Stack, ngăn xếp - Thiết lập và ứng dụng stack trong C
    Gửi bởi PoPoPoPo trong diễn đàn Thủ thuật, Tutorials CTDL & Giải thuật
    Trả lời: 8
    Bài viết cuối: 15-11-2010, 11:24 PM
  4. Stack trên C | Lỗi khó hiểu trong Stack
    Gửi bởi tom3cang trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 22-05-2009, 11:09 PM
  5. Code về stack | Chuyển hệ số 10 sang 2 dùng stack
    Gửi bởi ahappyboy89 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 13
    Bài viết cuối: 17-04-2009, 09:48 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn