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指针，并且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>只是为了排除错误来源。
< / LI>

大免责声明：现在，这段代码实际上并没有太大的异常安全。我会假设本课程的菜单上没有异常安全性。修改，但请参阅评论。

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

程序运行不断失败

1 个答案: