Quin és l'ús de la cadena C++ Constexpr?
L'ús de constexpr pot conduir a fitxers executables més compactes i optimitzats. Com que el compilador determina els valors per endavant, els binaris resultants poden ser de mida més petita, aconseguint un ús més econòmic dels recursos del sistema que al seu torn pot millorar el rendiment del programari en diverses plataformes. Un avantatge significatiu especial d'aquesta característica és la reducció que comporta els càlculs en temps d'execució. Com que els valors es calculen durant el procés de compilació sempre que sigui possible, l'avaluació del temps d'execució es fa menys necessària. Aquest augment de l'eficiència no només accelera l'execució, sinó que també racionalitza les operacions generals del programa.
Exemple 1: Ús de Constexpr en C++ per al càlcul factorial
En aquest exemple, farem servir constexpr que permet que els càlculs es realitzin en temps de compilació en lloc d'execució. En el context del càlcul de factorials, es pot aprofitar una operació matemàtica comuna, que és constexpr, per calcular valors factorials durant la compilació. Examinem i revisem el codi següent i després mirem l'explicació del codi:
#inclou
constexpr int factorial ( int n ) {
tornar n <= 1 ? 1 : ( n * factorial ( n - 1 ) ) ;
}
int principal ( ) {
int en una = 5 ;
std :: cout << 'Factorial de' << en una << ' = ' << factorial ( en una ) << std :: endl ;
}
L'exemple de codi donat demostra l'ús de constexpr per calcular el factorial d'un nombre de manera recursiva. El compilador és capaç d'avaluar l'expressió factorial en temps de compilació en aquest exemple perquè la funció factorial es declara i es defineix amb l'especificador constexpr. Utilitzant constexpr en un programa C++, el compilador avalua l'expressió factorial de 5 en temps de compilació, eliminant la necessitat de càlcul en temps d'execució.
Ara, vegem el desglossament detallat del codi amb detalls i explicacions específiques.
Primer, utilitzem #include
Després, passem a la funció factorial() (recursiva) que és 'constexpr int factorial(int n)'. Aquesta funció factorial() defineix una funció recursiva que calcula el factorial d'un nombre enter 'n'. Constexpr implica que les optimitzacions de rendiment poden resultar de l'avaluació de la funció durant la compilació.
El retorn n <= 1 ? 1 : la línia (n * factorial(n – 1)) utilitza una expressió condicional per a la recursivitat que indica que si “n” és menor o igual a 1, retorna 1 (cas base). Si no, fa el càlcul factorial (n! = n * (n-1)!), que és la fórmula general per calcular el factorial, anomenant-se repetidament amb “n – 1” i després multiplicant el resultat per “n ”. Aquestes línies actuen com un gatekeeper per al càlcul factorial. Comprova si el nombre està al nivell base i retorna 1 si és així. Si no, s'inicia una reacció en cadena de trucades de funcions, cadascuna treballant en números més petits fins que s'arriba al cas base. Aleshores, els resultats es multipliquen en ordre invers. El següent és la sortida del codi per a la vostra referència:
Exemple 2: comptant les lletres minúscules demostrant la cadena C++ Constexpr
Aquí, aprendrem a comptar el nombre de lletres minúscules mitjançant una cadena countexpr. En aquest exemple, el propòsit és comptar el nombre de lletres minúscules d'una cadena determinada mitjançant la funció constexpr per reduir el càlcul del temps d'execució. La funció countLowercase(), declarada com a constexpr, pren una cadena 'string_view' com a paràmetre i itera a través de cada caràcter de la cadena donada com a entrada. Per cada lletra minúscula que trobem, el recompte s'incrementa. Aleshores, el resultat s'obté en temps de compilació, ja que la funció opera amb expressions constants, mostrant els beneficis d'eficiència i rendiment de l'avaluació en temps de compilació. Primer, comproveu el codi següent. A continuació, passeu a l'explicació detallada:
#inclou#include
utilitzant l'espai de noms std ;
constexpr mida_t countMinúscules ( string_view s ) {
mida_t comptar = 0 ;
per ( char c : s ) {
si ( és més baix ( c ) ) {
comptar ++;
}
}
tornar comptar ;
}
int principal ( ) {
cout << 'Total de lletres minúscules en' Lletres minúscules 'són ='
<< countMinúscules ( 'Lletres minúscules' ) << endl ;
}
Aquí teniu un desglossament detallat del codi amb una explicació de cada línia:
S'inclou #include
A la funció countLowercase(), la funció 'constexpr size_t countlower(string_view s)', compta les lletres minúscules en una vista de cadena determinada. L'int main() és el punt d'entrada del programa que imprimeix un missatge que indica el nombre de lletres minúscules a 'Lower Case LeTtErS' i crida a la funció countLowercase() amb 'Lower Case LeTtErS' com a entrada i imprimeix el resultat. Consulteu la sortida següent del programa:
Exemple 3: demostració de matriu utilitzant el C++ Constexpr
Una demostració de matrius mostra com es creen, s'accedeix i es manipulen les matrius que són col·leccions estructurades d'elements del mateix tipus de dades dins d'un llenguatge de programació. A continuació, explicarem mitjançant un exemple de codificació en què el programa proporciona un exemple senzill d'inicialització i manipulació de matrius en temps de compilació.
Una demostració de matrius il·lustra el concepte de matrius, una col·lecció estructurada d'elements que comparteixen el mateix tipus de dades, i com es poden crear, accedir i manipular mitjançant un llenguatge de programació. En el següent exemple de codificació, demostrarem com inicialitzar una matriu en temps de compilació, calcular-ne la mida i imprimir els elements de la matriu donada. Vegeu el següent codi donat i aneu a l'explicació:
#inclouutilitzant l'espai de noms std ;
int principal ( ) {
constexpr int arrayint [ 9 ] = { 5 , 55 , 555 , 5555 , 55555 } ;
constexpr int size_array = mida de arrayint / mida de ( int ) ;
cout << 'La longitud de la matriu és = ' << size_array << endl ;
cout << 'Els elements de la matriu són = ' ;
per ( int i = 0 ; i < size_array ; ++ i ) {
cout << arrayint [ i ] << ' ' ;
}
}
Aquest programa inicialitza una matriu constexpr, calcula la seva longitud en temps de compilació i després imprimeix la longitud i els elements de la matriu a la consola. Constexpr assegura que la matriu i les seves propietats es determinen en temps de compilació. Trenquem el codi i expliquem els detalls específics un per un:
Per incloure la biblioteca de flux d'entrada-sortida estàndard, que permet l'ús de funcions com 'cout' per a la sortida, s'anomena #include
Un bucle 'for' itera a través dels elements de la matriu 'arrayint[]', i els valors s'imprimeixen a la consola. Vegem la següent sortida del codi donat:
Conclusió
La introducció i l'evolució de la paraula clau constexpr en C++ han revolucionat la manera com es gestionen les expressions i els valors constants. Aquest article va explorar tres exemples pràctics, mostrant el poder de constexpr en calcular factorials, comptar les lletres minúscules i inicialitzar les matrius en temps de compilació. Els punts clau inclouen un rendiment millorat, càlculs de temps d'execució reduïts i una millora de l'eficiència de la memòria. Constexpr és un actiu valuós per crear entitats fiables i constants dins d'una base de codi, assegurant la immutabilitat i contribuint a programes més eficients i eficients.