Homework List & Node Help

[Julio]

Create a List class with the following interface (at a minimum):
List::addItem //add an item to the list
List::getLargestValue //find the largest value stored in the list
In addition, create a Node class that stores an integer.
The list will contain nodes that encapsulate an integer value. Your driver program should accept ten integers from the console, store them in the list, then display the largest value in the list.
You'll end up with at least two objects: the list object, and a node object.
The list object shouldn’t know what is contained in its constituent nodes. Also, when adding a node to the list, the method should add new nodes to the bottom of the list, and start at the top of the list, iterating through it to find the bottom. In other words, don’t just keep a pointer to the bottom node…find it each time, starting from the top. The same goes for finding the largest value; start at the top of the list and work your way to the bottom. In main you will create a new node, set its value, and then pass that node to the list, which will will add it.
When looking for the largest node in the list, the list object should ask each node object in the list what its value is, and keep track of the largest seen. It should then return a pointer to that node…print the value out from main.
You should have at at least five files in your project: Header files for List and Node, implementation files for List and Node, and a file containing main.
Your deliverable is the source code and a sample run.



I need help with the question how to accept 10 integers into the console? Also what Am i missing? This is what I have so far!

List.H
#pragma once

#include "Node.h"

class List {
private:
Node* top;

public:
List();
void additem(Node*);
Node* getLargestValue();
void foo (void);
};


List.CPP

#include "Node.h"

using namespace std;

List::List() {
top = NULL;
}

void List::additem(Node* theNode) {

if (top == NULL) {
top = theNode;
}
else {
Node* temp = top;

while (temp->getNext() != NULL) {
temp = temp->getNext();
}
temp->setNext(theNode);
}
}



Node* List::getLargestValue() {
Node* largestNode = NULL;
Node* temp= top;

if( top == NULL) {
cout << "The list is empty" << endl;
return NULL;
}

int maxval = temp->getValue();

while (temp != NULL) {

if ( temp->getValue() > maxval) {
maxval = temp->getValue();
largestNode = temp;
}

temp = temp->getNext();
}

return largestNode;
}

Node.H

#pragma once

class Node {
protected:
Node * next;

public:
Node();
Node* getNext(void);
void setNext(Node*);
~Node();
virtual void printValue() = 0;
virtual void setData(void) = 0;
};

class floatNode : public Node {

float data;

public:
virtual void printValue();
floatNode(float f) { data = f; }

};

Node.CPP
#include <cstddef>
#include <iostream>
using namespace std;

#include "Node.h"


void floatNode::printValue() {
cout << "It's a float: " << data << endl;
}

Node::Node() {
data = 0;
next = NULL;
}

Node::Node(int anInt) {
data = anInt;
next = NULL;
}

Node* Node::getNext() { return next; }
void Node::setNext(Node* aNode) { next = aNode; }

int Node::getValue(void) { return data; }

Node::~Node() {
int foo = 0; }

Main

#include <iostream>
using namespace std;

#include "List.h"
#include "Node.h"

using namespace std;

int main () {
Node* aNode = new Node;
aNode = new floatNode;
floatNode* aFloatNode = new floatNode;
aFloatNode->
List* list = new List;
return 0;
}

}