The document provides instructions for implementing a linked list, stack, and queue in C++ with specific methods and behaviors for handling currency objects. It outlines the structure for a LinkNode and a SinglyLinkedList, along with methods for adding, removing, and managing currency objects within those data structures. Additionally, it details the requirements for a driver program to demonstrate the functionality of these data structures with a series of operations on currency objects.

1. Please solve the following problem using C++. Thank you
Instructions: ----
A LinkNode structure or class which will have two attributes -
a data attribute, and
a pointer attribute to the next node.
The data attribute of the LinkNode should be a reference/pointer of the Currency class of Lab 2.
Do not make it an inner class or member structure to the SinglyLinkedList class of #2 below.
A SinglyLinkedList class which will be composed of three attributes -
a count attribute,
a LinkNode pointer/reference attribute named as and pointing to the start of the list and
a LinkNode pointer/reference attribute named as and pointing to the end of the list.
Since this is a class, make sure all these attributes are private.
The class and attribute names for the node and linked list are the words in bold in #1 and #2.
For the Linked List, implement the following linked-list behaviors as explained in class -
getters/setters/constructors/destructors, as needed, for the attributes of the class.
createList method in addition to the constructor - this is optional for overloading purposes.
destroyList method in place of or in addition to the destructor - this is optional for overloading
purposes,
addCurrency method which takes a Currency object and a node index value as parameters to add
the Currency to the list at that index.
removeCurrency method which takes a Currency object as parameter and removes that Currency
object from the list and may return a copy of the Currency.
removeCurrency overload method which takes a node index as parameter and removes the
Currency object at that index and may return a copy of the Currency.
findCurrency method which takes a Currency object as parameter and returns the node index at
which the Currency is found in the list.

2. getCurrency method which takes an index values as a parameter and returns the Currency object.
printList method which returns a string of all the Currency objects in the list in the order of
index, tab spaced.
isListEmpty method which returns if a list is empty or not.
countCurrency method which returns a count of Currency nodes in the list.
Any other methods you think would be useful in your program.
A Stack class derived from the SinglyLinkedList but with no additional attributes and the usual
stack methods -
constructor and createStack (optional) methods,
push which takes a Currency object as parameter and adds it to the top of the stack.
pop which takes no parameter and removes and returns the Currency object from the top of the
stack.
peek which takes no parameter and returns a copy of the Currency object at the top of the stack.
printStack method which returns a string signifying the contents of the stack from the top to
bottom, tab spaced.
destructor and/or destroyStack (optional) methods.
Ensure that the Stack objects do not allow Linked List functions to be used on them.
A Queue class derived from the SinglyLinkedList but with no additional attributes and the usual
queue methods -
constructor and createQueue (optional) methods,
enqueue which takes a Currency object as parameter and adds it to the end of the queue.
dequeue which takes no parameter and removes and returns the Currency object from the front of
the queue.
peekFront which takes no parameter and returns a copy of the Currency object at the front of the
queue.
peekRear which takes no parameter and returns a copy of the Currency object at the end of the
queue.

3. printQueue method which returns a string signifying the contents of the queue from front to end,
tab spaced.
destructor and/or destroyQueue (optional) methods.
Ensure that the Queue objects do not allow Linked List functions to be used on them.
Ensure that all your classes are mimimal and cohesive with adequate walls around them. Make
sure to reuse and not duplicate any code.
Then write a main driver program that will demonstrate all the capabilities of your ADTs as
follows -
First, print a Welcome message for the demonstration of your ADTs - you can decide what the
message says but it should include your full name(s).
Second, create the following twenty (20) Krone objects in a Currency array to be used in the
program.
Kr 57.12
Kr 23.44
Kr 87.43
Kr 68.99
Kr 111.22
Kr 44.55
Kr 77.77
Kr 18.36
Kr 543.21
Kr 20.21
Kr 345.67
Kr 36.18
Kr 48.48
Kr 101.00

4. Kr 11.00
Kr 21.00
Kr 51.00
Kr 1.00
Kr 251.00
Kr 151.00
Then, create one each of SinglyLinkedList, Stack and Queue objects.
For the linked list, perform the following operations in order -
Add the first seven (7) objects from the array into the linked list in order such that they end up in
the reverse order in the linked list, i.e. the seventh element as first node and first element as
seventh node. If it is easier, you are allowed to insert copies of the objects.
Search for Kr 87.43 followed by Kr 44.56 - print the results of each.
Remove the node containing Kr 111.22 followed by the node at index 2.
Print the contents of the list.
Then add the next four (4) objects (#9 thru 12) such that their index in the linked list is calculated
as (index in array % 5).
Remove two (2) objects at indexes (countCurrency % 6) and (countCurrency / 7) in that order.
Print the contents of the list.
For the stack, perform the following operations in order -
Push seven (7) objects starting from the array index 13 onwards to the stack.
Peek the top of the stack - print the result.
Perform three (3) pops in succession.
Print the contents of the stack.
Push five (5) more objects from the start of the objects array to the stack.
Pop twice in succession.

5. Print the contents of the stack.
For the queue, perform the following operations in order -
Enqueue the seven (7) objects at odd indexes starting from index 5 in the array.
Peek the front and end of the queue - print the results.
Perform two (2) dequeues in succession.
Print the contents of the queue.
Enqueue five (5) more objects from the index 10 in the array.
Dequeue three times in succession.
Print the contents of the queue.
End the program with a leaving message of your choice. Remember to clean up before the
program ends.
Restrict all your input / output to the main driver program only, except for the existing screen
print inside the Currency print methods.
code that for currency class before this-
#include <iostream>
#include <cmath>
class Currency {
protected:
int whole;
int fraction;
virtual std::string get_name() = 0;
public:
Currency() {
whole = 0;
fraction = 0;
}
Currency(double value) {
if (value < 0)
throw "Invalid value";
whole = int(value);
fraction = std::round(100 * (value - whole));
}

6. Currency(const Currency& curr) {
whole = curr.whole;
fraction = curr.fraction;
}
int get_whole() { return whole; }
int get_fraction() { return fraction; }
void set_whole(int w) {
if (w >= 0)
whole = w;
}
void set_fraction(int f) {
if (f >= 0 && f < 100)
fraction = f;
}
void add(const Currency* curr) {
whole += curr->whole;
fraction += curr->fraction;
if (fraction > 100) {
whole++;
fraction %= 100;
}
}
void subtract(const Currency* curr) {
if (!isGreater(*curr))
throw "Invalid Subtraction";
whole -= curr->whole;
if (fraction < curr->fraction) {
fraction = fraction + 100 - curr->fraction;
whole--;
}
else {
fraction -= curr->fraction;
}
}
bool isEqual(const Currency& curr) {
return curr.whole == whole && curr.fraction == fraction;
}
bool isGreater(const Currency& curr) {
if (whole < curr.whole)

7. return false;
if (whole == curr.whole && fraction < curr.fraction)
return false;
return true;
}
void print() {
std::cout << whole << "." << fraction << " " << get_name() << std::endl;
}
};
class Krone : public Currency {
protected:
std::string name = "Krone";
std::string get_name() {
return name;
}
public:
Krone() : Currency() { }
Krone(double value) : Currency(value) { }
Krone(Krone& curr) : Currency(curr) { }
};
class Soum : public Currency {
protected:
std::string name = "Soum";
std::string get_name() {
return name;
}
public:
Soum() : Currency() { }
Soum(double value) : Currency(value) { }
Soum(Krone& curr) : Currency(curr) { }
};
int main() {
Currency* currencies[2] = { new Soum(), new Krone() };
while (true) {
currencies[0]->print();
currencies[1]->print();
char oprr;
char oprd;
double value;
char curr[10];

8. std::cin >> oprr;
if (oprr == 'q') {
return 0;
}
std::cin >> oprd >> value >> curr;
std::string currency(curr);
try {
switch (oprr) {
case 'a':
if (oprd == 's' && currency == "Soum")
currencies[0]->add(new Soum(value));
else if (oprd == 'k' && currency == "Krone")
currencies[1]->add(new Krone(value));
else
throw "Invalid Addition";
break;
case 's':
if (oprd == 's' && currency == "Soum")
currencies[0]->subtract(new Soum(value));
else if (oprd == 'k' && currency == "Krone")
currencies[1]->subtract(new Krone(value));
else
throw "Invalid Subtraction";
break;
default:
throw "Invalid Operator";
}
}
catch (const char e[]) {
std::cout << e << std::endl;
}
}
}