связанный список — C ++ Нет & lt; & lt; найден оператор, который принимает правый операнд

Я работаю над некоторыми домашними заданиями на C ++ и попал в ловушку, я не могу запустить функцию displayList () в своем классе связанного списка. Я получаю следующую ошибку.

Ошибка 1, ошибка C2679: двоичный файл ‘<<‘: не найден оператор, который принимает правый операнд типа’ weatherstats ‘(или нет приемлемого преобразования) c: \ users \ larry \ documents \ visual studio 2013 \ projects \ weatherstats \ weatherstats \ connectedlist.h 100 1 WeatherStats

Поэтому мне нужно перегрузить << операнд, но я попытался использовать несколько примеров, которые я нашел в Интернете, но безуспешно. Может ли кто-нибудь помочь мне с моим << оператор перегрузки пожалуйста?

РЕДАКТИРОВАТЬ: Добавлен Weatherstats.cpp

РЕДАКТИРОВАТЬ 2: Я создал перегруженный << операнд в моем файле weatherstats.cpp, я обновил свой контент ниже. Вместо того, чтобы выводить мои данные, он выводит все данные, которые я ввел как 1. Я ввожу 2 для снега и выводит 1 при использовании моей функции displayList ().

linkedlist.h

#pragma once

#include"WeatherStats.h"#include<iostream>
#include<string>

using namespace std;template <class T>
class linkedlist
{
private:

struct ListNode
{
T value;                //Current value of node
struct ListNode *next;  //Pointer to next node
};

ListNode *head;             //Head pointer

public:
/*!
Constructors
!*/
linkedlist()
{
head = NULL;
};/*!
Destructors
!*/
~linkedlist();

/*!
Prototypes
!*/
void appendNode(T);         //Append a node to list
void insertNode(T);         //Insert a node to list
void deleteNode(T);         //delete a node in list
void searchList(T);         //Search a node in list
void displayList() const;           //Display the full list

friend ostream &operator << (ostream&, linkedlist<T> &);
};//**
//Append Node
//**
template <class T>
void linkedlist<T>::appendNode(T newValue)
{
ListNode *newNode;          //Point to new node
ListNode *nodePtr;          //Move through list

//Assign newValue to new node
newNode = new ListNode;
newNode->value = newValue;
newNode->next = NULL;

if (!head)
{   //If empty assign new node as head
head = newNode;
}
else
{   //Assign head to nodePtr
nodePtr = head;

//Find last node in list
while (nodePtr->next)
{
nodePtr = nodePtr->next;
}

//Insert newNode as the last node
nodePtr->next = newNode;
}
}

//**
//Display List
//**

template <class T>
void linkedlist<T>::displayList()const
{

ListNode *nodePtr;

//Assign head to nodePtr
nodePtr = head;

//While nodePtr pointing to a node, print to screen
while (nodePtr)
{
//Print value
cout << nodePtr->value << endl; //ERROR C2679 HERE

//Move nodePtr to next node
nodePtr = nodePtr->next;
}

}//**
//Insert Node
//**
template <class T>
void linkedlist<T>::insertNode(T newValue)
{
ListNode *newNode;
ListNode *nodePtr;
ListNode *previousNode = NULL;

//New node
newNode = new ListNode;
newNode->value = newValue;

//If list is empty assign newValue to head
if (!head)
{
head = newNode;
newNode->next = NULL;
}
else
{
//Assign head to nodePtr
nodePtr = head;

//Pass over all nodes who are less than newValue
while (nodePtr != NULL && nodePtr->value < newValue)
{
previousNode = nodePtr;
nodePtr = nodePtr->next;
}

//If new node will be first, insert before all other nodes
if (previousNode == NULL)
{
head = newNode;
newNode->next = nodePtr;
}
else
{
previousNode->next = newNode;
newNode->next = nodePtr;
}
}
}//**
//Delete Node
//**
template <class T>
void linkedlist<T>::deleteNode(T searchValue)
{

ListNode *nodePtr;              //Traverse our list
ListNode *previousNode = NULL;  //Points to previous node

//Check if list is empty
if (!head)
{
cout << "This list is empty." << endl;
return;
}

//Delete head if == searchValue
if (head->value == searchValue)
{
nodePtr = head->next;
cout << head->value << " deleted" << endl;
delete head;
head = nodePtr;
}

else
{
//Set nodePtr to head
nodePtr = head;

//Skip nodes not equal num
while (nodePtr != NULL && nodePtr->value != searchValue)
{
previousNode = nodePtr;
nodePtr = nodePtr->next;
}

//Link previous node to the node after nodePtr and then delete
if (nodePtr)
{
previousNode->next = nodePtr->next;
cout << nodePtr->value << " deleted" << endl;
delete nodePtr;
}
}
}//**
//Search List
//**
template <class T>
void linkedlist<T>::searchList(T searchValue)
{
ListNode *nodePtr;              //Traverse our list
ListNode *previousNode = NULL;  //Points to previous node
int counter = 0;

//Check if list is empty
if (!head)
{
cout << "This list is empty." << endl;
return;
}

//Check if head == searchValue
if (head->value == searchValue)
{
cout << head->value << " found at position 0" << endl;
}

else
{

//set nodePtr to head
nodePtr = head;

//Pass over all nodes that do not equal searchValue
while (nodePtr != NULL && nodePtr->value != searchValue)
{
previousNode = nodePtr;
nodePtr = nodePtr->next;
counter++;
}

//When nodePtr == searchValue
if (nodePtr)
{
cout << nodePtr->value << " found at position " << counter << endl;
}

else
{
cout << "-1: Value not found." << endl;
}
}
}//**
//Destructor
//**
template <class T>
linkedlist<T>::~linkedlist()
{
ListNode *nodePtr;   // To traverse the list
ListNode *nextNode;  // To point to the next node

// Position nodePtr at the head of the list.
nodePtr = head;

// While nodePtr is not at the end of the list...
while (nodePtr != NULL)
{
// Save a pointer to the next node.
nextNode = nodePtr->next;

// Delete the current node.
delete nodePtr;

// Position nodePtr at the next node.
nodePtr = nextNode;
}
}template <class T>
ostream &operator << (ostream stream, linkedlist<T> &obj)
{
stream >> obj.value;

return stream;
}

main.cpp

#include "linkedlist.h"#include "WeatherStats.h"#include <iostream>
#include <string>

using namespace std;

int main()
{
int int_numMonths;      //Hold number of months value
double dbl_rain;        //Hold rain value
double dbl_snow;        //Hold snow value
double dbl_sunnyDays;   //Hold sunny days value

//Create lnk_list object with weatherstats
linkedlist<weatherstats>weather_list;

cout << "Weather Data" << endl;
cout << endl;
cout << "What is the number of months you want to enter data for?: ";
cin >> int_numMonths;
cout << endl;

//Loop to enter each months values
for (int i = 0; i < int_numMonths; i++)
{
cout << "Month " << i + 1 << endl;
cout << "Enter amount of rain: " << endl;
cin >> dbl_rain;
cout << "Enter amount of snow: " << endl;
cin >> dbl_snow;
cout << "Enter number of Sunny Days: " << endl;
cin >> dbl_sunnyDays;

//Create weatherstats obj and pass it rain,snow and sunnyDays
weatherstats month_data(dbl_rain,dbl_snow,dbl_sunnyDays);

weather_list.appendNode(month_data);

}

weather_list.displayList();

}

Weatherstats.cpp

    #include "WeatherStats.h"
#include <iostream>

using namespace std;

/*!
Constructors
!*/
weatherstats::weatherstats()
{
dbl_rain = 0;
dbl_snow = 0;
dbl_sunnyDays = 0;
}

weatherstats::weatherstats(double r, double s, double d)
{
dbl_rain = r;
dbl_snow = s;
dbl_sunnyDays = d;
}

/*!
Accessors
!*/
double weatherstats::getRain()
{
return dbl_rain;
}

double weatherstats::getSnow()
{
return dbl_snow;
}

double weatherstats::getsunnyDays()
{
return dbl_sunnyDays;
}

/*!
Mutators
!*/
void weatherstats::setRain(double r)
{
dbl_rain = r;
}

void weatherstats::setSnow(double s)
{
dbl_snow = s;
}

void weatherstats::setsunnyDays(double d)
{
dbl_sunnyDays = d;
}

//Overload Opperator
ostream& operator << (ostream &stream, weatherstats &obj)
{
stream <<&weatherstats::getRain << " - " << &weatherstats::dbl_snow << " - " << &weatherstats::getsunnyDays << endl;
return stream;
}