$$ Overload the binary XOR operator $^.$

$$ Overload the binary AND operator $$&$.$

$$ Overload a COMBO combination of $$AND$,$ XOR $$ to change it$$s behavior.

o Instead of doing the binary operations do a three element addition.

o a & b $^$ c $->$ a $+$ b $+$ c

$$ Overload a COMBO$2$ combination of $$ XOR, AND $$ to change it$$s behavior.

o Instead of doing the binary operations do a three element subtraction.

o a $^$ b & c $->$ a $$ b $-$ c

$$ Do not ADD any files to the project

$$ No free functions do all overloading inside classes as methods

$//$ Binary

#ifndef BINARY$\_$H

#define BINARY$\_$H

struct Binary;

struct XOR;

struct AND;

struct COMBO;

struct COMBO$2$;

struct Binary

$\{$

$//$ Cannot modify these operators

Binary$()$;

Binary$($unsigned int $\_$x$)$;

Binary$($const Binary &r$)$;

~Binary$()$;

Binary operator $=($const Binary &r$)$;

$//$ add $/$ modify methods here:

$//$ HINT: you might need to delete the next three methods

$//$ start doing your proxy with a empty Binary class

$//$ easier than trying to refactor...

XOR operator $^($const Binary& r$)$ const;

AND operator & $($const Binary& r$)$ const;

operator unsigned int$()$ const;

$//$ Data: $($do not add or modify the data$)$

unsigned int x;

$\}$;

#endif

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

#include "Binary.h$"$

#include "AND.h$"$

#include "XOR.h$"$

#include "COMBO$2.$h$"$

Binary::Binary$()$

$\{$

this$->$x $=0$;

$\}$

Binary::Binary$($unsigned int $\_$x$)$

$\{$

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

$\}$

Binary::Binary$($const Binary &r$)$

$\{$

this$->$x $=$ r$.$x;

$\}$

Binary::~Binary$()$

$\{$

$\}$

Binary Binary::operator $=($const Binary &r$)$

$\{$

this$->$x $=$ r$.$x;

return $*$this;

$\}$

XOR Binary::operator $^($const Binary& r$)$ const

$\{$

return XOR$(*$this$,$ r$)$;

$\}$

AND Binary::operator & $($const Binary& r$)$ const

$\{$

return AND$(*$this$,$ r$)$;

$\}$

Binary::operator unsigned int$()$ const

$\{$

return this$->$x;

$\}$

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

$//$ AND

#ifndef AND$\_$H

#define AND$\_$H

struct Binary;

struct XOR;

struct AND;

struct COMBO;

struct COMBO$2$;

struct AND

$\{$

AND$($const Binary& a$,$ const Binary& b$)$;

operator Binary$()$ const;

operator unsigned int$()$ const;

private:

unsigned int result;

$\}$;

#endif

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

#include "AND.h$"$

#include "Binary.h$"$

#include "COMBO.h$"$

$//$ Add methods here:

AND::AND$($const Binary& a$,$ const Binary& b$)$

: result$($a$.$x& b$.$x$)$

$\{$

$\}$

AND::operator Binary$()$ const

$\{$

return Binary$($result$)$;

$\}$

AND::operator unsigned int$()$ const

$\{$

return result;

$\}$

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

$//$ XOR

#ifndef XOR$\_$H

#define XOR$\_$H

$//$ forward declaration

struct Binary;

struct XOR;

struct AND;

struct COMBO;

struct COMBO$2$;

struct XOR

$\{$

XOR$($const Binary& a$,$ const Binary& b$)$;

operator Binary$()$ const;

operator unsigned int$()$ const;

private:

unsigned int result;

$\}$;

#endif

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

#include "XOR.h$"$

#include "Binary.h$"$

$//$ Add methods here:

XOR::XOR$($const Binary& a$,$ const Binary& b$)$

: result$($a$.$x$^$ b$.$x$)$

$\{$

$\}$

XOR::operator Binary$()$ const

$\{$

return Binary$($result$)$;

$\}$

XOR::operator unsigned int$()$ const

$\{$

return result;

$\}$

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

$//$ COMBO

#ifndef COMBO$\_$H

#define COMBO$\_$H

struct Binary;

struct XOR;

struct AND;

struct COMBO;

struct COMBO$2$;

struct COMBO

$\{$

$//$ TODO

$\}$;

#endif

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

#include "COMBO.h$"$

#include "Binary.h$"$

$//$ TODO

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

$//$ COMBO$2$

#ifndef COMBO$2\_$H

#define COMBO$2\_$H

struct Binary;

struct XOR;

struct AND;

struct COMBO;

struct COMBO$2$;

struct COMBO$2$

$\{$

$//$ TODO

$\}$;

#endif

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

#include "COMBO$2.$h$"$

#include "Binary.h$"$

$//$ TODO

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

Should see something like this sample codes:

Binary b$1(0$xa$)$;

Binary b$2(0$x$6)$;

Binary b$\_$Binary;

unsigned int b$\_$Value;

$//$ Normal

b$\_$Binary $=$ b$1^$ b$2$;

b$\_$Value $=$ b$1^$ b$2$;

b$\_$Binary $=$ b$1$ & b$2$;

b$\_$Value $=$ b$1$ & b$2$;

Binary a$1(0$x$1)$;

Binary a$2(0$x$2)$;

Binary a$3(0$x$5)$;

Binary a$\_$Binary;

unsigned int a$\_$Value;

$//$ Combo

a$\_$Binary $=$ a$1$ & a$2^$ a$3$;

a$\_$Value $=$ a$1$ & a$2^$ a$3$;

Binary c$1(0$xF$)$;

Binary c$2(0$x$7)$;

Binary c$3(0$x$5)$;

Binary c$\_$Binary;

unsigned int c$\_$Value;

$//$ Combo$2$

c$\_$Binary $=$ c$1^$ c$2$ & c$3$;

output :

b$1-->0$xa

b$2-->0$x$6$

b$\_$Binary $=$ b$1^$ b$2-->0$xc

b$\_$Value $=$ b$1^$ b$2-->0$xc

b$\_$Binary $=$ b$1$ & b$2-->0$x$2$

b$\_$Value $=$ b$1$ & b$2-->0$x$2$

a$1-->0$x$1$

a$2-->0$x$2$

a$3-->0$x$5$

a$\_$Binary $=$ a$1$ & a$2^$ a$3-->0$x$8$

a$\_$Value $=$ a$1$ & a$2^$ a$3-->0$x$8$

c$1-->0$xF

c$2-->0$x$7$

c$3-->0$x$5$

c$\_$Binary $=$ c$1^$ c$2$ & c$3-->0$x$3$

c$\_$Value $=$ c$1^$ c$2$ & c$3-->0$x$3$