C ++沒有找到需要右手操作數的<<運算符

Question

我正在做一些C ++作業，遇到了麻煩，無法在我的鏈表類中運行displayList（）函數。 我收到以下錯誤。

錯誤1錯誤C2679：二進制'<<'：未找到采用'weatherstats'類型的右側操作數的運算符（或沒有可接受的轉換）c：\\ users \\ larry \\ documents \\ visual studio 2013 \\ projects \\ weatherstats \\ weatherstats \\ linkedlist.h 100 1 WeatherStats

因此，我需要重載<<操作數，但是我嘗試使用一些我在網上找到但沒有運氣的示例。 有人可以幫我<<過載運算符嗎？

編輯：添加了Weatherstats.cpp

編輯2：我在weatherstats.cpp文件中創建了一個重載的<<操作數，我在下面更新了我的內容。 它不輸出我的數據，而是輸出我輸入為1的所有數據。我輸入2表示積雪，並且在使用displayList（）函數時將輸出1。

鏈表

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

Answer 1

我將為此在暗中刺傷，因為我已經兩年沒有碰模板或超載了。

您的weatherstats類是否有<<操作符過載？

您的錯誤行正在嘗試打印value成員變量。 在ListNode定義中，您說value是T類型（即模板）。

在你main()要創建一個使用您的模板類型作為一個LinkedList weatherstats 。 您的錯誤還指出，它無法轉換weatherstats類型。

因此，問題是： 您是否在weatherstats類中超載<< ？

不幸的是，您尚未發布該類的代碼，因此我們別無所求。 編輯：代碼已發布-仍然沒有超載的證據

（另外，我認為Baget稍后將為您的流運算符的方向提供一個很好的觀點）

EDIT2 ：您應該如何調用函數？ 是&classname::function還是object.function()嗎？

Answer 2

不是stream >> obj.value; 需要為stream<<obj.value;

是OUTPUT流而不是INPUT