Complete the missing code then compile, debug and test your program using the command lines below: c++ -o project1 project1.cpp ./project1 n m k Where n is the size of the stack, m is the modular of the real part and imagination part of a random complex number, and k is the number of elements displayed per line. In the main function, you need to Get the values n, m, and k from the command line. Declare a complex number stack of size n, generate n random complex numbers and push them into the stack. Meantime display all these numbers, k numbers per line. Display all elements of the stack, k elements per line. Create two random complex numbers c1 and c2, display c1, c2 and the results of the addition c1+c2, the subtraction c1-c2, the multiplication c1*c2, and the division c1/c2.

Complete the missing code then compile, debug and test your program using the command lines below:

c++ -o project1 project1.cpp <enter>

./project1 n m k <enter>

Where n is the size of the stack, m is the modular of the real part and imagination part of a random complex number, and k is the number of elements displayed per line.

In the main function, you need to

1. Get the values n, m, and k from the command line.
2. Declare a complex number stack of size n, generate n random complex numbers and push them into the stack. Meantime display all these numbers, k numbers per line.
3. Display all elements of the stack, k elements per line.
4. Create two random complex numbers c1 and c2, display c1, c2 and the results of the addition c1+c2, the subtraction c1-c2, the multiplication c1*c2, and the division c1/c2.

#include <iostream>

#include <cstdlib>

#include <ctime>

using namespace std;

class Complex { // complex number class

float re; // real part

float im; // imagination part

public:

Complex(float r=0.0, float i=0.0){re=r; im=i;} // constructor

Complex(const Complex& c){re=c.re; im=c.im;} // copy constructor

void operator =(const Complex& c){re=c.re; im=c.im;} // assignment

Complex operator -()const{return Complex(-re, -im);} // unary negation

Complex operator +(const Complex&) const; // addition operator

Complex operator -(const Complex&) const; // subtraction operator

Complex operator *(const Complex&) const; // multiplication operator

Complex operator /(const Complex&) const; // division operator

friend ostream& operator <<(ostream&, const Complex&); // output operator

};

// overloaded addition operator, to be implemented

Complex Complex::operator +(const Complex& c) const {}

// overloaded subtraction operator, to be implemented

Complex Complex::operator -(const Complex& c) const{}

// overloaded multiplication operator, to be implemented

Complex Complex::operator *(const Complex& c) const {}

// overloaded division operator, to be implemented

Complex Complex::operator /(const Complex& c) const {}

// overloaded stream output operator, to be implemented

ostream& operator <<(ostream& os, const Complex& c) {}

template <class T> class myStack{

T *ptr; // storage body

int size; // storage size

int top; // top position

public:

myStack(int); // constructor

~myStack(){free(ptr);} // destructor

bool empty(){return top==-1;} // empty or not

bool full(){return top==size-1;} // full or not

int hold(){return top+1;} // number of items hold

void push(T v){ptr[++top]=v;} // put an item on top

T pop(){return ptr[top--];} // take an item from top

void display(int); // display items

};

// constructor that creates an empty stack, to be implemented

template <class T> myStack<T>::myStack(int s){}

// display function, k items per line, to be implemented

template <class T> void myStack<T>::display(int k){}

// Operator Overloading and Stack Template Program

int main(int argc, char **argv){

// get n, m, and k from command line and create a complex number stack s(n)

// generate n number of random complex numbers and push them onto the stack,

// meantime display these complex numbers, k items per line

// display all complex numbers in the stack, k elements per line

// create two random complex numbers c1 and c2, display c1, c2

// display the results of the addition c1+c2, the subtraction c1-c2, the multiplication c1*c2, and the division c1/c2.

return 0;

}