I just want the code, instructions are as follow: Read each argument carefully.

Understands all the arguments and compares them with the knowledge acquired in the module.

Make the code

Verify each step Program should be in C$++,$ This is the header file list.h$.$ This is the interface for the class List. Objects of type List can be a list of items of any type for which the operators $<<$ and $=$ are defined. All the items on any one list must be of the same type. A list that can hold up to max items all of type Type$\_$Name is declared as follows: List the$\_$object$($max$)$;

#ifndef LIST$\_$H

#define LIST$\_$H

#include

using namespace std;

namespace listsavitch

$\{$

template

class List

$\{$

public:

List$($int max$)$;

$//$Initializes the object to an empty list that can hold up to

$//$max items of type ItemType.

~List$()$;

$//$Returns all the dynamic memory used by the object to the freestore.

int length$()$ const;

$//$Returns the number of items on the list.

void add$($ItemType new$\_$item$)$;

$//$Precondition: The list is not full.

$//$Postcondition: The new$\_$item has been added to the list.

bool full$()$ const;

$//$Returns true if the list is full.

void erase$()$;

$//$Removes all items from the list so that the list is empty.

friend ostream& operator $<<($ostream& outs,

const List& the$\_$list$)$;

$//$Overloads the $<<$ operator so it can be used to output the

$//$contents of the list. The items are output one per line.

$//$Precondition: If outs is a file output stream, then outs has

$//$already been connected to a file.

private:

ItemType $*$item; $//$pointer to the dynamic array that holds the list.

int max$\_$length; $//$max number of items allowed on the list.

int current$\_$length; $//$number of items currently on the list.

$\}$;

$\}//$listsavitch

#endif $//$LIST$\_$H

Write a code for a program list cpp

#ifndef LIST$\_$CPP

#define LIST$\_$CPP

#include

#include

#include "list.h$"//$This is not needed when used as we are using this file,

$//$but the #ifndef in list.h makes it safe.

using namespace std;

namespace listsavitch

$\{$

$//$Uses cstdlib:

template

List::List$($int max$)$ : max$\_$length$($max$),$ current$\_$length$(0)$

$\{$

item $=$ new ItemType$[$max$]$;

$\}$

template

List::~List$()$

$\{$

delete $[]$ item;

$\}$

template

int List::length$()$ const

$\{$

return $($current$\_$length$)$;

$\}$

$//$Uses iostream and cstdlib:

template

void List::add$($ItemType new$\_$item$)$

$\{$

if $($ full$())$

$\{$

cout $<<$ "Error: adding to a full list.

$"$;

exit$(1)$;

$\}$

else

$\{$

item$[$current$\_$length$]=$ new$\_$item;

current$\_$length $=$ current$\_$length $+1$;

$\}$

$\}$

template

bool List::full$()$ const

$\{$

return $($current$\_$length $==$ max$\_$length$)$;

$\}$

template

void List::erase$()$

$\{$

current$\_$length $=0$;

$\}$

$//$Uses iostream:

template

ostream& operator $<<($ostream& outs, const List& the$\_$list$)$

$\{$

for $($int i $=0$; i $<$ the$\_$list.current$\_$length; i$++)$

outs $<<$ the$\_$list.item$[$i$]<<$ endl;

return outs;

$\}$

$\}//$listsavitch

#endif $//$ LIST$\_$CPP Notice that we have enclosed all the template

$//$ definitions in #ifndef... #endif.

demonstrate use of the class template List.

#include

#include "list.h$"$

#include "list.cpp$"$

using namespace std;

using namespace listsavitch;

int main$()$

$\{$

List first$\_$list$(2)$;

first$\_$list.add$(1)$;

first$\_$list.add$(2)$;

cout $<<$ "first$\_$list $=$

$"$

$<<$ first$\_$list;

List second$\_$list$(10)$;

second$\_$list.add$($A$)$;

second$\_$list.add$($B$)$;

second$\_$list.add$($C$)$;

cout $<<$ "second$\_$list $=$

$"$

$<<$ second$\_$list;

return $0$;

$\}$