VsUyx(0w=i=Pf!l+FZ0_L#34-k>k$5*`;wIOlxCzk{;hrzKxc7QFxFjD3SeeRx
zaGfl8e$F!Rhe~)6cOoQx&|Xo2p~*1=zZ~_lmMk|LpfT1AP#?ejEVzcuoK2fo%vlE%
z4@8sptcEG*xNolm_=@4~=Sth4swp6=nq^wO@1Vv$JO5SP57yh(j5E8TzFcSb71??drjdZjMUGPs}Jog
zl~gTPD$-fvbLDPcj%79S`jWs?#o*8gbiPN}>kD|r!>!dI#n?nUQW(C+<_OpfhIqc1
z?VQaJ?B}vyLo%}M7I%oexU7CmXX6jo}=Q!Z~gPa
z;L>qpE+NSk8nPK(LKRZZ$RO3&vP>>W5xN;v(k6YDSaSb$yB4){S)gwen_lwX5%%Z9
zJC0&o3%0ye=62MTU;kf0H`L4b2fcEnsKS{7&cBEVqG;97Fe*LsQ6-%C#W}d-1#obs
z&Eo8P6D-I>*E;Kk;SC#*mv*&eo|=-dZUn(4;_M
zm0=}#_dV@nOC}4fZ(b`+1H=Jo^=SsNl`{D4`VPTb(*|>_FC)hoT`vz?bN|UnB`+*b
zIeA6Zw?=*eXXj{Q2r^0GeTHiUl4Y7V%S!6=g$=S;JaB{E?leVOPo~KWX)2$}n0Q29
zGUFbHqEVl^>7Pd(lO@=2rBv}>*2Y!7C)QWfkydB_aVM&gA*LX`(XW*1Sp$7f@-pkW
z47J(BwEsQyb~w~aEZ}x5dzURP-`YA8yPWaN(fdfl{K?Ld%P=O`)U}p^>?66>;cC;&
zZrss&x%!)t^^lXSbEmbLObflm5>@K&AwS+gf=)<6I-`Y-y3U-D
zaifwAa@DlG;kQv#<+Md2nOAD+vysBcHlFF$g*y&Z$o}GEXk>zkn{8ZV+_uZC2bDC3
zVSjjx|90Pu5O(mlkpMDz9CBl&Y^&-kQTZ=qH4bA1E?Fx|73aHefmN8}wHT%EXCPF=
zUn5gL`3sqHN!(GL5F?dkNHx$_`Z~S>0+P!Udm`D@5R28&b>z@-RNj}h{Dw!os
zP!==UgM@^_!!(`jW6Ih3K8MDt%3hfIua(8Eh9T{6=ql*XKBN9)_RYanwqmp8R*VDI
zhHBpxJg|4r!Cuu1YGjRVr+_Z2IwVYLyA*w|-uo}PY2Ku$#}{Nanbir<*l|{}%=d;{
zRdxkL+QA)w*7L4N*j%X@rq8ns|8#<<4%~zx9eqFuH=Ir+OP>=tDKaF(_0*=r&2**$
zXDt%N`XVi-%~lA`dz3Xz8~p_v)Vmn^0bdxyT_CuOU%y5qmfd>Y&3m-{2EMkRO4fHpQ?Q$Ued;
zEdC=8+)-(|R=TU+{#m&-k9fpFsL)B@+RfJ;9?0_`8L{*-
zI8JheAKJaEcU^3v!_jfo`X;GN>&t~)6jy;>H~U~fYCjN1GgF9fmw*7+yQ)e$QoaW%-S>yy
z&Y=c$vxEWJqwH$NyC)4sk_XwxAI45+zKZf+ASBmX!EUcTv(3B?c*l{ohN3X6j$9EM`}8gI^bqOgm{2wT|`WRQtOrWmJeJI
z@!f<@gJv~o+7_I;BjB=*hFJIv4Z>(BhG#6x!QfLj6LdXgj2ur4O}W0_DLNLm#;`N7
z4lmft8yL^VfSRLO7z(6V4H&f=B$g%gd-oQyIXhksvu?n5bZgPhWvhi!ts`Y^3J1vUx696E
zvXz>6CAwSAsT=`ZT;@6|S?mp$1%;4DHxpetCu
z{Hn4VqsSMPs9BV#foNZ4HJ}7Q%nu!pu_h;^pe*a@>;jGl#_y-mZz2>L&8M7_ZDR~N
zTiC+||ImG3f?3^GB>H{gCy_u-nBT?T7$wseyF~k;W|p2n
zQeh?WrPSr0_1l~X6t#o3rCrfD@XH0kf2^QVzIJjbQ5g4W=AV68<9)|2v|{$CVVvjx
zi%8wMn4TIU-BW_u;@5zxutzc1AVWEww7R|-YIdxUyNyv}2QvPh{tQTOl=S_~H!BYB
z+R60K=h}t#b9WcLM(ud7vU-32IK`H{cSrM~GJr;=T0k{70rAkN=&trz%e{VNMDfaW
zo~;jsX%Fubl24Lv~RjYF`VbnjWW2tazEU3UAJ#BmUb{k(xZ#OPWEuVYX#wUT|4#NE`5AXXZzR!aC2E)F)Xk*7IcH##9jP_~k!1efFwTe&|#
zVMBfqb|N$14su~Zs6egW_(aGu1m}ADEt-AvU(v9Ftnv@&*&060em6kQ+rRf
zbfL7LgZ-Ww6=fg%AvI&thin(`yqmt*K;2~o;4H+zyI}t;$_TgJ8_&);0>c5=PhJ?>X}uMpnaYvA|ir67k>V=dIXfi;LVSAl%uPj
zyiTm|nzPJ;mCzk@lgDAqV!xYUJtO>9HO-OU9n;S)k~p@}B>lCC8;ZLBdeGPeFg;~THz(=P0N}&V4I)1~
zS{aazswyhiHLgrm;_3R|@UJnx`jc)5hp$@n0c&}
zOLPLUiFeNFA{601o}1*i@mCu{$dM@%71Er^`$mNiQ_>oKpc_xz_fh>n6VF~JxqB7!
zl@rNH1Gixj2=petgY&aZ!7XwbmhQun>?qsfmJ`QU6nq_Q#8W_-r&ze-bWG6EeO>W=NLwi8ql9{#?jA?{O+3cb9Sb1y;7c~TH=cWIG>2bJ
z>3=+hmC}o%!k_zDBEc;z3Z!chf(;qSQem8>b+WQwwT>`s#sh$Zk-^N$Myg8N$wns+4x=X7P(DH2zvey8wQB~QvV@e?
zmh+5I%kgTXg~@hbU`t&iq2Ke@uK*SFOG2vOrVHF4FIjZ|zi(T=mMyth(^Km0YfMzJo
zrIV0xhtT08Qi>Ugpsh0yCo?PJ;inD}dgmao+#AB)m~7~l(EBK<*Boxg>ntNgi4@iH6X(_%#0XLaVp=$6X_c4QBhG=3;
zP4sgsyYHq2w4GvV+2cAdI}nG5)o32rzvnJTcn)zY9$|)`3i#el@$j42=-&|w`?P)6
z6#o0}{4ORnY&Gs#y<7;v#?oAZ`+-0e?Qcx#-i5C!7vl{i^+l=mVwBYXH}UwP
z)#pP>p6U?)u_p=j-pk92_GN=A
z?H?@zY4+)1(T&-oDRrG~OW;21)bTpDr(nh?P2}-7j4o5xP*L4QbA(W4MC2H1iSFU&
z+m-uUV47#$a8!A?f!_-iiPtf?H^qOvs1*63r6f?_>s8@?V}V8El2lCj4(EXek%y$<
zX+Of9d5Ib5r-f_aZl0t))4b?;eO
zt-0PG&l!sQ#kA#_5}9c=cg5ByWO6#{xJh-L@^8{aj-}#UVsv&Np#lhQ_6<1K4msKM
zKs5TR2*Alfbyf;gw%Q_ZW)o8(z|u~59M7(ttgOpLvqsq;Kl?0Nk%#{H>OQ009r)0t_vY3xsxOj~YrxEhLE#;nYy
z^UQRJgKJzolfur2@_M=8da5jLY+Rg_tZXE+;w7Qu)Q_||nE<6#?65Q2K0Te&-~VCy
zJ#}uKtc*3BVq8Ey2h$e~I_w*t!+C-mR~?ow8M9Pg^xsGcPqU?$tV5fcW4upF(*C4o
zAxFfVav9ST`Y!w#EtjU!x;i^8L9Puoi)N2M;vrTla&zQwE0+DklQjOGF292)mly
zUsNe70=}XF<|<1ViX6lg6U6d+DDn@(ADWNUIzJHp^$a}~_oF>pgXUVu^`mxYwh6}b
z20ir}PTSa-q#h~-XZHCdz%-RBe$1itIg+NWQV}r5<30|Tw&5}Y(X@|89yA;+7
zUk8oOcReA8-j5bV6lR(vL8*PuCh4wr?HVPp$!mZ?0JG!Kb^-%%>x}V^Ox#nP#3`c#
z&cJUtehAzYMu6BN14j#$J>G-fAT|)v?hdRX6Z`9!0{`J9l
z`c$?4_pAoaeHaq{?vGEukJrGMN*nPmR)%F07Yf#DA$0}-=;!Obl^&Kik;u>O0Osk9
zZ|3Ia&0c0&tB6Eb{lCk>N3m8tSm`!VlUg8`#=KVjFyYMAPJ+)NOe`myAu}2b>4eX1
z?cOq)97FvN-y$Z=fOVk8;n6)~7l0cBlASHrhVh~v3dI122q!&Bs?eXRJ4X(*SGD!5
zoOF&PAo=w;4FE8R2REcv2TDP;l)I$hH#2THV2>C
zF_|N{SB-Y$v%0z(Z?@-|Dt&G!EBK$LeC3IdK#!S!0mb-3Ly^whcV0r4DCh44YHCS(
z`=d|U2Hak$cVid0IlRvL!Ua~~Qn(YFUOJC#6y8mQ7KMQ@qJ({3`t;;}&yJ^At$w%5
z10M7WA)muz55@R2>q|vU;q>wpydK-D`7bji%$dPsBga=MQeu}yX1$IdX?ZyPt|yO>
zNz@ASDfJp<-A=~YLPZYVK0~|?_`Xq2w?Ym$xCeFaV0vcII##-z4(wkwpnen8_dIr4
zw;KG*PHH>E;lCT8gQ=_un4V1pP|if?5GPID$9U8_7!DHTl!#
zXrEH>AQ<1spo8!2%mw&*kt^iA3&yXSZ|d9!VUW65FHyjV6NB@Q1RBDgC{E)cI3F;V
z*HXSS7-j;#TC~)46OQQJ2UF**4Q(z(vnC+7T`U4XYYk>{-mBKwqcbJCO4WEBnk!(}
zu8w(5GPgWbM%6B`!@|f21x`=^xiw86zyJF_U2(0M$r$C6hawL7nkqB7??fH
zj2gq509rvL95Nca+X9vY15fMKYlOZIjeFA`MxQJ7(Rf~32yY!;jjn}T|`bw-1;
z?amfDx(cDfJR2^U9-Fj@x~O3}Q()i2(5iIUA9~$PH6oQ=%K^Sb2@HKug3N#9DxG3P
z2(>F^uuDc)j3gcP0SOCSkxuE!2)mag(@mH0_Zp0X?!0=eA
z=Nf~!{vQ_~y_U7J4Zm)-t=X8SNEQ=TGSlZS_%;})HOn=9;fvL;7b=(2bNZ_Ezkq&bBSj}8_lSq
zR7e2nKW~i6FB*}LRu0A~_AjZARF;q{jk_A59oh2SYVDAg27F2)BJrx`guJUt`Emvu
zbi+K7+Xth?23oiLbnN=KFdJ^A&@Civ>d9zyI~Xr_CqvA%&IWk1Vjx#EB`DkV*`~ff
zoyHu~QDT#Zd}9K0t(u6}KU6{j%Km}9|L^Q|6dwhlLsXWXo|RIo{f6#%Dd-N&=|Y2f
z-sRzO2(8%UWUTNkbue2K`F7R2rC!z6hPO8w*BWxMA^5VNwEa>J>>7IqvnJM}XKFQR
zJY-RCB&&PRCUHXM41>;$?a^)>wM^fMH^v^E-tb|ihMvbST$44TEC5dyxt>78wQk{u
z-`~fkrkYFY9Y4T;mmL^fZ#X|6*1Z?=17lU*!>7Wr)P=5!zY#VDD!THo;30g>?!kbD
z(_8eK$;?8lZYb`SWKXW-23*}uGxH%yzKDE}cm|_9A*0FDw#HE34BbE4S*MM2Qq~9)Y
zW%VC(a
zaOz&kSI8K~P$r6x@7ozv?_*p?a~K|7fPOQsTQhc~NV0aLQmtKdTimud;QL$DTD
z|9=o{9f`mhtP?Fd7y~4LcmP%{Z`2Z8vHbIrX}QWyziq%ya_Q_+BjyPgJbIN=qUAf~
z0(+D**Qd&nH$?F0ql6}z2>fhG_(R8=+TI5=c=S1sDI4nrhHi(vHa;qDK7+vV+y4Zf
zN~#+S>>GDq`Yn3+i-HlA-uvLhB7Lyg*6X|XT6gvSQ*;9_v2m4Jbg&B6b{cSP8vN5h
z7NLUu@_!uY|7m%Ghlc5>=Rd&Iy91oZ1b(9zV5yZxs(G0O{I27)jl$pxhktKy5UN=_
zOZz7v$X-Qkk>{U)tt1*34|4wmG;5_TI3@fipiW%n<15ua0ULCZl^>8H@)!!KL||WV
z$o^g%?Hh=R&~SX!dNF_VHJT7xv&i@vuU#F@w`Cf`LA)80gTIEiP3!|&LlICjKaV{%-n54&4Dd-^s
z)ucZdUm7&~iX3idKahWkO1_{?jhkn;BJ(k0+P}#a#bz>s#HiUt6oo7Q&E+1-=W#F%
zZ=D|BYSnz7L^o{o${V)~il}y9CoZF{9YO5pnP2*YEDK{?EbQZvv2LfhrhhS0qSsac
z-wC{j^LN@uN`;|V&nF6bbL;6o1DfjE$PY&Vj=x4EpvbnP@VfXS0Sqvwg7;60H3by%ZPvPKQ=?rQ_uj8bOU
zz3_j$4F~W;2>-p{GbGIVBgAteRHjW0*4Z0Z#H(~R?;9Qz$EM%v(Z^nTLC$G+!Pd0n
zXT{I|MK?tziSp+E683oBzjQBQD{zD2C9%{J
zkQmR7wSaosA&R;!eTri1SxAVsL=q>A73=naYhq>1`-sI2oSa@&7j5Zk#>g|bFx(gr
z!rSm6R()*-#=(A%uXBf3Lq-~o$fmhD=~6iUV}gfM+7ruXa2|N_<=ShFl|VKDN6Pzy
zt%fOJal-rDM?%9+frE!>G*vugES(2c%cN{KcQ>v&vREcH8OqdrUSv$-v<2W%IC>D~
zdGyB;Nsl+--dz}jF6`w8!EUGUm*~u2#LlGRtO&%za$A&t4^t=-f8m
z+=WnEZgqG~P0z!55^cT_%Tg4gVQ2pmc_fI`uXHyYU}9V8wWmWFLLRu@jDSNe<*6${
z$I$s2*7$2qm<_C3
z*F$;+KPF+>Oc6~``3!BeojXRQ`hn4pJozez7k(%8=&H{mJESBjC*As%Qkh?QeN9$z
zg}D9KVaZl)z3xbfhqmIv$OTSu_JEJGUv^UN6g)h*dk$Uiv15u^fdyga6t24{E?2EY
zoH~6K5yipjksos3ZDrHjjUcFJ(xdlJPNe@DL#y|6L+W*+NTw~Gv8EFjh&Z^(X
zlPuB|&>gWhILR}+#KIRm$qx^y44u8W+udn9ADVYbIphheqb$|q81hFCV~%JZ;3o<~
zWU)I}J}X(@ZYo
zEhR)c&_IWZ-<;TQvRQ*eZRRxNQ`LqS9v!$hDX8Q#+g})k-3rG*bkypkiM
zj68}^8%|E_SrYoA(@guv;TH!BeCIK_`QRzCk|04=(J>mBK&qtduh(NcOsL13Yvp*I
zlpp*Z_DT`@`tnVY`L?yHuPyZ+&}Ji`-sSzfOx6;%g+K~^L)C=D9((e|3mM1ZlL%D)
zd!I5%zqo#T~}-KxPrS@}WP)<6jU>$2+zYNzVAubQUz>49lIz1TFH_@UBwIV%_<
zXeKAiLPEY+bQg@XsMRrvK*d1@fHPX7EjAAKd5oiyJ9I2o!5J4hYf7?e59>X#2=a{>
zKEc-ZRBSgZq4Q5pkzvDdOHn$0qd)s4nyG^De<$0vULW7COR7Db9=76w
z?%h)Ha?eGU;b0PBL<$?BYb(3Erk0usb{Vn1_DTUh>x;wFHqE^?lm@#(IoOW=P`Y$C
zqS0865zBcvN%)cQmsTgai~dO_XA2iL#pi%+0#u-54i;Y{I2(RHHkEjn(X;Shxu
z(zHujEV
z)Q6t@&}O)yQ<-ccPZ~=Lsunz}Y-ceTrJ)q~*b~C&TA7AE3wBxx)|%agqTGS=b;H?F
z=Z)mYQh;U86O;PAV}@fO%arabg%@WRgO@IWaRxhgP_ACSC83vVPEbFGh4E@%ES`WX
zqw8P#ceghD%FUdR$CeXvWX}clBHu9u7}+s-nRyIMZR!{a>v>9fgKIiqG0@m`Fs!b`
z7i;s7QNEP)y47X7oySrah_&Sp)y;!rtaNB!rIQz|fvY|&)oL{uQ~EBIAUf~*?8B8x
zh9$0glyB8IVmZeMlm3GC>RPnSr*f!tuaviWOd>bntVJ3P4
z{ghEuw>M^5WqU++F@z9abaCDU{d_jQMP>o|lC910)#ij@s_k)AlT9Ee^xOe(FtXE^
zXq#ngB%?%TF+wfaLV9=*Ud#n2#aRnt9U6W6S!@rBUevQTavF|DW#r0u
zejXC0I~2p63g@=7FpW84XwIf6(Yr$&+uTp~jNA6Jbz76Es
zOM9F0cx|+=JdPYpMs$a19px+qDgOPBz)kzu!We2wuN2jn=%Qsl?Ca|_6iC!M5J>(T
zgN!DwNAva%S6hiIuc84DtuUsA!VnF6I!Q4oS(0w1v^bt$Js~6X2-dPG6^ouujl^Gr
zGSw^%w022h@@>n!?&mrWYm8jONBZjgV2$KNjb1tyQS3l8wukkWf+kl1AtM!e8#n*7
zW9EHVYnu(dI#Pv~55`p&w!hCSvaWy!=@M!wpAPD)YjIvvGS)}dX(w`R(fX`^;`O}^
zdmC|PSTaSu1FG(_i@@u>b!}S8rr*NJFP*$roLz}$ct)Kzk{uy;L)95PUCK);Tqa&`
zOAertV4$l&SwXW>t|?(fbI;A|Ei~%aRu*kDY(d8rOQaK^c)74bLc*i)rqWyXA>qk$
zHc4UXFYlfAh{mPX?aihGyd)o*TrXdt13d|YLpLK(#X3NjH=k_
z-Z|>^z^bH&!{rw|m
z-fWB{F*^t1L)fN~;wcWRTyA(4yKRkXp!vD3AifPPeS+WETC0*o+T%^Q)qJjSVN)4t
ztHi5bxJzQ`&3_#*3tcn7n_o9@rF+7!h21WX4(DA(lh3yOcu2)tg94okajK7^wu_lR
zyiUr>ll^U-;uD7NTo8qI>Zf0SaqjPAq;uP_$530UI_3hAGqiZ!C{Rb^NF>xn8H!6E
zLqhz2*Zjnoy;qcz_x>B
zW37_po_cR7d;1FO6}A^g5{e)fHhhy0+e6sY*fB2}rYvs3M(z`<>jU$Bk*D^XUDT}O
zwz9;GVqsVeC%}re1hS?s|4)jX3Ey0WZTj3zWxR^f2t-nGdyJz95?Z`!9gK1<}`t
z1I|33-B1i$U2!hu1SNL+fnkN;Ba?z%z3ylv=lzW*^pO`l$gtd_M)$L(5(}vFL!XYk
zbtb5vKr2l&RT4iSxSnewu_vL&d1AyBX0V6LZK5(s}u94iw`>c1TOdi1|k!$n0DBD`H#4coF&UtNXkfJRG~k{rxl;MSI2NmX$$
ze<6!&uE)KrV09qt(En=Y%%h=j*Emk)*s>*imN6z|vc_OELbgo9PfP}>ESVa6_B}$O
zvSqI+`%GgQLiQywlyC@*?E5l?k!7rR+&}JL_x^wXeV*sM=RNN^?|IJmSw5X(K@Un`
z|0uc7x9^GN7nAhHt6j`7DPrmUIdx_{1&!|#=uJrL7gxv9PJ`o6WQ`9t1qBU(!>3A#cC{&Qg@{Jlqg&CYW4Af3fIe(*k66Ozg7$j
zCQ4+O>pFwKu%l$f@>j?G2JNb2ii+l&4vh%7Onk0>t1jQhkk|mLB<7Ic0`ykD_1{7t
zw2$|QX$3L#J>FOkFvWT*{-Y5V(sHL3SH@1|f3xh_^NsJIX3t+EzXMR^KPUaRvL$=0
z8hN-HT4$f0t6A|72TdMz?QP7MEbc|zfWyxt!1gAB2MHCcJTWE`G*A|99J7s53rjnI
zmfwz>Fx)*JR0*81^2J!X1bH8mjKIKhw-hD_!rzF7}
z=&_Y{AqAVo-i?0S&&^&sqw=-pD?kz>7rwH>v$^8bovA>{?IYJ+>K-`Spvj8JIRjDB
z{Pf2tQ|_`(@PwT}+exLQ7&%PW?;CV)>xh`y7`vm#?)=8wT9smxDV6}uKsR3MUY2tx
zxj7yz&RpKY=MKY^;7|#R({Po#U>kEN9|0QF4d3faCBQH>H3_8)Rh{a-H8Z*mYJBj9
z7_c+_{^1ed6=bC21Y(N0=N3>`tM8DL{<%#(0HOsE{mgQrrpn%xej=J0UnB)_k%{Vs
zByR=>xM?RD_@_v*)ba0z>0Dy<30U6gMd|19O1?LSaw<|GKSD7&B6xFy<7?!b>Xh0!
z%RGhj0N5=DruIv;=|?UR8a%svvC%@-n?5p&L9DcppUuC{N{tu@GTwT4$n}*%7{8$X
zwoxKj!3ZFpYin;ZMu?nIfPmOpi)UD
zP$8^&@ibL(y@YHdFf7Qk!+hMh%}Y}oPKk1M+}O}`v#S)&*?BaUY1k#3$3<ucPe^?TTUh~NF62F)i!?h!u
zL_|g#0+hnRZm|a>&?Fg0QTDP>z3l!${1OsRyEE7{o1?*Mfx!2Jh#5o?1Ka6mF3UDw
zJb*r=-fzWe`KXThmjKUXX8~wUh}coi^R|GA*EttBHb|{yHWg}dGkB90G35)89ZK|%
z<&%P1nN$(iAl2K@zv48a^K_lcL6UZaaJJx+2KUmKQbeGi57H2t*pfz2gxzReH5km^
zBdD|&8kQ$#k`pvO#1=|vLb-@@j@|=h{KBr|=gb<$)p+vUoE3|%&U2O9rjBpk$tH5UK
zU4L@SC)*5>*U=KxL=CZxquJ`H#y%A9mw`#SqiO!{_+7%ilP28ZZRqj$s_9FU(Zezn
z?2<=jwStgV9d#F!0#&T$#D!jEnsGyot@g#8%H)Aw9F7Y^y|gcv-L4Kcull}N1FeX}^kTh`-dy
zJMX#UZ|`#lDwJCGt$==!Bhl>#ZBW04)vC_xI8x5vNbfJ{-0z7Ndf^8yVOd52(E|V>6>U0|9$1_<-I!SL=G?!YI>p^e+V>dWTsDp({5V
ze7A}C^@8{oA1HD9u1YdciwBz0g3sI^F=h)4VvOvD4u6SFX35G)e?Z2L5Wg{L0g70|
zWB#>WP1}MA+KA4
zja`iG2&Bi&T3!~SdwCf9XvYh6Skx*?PvOM(9gsIm{VuQBr^XH=vFd9&y7fK86#27G
zwnzL`PZv0UMpUbMI6Mt-YVR)|@cnxtHQ)U(#nlrMgj?faW@WRVj$is~w6$6-J
zZ0NRiWh
Date: Sun, 24 Jan 2021 18:42:14 +1100
Subject: [PATCH 21/92] pdf: fix rendering issue due to line break (#170)
Fixes #149
---
book/zh-cn/01-intro.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/book/zh-cn/01-intro.md b/book/zh-cn/01-intro.md
index 94a9a1b8..80e324c1 100644
--- a/book/zh-cn/01-intro.md
+++ b/book/zh-cn/01-intro.md
@@ -25,6 +25,7 @@ InstalledDir: /Library/Developer/CommandLineTools/usr/bin
> **注意**:弃用并非彻底不能用,只是用于暗示程序员这些特性将从未来的标准中消失,应该尽量避免使用。但是,已弃用的特性依然是标准库的一部分,并且出于兼容性的考虑,大部分特性其实会『永久』保留。
- **不再允许字符串字面值常量赋值给一个 `char *`。如果需要用字符串字面值常量赋值和初始化一个 `char *`,应该使用 `const char *` 或者 `auto`。**
+
```cpp
char *str = "hello world!"; // 将出现弃用警告
```
From 25aa34742824597330ab6ba066313f5833b976a3 Mon Sep 17 00:00:00 2001
From: Changkun Ou
Date: Sat, 6 Feb 2021 23:35:01 +0100
Subject: [PATCH 22/92] website: add urlstat
---
website/themes/moderncpp/layout/layout.ejs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/website/themes/moderncpp/layout/layout.ejs b/website/themes/moderncpp/layout/layout.ejs
index 44f18961..442f1810 100755
--- a/website/themes/moderncpp/layout/layout.ejs
+++ b/website/themes/moderncpp/layout/layout.ejs
@@ -29,7 +29,7 @@
-
+
<% if (page.type == 'book-en-us') { %>
From aa4d1eead5ac49af6669ea6526b0b2232316d42c Mon Sep 17 00:00:00 2001
From: Changkun Ou
Date: Thu, 11 Feb 2021 14:12:32 +0100
Subject: [PATCH 23/92] github: add sponsor button
---
.github/FUNDING.yml | 12 ++++++++++++
1 file changed, 12 insertions(+)
create mode 100644 .github/FUNDING.yml
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..2957eb0e
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [changkun] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
From a386449dec9a3f28b323e1004ea59f2dd6960254 Mon Sep 17 00:00:00 2001
From: Kartik Saranathan <278928+Kartiku@users.noreply.github.com>
Date: Mon, 15 Mar 2021 05:39:11 -0400
Subject: [PATCH 24/92] book: typo fixes (#175)
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 6ef8ae93..537b6adb 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Each chapter of this book contains a lot of code. If you encounter problems whil
## Exercises
-There are few exercises at the end of each chapter of the book. These are ment to test whether you have mastered the knowledge in the current chapter. You can find the possible answer to the problem [here](./exercises). Again, the folder name is the chapter number.
+There are few exercises at the end of each chapter of the book. These are meant to test whether you have mastered the knowledge in the current chapter. You can find the possible answer to the problem [here](./exercises). Again, the folder name is the chapter number.
## Website
From 4cb055f6292be47405a0fc2b80201a4d2c4f1f4e Mon Sep 17 00:00:00 2001
From: LaChimere
Date: Tue, 6 Apr 2021 05:30:43 +0800
Subject: [PATCH 25/92] book: typo fixes (#177)
---
book/en-us/04-containers.md | 2 +-
book/zh-cn/04-containers.md | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/book/en-us/04-containers.md b/book/en-us/04-containers.md
index bdfe6386..0f04375b 100644
--- a/book/en-us/04-containers.md
+++ b/book/en-us/04-containers.md
@@ -292,7 +292,7 @@ This will iterate over the tuple:
```cpp
for(int i = 0; i != tuple_len(new_tuple); ++i)
// runtime indexing
- std::cout << tuple_index(i, new_tuple) << std::endl;
+ std::cout << tuple_index(new_tuple, i) << std::endl;
```
## Conclusion
diff --git a/book/zh-cn/04-containers.md b/book/zh-cn/04-containers.md
index a9999a66..d39205db 100644
--- a/book/zh-cn/04-containers.md
+++ b/book/zh-cn/04-containers.md
@@ -292,7 +292,7 @@ auto tuple_len(T &tpl) {
// 迭代
for(int i = 0; i != tuple_len(new_tuple); ++i)
// 运行期索引
- std::cout << tuple_index(i, new_tuple) << std::endl;
+ std::cout << tuple_index(new_tuple, i) << std::endl;
```
## 总结
From 5e2531058c724d3dccc7343f5b4a0d4c31a0853a Mon Sep 17 00:00:00 2001
From: Umedzhon Abdumuminov
Date: Mon, 12 Apr 2021 12:42:50 +0300
Subject: [PATCH 26/92] book: fix anchor link (#181)
---
book/en-us/01-intro.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/book/en-us/01-intro.md b/book/en-us/01-intro.md
index c44a651b..c28197f9 100644
--- a/book/en-us/01-intro.md
+++ b/book/en-us/01-intro.md
@@ -55,7 +55,7 @@ For some force majeure and historical reasons, we had to use some C code (even o

-From now on, you should have the idea that "C++ is **not** a superset of C" in your mind (and not from the beginning, later [References for further reading] (# further reading references) The difference between C++98 and C99 is given). When writing C++, you should also avoid using program styles such as `void*` whenever possible. When you have to use C, you should pay attention to the use of `extern "C"`, separate the C language code from the C++ code, and then unify the link, for instance:
+From now on, you should have the idea that "C++ is **not** a superset of C" in your mind (and not from the beginning, later [References for further reading](#further-readings) The difference between C++98 and C99 is given). When writing C++, you should also avoid using program styles such as `void*` whenever possible. When you have to use C, you should pay attention to the use of `extern "C"`, separate the C language code from the C++ code, and then unify the link, for instance:
```cpp
// foo.h
From ad4b9580a51082acc83eba88a0207b44e3228d7b Mon Sep 17 00:00:00 2001
From: Dw9 <36155473+Dw9@users.noreply.github.com>
Date: Tue, 13 Apr 2021 15:36:31 +0800
Subject: [PATCH 27/92] book: rephrease unique_ptr value capturing (#182)
---
book/en-us/03-runtime.md | 2 +-
book/zh-cn/03-runtime.md | 3 +--
2 files changed, 2 insertions(+), 3 deletions(-)
diff --git a/book/en-us/03-runtime.md b/book/en-us/03-runtime.md
index a3efdf63..3a10ac53 100644
--- a/book/en-us/03-runtime.md
+++ b/book/en-us/03-runtime.md
@@ -114,7 +114,7 @@ void lambda_expression_capture() {
}
```
-In the above code, `important` is an exclusive pointer that cannot be caught.
+In the above code, `important` is an exclusive pointer that cannot be caught by value capture using `=`.
At this time we need to transfer it to the rvalue and
initialize it in the expression.
diff --git a/book/zh-cn/03-runtime.md b/book/zh-cn/03-runtime.md
index 2c880375..87612c17 100644
--- a/book/zh-cn/03-runtime.md
+++ b/book/zh-cn/03-runtime.md
@@ -102,8 +102,7 @@ int main() {
}
```
-在上面的代码中,`important` 是一个独占指针,是不能够被捕获到的,这时候我们需要将其转移为右值,
-在表达式中初始化。
+在上面的代码中,important 是一个独占指针,是不能够被 "=" 值捕获到,这时候我们可以将其转移为右值,在表达式中初始化。
### 泛型 Lambda
From 45bef893a7edd728af9a019e8e06582e4b8a3287 Mon Sep 17 00:00:00 2001
From: obweix <55910226+obweix@users.noreply.github.com>
Date: Fri, 16 Apr 2021 15:01:20 +0800
Subject: [PATCH 28/92] book: typo fixes (#183)
---
book/zh-cn/07-thread.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/book/zh-cn/07-thread.md b/book/zh-cn/07-thread.md
index c41bcc26..f5c67cb5 100644
--- a/book/zh-cn/07-thread.md
+++ b/book/zh-cn/07-thread.md
@@ -66,7 +66,7 @@ int main() {
}
```
-由于 C++ 保证了所有栈对象在声明周期结束时会被销毁,所以这样的代码也是异常安全的。
+由于 C++ 保证了所有栈对象在生命周期结束时会被销毁,所以这样的代码也是异常安全的。
无论 `critical_section()` 正常返回、还是在中途抛出异常,都会引发堆栈回退,也就自动调用了 `unlock()`。
而 `std::unique_lock` 则相对于 `std::lock_guard` 出现的,`std::unique_lock` 更加灵活,
From 731a219d89c99047db230873f70cd9972179f57b Mon Sep 17 00:00:00 2001
From: Nikhil Garuda <34582615+Nikhil0504@users.noreply.github.com>
Date: Sun, 18 Apr 2021 15:42:26 +0530
Subject: [PATCH 29/92] book: typo and grammar fixes (#185)
---
book/en-us/00-preface.md | 20 +--
book/en-us/01-intro.md | 18 +-
book/en-us/02-usability.md | 50 +++---
book/en-us/03-runtime.md | 260 ++++++++++++++---------------
book/en-us/04-containers.md | 32 ++--
book/en-us/05-pointers.md | 26 +--
book/en-us/06-regex.md | 74 ++++-----
book/en-us/07-thread.md | 316 ++++++++++++++++++------------------
book/en-us/09-others.md | 60 ++++---
book/en-us/10-cpp20.md | 22 +--
10 files changed, 435 insertions(+), 443 deletions(-)
diff --git a/book/en-us/00-preface.md b/book/en-us/00-preface.md
index ae620ce4..83835094 100644
--- a/book/en-us/00-preface.md
+++ b/book/en-us/00-preface.md
@@ -13,33 +13,33 @@ order: 0
C++ user group is fairly large. From the advent of C++98 to the official finalization of C++11, it has accumulated over a decade. C++14/17 is an important complement and optimization for C++11, and C++20 brings this language to the door of modernization. The extended features of all these new standards are given to the C++ language. Infused with new vitality.
C++ programmers, who are still using **traditional C++** (this book refers to C++98 and its previous C++ standards as traditional C++), may even amazed by the fact that they are not using the same language while reading modern C++ code.
-**Modern C++** (this book refers to C++11/14/17/20) introduces a lot of features into traditional C++, which makes the whole C++ become language that modernized. Modern C++ not only enhances the usability of the C++ language itself, but the modification of the `auto` keyword semantics gives us more confidence in manipulating extremely complex template types. At the same time, a lot of enhancements have been made to the language runtime. The emergence of Lambda expressions has made C++ have the "closure" feature of "anonymous functions", which is almost in modern programming languages (such as Python/Swift/.. It has become commonplace, and the emergence of rvalue references has solved the problem of temporary object efficiency that C++ has long been criticized.
+**Modern C++** (this book refers to C++11/14/17/20) introduces a lot of features into traditional C++, which makes the whole C++ become a language that modernized. Modern C++ not only enhances the usability of the C++ language itself, but the modification of the `auto` keyword semantics gives us more confidence in manipulating extremely complex template types. At the same time, a lot of enhancements have been made to the language runtime. The emergence of Lambda expressions has made C++ have the "closure" feature of "anonymous functions", which is almost in modern programming languages (such as Python, Swift, etc). It has become commonplace, and the emergence of rvalue references has solved the problem of temporary object efficiency that C++ has long been criticized for.
C++17 is the direction that has been promoted by the C++ community in the past three years. It also points out an important development direction of **modern C++** programming. Although it does not appear as much as C++11, it contains a large number of small and beautiful languages and features (such as structured binding), and the appearance of these features once again corrects our programming paradigm in C++.
-Modern C++ also adds a lot of tools and methods to its own standard library, such as `std::thread` at the level of the language itself, which supports concurrent programming and no longer depends on the underlying system on different platforms. The API implements cross-platform support at the language level; `std::regex` provides full regular expression support and more. C++98 has been proven to be a very successful "paradigm", and the emergence of modern C++ further promotes this paradigm, making C++ a better language for system programming and library development. Concepts provide verification on the compile-time of template parameters, further enhancing the usability of the language.
+Modern C++ also adds a lot of tools and methods to its standard library, such as `std::thread` at the level of the language itself, which supports concurrent programming and no longer depends on the underlying system on different platforms. The API implements cross-platform support at the language level; `std::regex` provides full regular expression support and more. C++98 has been proven to be a very successful "paradigm", and the emergence of modern C++ further promotes this paradigm, making C++ a better language for system programming and library development. Concepts verify the compile-time of template parameters, further enhancing the usability of the language.
In conclusion, as an advocate and practitioner of C++, we always maintain an open mind to accept new things, and we can promote the development of C++ faster, making this old and novel language more vibrant.
## Targets
-- This book assumes that readers are already familiar with traditional C++ (i.e. C++98 or earlier), at least they do not have any difficulty in reading traditional C++ code. In other words, those who have long experience in traditional C++ and people who desire to quickly understand the features of modern C++ in a short period of time are well suited to read the book;
+- This book assumes that readers are already familiar with traditional C++ (i.e. C++98 or earlier), at least they do not have any difficulty in reading traditional C++ code. In other words, those who have long experience in traditional C++ and people who desire to quickly understand the features of modern C++ in a short period are well suited to read the book;
-- This book introduces to a certain extent of the dark magic of modern C++. However, these magics are very limited, they are not suitable for readers who want to learn advanced C++. The purpose of this book is offering a quick start for modern C++. Of course, advanced readers can also use this book to review and examine themselves on modern C++.
+- This book introduces to a certain extent of the dark magic of modern C++. However, these magics are very limited, they are not suitable for readers who want to learn advanced C++. The purpose of this book is to offer a quick start for modern C++. Of course, advanced readers can also use this book to review and examine themselves on modern C++.
## Purpose
-The book claims "On the Fly". Its intent is to provide a comprehensive introduction to the relevant features regarding modern C++ (before 2020s).
+The book claims "On the Fly". It intends to provide a comprehensive introduction to the relevant features regarding modern C++ (before the 2020s).
Readers can choose interesting content according to the following table of content to learn and quickly familiarize the new features you would like to learn.
-Readers should aware that all of these features are not required. It should be learnt when you really need it.
+Readers should aware that all of these features are not required. It should be learned when you need it.
-At the same time, instead of grammar-only, the book introduces the historical background as simple as possible of its technical requirements, which provides great help in understanding why these features comes out.
+At the same time, instead of grammar-only, the book introduces the historical background as simple as possible of its technical requirements, which provides great help in understanding why these features come out.
-In addition, The author would like to encourage that readers should be able to use modern C++ directly in their new projects and migrate their old projects to modern C++ gradually after read the book.
+Also, the author would like to encourage that readers should be able to use modern C++ directly in their new projects and migrate their old projects to modern C++ gradually after reading the book.
## Code
-Each chapter of this book has a lot of code. If you encounter problems when writing your own code with the introductory features of the book, you might as well read the source code attached to the book. You can find the book [here](../../code). All the code organized by chapter, the folder name is the chapter number.
+Each chapter of this book has a lot of code. If you encounter problems when writing your own code with the introductory features of the book, you might as well read the source code attached to the book. You can find the book [here](../../code). All the code is organized by chapter, the folder name is the chapter number.
## Exercises
@@ -49,4 +49,4 @@ There are few exercises At the end of each chapter of the book. It is for testin
## Licenses
-
This work was written by [Ou Changkun](https://changkun.de) and licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. The code of this repository is open sourced under the [MIT license](../../LICENSE).
\ No newline at end of file
+
This work was written by [Ou Changkun](https://changkun.de) and licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. The code of this repository is open sourced under the [MIT license](../../LICENSE).
diff --git a/book/en-us/01-intro.md b/book/en-us/01-intro.md
index c28197f9..e31087bb 100644
--- a/book/en-us/01-intro.md
+++ b/book/en-us/01-intro.md
@@ -8,7 +8,7 @@ order: 1
[TOC]
-**Compilation Environment**: This book will use `clang++` as the only compiler used,
+**Compilation Environment**: This book will use `clang++` as the only compiler used,
and always use the `-std=c++2a` compilation flag in your code.
```bash
@@ -21,15 +21,15 @@ InstalledDir: /Library/Developer/CommandLineTools/usr/bin
## 1.1 Deprecated Features
-Before learning modern C++, let's take a look at the main features that have been deprecated since C++11:
+Before learning modern C++, let's take a look at the main features that have deprecated since C++11:
-> **Note**: Deprecation is not completely unusable, it is only intended to imply that features will disappear from future standards and should be avoided. However, the deprecated features are still part of the standard library, and most of the features are actually "permanently" reserved for compatibility reasons.
+> **Note**: Deprecation is not completely unusable, it is only intended to imply that features will disappear from future standards and should be avoided. But, the deprecated features are still part of the standard library, and most of the features are actually "permanently" reserved for compatibility reasons.
- **The string literal constant is no longer allowed to be assigned to a `char *`. If you need to assign and initialize a `char *` with a string literal constant, you should use `const char *` or `auto`.**
- ```cpp
- char *str = "hello world!"; // A deprecation warning will appear
- ```
+ ```cpp
+ char *str = "hello world!"; // A deprecation warning will appear
+ ```
- **C++98 exception description, `unexpected_handler`, `set_unexpected()` and other related features are deprecated and should use `noexcept`.**
@@ -47,11 +47,11 @@ Before learning modern C++, let's take a look at the main features that have bee
- ... and many more
-There are also other features such as parameter binding (C++11 provides `std::bind` and `std::function`), `export`, and etc. are also deprecated. These features mentioned above **If you have never used or heard of it, please don't try to understand them. You should move closer to the new standard and learn new features directly**. After all, technology is moving forward.
+There are also other features such as parameter binding (C++11 provides `std::bind` and `std::function`), `export` etc. are also deprecated. These features mentioned above **If you have never used or heard of it, please don't try to understand them. You should move closer to the new standard and learn new features directly**. After all, technology is moving forward.
## 1.2 Compatibilities with C
-For some force majeure and historical reasons, we had to use some C code (even old C code) in C++, for example, Linux system calls. Before the advent of modern C++, most people talked about "what is the difference between C and C++". Generally speaking, in addition to answering the object-oriented class features and the template features of generic programming, there is no other opinion, or even a direct answer. "Almost" is also a lot of people. The Venn diagram in Figure 1.2 roughly answers the C and C++ related compatibility.
+For some force majeure and historical reasons, we had to use some C code (even old C code) in C++, for example, Linux system calls. Before the advent of modern C++, most people talked about "what is the difference between C and C++". Generally speaking, in addition to answering the object-oriented class features and the template features of generic programming, there is no other opinion or even a direct answer. "Almost" is also a lot of people. The Venn diagram in Figure 1.2 roughly answers the C and C++ related compatibility.

@@ -121,7 +121,7 @@ clean:
rm -rf *.o $(TARGET)
```
-> Note: Indentation in `Makefile` is a tab instead of a space character. If you copy this code directly into your editor, the tab may be automatically replaced. Please ensure the indentation in the `Makefile`. It is done by tabs.
+> **Note**: Indentation in `Makefile` is a tab instead of a space character. If you copy this code directly into your editor, the tab may be automatically replaced. Please ensure the indentation in the `Makefile` is done by tabs.
>
> If you don't know the use of `Makefile`, it doesn't matter. In this tutorial, you won't build code that is written too complicated. You can also read this book by simply using `clang++ -std=c++2a` on the command line.
diff --git a/book/en-us/02-usability.md b/book/en-us/02-usability.md
index e2aadf84..66ff6a46 100644
--- a/book/en-us/02-usability.md
+++ b/book/en-us/02-usability.md
@@ -92,12 +92,11 @@ We will discuss them in detail later in the [decltype](#decltype) section.
### constexpr
-C++ itself already has the concept of constant expressions,
-such as 1+2, 3*4. Such expressions always produce the same result
-without any side effects. If the compiler can directly optimize
-and embed these expressions into the program at compile time,
-it will increase the performance of the program.
-A very obvious example is in the definition phase of an array:
+C++ itself already has the concept of constant expressions, such as 1+2,
+3\*4. Such expressions always produce the same result without any side effects.
+If the compiler can directly optimize and embed these expressions into the program at
+compile-time, it will increase the performance of the program. A very obvious example
+is in the definition phase of an array:
```cpp
#include
@@ -147,14 +146,14 @@ we need to use the `constexpr` feature introduced in C++11, which will be introd
to solve this problem; for `arr_5`, before C++98 The compiler cannot know that `len_foo()`
actually returns a constant at runtime, which causes illegal production.
-> Note that most compilers now have their own compiler optimizations.
+> Note that most compilers now have their compiler optimizations.
> Many illegal behaviors become legal under the compiler's optimization.
> If you need to reproduce the error, you need to use the old version of the compiler.
C++11 provides `constexpr` to let the user explicitly declare that the function or
object constructor will become a constant expression at compile time.
This keyword explicitly tells the compiler that it should verify that `len_foo`
-should be a compile time constant expression. Constant expression.
+should be a compile-time constant expression. Constant expression.
In addition, the function of `constexpr` can use recursion:
@@ -240,7 +239,7 @@ Initialization is a very important language feature,
the most common one is when the object is initialized.
In traditional C++, different objects have different initialization methods,
such as ordinary arrays, PODs (**P**lain **O**ld **D**ata,
-ie classes without constructs, destructors, and virtual functions)
+i.e. classes without constructs, destructors, and virtual functions)
Or struct type can be initialized with `{}`,
which is what we call the initialization list.
For the initialization of the class object,
@@ -332,7 +331,7 @@ provided in other languages. In the chapter on containers,
we will learn that C++11 has added a `std::tuple` container for
constructing a tuple that encloses multiple return values. But the flaw
is that C++11/14 does not provide a simple way to get and define
-the elements in the tuple directly from the tuple,
+the elements in the tuple from the tuple,
although we can unpack the tuple using `std::tie`
But we still have to be very clear about how many objects this tuple contains,
what type of each object is, very troublesome.
@@ -360,7 +359,7 @@ The `auto` type derivation is described in the
## 2.3 Type inference
-In traditional C and C++, the types of parameters must be clearly defined, which does not help us to quickly encode, especially when we are faced with a large number of complex template types, we must clearly indicate the type of variables in order to proceed. Subsequent coding, which not only slows down our development efficiency, but also makes the code stinking and long.
+In traditional C and C++, the types of parameters must be clearly defined, which does not help us to quickly encode, especially when we are faced with a large number of complex template types, we must indicate the type of variables to proceed. Subsequent coding, which not only slows down our development efficiency but also makes the code stinking and long.
C++11 introduces the two keywords `auto` and `decltype` to implement type derivation, letting the compiler worry about the type of the variable. This makes C++ the same as other modern programming languages, in a way that provides the habit of not having to worry about variable types.
@@ -415,6 +414,7 @@ auto arr = new auto(10); // arr as int *
> **Note**: `auto` cannot be used for function arguments, so the following
> is not possible to compile (considering overloading,
> we should use templates):
+>
> ```cpp
> int add(auto x, auto y);
>
@@ -437,7 +437,6 @@ auto arr = new auto(10); // arr as int *
The `decltype` keyword is used to solve the defect that the auto keyword
can only type the variable. Its usage is very similar to `typeof`:
-
```cpp
decltype(expression)
```
@@ -485,9 +484,9 @@ R add(T x, U y) {
> Note: There is no difference between typename and class in the template parameter list. Before the keyword typename appears, class is used to define the template parameters. However, when defining a variable with [nested dependency type](http://en.cppreference.com/w/cpp/language/dependent_name#The_typename_disambiguator_for_dependent_names) in the template, you need to use typename to eliminate ambiguity.
-Such code is actually very ugly, because the programmer must explicitly
+Such code is very ugly because the programmer must explicitly
indicate the return type when using this template function.
-But in fact we don't know what kind of operation
+But in fact, we don't know what kind of operation
the `add()` function will do, and what kind of return type to get.
This problem was solved in C++11. Although you may immediately
@@ -583,7 +582,7 @@ decltype(auto) look_up_a_string_2() {
### if constexpr
-As we saw at the beginning of this chapter, we know that C++11 introduces the `constexpr` keyword, which compiles expressions or functions into constant results. A natural idea is that if we introduce this feature into the conditional judgment, let the code complete the branch judgment at compile time, can it make the program more efficient? C++17 introduces the `constexpr` keyword into the `if` statement, allowing you to declare the condition of a constant expression in your code. Consider the following code:
+As we saw at the beginning of this chapter, we know that C++11 introduces the `constexpr` keyword, which compiles expressions or functions into constant results. A natural idea is that if we introduce this feature into the conditional judgment, let the code complete the branch judgment at compile-time, can it make the program more efficient? C++17 introduces the `constexpr` keyword into the `if` statement, allowing you to declare the condition of a constant expression in your code. Consider the following code:
```cpp
#include
@@ -619,7 +618,7 @@ int main() {
### Range-based for loop
-Finally, C++11 introduces a range-based iterative method, and we have the ability to write loops that are as concise
+Finally, C++11 introduces a range-based iterative method, and we can write loops that are as concise
as Python, and we can further simplify the previous example:
```cpp
@@ -642,7 +641,7 @@ int main() {
## 2.5 Templates
-C++ templates have always been a special art of the language, and templates can even be used independently as a new language. The philosophy of the template is to throw all the problems that can be processed at compile time into the compile time, and only deal with those core dynamic services at runtime, so as to greatly optimize the performance of the runtime. Therefore, templates are also regarded by many as one of the black magic of C++.
+C++ templates have always been a special art of the language, and templates can even be used independently as a new language. The philosophy of the template is to throw all the problems that can be processed at compile time into the compile time, and only deal with those core dynamic services at runtime, to greatly optimize the performance of the runtime. Therefore, templates are also regarded by many as one of the black magic of C++.
### Extern templates
@@ -697,7 +696,7 @@ typedef MagicType, std::string> FakeDarkMagic;
C++11 uses `using` to introduce the following form of writing, and at the same time supports the same effect as the traditional `typedef`:
-> Usually we use `typedef` to define the alias syntax: `typedef original name new name; `, but the definition syntax for aliases such as function pointers is different, which usually causes a certain degree of difficulty for direct reading.
+> Usually, we use `typedef` to define the alias syntax: `typedef original name new name; `, but the definition syntax for aliases such as function pointers is different, which usually causes a certain degree of difficulty for direct reading.
```cpp
typedef int (*process)(void *);
@@ -746,7 +745,7 @@ and there is no need to fix the number of parameters when defining.
template class Magic;
```
-The template class Magic object can accept unrestricted number of typename as
+The template class Magic object can accept an unrestricted number of typename as
a formal parameter of the template, such as the following definition:
```cpp
@@ -799,7 +798,6 @@ the parameter package, but there are two classic processing methods:
Recursion is a very easy way to think of and the most classic approach. This method continually recursively passes template parameters to the function, thereby achieving the purpose of recursively traversing all template parameters:
-
```cpp
#include
template
@@ -833,7 +831,7 @@ void printf2(T0 t0, T... t) {
**3. Initialize list expansion**
-Recursive template functions are a standard practice, but the obvious drawback is that you must define a function that terminates recursion.
+Recursive template functions are standard practice, but the obvious drawback is that you must define a function that terminates recursion.
Here is a description of the black magic that is expanded using the initialization list:
@@ -880,7 +878,7 @@ auto add(T t, U u) {
The parameters of the template `T` and `U` are specific types.
But there is also a common form of template parameter that allows different literals
-to be template parameters, ie non-type template parameters:
+to be template parameters, i.e. non-type template parameters:
```cpp
template
@@ -896,7 +894,7 @@ buffer_t buf; // 100 as template parameter
```
In this form of template parameters, we can pass `100` as a parameter to the template.
-After C++11 introduced the feature of type derivation, we will naturally ask, since the template parameters here
+After C++11 introduced the feature of type derivation, we will naturally ask, since the template parameters here.
Passing with a specific literal, can the compiler assist us in type derivation,
By using the placeholder `auto`, there is no longer a need to explicitly specify the type?
Fortunately, C++17 introduces this feature, and we can indeed use the `auto` keyword to let the compiler assist in the completion of specific types of derivation.
@@ -1022,7 +1020,7 @@ struct SubClass3: Base {
### Explicit delete default function
-In traditional C++, if the programmer does not provide it, the compiler will default to generating default constructors, copy constructs, assignment operators, and destructors for the object. In addition, C++ also defines operators such as `new` `delete` for all classes. This part of the function can be overridden when the programmer needs it.
+In traditional C++, if the programmer does not provide it, the compiler will default to generating default constructors, copy constructs, assignment operators, and destructors for the object. Besides, C++ also defines operators such as `new` `delete` for all classes. This part of the function can be overridden when the programmer needs it.
This raises some requirements: the ability to accurately control the generation of default functions cannot be controlled. For example, when copying a class is prohibited, the copy constructor and the assignment operator must be declared as `private`. Trying to use these undefined functions will result in compilation or link errors, which is a very unconventional way.
@@ -1041,7 +1039,7 @@ class Magic {
### Strongly typed enumerations
-In traditional C++, enumerated types are not type-safe, and enumerated types are treated as integers, which allows two completely different enumerated types to be directly compared (although the compiler gives the check, but not all) , ** Even the enumeration value names of different enum types in the same namespace cannot be the same**, which is usually not what we want to see.
+In traditional C++, enumerated types are not type-safe, and enumerated types are treated as integers, which allows two completely different enumerated types to be directly compared (although the compiler gives the check, but not all), ** Even the enumeration value names of different enum types in the same namespace cannot be the same**, which is usually not what we want to see.
C++11 introduces an enumeration class and declares it using the syntax of `enum class`:
@@ -1085,7 +1083,7 @@ std::cout << new_enum::value3 << std::endl
This section introduces the enhancements to language usability in modern C++, which I believe are the most important features that almost everyone needs to know and use:
-1. auto type derivation
+1. Auto type derivation
2. Scope for iteration
3. Initialization list
4. Variable parameter template
diff --git a/book/en-us/03-runtime.md b/book/en-us/03-runtime.md
index 3a10ac53..f7a71c97 100644
--- a/book/en-us/03-runtime.md
+++ b/book/en-us/03-runtime.md
@@ -10,9 +10,9 @@ order: 3
## 3.1 Lambda Expression
-Lambda expressions are one of the most important features in modern C++, and Lambda expressions actually provide a feature like anonymous functions.
-Anonymous functions are used when a function is needed, but you don’t want to use name to call a function. There are actually many, many scenes like this.
-So anonymous functions are almost standard on modern programming languages.
+Lambda expressions are one of the most important features in modern C++, and Lambda expressions provide a feature like anonymous functions.
+Anonymous functions are used when a function is needed, but you don’t want to use a name to call a function. There are many, many scenes like this.
+So anonymous functions are almost standard in modern programming languages.
### Basics
@@ -24,22 +24,22 @@ The basic syntax of a Lambda expression is as follows:
}
```
-The above grammar rules are well understood except for the things in `[capture list]`,
+The above grammar rules are well understood except for the things in `[capture list]`,
except that the function name of the general function is omitted.
-The return value is in the form of a `->`
+The return value is in the form of a `->`
(we have already mentioned this in the tail return type earlier in the previous section).
-The so-called capture list can be understood as a type of parameter.
-The internal function body of a lambda expression cannot use variables outside
+The so-called capture list can be understood as a type of parameter.
+The internal function body of a lambda expression cannot use variables outside
the body of the function by default.
-At this time, the capture list can serve to transfer external data.
-According to the behavior passed,
+At this time, the capture list can serve to transfer external data.
+According to the behavior passed,
the capture list is also divided into the following types:
#### 1. Value capture
-Similar to parameter passing, the value capture is based on the fact that
-the variable can be copied, except that the captured variable is copied
+Similar to parameter passing, the value capture is based on the fact that
+the variable can be copied, except that the captured variable is copied
when the lambda expression is created, not when it is called:
```cpp
@@ -76,13 +76,13 @@ void lambda_reference_capture() {
#### 3. Implicit capture
-Manually writing a capture list is sometimes very complicated.
-This mechanical work can be handled by the compiler.
-At this point, you can write a `&` or `=` to the compiler to
+Manually writing a capture list is sometimes very complicated.
+This mechanical work can be handled by the compiler.
+At this point, you can write a `&` or `=` to the compiler to
declare the reference or value capture.
-To summarize, capture provides the ability for lambda expressions
-to use external values. The four most common forms of
+To summarize, capture provides the ability for lambda expressions
+to use external values. The four most common forms of
capture lists can be:
- \[\] empty capture list
@@ -92,16 +92,16 @@ capture lists can be:
#### 4. Expression capture
-> This section needs to understand the rvalue references and smart pointers that
+> This section needs to understand the rvalue references and smart pointers that
> will be mentioned later.
-The value captures and reference captures mentioned above are variables that have been
-declared in the outer scope, so these capture methods capture the lvalue
+The value captures and reference captures mentioned above are variables that have been
+declared in the outer scope, so these capture methods capture the lvalue
and not capture the rvalue.
-C++14 gives us the convenience of allowing the captured members to be initialized
+C++14 gives us the convenience of allowing the captured members to be initialized
with arbitrary expressions, which allows the capture of rvalues.
-The type of the captured variable being declared is judged according to the expression,
+The type of the captured variable being declared is judged according to the expression,
and the judgment is the same as using `auto`:
```cpp
@@ -114,20 +114,20 @@ void lambda_expression_capture() {
}
```
-In the above code, `important` is an exclusive pointer that cannot be caught by value capture using `=`.
-At this time we need to transfer it to the rvalue and
+In the above code, `important` is an exclusive pointer that cannot be caught by value capture using `=`.
+At this time we need to transfer it to the rvalue and
initialize it in the expression.
### Generic Lambda
-In the previous section we mentioned that the `auto` keyword cannot be used
+In the previous section, we mentioned that the `auto` keyword cannot be used
in the parameter list because it would conflict with the functionality of the template.
But Lambda expressions are not ordinary functions, so Lambda expressions are not templated.
-This has caused us some trouble: the parameter table cannot be generalized,
+This has caused us some trouble: the parameter table cannot be generalized,
and the parameter table type must be clarified.
Fortunately, this trouble only exists in C++11, starting with C++14.
-The formal parameters of the Lambda function can use the `auto` keyword
+The formal parameters of the Lambda function can use the `auto` keyword
to generate generic meanings:
```cpp
@@ -135,7 +135,7 @@ void lambda_generic() {
auto generic = [](auto x, auto y) {
return x+y;
};
-
+
std::cout << generic(1, 2) << std::endl;
std::cout << generic(1.1, 2.2) << std::endl;
}
@@ -143,15 +143,15 @@ void lambda_generic() {
## 3.2 Function Object Wrapper
-Although the features are part of the standard library and not found in runtime,
+Although the features are part of the standard library and not found in runtime,
it enhances the runtime capabilities of the C++ language.
-This part of the content is also very important, so put it here for introduction.
+This part of the content is also very important, so put it here for the introduction.
### `std::function`
-The essence of a Lambda expression is an object of a class type (called a closure type)
+The essence of a Lambda expression is an object of a class type (called a closure type)
that is similar to a function object type (called a closure object).
-When the capture list of a Lambda expression is empty, the closure object
+When the capture list of a Lambda expression is empty, the closure object
can also be converted to a function pointer value for delivery, for example:
```cpp
@@ -170,20 +170,19 @@ int main() {
}
```
-The above code gives two different forms of invocation, one is to call Lambda
-as a function type, and the other is to directly call a Lambda expression.
-In C++11, these concepts are unified.
-The type of object that can be called is collectively called the callable type.
+The above code gives two different forms of invocation, one is to call Lambda
+as a function type, and the other is to directly call a Lambda expression.
+In C++11, these concepts are unified.
+The type of object that can be called is collectively called the callable type.
This type is introduced by `std::function`.
-C++11 `std::function` is a generic, polymorphic function wrapper
-whose instances can store, copy, and call any target entity that can be called.
-It is also an existing callable to C++. A type-safe package of entities (relatively,
-the call to a function pointer is not type-safe), in other words,
-a container of functions. When we have a container for functions,
+C++11 `std::function` is a generic, polymorphic function wrapper
+whose instances can store, copy, and call any target entity that can be called.
+It is also an existing callable to C++. A type-safe package of entities (relatively,
+the call to a function pointer is not type-safe), in other words,
+a container of functions. When we have a container for functions,
we can more easily handle functions and function pointers as objects. e.g:
-
```cpp
#include
#include