自己写了一个模板栈，用的是链表（PS： 在链表节点这个问题上出现了问题）

施主请留步

当使用结构体作为节点时，栈和驱动程序可以运行
可是当用一个类来代替结构体作为一个节点时，出现了各种各样的错误。
结构体：
struct Node        <----SUCCEED
{
        T data;
        Node<T> *link;
};
类 ：
class Node
{
        friend class LinkedStack;
private :
        T data;
        Node<T> *link;
};
出现的错误：

错误列表

施主请留步

希望有写过栈链表的指点一下

荒年

你少了类模板申明

1. template<class T>

复制代码

施主请留步

荒年 发表于 2016-6-21 13:58
你少了类模板申明

有加，这个写有

荒年

我自己写了一个

1. #define TYLIST(T)  ListNode<T>*
   
2. //template<typename T>
   
3. //struct ListNode{
   
4. //        //数据成员
   
5. //        struct ListNode<T> *pre, *next;//双向列表
   
6. //        T info;
   
7. //        //构造函数
   
8. //        ListNode(){};
   
9. //        ListNode(T e, TYLIST(T) p1, TYLIST(T) p2) :info(e), pre(p1), next(p2){};//在函数形参之后大括号之前：是初始化操作
   
10. //        //操作接口
    
11. //        TYLIST(T) Insertpre(T const&el);//在当前节点之后插入节点
    
12. //        TYLIST(T) Insertnext(T const&el);//插入操作，在当前节点之后插入节点
    
13. //};//节点类
    
14. //template<typename T>
    
15. //TYLIST(T) ListNode<T>::Insertpre(T const &el)
    
16. //{
    
17. //        TYLIST(T) N = new ListNode(el,pre,this);
    
18. //        pre->next = N;
    
19. //        pre = N;//即，在this和this->pre之间插入N，建立相互之间的链接
    
20. //        return N;
    
21. //}
    
22. //template<typename T>
    
23. //TYLIST(T) ListNode<T>::Insertnext(T const &el)
    
24. //{
    
25. //        TYLIST(T) N= new ListNode(el,this,next);
    
26. //        next->pre = N;
    
27. //        next = N;
    
28. //        return N;
    
29. //}
    
30. template<class T>
    
31. class ListNode {
    
32. public:
    
33.         ListNode<T> *pre, *next;
    
34.         T info;
    
35.         //构造函数
    
36.         ListNode(){};
    
37.         ListNode(T e, TYLIST(T) p1, TYLIST(T) p2) :info(e), pre(p1), next(p2){};//在函数形参之后大括号之前：是初始化操作
    
38.         //操作接口
    
39.         TYLIST(T) Insertpre(T const&el);//在当前节点之后插入节点
    
40.         TYLIST(T) Insertnext(T const&el);//插入操作，在当前节点之后插入节点
    
41. };
    
42. template<typename T>
    
43. TYLIST(T) ListNode<T>::Insertpre(T const &el)
    
44. {
    
45.         TYLIST(T) N = new ListNode(el,pre,this);
    
46.         pre->next = N;
    
47.         pre = N;//即，在this和this->pre之间插入N，建立相互之间的链接
    
48.         return N;
    
49. }
    
50. template<typename T>
    
51. TYLIST(T) ListNode<T>::Insertnext(T const &el)
    
52. {
    
53.         TYLIST(T) N= new ListNode(el,this,next);
    
54.         next->pre = N;
    
55.         next = N;
    
56.         return N;
    
57. }

复制代码

是可以的，注释掉的是struct，是可以用的。我也是菜鸟，相互学习

学习电脑

来看看

施主请留步

荒年 发表于 2016-6-22 14:30
我自己写了一个
是可以的，注释掉的是struct，是可以用的。我也是菜鸟，相互学习

你这样是吧结点和操作放到了同一个类里。而我是把结点作为一个类，然后操作作为友元

施主请留步

荒年 发表于 2016-6-22 14:30
我自己写了一个
是可以的，注释掉的是struct，是可以用的。我也是菜鸟，相互学习

这是我单独写的栈链表

1. #ifndef _ST_H_
   
2. #define _ST_H_
   
3. 
   
4. #include<iostream>
   
5. template <class T>
   
6. /*struct Node        <----SUCCEED
   
7. {
   
8.         T data;
   
9.         Node<T> *link;
   
10. };*/       
    
11. class Node
    
12. {
    
13.         friend class LinkedStack;
    
14. private :
    
15.         T data;
    
16.         Node<T> *link;
    
17. };
    
18. template <class T>
    
19. class LinkedStack
    
20. {
    
21.         public :
    
22.                 LinkedStack(){top = 0;}
    
23.                 ~LinkedStack();
    
24.                 bool IsEmpty() const {return top == NULL;}
    
25.                 bool IsFull() const;
    
26.                 T Top() const;
    
27.                 LinkedStack<T>& Add(const T& x);
    
28.                 LinkedStack<T>& Delete(T& x);
    
29.         private :
    
30.                 Node<T> *top;        //指向栈顶结点
    
31. };
    
32. template <class T>
    
33. LinkedStack<T>::~LinkedStack()
    
34. {
    
35.         Node<T> *next;
    
36.         while(top)
    
37.         {
    
38.                 next = top -> link;
    
39.                 delete top;
    
40.                 top = next;
    
41.         }
    
42. }
    
43. template<class T>
    
44. bool LinkedStack<T>::IsFull()const
    
45. {
    
46.         //堆栈是否满
    
47.         Node<T> *p = new Node<T>;
    
48.         if(p == NULL)
    
49.                 return true;
    
50.         return false;
    
51. }
    
52. template<class T>
    
53. T LinkedStack<T>::Top()const
    
54. {
    
55.         //返回栈顶元素
    
56.         if(IsEmpty()) exit(1);
    
57.         return top->data;
    
58. }
    
59. template<class T>
    
60. LinkedStack<T>& LinkedStack<T>::Add(const T& x)
    
61. {
    
62.         //添加元素x
    
63.         Node<T> *p = new Node<T>;
    
64.         p->data = x;
    
65.         p->link = top;
    
66.         top = p;
    
67.         return *this;
    
68. }
    
69. template<class T>
    
70. LinkedStack<T>& LinkedStack<T>::Delete(T& x)
    
71. {
    
72.         if(IsEmpty()) exit(1);
    
73.         x = top -> data;
    
74.         Node<T> *p = top;
    
75.         top = top->link;
    
76.         delete p;
    
77.         return *this;
    
78. }
    
79. #endif
    

复制代码