Write the memory system with Cpp:

$1.$ Write all programs in cross$-$platform C$++$

$2.$ No Containers, NO STL allowed $\{$Vector$,$ Lists, Sets, etc...$\}$

$3.$ Simple Old$-$fashion C$++.$ No modern C$++$

$4.$ No Adding files

Create a memory system within a heap

$$ Take the given memory system framework for the heap layout:

o Add the allocators

o Add the de$-$allocators

$//1.$ Mem.h

#include "Heap.h$"$

class Mem

$\{$

public:

static const uint$32\_$t TotalSize $=(50*1024)$;

static const uint$32\_$t HeapAlign $=16$;

static const uint$32\_$t HeapAlignMask $=$ HeapAlign $-1$;

static const uint$32\_$t HeaderGuards $=128$;

enum class Guard $\{$Type$\_$A$,$ Type$\_5,$ Type$\_$None$\}$;

public:

Mem$($ Guard type $)$;

Mem$()=$ default;

Mem$($const Mem &$)=$ delete;

Mem & operator $=($const Mem &$)=$ delete;

~Mem$()$;

void free$($ void $*$ const data $)$;

void $*$malloc$($ const uint$32\_$t size $)$;

void initialize$()$;

Heap $*$GetHeap$()$;

void Print$($int count$)$;

private:

$//$ Useful in malloc and free

Heap $*$poHeap;

$//!!!!$Below: Not used in malloc, free, or initialize

Guard type;

void $*$poRawMem;

$\}$;

#endif

$//---$ End of File $---$

$//2.$ Mem.cpp

#include "Mem.h$"$

#include "Heap.h$"$

#include "Type.h$"$

$//$ To help with coalescing... not required

struct SecretPtr

$\{$

Free $*$pFree;

$\}$;

$//----------------------------------------------------$

$//$ Initialized the Memory block:

$//$ Update the Heap

$//$ Create a free block

$//$ Heap structure links to free hdr

$//-----------------------------------------------------$

void Mem::initialize$()$

$\{$

$//$ TODO

$\}$

$//----------------------------------------------------$

$//$ Find a free block that fits

$//$ Change it to used $($may require subdivision$)$

$//$ Correct the heap Links $($used$,$free$)$ headers

$//$ Update stats

$//$ Return pointer to block

$//-----------------------------------------------------$

void $*$Mem::malloc$($ const uint$32\_$t $\_$size $)$

$\{$

$//$ TODO

$\}$

$//----------------------------------------------------$

$//$ Return the free block to the system

$//$ May require Coalescing

$//$ Correct the heap Links $($used$,$free$)$ headers

$//$ Update stats

$//-----------------------------------------------------$

void Mem::free$($ void $*$ const data $)$

$\{$

$//$ TODO

$\}$

Mem::~Mem$()$

$\{$

$//--$skip$--$ do not modify

$\}$

Heap $*$Mem::GetHeap$()$

$\{$

return this$->$poHeap;

$\}$

Mem::Mem$($Guard $\_$type$)//$ do not modify

$\{$

this$->$poHeap $=$ nullptr;

this$->$poRawMem $=$ nullptr;

this$->$type $=\_$type;

$//$ Do a land grab $---$ get the space for the entire heap

$//$ Since OS have Different Alignments... I forced it to $16$ byte aligned

poRawMem $=\_$aligned$\_$malloc$($Mem::TotalSize $+$ Mem::HeaderGuards, Mem::HeapAlign$)$;

assert$($poRawMem $!=$ nullptr$)$;

if $($this$->$type $==$ Guard::Type$\_$A$)$

$\{$

HEAP$\_$SET$\_$BOTTOM$\_$A$\_$GUARDS

$\}$

else

$\{$

HEAP$\_$SET$\_$BOTTOM$\_5\_$GUARDS

$\}$

assert$((($uint$32\_$t$)$poRawMem & Mem::HeapAlignMask$)==0$x$0)$;

Heap $*$p $=$ new$($poRawMem$)$ Heap$()$;

assert$($p$)$;

this$->$poHeap $=$ p;

$\}$

void Mem::Print$($int count$)$

$\{$

$//--$skip$--$ do not modify

$\}$

$//---$ End of File $---$

$//3.$ Heap.h

#include "Used.h$"$

#include "Free.h$"$

class Heap

$\{$

public:

Heap$()$;

Heap$($const Heap&$)=$ delete;

Heap& operator $=($const Heap&$)=$ delete;

~Heap$()=$ default;

public:

Used $*$pUsedHead;

Free $*$pFreeHead;

Free $*$pNextFit;

uint$32\_$t currNumUsedBlocks;

uint$32\_$t currUsedMem;

uint$32\_$t currNumFreeBlocks;

uint$32\_$t currFreeMem;

uint$32\_$t pad;

$\}$;

#endif

$//4.$ Heap.cpp

#include "Heap.h$"$

#include "Mem.h$"$

Heap::Heap$()$

: pUsedHead$($nullptr$),$

pFreeHead$($nullptr$),$

pNextFit$($nullptr$),$

currNumUsedBlocks$(0),$

currUsedMem$(0),$

currNumFreeBlocks$(0),$

currFreeMem$(0),$

pad$(0)$

$\{$

$\}$

$//$ Free.h

#include "Type.h$"$

class Used;

class Free

$\{$

public:

$//$ Do not reorder, change or add data fields

$//$ You can add methods if you wish

Free $*$pNext;

Free $*$pPrev;

uint$32\_$t mData;

Free$()=$ default;

$\}$;

#endif

$//6.$Free.cpp

#include "Used.h$"$

#include "Free.h$"$

#include "Type.h$"$

$//$ TODO

$//$ Used.h

#ifndef USED$\_$H

#define USED$\_$H

#include "Type.h$"$

class Free;

class Used

$\{$

public:

$//$ Do not reorder, change or add data fields

$//$ You can add methods if you wish

Used $*$pNext;

Used $*$pPrev;

uint$32\_$t mData;

Used$()=$ default;

$\}$;

#endif

$//$ Used.cpp

#include "Free.h$"$

#include "Used.h$"$

$//$ TODO