c++ - 程序运行一直失败

Question

以下代码运行失败。

这是我的代码:

#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;
}

Answer 1

您正在按值推送二叉树:

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

然而，BinaryTree 不支持 复制，因为它会进行浅复制(没有三规则特殊成员)。这意味着，拷贝将共享 root指针和二叉树的意志 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> 之上只是为了排除这是错误的来源。

Big DISCLAIMER: Not much of this code is actually exception safe as written, now. I'll assume that exception safety hasn't been on the menu for this course, yet. Edit but see comment.

查看 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