在本论坛找到一个堆栈的源代码，用了两重指针，请问有必要吗

skybyte

1. 
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <malloc.h>
   
5. #include <string.h>
   
6. 
   
7. 
   
8. typedef struct elementT
   
9. {
   
10.     struct elementT *next;
    
11.     void *data;
    
12. }element;
    
13. 
    
14. int push(element **stack, void *data)
    
15. {
    
16.     element *elem = NULL;
    
17.     elem = (element *)malloc(sizeof(element));
    
18.     if(!elem)
    
19.     {
    
20.         return -1;
    
21.     }
    
22.     elem->data = data;
    
23.     elem->next = *stack;
    
24.     *stack = elem;
    
25.     return 0;
    
26. }
    
27. 
    
28. int pop(element **stack, void **data)
    
29. {
    
30.     element *elem;
    
31.     if(!(elem = *stack))
    
32.     {
    
33.         return -1; /** the stack is null*/
    
34.     }
    
35.     *data = elem->data;
    
36.     *stack = elem->next;
    
37.     free(elem->data);
    
38.     elem->next = NULL;
    
39.     free(elem);
    
40.     return 0;
    
41. }
    
42. 
    
43. int creat_stack(element **stack)
    
44. {
    
45.     *stack = NULL;
    
46.     return 0;
    
47. }
    
48. 
    
49. int delete_stack(element **stack)
    
50. {
    
51.     element *elem;
    
52.     while(*stack)
    
53.     {
    
54.         elem = (*stack)->next; /** not elem = *stack->next;*/
    
55.         free(*stack);
    
56.         *stack = elem;
    
57.     }
    
58.     return 0;
    
59. }
    
60. 
    
61. int main(int argc, char *argv[])
    
62. {
    
63.     char data_c[20] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
    
64.     int  data_i[20] = {1, 2, 3, 4, 5, 6, 7};
    
65.     int i, ret=0;
    
66.     element stack_char, stack_int, *stack_c, *stack_i;
    
67.     char *p_c;
    
68.     int *p_i;
    
69.    
    
70.     creat_stack(&stack_c);
    
71.     creat_stack(&stack_i);
    
72.    
    
73.     for(i=0; i<7; i++)
    
74.     {
    
75.         ret = push(&stack_c, (void *)&data_c[i]);
    
76.         if(ret)
    
77.         {
    
78.             printf("push element to stack_c error\n");
    
79.             return -1;
    
80.         }      
    
81. 
    
82.         ret = push(&stack_i, (void *)&data_i[i]);         
    
83.         if(ret)        
    
84.         {
    
85.                 printf("push element to stack_i error\n");
    
86.                 return -1;
    
87.         }      
    
88.     }
    
89. 
    
90.     for(i=0; i<7; i++)   
    
91.     {
    
92.         ret = pop(&stack_c, (void **)&p_c);
    
93.         if(ret)        
    
94.         {
    
95.                 printf("pop element to stack_c error\n");
    
96.                 return -1;
    
97.         }               
    
98.         printf("pop stack_c element [%c]\n", *(char *)p_c);
    
99.     }
    
100. 
     
101.     for(i=0; i<7; i++)   
     
102.     {
     
103.         ret = pop(&stack_i, (void **)&p_i);
     
104.         if(ret)        
     
105.         {
     
106.                 printf("pop element to stack_i error\n");
     
107.                 return -1;
     
108.         }               
     
109.         printf("pop stack_i element [%d]\n", *(int *)p_i);      
     
110.     }
     
111.     delete_stack(&stack_i);
     
112.     system("pause");   
     
113. 
     
114. }
     
115. 
     

复制代码

spacegrass

若将 element 改为 void 类型，则可以将任意类型的数据放入栈中。
代码很好，通用性强。
值得学习。