The code below is an example question for C$++$ Data Align.

Good Output :

data data A:

$0$x$00$: $00000000$

$0$x$04$: $00$ aa aa aa

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

size : $8$ padding : $3$

My Output:

data data A:

$0$x$00$: $00000000$

$0$x$04$: $00$ aa aa aa

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

size : $8$ padding : $0$

The example of the output is as above, but the code below fails to check padding $($it only outputs $0).$

Align.h $($DO NOT MODIFY$)$ :

#ifndef ALIGN$\_$H

#define ALIGN$\_$H

class Align

$\{$

public:

struct Info

$\{$

int NumTotalBytes;

int NumBytesOfPadding;

$\}$;

static Info PrintME$($void $*$p$,$ int StructSize, char $*$s$)$;

$\}$;

#endif

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

Align.cpp:

#include "Align.h$"$

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

$//$ PrintME$()$

$//$

$//$ Write your alignment printing function here

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

Align::Info Align::PrintME$($void $*$pData$,$ int StructSize, char $*$pString$)$

$\{$

$//$ Use Trace::out$2(...)$ to display the data layout and padding

$//$ Mimic the KeenanSampleOutput$\_$Debug.txt

char$*$ pDataBytes $=$ reinterpret$\_$cast$($pData$)$;

Trace::out$2("$data $\%$s: $",$ pString$)$;

int paddingBytes $=0$;

int totalBytes $=0$;

char$*$ pMember $=$ pDataBytes;

while $($pMember $<$ pDataBytes $+$ StructSize$)$

$\{$

if $($totalBytes $\%4==0)$

$\{$

Trace::out$2("$

$0$x$\%02$x: $",$ totalBytes$)$;

$\}$

for $($int i $=0$; i $<$ sizeof$(*$pMember$)$; $++$i$)$

$\{$

Trace::out$2("\%02$x $",$ static$\_$cast$(*($pMember $+$ i$)))$;

$++$totalBytes;

$\}$

int memberSize $=$ sizeof$(*$pMember$)$;

int memberAlignment $=$ alignof$($decltype$(*$pMember$))$;

if $($memberSize $==$ sizeof$($double$)||$ memberSize $==$ sizeof$($long long$))\{$

memberAlignment $=8$;

$\}$

int padding $=($totalBytes $\%$ memberAlignment $==0)?0$ : memberAlignment $-($totalBytes $\%$ memberAlignment$)$;

paddingBytes $+=$ padding;

for $($int i $=0$; i $<$ paddingBytes; $++$i$)$

$\{$

Trace::out$2("00")$; $//$ Output padding bytes as zeros

$++$totalBytes;

$\}$

pMember $+=$ memberSize;

$\}$

Info info;

info.NumBytesOfPadding $=$ paddingBytes;

info.NumTotalBytes $=$ totalBytes;

Trace::out$2("$

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

$")$;

Trace::out$2("$size : $\%$d padding : $\%$d

$",$ totalBytes, paddingBytes$)$;

return info;

$\}$

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

AlignData.h:

#ifndef ALIGN$\_$DATA$\_$H

#define ALIGN$\_$DATA$\_$H

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

$//$ Add default constructor to each structure

$//$ Initialize all variables to $0$

$//$ Do NOT rearrange any data layout...

$//$ These are the classes used with Align::PrintMe$()$;

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

struct A

$\{$

$//$ Hint add the default constructor and set variables to zero

A$()$ : a$0(0),$ a$1(0)\{\}$

int a$0$;

char a$1$;

$\}$;

struct B

$\{$

B$()$ : b$0(0),$ b$1(0),$ b$2($false$),$ b$3(0)\{\}$

float b$0$;

float b$1$;

bool b$2$;

float b$3$;

$\}$;

struct C

$\{$

C$()$ : c$0(0),$ c$1(0),$ c$2(0)\{\}$

char c$0$;

double c$1$;

char c$2$;

$\}$;

struct D

$\{$

D$()$ : d$0(),$ d$1(0),$ d$2(),$ d$3(0),$ d$4()\{\}$

A d$0$;

double d$1$;

B d$2$;

char d$3$;

C d$4$;

$\}$;

struct E

$\{$

E$()$ : a$0(),$ c$0(),$ aa$(0),$ b$0()\{\}$

A a$0$;

C c$0$;

char aa;

B b$0$;

$\}$;

#endif

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

AlignData.cpp:

#include "AlignData.h$"$

$//$ Insert code

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

Please modify 'Align.cpp$\text{'}$ to calculate padding.

Must be able to pass the test below.

#include $"\_$UnitTestConfiguration.h$"$

#include "AlignData.h$"$

#include "Align.h$"$

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

$//---$ DO NOT MODIFY FILE $---$

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

static char $*$pBuff $=$ nullptr;

TEST$\_$WITH$\_$TEARDOWN$($Print$\_$Alignment, TestConfig::ALL$)$

$\{$

Align::Info Info;

$//$ Create a tmp buffer

const unsigned int BUFF$\_$SIZE $=256$;

pBuff $=$ new char$[$BUFF$\_$SIZE$]$;

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

memset$($pBuff$,0$xAA, BUFF$\_$SIZE$)$;

AZUL$\_$PLACEMENT$\_$NEW$\_$BEGIN

#undef new

E$*$ pE $=$ new$($pBuff$)$ E$()$;

AZUL$\_$PLACEMENT$\_$NEW$\_$END

Info $=$ Align::PrintME$($pE$,$ sizeof$($E$),$ "data E$")$;

CHECK$($Info$.$NumTotalBytes $==56)$;

CHECK$($Info$.$NumBytesOfPadding $==27)$;

delete$[]$ pBuff;

pBuff $=$ nullptr;

$\}$ TEST$\_$END

TEST$\_$TEARDOWN$($Print$\_$Alignment$)$

$\{$

delete$[]$ pBuff;

$\}$

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