Mobile versionCode: Select all
#ifndef ROSTER_
#define ROSTER_
#include "BinaryNode.hpp"
#include "Visitor.hpp"
#include "Student.hpp"
#include "Printer.hpp"
#include
#include
template
class Roster
{
public:
Roster(); // Constructor
Roster(const Roster& tree); //Copy constructor
~Roster(); // Destructor
bool isEmpty() const;
int getHeight() const;
int getNumberOfNodes() const;
void add(const T& new_item);
void add(const std::vector& new_items);
void remove(const T& target);
void display();
T find(const T& item);
void clear();
void inorderTraverse(Visitor& visit) const;
Roster& operator= (const Roster& rhs);
private:
std::shared_ptr root_ptr_;
std::shared_ptr copyTree(const std::shared_ptr old_tree_root_ptr) const;
void destroyTree(std::shared_ptr sub_tree_ptr);
int getHeightHelper(std::shared_ptr sub_tree_ptr) const;
auto placeNode(std::shared_ptr sub_tree_ptr, std::shared_ptr new_node_ptr);
auto removeValue(std::shared_ptr sub_tree_ptr, const T target);
auto removeNode(std::shared_ptr node_ptr);
auto removeLeftmostNode(std::shared_ptr nodePtr, T& inorderSuccessor);
void inorder(Visitor& visit, std::shared_ptr tree_ptr) const;
//Operator overloading for students objects
friend bool operator (const Student& a, const Student& b);
friend bool operator ==(const Student& a, const Student& b);
};
#include "Roster.cpp"
#endif
< /code>
In diesem Fall möchte ich dieselbe Klasse implementieren, aber nur verwenden Objekt vom Typ Schüler. Die Implementierung funktioniert bei der Deklaration als Kader my_student; < /code> < /p>
Wenn ich jedoch versuche, denselben Code zu implementieren, ist es jedoch anstelle einer Vorlagenklasse eine Klasse, die nur Objekte vom Typ Schüler entfernen und die Vorlage angeben und jede Funktion angeben.auto removeNode(std::shared_ptr node_ptr);
auto removeLeftmostNode(std::shared_ptr nodePtr, Student& inorderSuccessor);
< /code>
Ich erhalte eine "Deklaration ist nicht kompatibel mit" "Meldung: < /p>
auto Roster::removeNode(std::shared_ptr node_ptr)
{
}
< /code>
Um die vollständige Implementierung des .cpp für Roster.hpp für die Vorlagenklasse zu sehen: < /p>
#include "Roster.hpp"
//Constructor
template
Roster::Roster()
{
root_ptr_ = nullptr;
}
//Copy Constructor
template
Roster::Roster(const Roster& tree)
{
root_ptr_ = copyTree(tree.root_ptr_);
}
//Destructor
template
Roster::~Roster()
{
destroyTree(root_ptr_);
}
//Check if empty
template
bool Roster::isEmpty() const
{
return root_ptr_ == nullptr;
}
//Clear
template
void Roster::clear()
{
destroyTree(root_ptr_);
}
//Get height
template
int Roster::getHeight() const
{
return getHeightHelper(root_ptr_);
}
//Add
template
void Roster::add(const T& new_item)
{
auto new_node_ptr = std::make_shared(new_item);
root_ptr_ = placeNode(root_ptr_, new_node_ptr);
}
//Add with vector
template
void Roster::add(const std::vector& new_items)
{
for(int i = 0; i < new_items.size(); i++)
{
auto new_node_ptr = std::make_shared(new_items[i]);
root_ptr_ = placeNode(root_ptr_, new_node_ptr);
}
}
//Remove
template
void Roster::remove(const T& target)
{
root_ptr_ = removeValue(root_ptr_, target);
}
//Diplay
template
void Roster::display()
{
Printer p;
inorderTraverse(p);
}
template
void Roster::inorderTraverse(Visitor& visit) const
{
inorder(visit, root_ptr_);
}
//Helper function
template
std::shared_ptr Roster::copyTree(const std::shared_ptr old_tree_root_ptr) const
{
std::shared_ptr new_tree_ptr;
// Copy tree nodes during preorder tranversal
if(old_tree_root_ptr != nullptr)
{
new_tree_ptr = std::make_shared(old_tree_root_ptr->getItem(), nullptr, nullptr);
new_tree_ptr->setLeftChildPtr(copyTree(old_tree_root_ptr->getLeftChildPtr()));
new_tree_ptr->setRightChildPtr(copyTree(old_tree_root_ptr->getRightChildPtr()));
}
return new_tree_ptr;
}
template
void Roster::destroyTree(std::shared_ptr sub_tree_ptr)
{
if(sub_tree_ptr != nullptr)
{
destroyTree(sub_tree_ptr->getLeftChildPtr());
destroyTree(sub_tree_ptr->getRightChildPtr());
sub_tree_ptr.reset();
}
}
template
int Roster::getHeightHelper(std::shared_ptr sub_tree_ptr) const
{
if(sub_tree_ptr == nullptr)
{
return 0;
}
else
{
return 1 + std::max(getHeightHelper(sub_tree_ptr->getLeftChildPtr()), getHeightHelper(sub_tree_ptr->getRightChildPtr()));
}
}
template
auto Roster::placeNode(std::shared_ptr sub_tree_ptr, std::shared_ptr new_node_ptr)
{
if(sub_tree_ptr == nullptr)
{
return new_node_ptr;
}
else
{
if(sub_tree_ptr->getItem() > new_node_ptr->getItem())
{
sub_tree_ptr->setLeftChildPtr(placeNode(sub_tree_ptr->getLeftChildPtr(), new_node_ptr));
}
else
{
sub_tree_ptr->setRightChildPtr(placeNode(sub_tree_ptr->getRightChildPtr(), new_node_ptr));
}
return sub_tree_ptr;
}
}
template
auto Roster::removeValue(std::shared_ptr sub_tree_ptr, const T target)
{
if(sub_tree_ptr == nullptr)
{
return sub_tree_ptr;
}
if(sub_tree_ptr->getItem() == target)
{
sub_tree_ptr = removeNode(sub_tree_ptr);
return sub_tree_ptr;
}
else
{
if(sub_tree_ptr->getItem() > target)
{
sub_tree_ptr->setLeftChildPtr(removeValue(sub_tree_ptr->getLeftChildPtr(), target));
}
else
{
sub_tree_ptr->setRightChildPtr(removeValue(sub_tree_ptr->getRightChildPtr(), target));
}
return sub_tree_ptr;
}
}
template
auto Roster::removeNode(std::shared_ptr node_ptr)
{
//Case 1: Node is a leaf - it is deleted
if(node_ptr->isLeaf())
{
node_ptr.reset();
return node_ptr;
}
//Case 2: Node has one child - parent adopts child
else if(node_ptr->getLeftChildPtr() == nullptr)
{
return node_ptr->getRightChildPtr();
}
else if(node_ptr->getRightChildPtr() == nullptr)
{
return node_ptr->getLeftChildPtr();
}
else
{
T new_node_value;
node_ptr->setRightChildPtr(removeLeftmostNode(node_ptr->getRightChildPtr(), new_node_value));
node_ptr->setItem(new_node_value);
return node_ptr;
}
}
template
auto Roster::removeLeftmostNode(std::shared_ptr nodePtr, T& inorderSuccessor)
{
if(nodePtr->getLeftChildPtr() == nullptr)
{
inorderSuccessor = nodePtr->getItem();
return removeNode(nodePtr);
}
else
{
nodePtr->setLeftChildPtr(removeLeftmostNode(nodePtr->getLeftChildPtr(), inorderSuccessor));
return nodePtr;
}
}
template
void Roster::inorder(Visitor& visit, std::shared_ptr tree_ptr) const
{
if(tree_ptr != nullptr)
{
inorder(visit, tree_ptr->getLeftChildPtr());
T the_item = tree_ptr->getItem();
visit(the_item);
inorder(visit, tree_ptr->getRightChildPtr());
}
}
//Operator Overloading for students objects
bool operator (const Student& a, const Student& b)
{
if( a.getLastName() > b.getLastName())
{
return true;
}
else if(a.getLastName() == b.getLastName())
{
if(a.getFirstName() > b.getFirstName())
{
return true;
}
}
return false;
}
bool operator ==(const Student& a, const Student& b)
{
return (a.getFirstName() == b.getFirstName() && a.getLastName() == b.getLastName());
}
< /code>
aktueller Roster.hpp: < /p>
#ifndef ROSTER_HPP
#define ROSTER_HPP
#include "BinaryNode.hpp"
#include "Visitor.hpp"
#include "Student.hpp"
#include "Printer.hpp"
#include
#include
class Roster
{
public:
Roster(); // Constructor
Roster(const Roster& tree); //Copy constructor
~Roster(); // Destructor
bool isEmpty() const;
int getHeight() const;
int getNumberOfNodes() const;
void add(const Student& new_item);
void add(const std::vector& new_items);
void remove(const Student& target);
void display();
Student find(const Student& item);
void clear();
void inorderTraverse(Visitor& visit) const;
Roster& operator= (const Roster& rhs);
private:
std::shared_ptr root_ptr_;
std::shared_ptr copyTree(const std::shared_ptr old_tree_root_ptr) const;
void destroyTree(std::shared_ptr sub_tree_ptr);
int getHeightHelper(std::shared_ptr sub_tree_ptr) const;
auto placeNode(std::shared_ptr sub_tree_ptr, std::shared_ptr new_node_ptr);
auto removeValue(std::shared_ptr sub_tree_ptr, const Student target);
auto removeNode(std::shared_ptr node_ptr);
auto removeLeftmostNode(std::shared_ptr nodePtr, Student& inorderSuccessor);
void inorder(Visitor& visit, std::shared_ptr tree_ptr) const;
//Operator overloading for students objects
friend bool operator (const Student& a, const Student& b);
friend bool operator ==(const Student& a, const Student& b);
};
#endif
< /code>
Fehler: < /p>
declaration is incompatible with
Roster::removeNode(std::__1::shared_ptr node_ptr)
