Почему при переключении из класса шаблонов появляется <-тип ошибки>? ⇐ C++

[Anonymous]

Я реализовал следующее дерево бинарного поиска, используя класс шаблонов: < /p>

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

В этом случае я хочу реализовать один и тот же класс, но используя только объект типа. Реализация работает при объявлении как список my_student; < /code> < /p>

Однако, когда я пытаюсь реализовать один и тот же код, но вместо класса шаблона - это класс, который принимает только объекты студента типа, поэтому удаляя шаблон и указание каждой функции.auto removeNode(std::shared_ptr node_ptr);
auto removeLeftmostNode(std::shared_ptr nodePtr, Student& inorderSuccessor);
< /code>

Я получаю «Объявление несовместимо с" "Сообщение: < /p>

auto Roster::removeNode(std::shared_ptr node_ptr)
{

}
< /code>

, чтобы увидеть полную реализацию .cpp для list.hpp для класса шаблонов: < /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);
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>

Текущий список .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>

ошибка: < /p>

declaration is incompatible with
Roster::removeNode(std::__1::shared_ptr node_ptr)


Подробнее здесь: https://stackoverflow.com/questions/592 ... late-class