Ano ang Paggamit ng C++ Constexpr String?
Ang paggamit ng constexpr ay maaaring humantong sa mas compact at na-optimize na mga executable na file. Dahil ang mga halaga ay natukoy nang maaga ng compiler, ang mga resultang binary ay maaaring maging mas maliit sa laki, na napagtatanto ang isang mas matipid na paggamit ng mga mapagkukunan ng system na kung saan ay maaaring mapahusay ang pagganap ng software sa iba't ibang mga platform. Ang isang espesyal na makabuluhang bentahe ng tampok na ito ay ang pagbabawas na dulot nito sa mga pagkalkula ng runtime. Habang ang mga halaga ay kinakalkula sa panahon ng proseso ng pagsasama-sama sa tuwing magagawa, ang pagsusuri ng runtime ay nagiging hindi gaanong kinakailangan. Ang pagpapalakas ng kahusayan na ito ay hindi lamang nagpapabilis sa pagpapatupad ngunit pinapadali rin ang pangkalahatang mga operasyon ng programa.
Halimbawa 1: Paggamit ng Constexpr sa C++ para sa Factorial Calculation
Sa halimbawang ito, gagamitin namin ang constexpr na nagbibigay-daan sa pag-compute na maisagawa sa compile-time kaysa sa run-time. Sa konteksto ng pagkalkula ng mga factorial, ang isang karaniwang operasyong matematika, na constexpr, ay maaaring gamitin upang makalkula ang mga factorial na halaga sa panahon ng pagsasama-sama. Suriin at suriin natin ang sumusunod na code at pagkatapos ay tingnan ang paliwanag ng code:
#include
constexpr int factorial ( int n ) {
bumalik n <= 1 ? 1 : ( n * factorial ( n - 1 ) ) ;
}
int pangunahing ( ) {
int sa isa = 5 ;
std :: cout << 'Factorial ng' << sa isa << '=' << factorial ( sa isa ) << std :: endl ;
}
Ang ibinigay na halimbawa ng code ay nagpapakita ng paggamit ng constexpr para sa pagkalkula ng factorial ng isang numero sa isang recursive na paraan. Nasusuri ng compiler ang factorial expression sa compile-time sa halimbawang ito dahil ang factorial function ay idineklara at tinukoy gamit ang constexpr specifier. Gamit ang constexpr sa isang C++ na programa, sinusuri ng compiler ang factorial expression ng 5 sa compile-time, inaalis ang pangangailangan para sa runtime computation.
Ngayon, tingnan natin ang detalyadong breakdown ng code na may mga partikular na detalye at paliwanag.
Una, ginagamit namin ang #include
Pagkatapos, lumipat tayo sa factorial() function (recursive) na 'constexpr int factorial(int n)'. Ang factorial() function na ito ay tumutukoy sa isang recursive function na kinakalkula ang factorial ng isang “n” integer. Ipinahihiwatig ng Constexpr na ang mga pag-optimize ng pagganap ay maaaring magresulta mula sa pagsusuri ng function sa panahon ng compilation.
Ang pagbabalik n <= 1 ? 1 : (n * factorial(n – 1)) na linya ay gumagamit ng conditional expression para sa recursion na nagsasaad na kung ang “n” ay mas mababa o katumbas ng 1, ito ay nagbabalik ng 1 (base case). Kung hindi, ginagawa nito ang factorial computation (n! = n * (n-1)!), na siyang pangkalahatang formula para sa pag-compute ng factorial, sa pamamagitan ng paulit-ulit na pagtawag sa sarili nito ng “n – 1” at pagkatapos ay pagpaparami ng resulta sa “n ”. Ang mga linyang ito ay kumikilos tulad ng isang gatekeeper para sa factorial na pagkalkula. Sinusuri nito kung ang numero ay nasa base level at nagbabalik ng 1 kung gayon. Kung hindi, magsisimula ito ng chain reaction ng mga function call, ang bawat isa ay gumagana sa mas maliliit na numero hanggang sa maabot ang base case. Pagkatapos, ang mga resulta ay pinarami nang sama-sama sa reverse order. Ang sumusunod ay ang output ng code para sa iyong sanggunian:
Halimbawa 2: Pagbibilang ng Mga Maliit na Titik na Nagpapakita ng C++ Constexpr String
Dito, matututunan natin kung paano bilangin ang bilang ng mga maliliit na titik gamit ang isang countexpr string. Sa halimbawang ito, ang layunin ay bilangin ang bilang ng mga maliliit na titik sa isang naibigay na string gamit ang tampok na constexpr upang bawasan ang runtime computation. Ang countLowercase() function, na idineklara bilang constexpr, ay kumukuha ng string na 'string_view' bilang parameter nito at umuulit sa bawat character ng ibinigay na string bilang input. Para sa bawat maliliit na titik na aming nararanasan, ang bilang ay dinadagdagan. Pagkatapos ay makukuha ang resulta sa oras ng pag-compile habang gumagana ang function sa mga pare-parehong expression, na nagpapakita ng kahusayan at mga benepisyo ng pagganap ng compile-time na pagsusuri. Una, suriin ang sumusunod na code. Pagkatapos, magpatuloy sa detalyadong paliwanag:
#include#include
gamit ang namespace std ;
constexpr laki_t countLowercase ( string_view s ) {
laki_t bilangin = 0 ;
para sa ( char c : s ) {
kung ( mas mababa ( c ) ) {
bilangin ++;
}
}
bumalik bilangin ;
}
int pangunahing ( ) {
cout << 'Kabuuang maliliit na titik sa ' MABABANG KASE LETtErS 'ay ='
<< countLowercase ( 'MABABANG KASE LETTERS' ) << endl ;
}
Narito ang isang detalyadong breakdown ng code na may paliwanag ng bawat linya:
Ang #include
Sa function na countLowercase(), ang function na 'constexpr size_t countlower(string_view s)', ay binibilang ang mga maliliit na titik sa isang ibinigay na string view. Ang int main() ay entry point ng program na nagpi-print ng mensahe na nagsasaad ng bilang ng mga maliliit na titik sa “LoWeR CaSe LeTtErS” at tinatawag ang countLowercase() function na may “LoWeR CaSe LeTtErS” bilang input at ini-print ang resulta. Sumangguni sa sumusunod na output ng programa:
Halimbawa 3: Array Demonstration sa pamamagitan ng Paggamit ng C++ Constexpr
Ang isang array demonstration ay nagpapakita kung paano ang mga array na mga structured na koleksyon ng mga elemento ng parehong uri ng data ay ginawa, ina-access, at manipulahin sa loob ng isang programming language. Sa mga sumusunod, ipapaliwanag namin sa pamamagitan ng isang halimbawa ng coding kung saan ang programa ay nagbibigay ng isang simpleng halimbawa ng pagsisimula at pagmamanipula ng array-time na array.
Inilalarawan ng isang array demonstration ang konsepto ng mga array—isang structured na koleksyon ng mga elemento na may parehong uri ng data—at kung paano sila malilikha, ma-access, at mamanipula gamit ang isang programming language. Sa sumusunod na halimbawa ng coding, ipapakita namin kung paano simulan ang isang array sa oras ng pag-compile, kalkulahin ang laki nito, at i-print ang mga elemento ng ibinigay na array. Tingnan ang sumusunod na ibinigay na code at magpatuloy sa paliwanag:
#includegamit ang namespace std ;
int pangunahing ( ) {
constexpr int arrayint [ 9 ] = { 5 , 55 , 555 , 5555 , 55555 } ;
constexpr int size_array = sukat ng arrayint / sukat ng ( int ) ;
cout << 'Ang haba ng Array ay =' << size_array << endl ;
cout << 'Ang mga elemento sa array ay =' ;
para sa ( int i = 0 ; i < size_array ; ++ i ) {
cout << arrayint [ i ] << '' ;
}
}
Nagsisimula ang program na ito ng constexpr array, kinakalkula ang haba nito sa oras ng pag-compile, at pagkatapos ay ipi-print ang haba at mga elemento ng array sa console. Tinitiyak ng Constexpr na ang array at ang mga katangian nito ay tinutukoy sa oras ng pag-compile. Hatiin natin ang code at ipaliwanag ang mga partikular na detalye nang paisa-isa:
Upang isama ang karaniwang input-output stream library, na nagpapahintulot sa paggamit ng mga function tulad ng 'cout' para sa output, ang #include
Ang isang 'para sa' loop ay umuulit sa pamamagitan ng mga elemento ng 'arrayint[]' array, at ang mga halaga ay ipi-print sa console. Tingnan natin ang sumusunod na output ng ibinigay na code:
Konklusyon
Binago ng pagpapakilala at ebolusyon ng constexpr keyword sa C++ kung paano pinangangasiwaan ang mga pare-parehong expression at value. Ang artikulong ito ay nag-explore ng tatlong praktikal na halimbawa, na nagpapakita ng kapangyarihan ng constexpr sa pag-compute ng mga factorial, pagbibilang ng mga maliliit na titik, at pagsisimula ng mga array sa oras ng pag-compile. Kabilang sa mga pangunahing takeaway ang pinahusay na pagganap, pinababang mga kalkulasyon ng runtime, at pinahusay na kahusayan sa memorya. Ang Constexpr ay isang mahalagang asset para sa paglikha ng maaasahan at patuloy na mga entity sa loob ng isang codebase, na tinitiyak ang hindi nababago at nag-aambag sa mas streamline at mahusay na mga programa.