I dont seem to understand my errors

[stefoka]

So i am implementing the class LinkedBinaryTree and i am aplying "Depth and Height" and "A linked structure for binary tree". I will post my code and I am hoping that somenone could help me with it.

#include <iostream>
using namespace std;

// InspectableContainer
template <typename Object>
class InspectableContainer {
public:
  int size();
  bool isEmpty() const;
};

// Code Fragment: InspectablePositionalContainer
template <typename Object>
class InspectablePositionalContainer
  : public InspectableContainer<Object> {
public:
  class Position;					    // node position type
  class PositionIterator;				// position iterator
  PositionIterator positions() const;	// get position iterator
};

// Code Fragment: PositionalContainer
template <typename Object>
class PositionalContainer :
  public InspectablePositionalContainer<Object> {
public:
  typedef typename InspectablePositionalContainer<Object>::Position Position;
  void swapElements(const Position& v, const Position& w);
  Object& replaceElement(const Position& v, const Object& e);
};

// Code Fragment: InspectableTree
template <typename Object>
class InspectableTree
  : public InspectablePositionalContainer<Object> {
public:
  typedef typename InspectablePositionalContainer<Object>::Position Position;
  typedef typename InspectablePositionalContainer<Object>::PositionIterator
                                                            PositionIterator;
  Position root() const;				        // get root of tree
  Position parent(const Position& v) const;		// get parent of v
  PositionIterator children(const Position& v) const;	// iterator for children
  bool isInternal(const Position& v) const;		// internal node?
  bool isExternal(const Position& v) const;		// external node?
  bool isRoot(const Position& v) const;			// the root?
};

// Code Fragment: Tree
template <typename Object>
class Tree
  : public InspectableTree<Object>, PositionalContainer<Object> {
};

template <typename Object>
class LinkedBinaryTree
{
protected:
    struct Node  						// a node in the tree
    {
        Object      element;				// the element
        Node*       parent;					// parent
        Node*       left;					// left child
        Node*       right;					// right child
        Node() : element(Object())				// default constructor
        {
            parent = left = right = NULL;
        }
        Node* sibling() const  				// get our sibling
        {
            return (this == parent->left ? parent->right : parent->left);
        }
    };
    typedef Node* NodePtr;				// a node pointer

public:
    class Position  					// position in the tree
    {
    private:
        NodePtr node;					// pointer to the node
    public:
        Position(NodePtr n = NULL)				// constructor
        {
            node = n;
        }
        Object& element() const 				// get element
        {
            return node->element;
        }
        bool isNull() const 				// null position?
        {
            return node == NULL;
        }
        friend LinkedBinaryTree;				// allow access
    };

private: 						// member data
    NodePtr    theRoot;			// pointer to the root
    int        sz;				// number of nodes
protected: 						// protected utilities
    NodePtr nodePtr(const Position& v) const 		// convert to NodePtr
    {
        return v.node;
    }
    bool isExternal(NodePtr n) const 			// is node external?
    {
        return (n->left == NULL && n->right == NULL);
    }
    bool isInternal(NodePtr n) const 			// is node internal?
    {
        return ! isExternal(n);
    }
    bool isRoot(NodePtr n) const 				// is node the root?
    {
        return (n == theRoot);
    }
    void setRoot(NodePtr r)				// make r the root
    {
        theRoot = r;
        r->parent = NULL;
    }
    void replaceElement(NodePtr n, const Object& o)	// replace element
    {
        n->element = o;
    }
    void swapElements(NodePtr n, NodePtr w)  		// swap elements
    {
        Object temp = w->element;
        w->element = n->element;
        n->element = temp;
    }
    void expandExternal(NodePtr n)  			// expand external node
    {
        n->left   = new Node;
        n->left->parent = n;
        n->right  = new Node;
        n->right->parent = n;
        sz += 2;
    }
    NodePtr removeAboveExternal(NodePtr n)  		// remove n and parent
    {
        NodePtr p = n->parent;
        NodePtr s = n->sibling();
        if (isRoot(p)) setRoot(s);				// p was root; now s is
        else
        {
            NodePtr g = p->parent;				// the grandparent
            if (p == g->left)	    g->left  = s;		// replace parent by sibling
            else 		    g->right = s;
            s->parent = g;
        }
        delete n;
        delete p;					// delete removed nodes
        sz -= 2;						// two fewer nodes
        return s;
    }

public:
    LinkedBinaryTree()					// constructor
    {
        theRoot = new Node;
        sz = 1;
    }
    int size() const  					// size of tree
    {
        return sz;
    }
    bool isEmpty() const 					// is tree empty?
    {
        return (sz == 0);
    }
    Position root() const 				// returns root
    {
        return Position(theRoot);
    }
    Position leftChild(const Position& v) const 		// returns left child
    {
        return Position(nodePtr(v)->left);
    }
    Position rightChild(const Position& v) const 		// returns right child
    {
        return Position(nodePtr(v)->right);
    }
    // ... parent(), and sibling() are omitted but similar)
    bool isRoot(const Position& v) const 			// is v the root?
    {
        return isRoot(nodePtr(v));
    }
    bool isInternal(const Position& v) const 		// is v internal?
    {
        return isInternal(nodePtr(v));
    }
    bool isExternal(const Position& v) const 		// is v external?
    {
        return isExternal(nodePtr(v));
    }
    void replaceElement(const Position& v, const Object& o)
    {
        replaceElement(nodePtr(v), o);    // replace element
    }
    void swapElements(const Position& v, const Position& w)
    {
        swapElements(nodePtr(v), nodePtr(w));    // swap elements
    }
    void expandExternal(const Position& v)
    {
        expandExternal(nodePtr(v));    // expand external node
    }
    Position removeAboveExternal(const Position& v)	// remove v and parent
    {
        return Position(removeAboveExternal(nodePtr(v)));
    }
    // ... (housekeeping and iterator functions omitted)
};

class Int
{
public:
    Int()
    {
        counter++;
        num = counter;
    }
private:
    static int counter;
    int num;
    friend ostream& operator<<(ostream& out, Int i);
};

ostream& operator<<(ostream& out, Int i)
{
    out << i.num << " ";
    return  out;
}

typedef LinkedBinaryTree<Int> Tree1;
typedef Tree1::Position Position;

int depth(const Tree1& T, const Position& v);

void binaryInorderPrint(const Tree1& T, const Position& v)
{
    if (T.isInternal(v))        // visit left child
        binaryInorderPrint(T, T.leftChild(v));
    cout << v.element();      // print element
    if (T.isInternal(v))        // visit right child
        binaryInorderPrint(T, T.rightChild(v));
}



int Int::counter = 0;

int height1(const Tree1& T)
{
    int h = 0;
    PositionIterator nodes = T.positions();
    while (nodes.hasNext())
    {
        Position v = nodes.next();
        if (T.isExternal(v)) h = max(h, depth(T, v));
    }
    return h;
}

int height2(const Tree1& T, const Position& v)
{
    if (T.isExternal(v))
        return 0;						// leaf has height 0
    else
    {
        int h = 0;
        PositionIterator children = T.children(v);
        while (children.hasNext())
            h = max(h, height2(T, children.next()));
        return 1 + h;					// 1 + (max height)
    }
}

int depth(const Tree& T, const Position& v)
{
    if (T.isRoot(v))
        return 0;						// root has depth 0
    else
        return 1 + depth(T, T.parent(v));			// 1 + (depth of parent)
}

int main()
{
    LinkedBinaryTree<Int> btree;
    btree.expandExternal(btree.root());
    binaryInorderPrint(btree, btree.root());
    cout << endl;
    btree.expandExternal(btree.leftChild(btree.root()));
    binaryInorderPrint(btree, btree.root());

    cout << depth(btree, btree.root());
    cout << height1(btree);
    cout << height2(btree, btree.root());

    return 0;
}

[keskiverto]

Could you list your errors too?

[stefoka]

.cpp||In function 'int height1(const Tree1&)':|
.cpp|257|error: 'PositionIterator' was not declared in this scope|
.cpp|257|error: expected ';' before 'nodes'|
.cpp|258|error: 'nodes' was not declared in this scope|
.cpp||In function 'int height2(const Tree1&, const Position&)':|
.cpp|273|error: 'PositionIterator' was not declared in this scope|
.cpp|273|error: 'const Tree1' has no member named 'children'|
.cpp|274|error: 'children' was not declared in this scope|
.cpp|280|error: invalid use of template-name 'Tree' without an argument list|
.cpp|280|error: ISO C++ forbids declaration of 'T' with no type [-fpermissive]|
.cpp||In function 'int depth(const int&, const Position&)':|
.cpp|282|error: request for member 'isRoot' in 'T', which is of non-class type 'const int'|
.cpp|285|error: request for member 'parent' in 'T', which is of non-class type 'const int'|
||=== Build finished: 10 errors, 0 warnings (0 minutes, 2 seconds) ===|

[keskiverto]

error: 'PositionIterator' was not declared in this scope

The height1 is a standalone function. Typename PositionIterator is not defined in it nor in the global namespace. What is 'PositionIterator' here?

Furthermore, your Tree1 does not seem to contain member positions(). (The compiler did not get far enough to complain about that.)

[kbw]

error: 'PositionIterator' was not declared in this scope

PositionIterator is a member of InspectablePositionalContainer, height1 has nothing to do with InspectablePositionalContainer, so to use PositionIterator there makes no sense.

The other errors ripple from this error.