Question

我的程序有问题。它应该是通过堆栈识别palindome的程序。一切都很好，唯一不起作用的是在完成功能后打印堆栈（原始和反转）。这是我的整个代码，问题出在案例d和e：

#include <iostream>

using namespace std;


const int MAXSTACK = 21;
class stack {
private:
    int  stop;  
    char stk[MAXSTACK];
public:
    stack();
    ~stack();
    stack(const stack& s);
    void push(const char c);
    char pop();
    char top(void);
    int  emptystack(void);
    int  fullstack(void);
    void stack_print(void);
    int stack::create(void);
};
stack::stack()
{
    stop = 0;
}
stack::~stack() { }  
stack::stack(const stack& s)
{
    stop = s.stop;
    strcpy(stk,s.stk);
}
void stack::push(const char c)
{
    stk[stop++] = c;
}
char stack::pop()
{
    return stop--;
}
char stack::top(void)
{
    return stk[stop - 1];
}
int  stack::emptystack(void)
{
    return !stop; 
}
int  stack::fullstack(void)
{
    return stop == MAXSTACK;
}
void stack::stack_print(void)
{
    for (int i=0; i<stop; i++)
        cout<<stk[i];
    cout<<endl;
}
int  stack::create(void)
{
    return !stop; 
}
char menu()
{

    char volba;

    cout<<"\n";
    cout<<" **********.\n";
    cout<<"\n";
    cout<<" a ... make new containers\n";
    cout<<" b ... delete content\n";
    cout<<" c ... enter string\n";
    cout<<" d ... print on screen first stack\n";
    cout<<" e ...  print on screen first stack\n";
    cout<<" f ... is it palindrom\n";
    cout<<" x ... exit\n";
    cout<<"\n your choice : ";

    cin >>  volba;
    return volba;
}
int main() {
    char  palindrome[MAXSTACK]; 
    char volba;
    stack original,reversed;
    int   stackitems = 0,i;
    //cin.getline(palindrome,MAXSTACK);
    do{
        volba = menu();
        switch (volba)
        {
        case'a':
            {
                original.create();
                reversed.create();
                cout<<"done'";
                break;
            }
        case'b':
            {
            original.emptystack();
            reversed.emptystack();
            cout<<"empty";
            break;
            }
        case'c':
            {
                cout<<"enter your string"<<endl;
            cin.get();
            //cin.get();
            cin.getline(palindrome,MAXSTACK);
    for(int o = 0; o < strlen(palindrome); o++)

        if (isalpha(palindrome[o]))
        {
            original.push(tolower(palindrome[o]));
            stackitems++;                           
        }
            original.stack_print();

        break;
            }
        case'd':
            {
                original.~stack();
                for(int g = 0; g < strlen(palindrome); g++)
                original.push(tolower(palindrome[g]));
                original.stack_print();
            }
            /*//cin.getline(palindrome,MAXSTACK);
    for(int g = 0; g < strlen(palindrome); g++)

        if (isalpha(palindrome[g]))
        {
            original.push(tolower(palindrome[g]));
            stackitems++;                           
        }

            }
            original.stack_print();*/
            break;


        /*{
                cout<<"original: ";
        original.stack_print();
                break;
            }*/
            break;
        case'e':
            {
            cout<<"reversed:"<<endl;
            for( i = 0; i < stackitems; i++) {
            reversed.push(original.top());
            original.pop();
        }
        reversed.stack_print();
            }
            break;

        case'f':
            {
            for( i = 0; i < stackitems / 2; i++) {
            reversed.push(original.top());
            original.pop();
        }


        if (stackitems % 2)
            original.pop();

        while (!original.emptystack()) {
            if (original.top() != reversed.top()) break;
            original.pop(); reversed.pop();
        }
        if (original.emptystack())
            cout << "it is palindrom\n";
        else
            cout << "not palindrom\n";

        break;

            }
        default:cout<<"!??!";


        }
    } while(volba!='x');
}

Answer 1

您已明确调用堆栈的析构函数。几乎没有充分的理由这样做。如果堆栈是本地的（“堆栈中”，嘻嘻），编译将为您完成。如果它在堆上，用new创建，则在其上调用delete，这将导致编译器调用析构函数。

    case'd':
            {
                    original.~stack();

Answer 2

你评论了回文：）

//cin.getline(palindrome,MAXSTACK);

Answer 3

我想回答一些事情。首先，我认为GMan，tpdi和Vinay都有优点。这个FAQ解释了为什么在局部变量上调用析构函数是个坏主意。

我意识到这只是一个简单的家庭作业问题，你可能只是想让你的堆栈类变轻，但你可能会考虑在堆栈类中使用using a container class instead of an array of characters。

接下来，我不确定您的空堆栈和创建函数是否正在执行您认为正在执行的操作。当您在主程序中声明原始和反向堆栈类时，将为内部字符数组分配内存。在这种情况下，创建函数并不是必需的。也许如果你在堆上为你的字符数组分配内存，你可以把那些代码放到create函数中（如果你因为某些原因选择将它留在构造函数之外），但这不是这里的情况。

同样，emptystack并没有真正做任何事情。最好让空堆栈将stop成员变量设置为0.至少在下次有人试图使用它时，堆栈看起来是空的。

关于这个类还有很多可以说的，但是如果你尝试了一些建议，比如使用std :: stack和调试，可能会更好。毕竟，这是你的家庭作业：如果你自己找到解决方案，它将在未来帮助你更多！

基于堆栈的回文检查器

3 个答案: