Exemplos de strings Constexpr em C++

Exemplos De Strings Constexpr Em C



Este artigo discutirá sobre constexpr, uma adição notável à linguagem de programação C++ que é introduzida no C++ 11 e aprimorada ainda mais no C++ 14, e sinaliza ao compilador que uma variável, função ou construtor de objeto é uma compilação. tempo constante. Ele revolucionou a forma como os desenvolvedores criam e manipulam as constantes. Através do constexpr, os desenvolvedores podem definir as expressões e valores que são imutáveis ​​e avaliados durante a compilação e não em tempo de execução. O benefício geral de incorporar constexpr ao código é a garantia de constância.

Qual é o uso da string C++ Constexpr?

A utilização do constexpr pode levar a arquivos executáveis ​​mais compactos e otimizados. Como os valores são determinados antecipadamente pelo compilador, os binários resultantes podem ser menores em tamanho, possibilitando um uso mais econômico dos recursos do sistema, o que por sua vez pode melhorar o desempenho do software em diversas plataformas. Uma vantagem especial significativa desse recurso é a redução que ele traz aos cálculos de tempo de execução. Como os valores são calculados durante o processo de compilação sempre que possível, a avaliação em tempo de execução torna-se menos necessária. Este aumento de eficiência não só acelera a execução, mas também agiliza as operações gerais do programa.

Exemplo 1: Usando Constexpr em C++ para cálculo fatorial

Neste exemplo, usaremos constexpr que permite que os cálculos sejam realizados em tempo de compilação e não em tempo de execução. No contexto do cálculo de fatoriais, uma operação matemática comum, que é constexpr, pode ser aproveitada para calcular valores fatoriais durante a compilação. Vamos examinar e revisar o código a seguir e, em seguida, dar uma olhada na explicação do código:







#include

constexpr interno fatorial ( interno n ) {

retornar n <= 1 ? 1 : ( n * fatorial ( n - 1 ) ) ;

}

interno principal ( ) {

interno num = 5 ;

padrão :: corte << 'Fatorial de' << num << '=' << fatorial ( num ) << padrão :: fim ;

}

O exemplo de código fornecido demonstra o uso de constexpr para calcular o fatorial de um número de forma recursiva. O compilador é capaz de avaliar a expressão fatorial em tempo de compilação neste exemplo porque a função fatorial é declarada e definida com o especificador constexpr. Usando constexpr em um programa C++, o compilador avalia a expressão fatorial de 5 em tempo de compilação, eliminando a necessidade de cálculo em tempo de execução.



Agora, vamos ver o detalhamento do código com detalhes e explicações específicas.



Primeiro, usamos #include para incorporar o arquivo de cabeçalho “iostream” que fornece funcionalidades essenciais de entrada e saída como “std::cout” para impressão no console.





Depois, passamos para a função factorial() (recursiva) que é “constexpr int factorial(int n)”. Esta função factorial() define uma função recursiva que calcula o fatorial de um número inteiro “n”. Constexpr implica que otimizações de desempenho podem resultar da avaliação da função durante a compilação.

O retorno n <= 1 ? 1: a linha (n * factorial (n – 1)) emprega uma expressão condicional para recursão que afirma que se “n” for menor ou igual a 1, ele retorna 1 (caso base). Caso contrário, ele faz o cálculo fatorial (n! = n * (n-1)!), que é a fórmula geral para calcular o fatorial, chamando-se repetidamente de “n – 1” e depois multiplicando o resultado por “n ”. Essas linhas atuam como um guardião do cálculo fatorial. Ele verifica se o número está no nível base e retorna 1 em caso afirmativo. Caso contrário, inicia uma reação em cadeia de chamadas de função, cada uma trabalhando em números menores até que o caso base seja alcançado. Em seguida, os resultados são multiplicados na ordem inversa. A seguir está a saída do código para sua referência:



Exemplo 2: contando as letras minúsculas demonstrando a string C++ Constexpr

Aqui, aprenderemos como contar o número de letras minúsculas usando uma string countexpr. Neste exemplo, o objetivo é contar o número de letras minúsculas em uma determinada string usando o recurso constexpr para reduzir o cálculo do tempo de execução. A função countLowercase(), declarada como constexpr, usa uma string “string_view” como parâmetro e itera através de cada caractere da string fornecida como entrada. Para cada letra minúscula que encontramos, a contagem é incrementada. O resultado é então obtido em tempo de compilação, pois a função opera em expressões constantes, mostrando a eficiência da avaliação em tempo de compilação e os benefícios de desempenho. Primeiro, verifique o código a seguir. Em seguida, passe para a explicação detalhada:

#include
#include
usando namespace std ;
constexpr tamanho_t contagem minúscula ( string_views ) {
tamanho_t contar = 0 ;
para ( Caracteres c : é ) {
se ( é inferior ( c ) ) {
contar ++;
}
}
retornar contar ;
}
interno principal ( ) {
corte << 'Total de letras minúsculas em' Letras minúsculas 'são ='
<< contagem minúscula ( 'Letras minúsculas' ) << fim ;
}

Aqui está uma análise detalhada do código com uma explicação de cada linha:

O #include está incluído para usar a biblioteca de fluxo de entrada/saída padrão para imprimir as mensagens. O #include inclui a classe “string_view” para manipulação eficiente de strings.

Na função countLowercase(), a função “constexpr size_t countlower(string_view s)”, conta as letras minúsculas em uma determinada visualização de string. O int main() é o ponto de entrada do programa que imprime uma mensagem que indica o número de letras minúsculas em “LoWeR CaSe LeTtErS” e chama a função countLowercase() com “LoWeR CaSe LeTtErS” como entrada e imprime o resultado. Consulte a seguinte saída do programa:

Exemplo 3: demonstração de array utilizando C++ Constexpr

Uma demonstração de array mostra como os arrays que são coleções estruturadas de elementos do mesmo tipo de dados são criados, acessados ​​e manipulados em uma linguagem de programação. A seguir, explicaremos por meio de um exemplo de codificação no qual o programa fornece um exemplo simples de inicialização e manipulação de array em tempo de compilação.

Uma demonstração de array ilustra o conceito de arrays — uma coleção estruturada de elementos que compartilham o mesmo tipo de dados — e como eles podem ser criados, acessados ​​e manipulados usando uma linguagem de programação. No exemplo de codificação a seguir, demonstraremos como inicializar um array em tempo de compilação, calcular seu tamanho e imprimir os elementos do array fornecido. Veja o código fornecido a seguir e prossiga para a explicação:

#include
usando namespace std ;
interno principal ( ) {
constexpr interno arrayint [ 9 ] = { 5 , 55 , 555 , 5555 , 55555 } ;
constexpr interno matriz_de_tamanho = tamanho de arrayint / tamanho de ( interno ) ;
corte << 'O comprimento do array é =' << matriz_de_tamanho << fim ;
corte << 'Os elementos da matriz são =' ;
para ( interno eu = 0 ; eu < matriz_de_tamanho ; ++ eu ) {
corte << arrayint [ eu ] << ' ' ;
}
}

Este programa inicializa um array constexpr, calcula seu comprimento em tempo de compilação e, em seguida, imprime o comprimento e os elementos do array no console. Constexpr garante que o array e suas propriedades sejam determinados em tempo de compilação. Vamos quebrar o código e explicar os detalhes específicos um por um:

Para incluir a biblioteca de fluxo de entrada-saída padrão, permitindo o uso de funções como “cout” para saída, #include é chamado. O programa inicia a execução a partir da função int main(). Dentro da função main(), o array “arrayint[]” é definido, tendo um tamanho de 9 com uma instrução constexpr int arrayint[9]. O array é inicializado com cinco números e os elementos restantes permanecem implicitamente 0. O int length_a = sizeof arrayint / sizeof(int); calcula o tamanho do “arrayint” em bytes.

Um loop “for” itera pelos elementos do array “arrayint[]” e os valores são então impressos no console. Vejamos a seguinte saída do código fornecido:

Conclusão

A introdução e evolução da palavra-chave constexpr em C++ revolucionaram a forma como expressões e valores constantes são tratados. Este artigo explorou três exemplos práticos, mostrando o poder do constexpr na computação de fatoriais, na contagem de letras minúsculas e na inicialização de arrays em tempo de compilação. As principais conclusões incluem desempenho aprimorado, cálculos de tempo de execução reduzidos e eficiência de memória aprimorada. Constexpr é um recurso valioso para criar entidades confiáveis ​​e constantes dentro de uma base de código, garantindo imutabilidade e contribuindo para programas mais simplificados e eficientes.