#include <iostream>
#include <stdlib.h>
struct customer {
void random_customer() {}
};
class Node
{
private:
customer data;
Node *next;
public:
/*Nodes constructors*/
Node(){next=nullptr;}
Node(customer X)
{
data=X;
next=nullptr;
}
/*Data setters and getters*/
void set_Data(customer X)
{data = X;}
customer get_Data()
{return data;}
/*next setters and getters*/
void set_next(Node * X){next=X;}
Node* get_next(){return next;}
};
class List
{
private:
Node * head;
Node * tail;
int counter;
public:
/*Constructors*/
List(){head=nullptr;tail=head;counter=0;}
/*Checks if the list is empty*/
bool isEmpty()
{
if (head==nullptr)
return true;
return false;
}
/*front manipulation*/
void add_Front(customer item)
{
if (isEmpty())
{
head = new Node(item);
tail = head;
counter++;
}
else{
Node * nw= new Node(item);
nw ->set_next(head);
head=nw;
counter++;
}
}
void pop_Front()
{
if (isEmpty())
return;
if (head==tail)
{
delete head;
delete tail;
counter--;
return;
}
Node * temphead=head;
head=head->get_next();
delete temphead;
counter--;
}
/*End Manipulation*/
void add_End(customer X)
{
if(isEmpty()){
add_Front(X);
counter++;}
else
{
Node * temp=new Node(X);
tail->set_next(temp);
tail=temp;
counter++;
}
}
/*freeing the whole list*/
void Clear()
{
while (!isEmpty())
pop_Front();
}
/*Destructor*/
~List(){Clear();}
/*Extras*/
int get_Size(){return counter;}
customer get_Front(){return head->get_Data();}
customer get_End(){return tail->get_Data();}
};
using namespace std;
int main()
{
List Data;
int numberofelements;
cout<<"How many customers you wanna randomly generate? : ";
cin >> numberofelements;
srand(time(NULL));
for (int i=0; i<numberofelements; i++)
{
customer temp;
temp.random_customer();
Data.add_Front(temp);
}
std::cout << "here goes the destructor\n";
return 0;
}
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