please convert this code in c$++$

import random

# Global counters for comparisons and swaps

comparisons $=0$

swaps $=0$

def reset$\_$counters$()$:

global comparisons, swaps

comparisons $=0$

swaps $=0$

def swap$($arr$,$ i$,$ j$)$:

global swaps

arr$[$i$],$ arr$[$j$]=$ arr$[$j$],$ arr$[$i$]$

swaps $+=1$

def selection$\_$sort$($arr$)$:

reset$\_$counters$()$

n $=$ len$($arr$)$

for i in range$($n $-1)$:

min$\_$index $=$ i

for j in range$($i $+1,$ n$)$:

global comparisons

comparisons $+=1$

if arr$[$j$]<$ arr$[$min$\_$index$]$:

min$\_$index $=$ j

swap$($arr$,$ i$,$ min$\_$index$)$

return arr

def insertion$\_$sort$($arr$)$:

reset$\_$counters$()$

n $=$ len$($arr$)$

for i in range$(1,$ n$)$:

key $=$ arr$[$i$]$

j $=$ i $-1$

while j $>=0$ and arr$[$j$]>$ key:

global comparisons

comparisons $+=1$

arr$[$j $+1]=$ arr$[$j$]$

j $-=1$

global swaps

swaps $+=1$

arr$[$j $+1]=$ key

return arr

def heapify$($arr$,$ n$,$ i$)$:

largest $=$ i

l $=2*$ i $+1$

r $=2*$ i $+2$

if l $<$ n and arr$[$l$]>$ arr$[$largest$]$:

largest $=$ l

if r $<$ n and arr$[$r$]>$ arr$[$largest$]$:

largest $=$ r

if largest $!=$ i:

swap$($arr$,$ i$,$ largest$)$

heapify$($arr$,$ n$,$ largest$)$

def heap$\_$sort$($arr$)$:

reset$\_$counters$()$

n $=$ len$($arr$)$

for i in range$($n $//2-1,-1,-1)$:

heapify$($arr$,$ n$,$ i$)$

for i in range$($n $-1,0,-1)$:

swap$($arr$,$ i$,0)$

heapify$($arr$,$ i$,0)$

return arr

def merge$\_$sort$($arr$)$:

reset$\_$counters$()$

if len$($arr$)>1$:

mid $=$ len$($arr$)//2$

L $=$ arr$[$:mid$]$

R $=$ arr$[$mid:$]$

merge$\_$sort$($L$)$

merge$\_$sort$($R$)$

i $=$ j $=$ k $=0$

while i $<$ len$($L$)$ and j $<$ len$($R$)$:

global comparisons

comparisons $+=1$

if L$[$i$]<$ R$[$j$]$:

arr$[$k$]=$ L$[$i$]$

i $+=1$

else:

arr$[$k$]=$ R$[$j$]$

j $+=1$

k $+=1$

while i $<$ len$($L$)$:

arr$[$k$]=$ L$[$i$]$

i $+=1$

k $+=1$

while j $<$ len$($R$)$:

arr$[$k$]=$ R$[$j$]$

j $+=1$

k $+=1$

return arr

def partition$($arr$,$ low, high$)$:

global comparisons

pivot $=$ arr$[$high$]$

i $=$ low $-1$

for j in range$($low$,$ high$)$:

if arr$[$j$]<$ pivot:

i $+=1$

swap$($arr$,$ i$,$ j$)$

comparisons $+=1$

swap$($arr$,$ i $+1,$ high$)$

return i $+1$

def quick$\_$sort$($arr$,$ low, high$)$:

reset$\_$counters$()$

if low $<$ high:

pi $=$ partition$($arr$,$ low, high$)$

quick$\_$sort$($arr$,$ low, pi $-1)$

quick$\_$sort$($arr$,$ pi $+1,$ high$)$

return arr

def generate$\_$random$\_$array$($size$)$:

return $[$random$.$randint$(1,1000)$ for $\_$ in range$($size$)]$

def generate$\_$almost$\_$sorted$\_$array$($size$)$:

arr $=[$i for i in range$($size$)]$

for i in range$($size $//10)$:

idx$1=$ random.randint$(0,$ size $-1)$

idx$2=$ random.randint$(0,$ size $-1)$

swap$($arr$,$ idx$1,$ idx$2)$

return arr

def generate$\_$almost$\_$reversed$\_$array$($size$)$:

arr $=[$i for i in range$($size$,0,-1)]$

for i in range$($size $//10)$:

idx$1=$ random.randint$(0,$ size $-1)$

idx$2=$ random.randint$(0,$ size $-1)$

swap$($arr$,$ idx$1,$ idx$2)$

return arr

def generate$\_$sorted$\_$except$\_$last$\_10\_$percent$($size$)$:

arr $=[$i for i in range$($size$)]$

for i in range$($size $-$ size $//10,$ size$)$:

idx$1=$ random.randint$(0,$ size $-1)$

idx$2=$ random.randint$(0,$ size $-1)$

swap$($arr$,$ idx$1,$ idx$2)$

return arr

def test$\_$sorting$\_$algorithms$($array$\_$generator, size$)$:

algorithms $=\{$

"Selection Sort": selection$\_$sort,

"Insertion Sort": insertion$\_$sort,

"Heap Sort": heap$\_$sort,

"Merge Sort": merge$\_$sort,

"Quick Sort": lambda arr: quick$\_$sort$($arr$,0,$ len$($arr$)-1)$

$\}$

for name, algorithm in algorithms.items$()$:

arr $=$ array$\_$generator$($size$)$

sorted$\_$arr $=$ algorithm$($arr$.$copy$())$

print$($f$"\{$name$\}$ on $\{$size$\}$ elements with $\{$array$\_$generator.$\_\_$name$\_\_\}$: Comparisons: $\{$comparisons$\},$ Swaps: $\{$swaps$\}")$

def main$()$:

print$("$Comparing sorting algorithms on different datasets:"$)$

print$("$Random Arrays:"$)$

test$\_$sorting$\_$algorithms$($generate$\_$random$\_$array, $128)$

test$\_$sorting$\_$algorithms$($generate$\_$random$\_$array, $1024)$

print$("$

Almost Sorted Arrays:"$)$

test$\_$sorting$\_$algorithms$($generate$\_$almost$\_$sorted$\_$array, $128)$

test$\_$sorting$\_$algorithms$($generate$\_$almost$\_$sorted$\_$array, $1024)$

print$("$

Almost Reversed Arrays:"$)$

test$\_$sorting$\_$algorithms$($generate$\_$almost$\_$reversed$\_$array, $128)$

test$\_$sorting$\_$algorithms$($generate$\_$almost$\_$reversed$\_$array, $1024)$

print$("$

Sorted Except Last $10\%$ Arrays:"$)$

test$\_$sorting$\_$algorithms$($generate$\_$sorted$\_$except$\_$last$\_10\_$percent, $128)$

test$\_$sorting$\_$algorithms$($generate$\_$sorted$\_$except$\_$last$\_10\_$percent, $1024)$

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

main$()$