功能访问链表

Question

我一直在寻找几天的答案，但似乎无法找到它。我是C ++的初学者，我的课程项目正在创建一个包含天气信息的课程。我的问题是，在项目中我必须找到最多和最少晴天，下雪和下雨天的月份。此功能必须存在于main中。链表类来自先前的赋值，并且指令没有说明有关修改它的内容。以下是我的主要内容。正如您所看到的，这是一个相对简单的程序，可以计算月份，然后询问日期类型，然后将其附加到链接列表中。程序的这一部分工作正常，我只是无法弄清楚如何从类外部访问链表节点，因为结构是私有的。有没有办法或者是修改链表类的唯一选择？

#include "LinkedList.h"
#include "weather stats.h"

void findHighLow(LinkList<WeatherStats> &);

void main()
{
LinkList<WeatherStats> weather;
WeatherStats stats;
double rain, snow;
int sun,months;

cout << "Please enter the amount of months you would like to store data for\n" << endl;
cin >> months;
stats.setMonths(months);
cout << endl;

for(int i=0; i<months; i++)
{

    cout << "Enter amount of rainy days for " << i+1 << endl;
    cin >> rain;
    stats.setRain(rain);
    cout << endl;
    cout << "Enter amount of snowy days for " << i+1 << endl;
    cin >> snow;
    stats.setSnow(snow);
    cout << endl;
    cout << "Enter amount of sunny days for " << i+1 << endl;
    cin >> sun;
    stats.setSun(sun);
    cout << endl;

            weather.appendNode(stats);

}

weather.displayList();

}

void findHighLow(LinkList<WeatherStats> &value)
{
}

LinkList模板类

#ifndef LINKLIST_H
#define LINKLIST_H

#include <iostream>
using namespace std;

template <class L>
class LinkList
{
private:
    //structure for list
    //stores value of node
    //pointer to next node
    struct LinkNode
    {
        L value;
        struct LinkNode *next;
    };

    LinkNode *head;

public:
    //constructor
    //sets head to NULL
    LinkList()
    {
        head = NULL;
    }

    //destructor
    ~LinkList();

    //list functions
    void appendNode(L);
    void insertNode(L);
    void deleteNode(L);
    void displayList();
    void searchList(L);

    //overload operators
    friend ostream &operator << (ostream&, LinkList<L> &);
    L &operator = (LinkList<L> &);
    L &operator != (LinkList<L> &);
    L &operator == (LinkList<L> &);
    L &operator < (LinkList<L> &);
};

//gets value passed into value and appends to list
template <class L>
void LinkList<L>::appendNode(L value)
{
    LinkNode *newNode; //pointer to new node
    LinkNode *newPtr; //ptr to transverse list

    //creates new node and sets value and next pointer
    newNode = new LinkNode;
    newNode -> value = value;
    newNode -> next = NULL;

    //checks to see if there are no nodes
    //if there are none newNode is set to head
    if(!head)
        head = newNode;
    //inserts newNode at the end of list
    else
    {
        newPtr = head;
        while (newPtr -> next)
            newPtr = newPtr -> next;

        newPtr -> next = newNode;
    }
}

//gets value from value and inserts new node
template <class L>
void LinkList<L>::insertNode(L value)
{

    LinkNode *newNode; //pointer to new node
    LinkNode *newPtr; //pointer to transverse list
    LinkNode *prevNode = NULL; //sets previous node

    newNode = new LinkNode;
    newNode -> value = value;

    //checks for no nodes
    //if none head is set to newNode
    if(!head)
    {
        head = newNode;
        newNode -> next = NULL;
    }
    //inserts newNode at the end of list
    else
    {
        //pointer set to head
        newPtr = head;

        prevNode = NULL;

        //checks for nodes less than value passed
        while(newPtr != NULL && newPtr -> value < value)
        {
            prevNode = newPtr;
            newPtr = newPtr -> next;
        }
        //sets new node to first node
        if(prevNode == NULL)
        {
            head = newNode;
            newNode -> next = newPtr;
        }
        //puts node after previous node
        else
        {
            prevNode -> next = newNode;
            newNode -> next = newPtr;
        }
    }
}

//searches for passed value and deletes that value from list
template <class L>
void LinkList<L>::deleteNode(L value)
{
    LinkNode *newPtr;
    LinkNode *prevNode;

    if(!head)
        return;
    //checks to see if first node is the value passed
    if(head -> value == value)
    {
        newPtr = head -> next;
        delete head;
        head = newPtr;
    }
    //searches list for value
    else
    {
        newPtr = head;

        while(newPtr != NULL && newPtr -> value != value)
        {
            prevNode = newPtr;
            newPtr = newPtr -> next;
        }

        if(newPtr)
        {
            prevNode -> next = newPtr -> next;
            delete newPtr;
        }
    }
}

//displays list
template <class L>
void LinkList<L>::displayList()
{
    LinkNode *newPtr;

    newPtr = head;

    while(newPtr)
    {
        cout << newPtr -> value << endl;

        newPtr = newPtr -> next;
    }
}

//searches list
template <class L>
void LinkList<L>::searchList(L value)
{
    temp = value;

    LinkNode *newPtr;

    newPtr = head;

    while(newPtr)
    {
        if(newPtr -> value = value)
        {
            return temp;
        }

        newPtr = newPtr ->next;
    }
    return NULL;
}

//list distructor deletes all values in list
template<class L>
LinkList<L>::~LinkList()
{
    LinkNode *newPtr;
    LinkNode *nextNode;

    newPtr = head;

    while(newPtr != NULL)
    {
        nextNode = newPtr -> next;

        delete newPtr;

        newPtr = nextNode;
    }
}

//overload operators
template <class L>
ostream &operator << (ostream stream, LinkList<L> &obj)
{
    stream >> obj.value;

    return stream;
}

template <class L>
L &LinkList<L>::operator = (LinkList<L> &obj)
{
    value = obj.value;

    return value;
}

template <class L>
L &LinkList<L>::operator == (LinkList<L> &obj)
{
    if(value = obj.value && obj.value = value)
        return true;
    else
        return false;
}

template <class L>
L &LinkList<L>::operator != (LinkList<L> &obj)
{
    if(value != obj.value && obj.value != value)
        return true;
    else
        return false;
}

template <class L>
L &LinkList<L>::operator < (LinkList<L> &obj)
{
    bool status;
    if(value > obj.value)
        status = true;
    else if(value == obj.value)
        return true;
    else
        status false;

    return status;
}
#endif

Answer 1

您唯一的选择是修改LinkedList类

最有意义的是添加迭代支持：

make iterator另一个内部类（它只是指向LinkNode的指针）

添加一个begin()方法，该方法返回指向head

的迭代器

和end()方法，返回指向NULL的迭代器

向get()添加一个（使其简单）iterator方法，返回迭代器的LinkNode所持有的值

向next()添加一个（使其简单）iterator方法，将迭代器指向的LinkNode更改为LinkNode的下一个

根据要求 - 没有编写代码