c++ - 程序运行不断失败

以下代码的运行失败。

这是我的代码:

#ifndef STACK_H
#define STACK_H
//#include "BinaryTree.h"
using namespace std;

template<class T>
class stack
{
public:
    stack();        // constructor
    T pop();        // pop with type BinaryTree
    void push(T x); // push BinaryTree on top
    bool empty();   // return t/f if stack is empty
    int size();     // return size to keep track of stack

private:
    T arr[10];      // array with 10 elements
    int ele;        // keeps track of top of list
};

/******************************************************/

template<class T>
stack<T>::stack()
{
    ele = 0;
}
template<class T>
T stack<T>::pop()
{
    return arr[--ele];
}
template<class T>
void stack<T>::push(T x)
{
    arr[ele++] = x;
}
template<class T>
bool stack<T>::empty()
{
    if(ele == 0)
    {
        return true;
    }
}
template<class T>
int stack<T>::size()
{
    return ele;
}

#endif  /* STACK_H */
#ifndef BINARYTREE_H
#define BINARYTREE_H
using namespace std;

我需要3个构造函数；对于第三个构造函数，它将不会处理。我认为这是因为我正在从同一类中调用另一个构造函数。

template<typename T> class BinaryTree
{
public:
    // Binary Tree Things
    BinaryTree();                 // default constructor to make empty tree
    BinaryTree(T ro);             // default constructor 2 to make tree with only root
    BinaryTree(T ro, T le, T ri); // default constructor 3 to make complete binary tree
    //~BinaryTree();                // destructor for dynamics
    bool  isEmpty();              // method that returns t/f if tree is empty
    T     info();                 // method to return value in root of the tree
    void  inOrder();              // traverses nodes in a tree left, root, right
    void  preOrder();             // traverses nodes in a tree root, left, right
    void  postOrder();            // traverses nodes in a tree left, right, root

private:
    struct Tree_Node              // represents a node
    {
        T Node_Info;
        BinaryTree<T> *left;      // left pointer
        BinaryTree<T> *right;     // right pointer
    };

    Tree_Node *root;              // create root with 2 pointers from this    };

};
/***********************************************************************/

template<typename T> BinaryTree<T>::BinaryTree()
{
}

template<typename T> BinaryTree<T>::BinaryTree(T ro)
{
    this->root->Node_Info = ro;
    this->root->left = 0;
    this->root->right = 0;
}

template<typename T> BinaryTree<T>::BinaryTree(T ro, T le, T ri)
{
    // create temps for left and right
    BinaryTree<T> *templeft = new BinaryTree(le);
    templeft->root->Node_Info = le;
    BinaryTree<T> *tempright = new BinaryTree(ri);
    tempright->root->Node_Info = ri;
    // re-assign everything
    this->root->Node_Info = ro;
    this->root->left = templeft;
    this->root->right = tempright;
}

/*template<typename T> BinaryTree<T>::~BinaryTree() {
    delete root; }*/

template<typename T> bool BinaryTree<T>::isEmpty()
{
    return false;
}

template<typename T> T BinaryTree<T>::info()
{
}

template<typename T> void BinaryTree<T>::inOrder()
{
}

template<typename T> void BinaryTree<T>::preOrder()
{
}

template<typename T> void BinaryTree<T>::postOrder()
{
}

#endif  /* BINARYTREE_H */

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <math.h>
#include <cmath>
#include <ctime>
#include <limits>
//#include "BinaryTree.h"
//#include "stack.h"

using namespace std;

int main()
{
    stack<BinaryTree<char> > testing;
    BinaryTree<char> testing2('d', 'd', 'd');
    testing.push(testing2);
    cout << testing.size();
    return 0;
}

最佳答案

您正在按值推送二叉树:

stack<BinaryTree<char> > testing;
BinaryTree<char> testing2('d', 'd', 'd');
testing.push(testing2);

但是，BinaryTree不支持复制，因为它会进行浅拷贝(没有“三人制”特殊成员)。这意味着，该副本将共享root指针，并且两个BinaryTree的副本都将delete相同的root(假设您取消注释该关键代码)。

这是将必要的特殊成员添加到BinaryTree<T>和BinaryTree<T>::Tree_Node的修复程序:

(复制)构造函数+ BinaryTree<T>的析构函数

BinaryTree(BinaryTree const& other)
    : root(other.root? new Tree_Node(*other.root) : 0)
{}

(复制)构造函数+ BinaryTree<T>::Tree_Node的析构函数

struct Tree_Node              // represents a node
{
    T data;
    Tree_Node *left;      // left pointer
    Tree_Node *right;     // right pointer

    Tree_Node(T data, Tree_Node* left = 0, Tree_Node* right = 0)
        : data(data), left(left), right(right) {}

    Tree_Node(Tree_Node const& other)
        : data(other.data),
        left (other.left? new Tree_Node(*other.left) : 0),
        right(other.right?new Tree_Node(*other.right) : 0)
    {}

    ~Tree_Node()
    {
        delete left;
        delete right;
    }
};

注意，我更改了Tree_Node，因此它拥有其他Tree_Node，而不是完整的BinaryTree(此更改相当免费，并且源于我在尝试修复任何问题之前尝试降低噪音的原因)

同样在“降噪”类别中，我在stack<T>之上重新放置了std::vector<T>，只是为了排除它是错误的来源。

观看 Live On IdeOne :

#ifndef STACK_H
#define STACK_H
//#include "BinaryTree.h"
using namespace std;

#include <cassert>
#include <vector>

template<class T>
class stack
{
public:
    T pop()         { assert(!empty()); T v = _data.back(); _data.pop_back(); return v; }
    void push(T x)  { _data.push_back(x); }
    bool empty()    { return _data.empty(); }
    int size()      { return _data.size(); }

private:
    std::vector<T> _data;
};

#endif  /* STACK_H */
#ifndef BINARYTREE_H
#define BINARYTREE_H
using namespace std;

template<typename T> class BinaryTree
{
public:
    // Binary Tree Things
    BinaryTree();                 // default constructor to make empty tree
    BinaryTree(T ro);             // default constructor 2 to make tree with only root
    BinaryTree(T ro, T le, T ri); // default constructor 3 to make complete binary tree
    ~BinaryTree();                // destructor for dynamics

    BinaryTree(BinaryTree const& other) : root(other.root? new Tree_Node(*other.root) : 0) {}

    bool  isEmpty();              // method that returns t/f if tree is empty
    T     info();                 // method to return value in root of the tree
    void  inOrder();              // traverses nodes in a tree left, root, right
    void  preOrder();             // traverses nodes in a tree root, left, right
    void  postOrder();            // traverses nodes in a tree left, right, root

private:
    struct Tree_Node              // represents a node
    {
        T data;
        Tree_Node *left;      // left pointer
        Tree_Node *right;     // right pointer

        Tree_Node(T data, Tree_Node* left = 0, Tree_Node* right = 0)
            : left(left), right(right) {}

        Tree_Node(Tree_Node const& other)
            : data(other.data),
            left (other.left? new Tree_Node(*other.left) : 0),
            right(other.right?new Tree_Node(*other.right) : 0)
        {}

        ~Tree_Node()
        {
            delete left;
            delete right;
        }
    };

    Tree_Node *root;              // create root with 2 pointers from this    };
};
/***********************************************************************/

template<typename T> BinaryTree<T>::BinaryTree()
    : root(0)
{
}

template<typename T> BinaryTree<T>::BinaryTree(T ro)
    : root(new Tree_Node(ro, 0, 0))
{
}

template<typename T> BinaryTree<T>::BinaryTree(T ro, T le, T ri)
    : root(new Tree_Node(ro,
            new Tree_Node (le, 0, 0),
            new Tree_Node (ri, 0, 0)))
{
}

template<typename T> BinaryTree<T>::~BinaryTree() {
    delete root;
}

template<typename T> bool BinaryTree<T>::isEmpty()
{
    return !root;
}

template<typename T> T BinaryTree<T>::info()
{
}

template<typename T> void BinaryTree<T>::inOrder()
{
}

template<typename T> void BinaryTree<T>::preOrder()
{
}

template<typename T> void BinaryTree<T>::postOrder()
{
}

#endif  /* BINARYTREE_H */

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <math.h>
#include <cmath>
#include <ctime>
#include <limits>
//#include "BinaryTree.h"
//#include "stack.h"

using namespace std;

int main()
{
    stack<BinaryTree<char> > testing;
    BinaryTree<char> testing2('d', 'd', 'd');
    testing.push(testing2);
    cout << testing.size();
    return 0;
}

enter code here

关于c++ - 程序运行不断失败，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/18994195/