Write a program with Old fashion C$++$ : Deep Copies

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

$$ Optimize for execution speed and robustness

$$ Working code doesn$$t mean full credit

$2.$ No Containers

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

o No automatic containers or arrays

o MUST to do this the old fashion way

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

$$ No modern C$++$

o No Lambdas, Autos, templates, etc...

o No Boost

$$ NO Streams

o Used fopen, fread, fwrite...

$$ No code in MACROS

o Code needs to be in cpp files to see and debug it easy

$4.$ Leaking Memory

$$ If a class creates an object using new$/$malloc$,$ It is responsible for its deletion

$$ Any MEMORY dynamically allocated that isn't freed up is LEAKING.

$5.$ No Adding files

$$ This project will work $$as$-$is$$ do not add files.

$$ Fundamentals : Deep Copies

$$ Write a double linked list

o Add to end of list

o Remove any node

o Print the contents of the list

o Deep copy

o Deep assignment

$$ Simple double linked list

o No tail pointers

Car.h:

#ifndef CAR$\_$H

#define CAR$\_$H

class Car

$\{$

public:

$//$ add methods

$//$Car$($const char $*\_$pName, int a$,$ int b$)$;

$//$Car$($const Car &$)$;

$//$Car &operator$=($const Car &$)$ ;

$//$~Car$()$;

$//$ do not add data

Car $*$pNext;

Car $*$pPrev;

const char $*$pName;

int a;

int b;

$\}$;

#endif

Garage.h:

#ifndef GARAGE$\_$H

#define GARAGE$\_$H

#include "Car.h$"$

class Garage

$\{$

public:

$//$ implement these big $4$

$//$Garage$()$;

$//$Garage$($const Garage &$)$;

$//$Garage & operator $=($const Garage &$)$;

$//$~Garage$()$;

$//$ add methods

$//$ do not add data

Car $*$poHead;

$\}$;

#endif

main.cpp:

#include "Car.h$"$

#include "Garage.h$"$

int main$()$

$\{$

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

$//$ Do not change the main$()$ function in any way

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

Trace::out$("---$ G$0---$

$")$;

Car $*$pA $=$ new Car$("$A$",11,14)$;

Car $*$pB $=$ new Car$("$B$",12,15)$;

Car $*$pC $=$ new Car$("$C$",13,16)$;

Garage $*$pG$0=$ new Garage$()$;

pG$0->$AddToEnd$($pA$)$;

pG$0->$AddToEnd$($pB$)$;

pG$0->$AddToEnd$($pC$)$;

pG$0->$Print$("$pG$0")$;

Trace::out$("---$ Deep Copy: $---$ G$1($G$0)$

$")$;

Garage $*$pG$1=$ new Garage$(*$pG$0)$;

pG$1->$Print$("$pG$1")$;

Trace::out$("---$ G$2---$

$")$;

Car $*$pD $=$ new Car$("$D$",21,24)$;

Car $*$pE $=$ new Car$("$E$",22,25)$;

Car $*$pF $=$ new Car$("$F$",23,26)$;

Garage $*$pG$2=$ new Garage$()$;

pG$2->$AddToEnd$($pD$)$;

pG$2->$AddToEnd$($pE$)$;

pG$2->$AddToEnd$($pF$)$;

pG$2->$Print$("$pG$2")$;

Trace::out$("---$ Deep Assignment $---$ G$0=$ G$2$

$")$;

$*$pG$0=*$pG$2$;

pG$0->$Print$("*$pG$0=*$pG$1")$;

delete pG$2$;

delete pG$1$;

delete pG$0$;

Trace::out$("$

$")$;

Test::RunTests$()$;

$\}$

$!!!!!!$ output MATCH this sample $($as close as possible $$ ptrs will be different$)!!!!!!$

$--------------------------------$

Memory Tracking: start$()$

$--------------------------------$

$---$ G$0---$

Garage$($pG$0)0$x$005$B$05$A$0$:

poHead:A

Car$($A$)0$x$005$B$8$D$20$

next: B

prev: null

a: $11$

b: $14$

Car$($B$)0$x$005$B$8$D$60$

next: C

prev: A

a: $12$

b: $15$

Car$($C$)0$x$005$B$8$DA$0$

next: null

prev: B

a: $13$

b: $16$

$---$ Deep Copy: $---$ G$1($G$0)$

Garage$($pG$1)0$x$005$B$8$DE$0$:

poHead:A

Car$($A$)0$x$005$B$8$E$10$

next: B

prev: null

a: $11$

b: $14$

Car$($B$)0$x$005$B$8$E$50$

next: C

prev: A

a: $12$

b: $15$

Car$($C$)0$x$005$B$8$E$90$

next: null

prev: B

a: $13$

b: $16$

$---$ G$2---$

Garage$($pG$2)0$x$005$B$8$ED$0$:

poHead:D

Car$($D$)0$x$005$BD$510$

next: E

prev: null

a: $21$

b: $24$

Car$($E$)0$x$005$BD$5$D$0$

next: F

prev: D

a: $22$

b: $25$

Car$($F$)0$x$005$BD$4$D$0$

next: null

prev: E

a: $23$

b: $26$

$---$ Deep Assignment $---$ G$0=$ G$2$

Garage$(*$pG$0=*$pG$1)0$x$005$B$05$A$0$:

poHead:D

Car$($D$)0$x$005$BDA$10$

next: E

prev: null

a: $21$

b: $24$

Car$($E$)0$x$005$BD$490$

next: F

prev: D

a: $22$

b: $25$

Car$($F$)0$x$005$BD$990$

next: null

prev: E

a: $23$

b: $26$