PROGRAM
// Welcome to the world of c++...
// Program to Overload copy construtor and assignment
operator..
// Programmer Name: Hamza Sajid
// Date of Creation: 12th Dec,2023.
// Compilation always starts from the first line of the
program..
// Including all necessary header files
#include <iostream> // For input output
using namespace std; // So that we don't have to write std::
with input output
// Structure for a linked list..
struct link
{
int data;
link *next;
};
// Class performing different operations on linked lists..
class linklist
{
private:
link *first;
public:
linklist() : first(NULL) {} // constructor to the class...
~linklist(); // destructor to the class..
void additem(int d); // Function to add item to link
list..
void display();
// Overloaded copy constructor
linklist(const linklist &other);
// Overloaded assignment operator
linklist &operator=(const linklist &other);
};
// Overloaded copy constructor..
linklist::linklist(const linklist &other)
{
// Copy constructor for deep copy
first = NULL; // Initialize first for the new object
// Traverse the other linked list and copy each element
link *currentOther = other.first;
while (currentOther != NULL)
{
additem(currentOther->data);
currentOther = currentOther->next;
}
}
// Function overloading an assignment operator..
linklist &linklist::operator=(const linklist &other)
{
if (this != &other)
{ // Check for self-assignment
// Clear existing data in the current object
link *current = first;
while (current != NULL)
{
link *temp = current;
current = current->next;
delete temp;
}
// Copy data from the other object
first = NULL;
link *currentOther = other.first;
while (currentOther != NULL)
{
additem(currentOther->data);
currentOther = currentOther->next;
}
}
return *this;
}
// Function to add into a linked list..
void linklist::additem(int d)
{
link *newlink = new link;
newlink->data = d;
newlink->next = NULL; // Set the next pointer of the new
link to NULL
if (first == NULL)
{
// If the list is empty, make the new link the first
link
first = newlink;
}
else
{
// Traverse the list to find the last link
link *current = first;
while (current->next != NULL)
{
current = current->next;
}
// Attach the new link to the last link in the list
current->next = newlink;
}
}
// Function to display the link list...
void linklist::display()
{
link *current = first;
while (current != NULL)
{
cout << endl
<< current->data;
current = current->next;
}
}
// Destructor to destroy the node..
linklist::~linklist()
{
link *current = first;
while (current != NULL)
{
link *temp = current;
current = current->next;
delete temp;
}
}
// End of all member functions definition...
// Start of main Function..
int main()
{
linklist li;
li.additem(12);
li.additem(13);
li.additem(14);
li.additem(15);
li.additem(16);
cout << endl;
// Test the copy constructor and assignment operator
linklist li2 = li; // Overloaded Copy constructor will be
used..
linklist li3;
li3 = li2; // Overloaded Assignment operator will be used..
// Display the Copied Lists Ensuring that both the
overloads work properly...
li2.display();
cout << endl;
li3.display();
cout << endl;
return 0;
}
PROGRAM
// Welcome to the world of c++...
// Program to Modify parse program to evaluate float
expressions
// Programmer Name: Hamza Sajid
// Date of Creation: 12th Dec,2023.
// Compilation always starts from the first line of the
program..
// Including all necessary header files
#include <iostream> // For input output
#include <cstring> // For char string methods like strlen
using namespace std; // So that we don't have to write std::
with input output
const int LEN = 80;
// Start of all classes declaration....
// ------------------------------------------------------------
-------------------------
// Abstract Base class for tokens....
class Token
{
public:
virtual float getNumber() const = 0; // Pure virtual
function for getting the numerical value
virtual char getOperator() const = 0; // Pure virtual
function for getting the operator
virtual ~Token() {} // Virtual destructor
for proper cleanup
};
// Operator class derived from Token
class Operator : virtual public Token
{
private:
char oper; // Operators: +, -, *, /
public:
Operator(char c) : oper(c) {} // Constructor to the class
char getOperator() const; // Implementation of the
getOperator function
float getNumber() const; // Dummy function (not used
for operators)
};
// Number class derived from Token
class Number : virtual public Token
{
private:
float fnum; // The number
public:
Number(float n) : fnum(n) {} // Constructor to the class
float getNumber() const; // Implementation of the
getNumber function
char getOperator() const; // Dummy function (not used
for numbers)
};
// Stack class modified to hold Token pointers
class Stack
{
private:
Token *st[LEN]; // Array of Token pointers
int top; // Index of the top element
public:
Stack(); // Constructor
void push(Token *var); // Function to push a Token pointer
onto the stack
Token *pop(); // Function to pop a Token pointer
from the stack
int gettop() const; // Function to get the index of the
top element
};
// Expression class using polymorphism
class Expression
{
private:
Stack s; // Stack to store Token pointers
char *pStr; // Pointer to the input string
int len; // Length of the input string
public:
Expression(char *ptr) : pStr(ptr), len(strlen(pStr)) {} //
Constructor to class..
void parse(); //
Function to parse the expression input string...
float solve(); //
Function to solve the expression..
};
//-------------------------------------------------------------
---
// End of all classes declarations....
// Start of all classes member functions Definitions...
//
***************************************************************
// Class Operator member functions Definitions..
char Operator::getOperator() const
{
return oper;
}
float Operator::getNumber() const
{
return 0; // Dummy implementation
}
// class Number member functions Definitions..
float Number::getNumber() const
{
return fnum;
}
char Number::getOperator() const
{
return '\0'; // Dummy implementation
}
// class Stack member functions Definitions..
Stack::Stack() : top(0) {}
void Stack::push(Token *var)
{
st[++top] = var;
}
Token *Stack::pop()
{
return st[top--];
}
int Stack::gettop() const
{
return top;
}
// class Expression member function definitions..
void Expression::parse()
{
char ch;
for (int j = 0; j < len; j++)
{
ch = pStr[j];
if (isdigit(ch))
{
// Convert the character to float and save
numerical value
float number = ch - '0';
s.push(new Number(number));
}
else if (ch == '.')
{
// Convert the next character to float (considering
it's a digit)
s.push(new Number(s.pop()->getNumber() + (pStr[++j]
- '0') / 10.0));
}
else if (ch == '+' || ch == '-' || ch == '*' || ch ==
'/')
{
if (s.gettop() == 1)
s.push(new Operator(ch));
else
{
Token *lastval = s.pop();
Token *lastop = s.pop();
if ((ch == '*' || ch == '/') && (lastop-
>getOperator() == '+' || lastop->getOperator() == '-'))
{
s.push(lastop);
s.push(lastval);
}
else
{
float result;
switch (lastop->getOperator())
{
case '+':
result = s.pop()->getNumber() +
lastval->getNumber();
break;
case '-':
result = s.pop()->getNumber() -
lastval->getNumber();
break;
case '*':
result = s.pop()->getNumber() *
lastval->getNumber();
break;
case '/':
result = s.pop()->getNumber() /
lastval->getNumber();
break;
default:
cout << "\nUnknown oper";
exit(1);
}
s.push(new Number(result));
}
s.push(new Operator(ch));
}
}
else
{
cout << "\nUnknown input character";
exit(1);
}
}
}
float Expression::solve()
{
while (s.gettop() > 1)
{
Token *lastval = s.pop();
Token *lastop = s.pop();
float result;
switch (lastop->getOperator())
{
case '+':
result = s.pop()->getNumber() + lastval-
>getNumber();
break;
case '-':
result = s.pop()->getNumber() - lastval-
>getNumber();
break;
case '*':
result = s.pop()->getNumber() * lastval-
>getNumber();
break;
case '/':
result = s.pop()->getNumber() / lastval-
>getNumber();
break;
default:
cout << "\nUnknown operator";
exit(1);
}
s.push(new Number(result));
}
return s.pop()->getNumber();
}
//
***************************************************************
*************
// End of all classes member functions definitions...
// Start of Main function the point from where execution
starts...
int main()
{
char ans;
char string[LEN];
cout << "\nEnter an arithmetic expression"
<< "\nof the form 2+3.4*4/3-2."
<< "\nNo number may have more than one digit."
<< "\nDon't use any spaces or parentheses.";
do
{
cout << "\nEnter expression: ";
cin >> string;
Expression *eptr = new Expression(string);
eptr->parse();
cout << "\nThe numerical value is: " << eptr->solve();
delete eptr;
cout << "\nDo another (Enter y or n)? ";
cin >> ans;
} while (ans == 'y');
return 0;
}
// End of main..
// End of program..
// ------------------------------------------------------------
------------
