I've been having some trouble with these nodes I'm trying to inherit. I've looked at a lot of examples online but can't figure out what I'm dong wrong.
My compiler is giving me these messages:
error: expected identifier before 'public'
error: expected '{' before 'public'
error: expected unqualified-id before 'public'
Any help would be much appreciated :)
template <typename T>
class Node
{
protected:
Node<T>* next;
Node<T>* prev;
T* data;
public:
Node();
~Node();
Node* getNext();
Node* getPrev();
void setNext(Node<T>*);
void setPrev(Node<T>*);
T* getData();
void setData(T*);
};
template <typename T>
class HeadNode : public Node<T>
{
public:
HeadNode();
~HeadNode();
};
template <typename T>
class TailNode : public Node<T>
{
public:
TailNode(Node<T>*);
~TailNode();
};
template <typename T>
class InternalNode : public Node<T>
{
public:
InternalNode(Node<T>*, Node<T>*, T*);
~InternalNode();
};
template <typename T>
Node<T>::Node()
{
next = 0;
prev = 0;
data = 0;
}
template <typename T>
Node<T>::~Node()
{
//delete data;
}
template <typename T>
Node<T>* Node<T>::getNext()
{
return next;
}
template <typename T>
Node<T>* Node<T>::getPrev()
{
return prev;
}
template <typename T>
void Node<T>::setNext(Node<T>* n)
{
next = n;
}
template <typename T>
void Node<T>::setPrev(Node<T>* n)
{
prev = n;
}
template <typename T>
T* Node<T>::getData()
{
return data;
}
template <typename T>
void Node<T>::setData(T* nData)
{
delete data;
data = nData;
}
template <typename T>
HeadNode<T>::HeadNode() : public Node<T>()
{
next = new TailNode<T>(this);
}
template <typename T>
HeadNode<T>::~HeadNode()
{
}
template <typename T>
TailNode<T>::TailNode(Node<T>* p) : public Node<T>()
{
prev = p;
}
template <typename T>
TailNode<T>::~TailNode()
{
}
template <typename T>
InternalNode<T>::InternalNode(Node<T>* n, Node<T>* p, T* nData): public Node<T>()
{
next = n;
prev = p;
data = nData;
}
template <typename T>
InternalNode<T>::~InternalNode()
{
//delete data;
}
I'm not so good at C++, but this passed the compiler.
remove public from the initialization at constructors
add Node<T>:: to where child classes want to use member of parent class
add virtual to the destructor of Node so that destructors of child classes will be called on deleting
template <typename T>
class Node
{
protected:
Node<T>* next;
Node<T>* prev;
T* data;
public:
Node();
virtual ~Node(); // add virtual
Node* getNext();
Node* getPrev();
void setNext(Node<T>*);
void setPrev(Node<T>*);
T* getData();
void setData(T*);
};
template <typename T>
class HeadNode : public Node<T>
{
public:
HeadNode();
~HeadNode();
};
template <typename T>
class TailNode : public Node<T>
{
public:
TailNode(Node<T>*);
~TailNode();
};
template <typename T>
class InternalNode : public Node<T>
{
public:
InternalNode(Node<T>*, Node<T>*, T*);
~InternalNode();
};
template <typename T>
Node<T>::Node()
{
next = 0;
prev = 0;
data = 0;
}
template <typename T>
Node<T>::~Node()
{
//delete data;
}
template <typename T>
Node<T>* Node<T>::getNext()
{
return next;
}
template <typename T>
Node<T>* Node<T>::getPrev()
{
return prev;
}
template <typename T>
void Node<T>::setNext(Node<T>* n)
{
next = n;
}
template <typename T>
void Node<T>::setPrev(Node<T>* n)
{
prev = n;
}
template <typename T>
T* Node<T>::getData()
{
return data;
}
template <typename T>
void Node<T>::setData(T* nData)
{
delete data;
data = nData;
}
template <typename T>
HeadNode<T>::HeadNode() : Node<T>() // remove public
{
Node<T>::next = new TailNode<T>(this); // add Node<T>::
}
template <typename T>
HeadNode<T>::~HeadNode()
{
}
template <typename T>
TailNode<T>::TailNode(Node<T>* p) : Node<T>() // remove public
{
Node<T>::prev = p; // add Node<T>::
}
template <typename T>
TailNode<T>::~TailNode()
{
}
template <typename T>
InternalNode<T>::InternalNode(Node<T>* n, Node<T>* p, T* nData): Node<T>() // remove public
{
Node<T>::next = n; // add Node<T>::
Node<T>::prev = p; // add Node<T>::
Node<T>::data = nData; // add Node<T>::
}
template <typename T>
InternalNode<T>::~InternalNode()
{
//delete data;
}
Related
How can do I implement the SearchTree constructor with the T type parameter by calling it's superclass ?
template <class T>
class SearchTree: protected unique_ptr<Node<T> >{
public:
SearchTree<T>();
SearchTree<T>(const T &); //How do I implement this ?
}
template <class T>
class Node{
friend class SearchTree<T>;
public:
Node<T>();
Node<T>(const T & sl_):sl(sl_){};
private:
const T sl;
SearchTree<T> left,right;
}
Inheriting from std::unique_ptr is an instant indicator of a design flaw.
Encapsulation is the way to go. Perhaps start with something like this?
#include <memory>
template<class T> struct Node;
template<class T>
void add_node(std::unique_ptr<Node<T>>& next, T t);
template<class T>
struct Node
{
Node(T t) : _value(std::move(t)) {}
void add(T t)
{
if (t < _value) {
add_node(_left, std::move(t));
}
else if(t > _value) {
add_node(_right, std::move(t));
}
else {
// what?
}
}
T _value;
std::unique_ptr<Node<T>> _left, _right;
};
template<class T>
void add_node(std::unique_ptr<Node<T>>& next, T t)
{
if (next) {
next->add(std::move(t));
}
else {
next = std::make_unique<Node<T>>(std::move(t));
}
}
template<class T>
struct SearchTree
{
void add(T t) {
add_node(_root, std::move(t));
}
std::unique_ptr<Node<T>> _root;
};
int main()
{
SearchTree<int> tree;
tree.add(5);
tree.add(3);
tree.add(4);
}
I the compiler can't find the definition of my constructor for the nested class.
My nested class Node is in the middle and the constructor is at the end.
Errors:
error C2244: 'CircularDoubleDirectedList::Node::Node' : unable
to match function definition to an existing declaration see
declaration of 'CircularDoubleDirectedList::Node::Node'
definition
'CircularDoubleDirectedList::Node::Node(const T &)'
existing declarations
'CircularDoubleDirectedList::Node::Node(const T &)'
Code:
#ifndef CIRCULARDOUBLEDIRECTEDLIST_H
#define CIRCULARDOUBLEDIRECTEDLIST_H
#include "ICircularDoubleDirectedList.h"
template <typename T> class CircularDoubleDirectedList;
template <typename T> class Node;
template <typename T>
class CircularDoubleDirectedList :
public ICircularDoubleDirectedList<T>{
public:
//Variabels
Node<T>* current;
int nrOfElements;
direction currentDirection;
//Functions
CircularDoubleDirectedList();
~CircularDoubleDirectedList();
void addAtCurrent(const T& element) override;
private:
template <typename T>
class Node
{
public:
T data;
Node<T>* forward;
Node<T>* backward;
Node(const T& element);// The constructor
};
};
template <typename T>
CircularDoubleDirectedList<T>::CircularDoubleDirectedList(){
this->nrOfElements = 0;
this->current = nullptr;
this->currentDirection = FORWARD;
}
template <typename T>
CircularDoubleDirectedList<T>::~CircularDoubleDirectedList(){
//TODO: Destroy all nodes
}
template <typename T>
void CircularDoubleDirectedList<T>::addAtCurrent(const T& element){
Node<T>* newNode = new Node<T>(element);
newNode->data = element;
if (this->nrOfElements == 0){
newNode->forward = newNode;
newNode->backward = newNode;
}
else{
//this->current->forward = newNode;
//this->current->forward->backward = newNode;
}
//this->current = newNode;
}
template <typename T>
CircularDoubleDirectedList<T>::Node<T>::Node(const T& element){
this->data = element;
}
#endif
First, the forward-declared template <typename T> class Node; is not the same as CircularDoubleDirectedList::Node - the former is a global class template, the latter is a nested class.
Second, you don't need to declare CircularDoubleDirectedList::Node as a template (and if you do, you have to use another template parameter name for it, not T). But as I understand, for this case you should just make it non-template, so:
template <typename T>
class CircularDoubleDirectedList :
public ICircularDoubleDirectedList<T>{
private:
class Node
{
public:
T data;
Node* forward;
Node* backward;
Node(const T& element);// The constructor
};
public:
Node* current;
//...
};
template <typename T>
CircularDoubleDirectedList<T>::Node::Node(const T& element){
this->data = element;
}
You have two class templates named Node, while in reality you want one non-template class named Node. You have forward-declared ::Node<T>, and you have the nested ::CircularDoubleDirectedList<T>::Node<U>.
If you really want it like that, you'll have to add another template keyword to the constructor definition:
template <typename T> //because CircularDoubleDirectedList is a template
template <typename U> //because Node is a template
CircularDoubleDirectedList<T>::Node<U>::Node(const T& element) : data(element)
{}
However, I can't see a single reason to have Node be a template. Inside CircularDoubleDirectedList<T>, do you want to use nodes with type other than T? If not, make Node a normal non-template class:
template <typename T>
class CircularDoubleDirectedList :
public ICircularDoubleDirectedList<T>{
public:
//Variabels
Node<T>* current;
int nrOfElements;
direction currentDirection;
//Functions
CircularDoubleDirectedList();
~CircularDoubleDirectedList();
void addAtCurrent(const T& element) override;
private:
class Node
{
public:
T data;
Node* forward;
Node* backward;
Node(const T& element);// The constructor
};
};
template <typename T>
CircularDoubleDirectedList<T>::Node::Node(const T& element) : data(element)
{}
I've created this pretty simple dynamic list which is implemented with a template class:
Node.h
template <class T> class Node
{
public:
typedef T data_type;
typedef T& reference_type;
void setData(data_type);
void setNextNull();
void setNext(Node*);
reference_type getData();
Node* getNext();
private:
data_type data;
Node* next;
};
template <class T> void Node<T>::setData(data_type _data)
{
data=_data;
}
template <class T> void Node<T>::setNextNull()
{
next=NULL;
}
template <class T> void Node<T>::setNext(Node* _next)
{
next=_next;
}
template <class T> typename Node<T>::reference_type Node<T>::getData()
{
return data;
}
template <class T> typename Node<T>::Node* Node<T>::getNext()
{
return next;
}
List.h
#ifndef LIST_H
#define LIST_H
#include <Node.h>
template <class T> class List
{
public:
typedef Node<T> node_type;
typedef node_type* node_pointer;
typedef T data_type;
typedef T& reference_type;
List();
void push_back(data_type);
reference_type at(int);
void clear();
void swap(int,int);
int size();
private:
int list_size = 0;
node_pointer head, tail;
};
template <class T> List<T>::List()
{
head=NULL;
}
template <class T> void List<T>::push_back(data_type data)
{
if(head == NULL) {
head = new node_type;
head->setData(data);
tail = head;
} else {
node_pointer temp = new node_type;
temp->setData(data);
temp->setNextNull();
tail->setNext(temp);
tail = tail->getNext();
}
list_size++;
}
template <class T> typename List<T>::reference_type List<T>::at(int x)
{
node_pointer pointer=head;
for(int i=0; i<x; i++)
pointer=pointer->getNext();
return pointer->getData();
}
template <class T> void List<T>::clear()
{
node_pointer pointer = head;
for(int i=0; i<list_size; i++) {
node_pointer temp = pointer;
pointer=pointer->getNext();
delete(temp);
}
head=NULL;
list_size=0;
}
template <class T> void List<T>::swap(int x, int y)
{
data_type buffer=at(x);
at(x)=at(y);
at(y)=buffer;
}
template <class T> int List<T>::size()
{
return list_size;
}
#endif // LIST_H
The list works perfectly with any form of data type, except when i use a class with a parameter inside it's constructor, then I get this error:
include/Node.h error: no matching function for call to ‘Player::Player()’
What am I doing wrong??
UPDATE 1
I've added a simple constructor as suggested but I get the same error
template <class T> Node<T>::Node(data_type _data)
{
data=_data;
}
You probably haven't defined a default constructor for your Player class. Just insert an empty constructor
Player() {}
And your problem will likely to be solved.
When you write a template method and use it in the main function like this:
Node<Player>
The compiler automatically calls the constructor of the Player class.
If you didn't define any constructors in Player, the compiler will use default constructor. However, any constructor you defined will hide the default one and force you to use this one.
For instance, a constructor like
Player(string, int, int)
Prevents you to create an object like this:
Player *p = new Player();
However, if you haven't written the constructor, the piece of code above would've worked just fine.
That's why your template needs a default constructor, iff you defined a parameterized constructor.
Your class Node should have a constructor which take a T so you can construct your T by copy instead of requiring to have a default constructor and copy.
your Node class would be something like:
template <class T>
class Node
{
public:
Node(const T& data) : data(data), next(0) {}
void setNextNull();
void setNext(Node*);
const T& getData() const { return data; }
T& getData() { return data; }
Node* getNext();
private:
T data;
Node* next;
};
and so you transform
head = new node_type;
head->setData(data);
by
head = new node_type(data);
I want to create a factory, that returns AVLNode, if BinaryTree is AVLTree, and Node if the tree is not AVL. I have following code:
#include "BinaryTree.h"
#include "AVLTree.h"
class NodeFactory {
public :
template <class T>
static Node<T>* getNode(BinaryTree<T>* tree);
};
template <class T>
Node<T>* NodeFactory::getNode(BinaryTree<T>* tree) {
if (tree->isAVL()) {
return new AVLNode<T>();
} else {
return new Node<T>();
}
}
UPD: (this is BinaryTree.h)
template <class T> class Node;
template <class T> class BinaryTree {
public:
BinaryTree() {
_isAVL = false;
root = new Node<T>();
}
bool isAVL() {
return _isAVL;
}
private:
T elem;
Node<T>* root;
bool _isAVL;
};
template <class T> class Node {
public:
Node() {
left = NULL;
right = NULL;
}
T get() {
return elem;
}
void setRight(const T elem) {
right = new Node<T>();
right->set(elem);
}
void setLeft(const T elem) {
left = new Node<T>();
left->set(elem);
}
private:
T elem;
Node* left;
Node* right;
};
I removed almost all methods to make code more readable.
Now i have this error during compilation: "expected initializer before '<' token". Also Qt do not highlights in Node, but highlights in BinaryTree
It's a syntax error. You need
template <class T> // or <typename T>
Node<T>* NodeFactory::getNode(BinaryTree<T>* tree) {
template <class T>
class BTree
{
private:
T Data;
BTree* Right;
BTree* Left;
public:
BTree();
BTree(T);
~BTree();
void SetData(T);
T GetData();
void SetRight(BTree*);
BTree* GetRight();
void SetLeft(BTree*);
BTree* GetLeft();
};
Is this the way to declare a non member function template?I seriously have some doubts about these definitions.
template <class T>
BTree<T>* NewNode();
template <class T>
BTree<T>* NewNode(T);
this below does not work!! gives me an error
template <class T>
BTree<T>* NewNode()
{
BTree<T>* Node=new BTree<T>;
return Node;
}
template <class T=int>
//template <class BTree>
BTree<T>* NewNode(T Num)
{
BTree<T>* Node=new BTree<T>(Num);
return Node;
}
int main()
{
BTree<int>* Root=NULL;
Root=NewNode(1); //it says undefined reference.
Root->SetLeft(NewNode(2));
Root->SetRight(NewNode(3));
return 0;
}
The error is as the following:
1.undefined reference to `BTree<int>* NewNode<int>(int)'
2.undefined reference to `BTree<int>::SetLeft(BTree<int>*)'
3.undefined reference to `BTree<int>::SetRight(BTree<int>*)'