C++ C++；模板链接列表链接器错误

我认为我的模板使用不当，但我不知道我做错了什么。这就像模板链表无法确定它需要使用我的术语类一样

列表->插入（临时多项式）；是导致链接器错误的代码行，位于function.cpp的末尾

以下是Visual Studio 2012中的确切错误：

---

• 错误LNK2019:未解析的外部符号“bool\uu cdecl运算符您的术语类需要一个较小的比较器。以下任一操作都可以：
  在术语类中，作为成员：

  bool operator <(const Term&) const; 
  

  示例II（自由操作员；不是

  术语的成员）
  
  bool运算符您声明了您的友好运算符，但没有定义它们。那么…定义它们？我不确定您的意思，因为linkedList类中的所有函数都已实现。链接器错误是由于以下代码行引起的：theList->insert（TempPolyman）链接器声称：
  bool\uCDECL操作符mdata
  是它被拉入的地方。在我的主要函数中，链接列表被初始化为一个类型项，这会使数据也有一个类型项。那么，它不应该被成功拉入吗？你是说它们必须被重载才能专门处理Term类吗？这是什么在学期课上我会超负荷工作吗？也谢谢你到目前为止的帮助。非常感谢你，这很有效，现在更有意义了。尽管我仍然没有得到“免费操作员”“概念。这是一个覆盖标准#include "header.h"
  
  
  void loadPolynomial(string expression, LinkedList<Term> *theList)
  {
      Term tempPolynomial;
  
      string varDelimiter = "x";
      string posDelimiter = "+";
      string negDelimiter = "-";
      string token = "";
  
      double coefficient;
      double exponent;
  
      bool isNeg;
  
      while(expression.length() > 0)
      {
          isNeg = false;
  
          if(expression.substr(0, 1) == "+")
          {
              expression.erase(0, 1);
          }
  
          else if(expression.substr(0, 1) == "-")
          {
              isNeg = true;
              expression.erase(0, 1);
          }
  
          //Get the coefficient
          token = expression.substr(0, expression.find(varDelimiter));
          //Remove the coefficient and variable from the string leaving only the exponent
          expression.erase(0, expression.find(varDelimiter) + varDelimiter.length());
          //Convert and put token's coeficient into a double
          coefficient = atof(token.c_str());
  
          if(isNeg = true)
          {
              coefficient = coefficient * -1;
          }
  
          //Put the coefficient value into the tempPolynomial
          tempPolynomial.setCoefficient(coefficient);
  
          //If posDelimiter has a smaller length then it is the beginning of the next expression
          if(expression.find(posDelimiter) < expression.find(negDelimiter))
          {
              //Get the exponent
              token = expression.substr(0, expression.find(posDelimiter));
              //Remove the exponent but leave the + 
              expression.erase(0, expression.find(varDelimiter));
              //Convert and put token's coeficient into a double
              exponent = atof(token.c_str());
          }
  
          else
          {
              //Get the exponent
              token = expression.substr(0, expression.find(posDelimiter));
              //Remove the exponent but leave the +
              expression.erase(0, expression.find(varDelimiter));
              //Convert and put token's coeficient into a double
              exponent = atof(token.c_str());
          }
  
          //Put the exponent value into the tempPolynomial
          tempPolynomial.setExponent(exponent);
  
          //Intert the first term into the linked list
          theList->insert(tempPolynomial);
      }
  }
  
  #ifndef LINKED_LIST_H
  #define LINKED_LIST_H
  
  #include <iostream>
  #include <fstream>
  using namespace std;
  
  template <class T>
  class LinkedList
  {
  private:
      T mData;
      LinkedList<T> *mNext;
  
  public:
      LinkedList();
      LinkedList(T data);
      ~LinkedList();
  
      T getData();
      LinkedList<T> *getNext();
  
      void setData(T data);
  
      void display();
      void insert(T data);
      bool isExist(T data);
      void remove(T data);
  
      friend ostream& operator<<(ostream &output, LinkedList<T> obj);
  
      bool operator==(T right);
      friend bool operator==(T left, LinkedList<T> right);
  
      bool operator!=(T right);
      friend bool operator!=(T left, LinkedList<T> right);
  
      bool operator>(T right);
      friend bool operator>(T left, LinkedList<T> right);
  
      bool operator<(T right);
      friend bool operator<(T left, LinkedList<T> right);
  };
  
  
  
  template <class T>
  LinkedList<T>::LinkedList()
  {
      mNext = NULL;
      mData = T();
  }
  
  
  
  template <class T>
  LinkedList<T>::LinkedList(T data)
  {
      mNext = NULL;
      mData = data;
  }
  
  
  
  template <class T>
  LinkedList<T>::~LinkedList()
  {
      LinkedList<T> *tempNode;
  
      tempNode = mNext;
  
      while(tempNode != NULL)
      {
          mNext = tempNode->mNext;
          tempNode->mNext = NULL;
  
          delete tempNode;
  
          tempNode = mNext;
      }
  }
  
  
  
  template <class T>
  T LinkedList<T>::getData()
  {
      return mData;
  }
  
  
  
  template <class T>
  LinkedList<T> *LinkedList<T>::getNext()
  {
      return mNext;
  }
  
  
  
  template <class T>
  void LinkedList<T>::setData(T data)
  {
      mData = data;
  }
  
  
  
  template <class T>
  void LinkedList<T>::display()
  {
      LinkedList<T> *tempNode;
  
      tempNode = mNext;
  
      while(tempNode != NULL)
      {
          cout << tempNode->mData << endl;
  
          tempNode = tempNode->mNext;
      }
  }
  
  
  
  template <class T>
  void LinkedList<T>::insert(T data)
  {
      LinkedList<T> *previousNode;
      LinkedList<T> *tempNode;
      LinkedList<T> *newNode;
  
      newNode = new LinkedList(data);
  
      if(mNext == NULL)
      {
          mNext = newNode;
      }
  
      else
      {
          previousNode = mNext;
          tempNode = mNext;
  
          while(tempNode != NULL && tempNode->mData < data)
          {
              previousNode = tempNode;
              tempNode = tempNode->mNext;
          }
  
          if(tempNode == mNext)
          {
              newNode->mNext = mNext;
              mNext = newNode;
          }
  
          else
          {
              previousNode->mNext = newNode;
              newNode->mNext = tempNode;
          }
      }
  }
  
  
  
  template <class T>
  bool LinkedList<T>::isExist(T data)
  {
      LinkedList<T> *tempNode;
      bool exist = false;
  
      tempNode = mNext;
  
      while(tempNode != NULL)
      {
          if(tempNode->mData == data)
          {
              exist = true;
  
              break;
          }
  
          tempNode = tempNode->mNext;
      }
  
      return exist;
  }
  
  
  
  template <class T>
  void LinkedList<T>::remove(T data)
  {
      LinkedList<T> *tempNode;
      LinkedList<T> *previousNode;
  
      if(isExist(data) == false)
      {
          return;
      }
  
      tempNode = mNext;
      previousNode = mNext;
  
      while(tempNode->mData != data)
      {
          previousNode = tempNode;
          tempNode = tempNode->mNext;
      }
  
      if(tempNode == mNext)
      {
          mNext = tempNode->mNext;
          tempNode->mNext = NULL;
      }
  
      else
      {
          if(tempNode->mNext == NULL)
          {
              previousNode->mNext = NULL;
          }
  
          else
          {
              previousNode->mNext = tempNode->mNext;
              tempNode->mNext = NULL;
          }
      }
  
      delete tempNode;
  }
  
  
  
  template <class T>
  ostream& operator<<(ostream &output, LinkedList<T> obj)
  {
      output << obj.mData;
  
      return output;
  }
  
  
  
  template <class T>
  bool LinkedList<T>::operator==(T right)
  {
      return mData == right;
  }
  
  
  
  template <class T>
  bool operator==(T left, LinkedList<T> right)
  {
      return left == right.mData;
  }
  
  
  
  template <class T>
  bool LinkedList<T>::operator!=(T right)
  {
      return mData != right;
  }
  
  
  
  template <class T>
  bool operator!=(T left, LinkedList<T> right)
  {
      return left != right.mData;
  }
  
  
  
  template <class T>
  bool LinkedList<T>::operator>(T right)
  {
      return mData > right;
  }
  
  
  
  template <class T>
  bool operator>(T left, LinkedList<T> right)
  {
      return left > right.mData;
  }
  
  
  
  template <class T>
  bool LinkedList<T>::operator<(T right)
  {
      return mData < right;
  }
  
  
  
  template <class T>
  bool operator<(T left, LinkedList<T> right)
  {
      return left < right.mData;
  }
  
  #endif
  
  #ifndef TERM_H
  #define TERM_H
  
  class Term
  {
  private:
      double mCoefficient;
      double mExponent; 
  
  public:
      Term();
      Term(double coefficient, double exponent);
      ~Term();
  
      double getCoefficient();
      double getExponent();
      void setCoefficient(double coefficient);
      void setExponent(double exponent);
  };
  
  #endif
  
  bool operator <(const Term&) const; 
  
  bool operator <(const Term& left, const Term& right);
  
  while(tempNode != NULL && tempNode->mData < data)
  
  bool operator <(const Term& rhs) const
  {
      return (mCoefficient < rhs.mCoefficient ||
             (!(rhs.mCoefficient < mCoefficient) == && mExponent < rhs.mExponent));
  }
  
  bool operator <(const Term& lhs, const Term& rhs)
  {
      return (lhs.getCoefficient() < rhs.getCoefficient() ||
             (!(rhs.getCoefficient() < lhs.getCoefficient()) == && 
               lhs.getExponent() < rhs.getExponent()));
  }