源码如下：编译没有错误，但是就是得不到结果！望各位大侠帮帮忙！


#include<iostream>

using namespace std;

typedef struct node      //节点定义
{
    int data;
    struct node *next;
}snode;

class stack    //栈的类定义
{
private:
    snode *top;    
    int length;
public:
    stack create_stack(stack *st);

    void push(stack *st,int x);

    void pop(stack *st);

    void print(stack *st);
};
//几个函数的实现
stack stack::create_stack(stack *st)
{
    st->top=NULL;
    st->length=0;
    return(*st);
}

void stack::push(stack *st,int x)
{
    node *s;
    s=(snode *)malloc(sizeof(snode));
    s->data=x;
    s->next=st->top;

    st->top=s;
    st->length++;
    return;
}
void stack::pop(stack *st)
{
    node *p,*s;
    p=(node *)malloc(sizeof(node));
    if(st->top==NULL)
        exit(0);
    else
    {
        p=st->top;
        st->top=st->top->next;
        free(p);
        st->length--;
    }
    return;
}

void stack::print(stack *st)
{
    node *s;
    s=(node *)malloc(sizeof(node));
    while(st->top!=NULL)
    {
        s=st->top;
        cout<<s->data<<endl;
        s=s->next;
    }
    return;
}
    
void main()
 {
    stack *st;
    st->create_stack(st);
    st->push(st,2);
    st->push(st,1);
    st->print(st);
    return;    
 }

1.指针没有指向就附值。
 stack *st;
 st->create_stack(st);
起码要 stack *st=new stack;否则指针往哪指，肯定错误。
2.如果你改正上面的，再看st->push(st,2);
void stack::push(stack *st,int x)
{
    node *s;
    s=(snode *)malloc(sizeof(snode));
    s->data=x;
    s->next=st->top; //错误，st->top总是指向盏顶，你新建的节点得next指针去指向盏顶明显不对，
插入明显应该盏顶的next指针指向s，就是s->next=NULL;st->top->next=s;top=s;

    st->top=s;
    st->length++;
    return;
}
3.如果你改正了上面
void stack::pop(stack *st)
{
    node *p,*s;
    p=(node *)malloc(sizeof(node)); //错误，出盏时还分配什么，肯定错误。
    if(st->top==NULL)
        exit(0);
    else
    {
        p=st->top;
        st->top=st->top->next; //错误st->top已经指到顶了，上面就没有了，st->top->next怎么来的，都乱指了。
        free(p);
        st->length--;
    }
    return;
}
//到此为止，后面错误也不断。
分析盏链，非官方，纯属看你程序想的。
建个链表，需要各头指针head作为链表的开头，top作为链尾，同时为栈顶。长度为length。进栈时放在top后，长度加1，top指向新节点。出栈时top下移，然后释放节点，长度减一。
编写程序例子如下：我就不弄对象指针了，因为本来就是对象自己操作，根本没有其他来调用这个对象，没必要用指针。就像自己家里没样东西都是自己的，你还每个东西贴个标签，
写上自己大名，多此一举。
#include<iostream>

using namespace std;

typedef struct node      //节点定义
{
    int data;
    struct node *next;
}snode;

class stack    //栈的类定义
{
private:
    snode *top;
    snode* head;
    int length;
public:
    void create_stack();
    void push(int x);
    void pop();
    void print();
};
//几个函数的实现
void stack::create_stack()
{
    this->top=NULL;
    this->head=NULL;
    this->length=0;
}

void stack::push(int x)
{
    //建一节点
    node *s;
    s=(snode *)malloc(sizeof(snode));
    s->data=x;
    s->next=NULL;
    //链表插入
    if(!head){
        head=s;
        top=s;
    }else{
        top->next=s;
        top=s;
    }
    length++;
}
void stack::pop()
{
    snode* p;
    p=head;
    if(top==NULL)                  
        cout<<"错误,空栈";
    else if(head==top){
        free(top);
        length--;
        head=NULL;
        top=NULL;
    }else {
        while(p->next!=top){
            p=p->next;
        }
        free(top);
        top=p;
        top->next=NULL;
        length--;
    }
}

void stack::print()
{
    snode* p;
    p=head;
    while(p)
    {
        cout<<p->data<<endl;
        p=p->next;
    }
}
     
int main()
{
    stack st;
    st.create_stack();
    st.push(2);
    st.push(1);
    st.print();
    st.pop();
    st.print();
    return 0;   
}

首先谢谢xufen340的回复！

1.指针没有指向就附值。这点确实是疏忽了，已改正，呵呵~~~~

2.->next=st->top; //错误，st->top总是指向盏顶，你新建的节点得next指针去指向盏顶明显不对，
插入明显应该盏顶的next指针指向s，就是s->next=NULL;st->top->next=s;top=s;
//我觉得咱们的思路有点不同，st->top总是指向栈顶，这没错，但既然是入栈，自然是新建的节点的next指针去指向原来的栈顶，入栈后新的元素作为栈顶
即st->top=s；

3.p=(node *)malloc(sizeof(node)); 错误，出盏时还分配什么，肯定错误。确实不用了，呵呵
st->top=st->top->next; //错误st->top已经指到顶了，上面就没有了，st->top->next怎么来的，都乱指了。
正因为st->top已经指到顶，它才有next;指向的是栈顶元素的下一个，即从栈顶起第二个元素;

[ 本帖最后由 feiying0323 于 2009-8-25 22:58 编辑 ]