1 Introduction You will create a C program that can evaluate

1 Introduction
You will create a C++ program that can evaluate arithmetic operators with integer numbers having any number of digits. These numbers are an alternative to xed size integers or oating point numbers that always have a maximum number of accurate digits (dependent on size of CPU register).
2 InputandOutput
The input is a regular text le, where each line is terminated with an end-of-line character(s). Each line will containanarithmeticoperationbetweentwonumbers. Theprogramshoulddisplaytheinputexpressionand the results, separated with =. Input example:
0*0 0+1 123456*2593 2*2000000000000000 2*3 1+10 10000000000000000+1 12345667890123456789+8765432109876543210 999999999999999999999+1
Output example:
0*0=0 0+1=1 123456*2593=320121408 2*2000000000000000=4000000000000000 2*3=6 1+10=11 10000000000000000+1=10000000000000001 1234567890123456789+8765432109876543210=9999999999999999999 999999999999999999999+1=1000000000000000000000
Advanced operators and functions example:
sqrt(16)=4 sqrt(81)=9
20/6=3,remainder=2 1500/5=300 sqrt(13489)=116.1421543 1000000000000/2=500000000000
3 Programinputandoutputspecication
The main program should be called ”innitearithmetic”. The output should be written to the console (e.g. printf or cout), but the TAs will redirect it to create some output le. Call syntax at the OS prompt (notice double quotes):
infinitearithmetic \"input=<file name>;digitsPerNode=<number>\".
Assumptions: • The le is a small plain text le (say < 10000 bytes); no need to handle binary les. • Only integer numbers as input (no decimals!). Output number without leading zeroes. • Operators: + • do not break an arithmetic expression into multiple lines as it will mess testing. Example of program call:
infinitearithmetic \"input=xyz.txt;digitsPerNode=2\"

Solution

// main.cpp
#include <stdio.h>
#include <iostream>
#include \"ArgumentManager.h\"
#include \"doublelinkedlist.h\"

using namespace std;

int main(int argc, char* argv[])
{
   if (argc < 2) {
       std::cerr << \"Usage: infinitearithmetic \\\"input=xyz.txt;digitsPerNode=<number>\\\"\ \";
   }
   ArgumentManager am(argc, argv);
   std::string filename = am.get(\"filename\");
   int digitsPerNode = std::stoi(am.get(\"digitsPerNode\"));
   std::ifstream ifs(filename.c_str());
   std::string line;
   while (getline(ifs, line)) {
       std::string num1;
       std::string num2;
       std::string op;
       // get num1 num2 and operator in line
// ...
       DoubleLinkedList l1(num1, digitsPerNode); // DoubleLinkedList(const std::string& num, int digitsPerNode)
       DoubleLinkedList l2(num2, digitsPerNode);
       DoubleLinkedList l(); // DoubleLinkedList();
       if (/* plus */)
       {l = l1 + l2;} // DoubleLinkedList operator + (const DoubleLinkedList& list) const; DoubleLinkedList& operator = (const DoubleLinkedList& list);
       else if (/* mult */) // DoubleLinkedList operator * (const DoubleLinkedList& list) const;
       {l = l1 * l2;}
       else if (/* div */)
       {l = l1 / l2;} // DoubleLinkedList operator / (const DoubleLinkedList& list) const;
       else if (/*...*/)
       {/*...*/}
       else {
           // ...
       }
      
       //output result
   }
      
   return 0;
}

============================================================================

//ArgumentManager.h

//Include guard
#ifndef _argumentmanager_h_INCLUDED
#define _argumentmanager_h_INCLUDED

#include <map>
#include <string>
#include <iostream>
#include <sstream>

using namespace std;

// This is a class that can parse the commnad line arguments we use in COSC 2430 homework.
class ArgumentManager {
private:
map<string, string> m_argumentMap;
public:
ArgumentManager() { }
ArgumentManager(int argc, char *argv[], char delimiter=\';\');
ArgumentManager(string rawArguments, char delimiter=\';\');
void parse(int argc, char *argv[], char delimiter=\';\');
void parse(string rawArguments, char delimiter=\';\');
string get(string argumentName);
string toString();
friend ostream& operator << (ostream &out, ArgumentManager &am);
};

void ArgumentManager::parse(string rawArguments, char delimiter) {
stringstream currentArgumentName;
stringstream currentArgumentValue;
bool argumentNameFinished = false;
  
for (unsigned int i=0; i<=rawArguments.length(); i++) {
if (i == rawArguments.length() || rawArguments[i] == delimiter) {
if (currentArgumentName.str() != \"\") {
m_argumentMap[currentArgumentName.str()] = currentArgumentValue.str();
}
// reset
currentArgumentName.str(\"\");
currentArgumentValue.str(\"\");
argumentNameFinished = false;
}
else if (rawArguments[i] == \'=\') {
argumentNameFinished = true;
}
else {
if (argumentNameFinished) {
currentArgumentValue << rawArguments[i];
}
else {
// ignore any spaces in argument names.
if (rawArguments[i] == \' \')
continue;
currentArgumentName << rawArguments[i];
}
}
}
}

void ArgumentManager::parse(int argc, char *argv[], char delimiter) {
if (argc > 1) {
for (int i=1; i<argc; i++) {
parse(argv[i], delimiter);
}
}
}

ArgumentManager::ArgumentManager(int argc, char *argv[], char delimiter) {
parse(argc, argv, delimiter);
}

ArgumentManager::ArgumentManager(string rawArguments, char delimiter) {
parse(rawArguments, delimiter);
}

string ArgumentManager::get(string argumentName) {
map<string, string>::iterator iter = m_argumentMap.find(argumentName);

//If the argument is not found, return a blank string.
if (iter == m_argumentMap.end()) {
return \"\";
}
else {
return iter->second;
}
}

string ArgumentManager::toString() {
stringstream ss;
for (map<string, string>::iterator iter = m_argumentMap.begin(); iter != m_argumentMap.end(); iter++) {
ss << \"Argument name: \" << iter->first << endl;
ss << \"Argument value: \" << iter->second << endl;
}
return ss.str();
}

ostream& operator << (ostream &out, ArgumentManager &am) {
out << am.toString();
return out;
}

#endif // _argumentmanager_h_INCLUDED

======================================================================

// DoubleLinkedList.h
struct Node {
   long long num;
   Node* prev;
   Node* next;
};

class DoubleLinkedList {
public:
DoubleLinkedList(); // default construct
   ~DoubleLinkedList(); // deconstruct
   DoubleLinkedList(const std::string& num, int digitsPerNode); // user defined construct
   DoubleLinkedList(const DoubleLinkedList& list); // copy construct
   DoubleLinkedList& operator = (const DoubleLinkedList& list); // assignment consturct
public:
DoubleLinkedList operator + (const DoubleLinkedList& list) const;
   DoubleLinkedList operator * (const DoubleLinkedList& list) const;
   // optional
   DoubleLinkedList operator - (const DoubleLinkedList& list) const;
   // 10% extra
   DoubleLinkedList operator / (const DoubleLinkedList& list) const;
   // 20% extra
   DoubleLinkedList Sqrt(const DoubleLinkedList& list) const;
public:
const Node* GetHead() const;
   const Node* GetTail() const;
   void Append(Node* node);
   void Print() const;
private:
Node* head;
Node* tail;
int m_digitsPerNode;
   long long remainder; // for / operator
   float decimal; // for sqrt() 7 valid digits.
};

============================================================================