No domínio da programação C++, priorizar eficiência e desempenho é crucial. A classe “std::string_view”, introduzida em C++17, apresenta uma alternativa versátil e com uso eficiente de memória à manipulação tradicional de strings. Em sua essência, “std::string_view” é uma referência sem propriedade a uma sequência de caracteres, geralmente representando uma substring de uma string maior. Ao contrário de “std::string” que possui seus dados e gerencia a memória internamente, “std::string_view” opera sem possuir os dados subjacentes. Essa característica o torna particularmente valioso para cenários onde a sobrecarga de cópia ou gerenciamento da memória é indesejável. Neste artigo, exploraremos os diferentes exemplos para compreender a utilização de “std::string_view” em C++.
Exemplo 1: Manipulação Eficiente de Strings
No desenvolvimento moderno em C++, o manuseio eficiente de strings é crucial para otimizar o desempenho e a utilização de recursos. Permite um acesso e manipulação eficiente de strings sem a necessidade de realocação ou duplicação de memória. Para ilustrar esse conceito, vamos nos aprofundar em um exemplo prático.
Considere o seguinte trecho de código:
#include
#include
processo vazioStringView ( std::string_view strView ) {
std::cout << 'Comprimento: ' << strView.length ( ) << std::endl;
std::cout << 'Contente: ' << strView << std::endl;
}
principal interno ( ) {
std::string originalString = 'Manuseio eficiente de strings' ;
std::string_view viewOfString ( String original ) ;
processStringView ( viewOfString ) ;
retornar 0 ;
}
Neste exemplo, temos a função “processStringView” que leva “std::string_view” como parâmetro. A função então imprime o comprimento e o conteúdo da visualização de string usando a saída padrão. A função principal inicializa o “std::string” denominado “originalString” com o valor “Efficient String Handling”. Posteriormente, é criado o “std::string_view” denominado ‘viewOfString”, referente ao conteúdo de “originalString”.
Ao passar “viewOfString” para a função “processStringView”, podemos realizar as operações na string de forma eficiente, eliminando a necessidade de alocações extras de memória. O “std::string_view” é uma referência leve à sequência de caracteres subjacente de “originalString” sem copiar os dados.
Aqui está a saída gerada:
Exemplo 2: Interoperabilidade com Código Legado
No domínio do desenvolvimento C++, a integração perfeita de bases de código novas e antigas costuma ser uma preocupação crítica. O “std::string_view” permite que os desenvolvedores interajam sem esforço com funções legadas que retornam os ponteiros “const char”.
Considere o exemplo a seguir que demonstra o uso prático de “std::string_view” para interoperabilidade. Aqui, temos uma função legada chamada “legacyFunction()” que retorna um ponteiro “const char”:
#include#include
const caractere * função legado ( ) {
retornar 'Corda Legada' ;
}
principal interno ( ) {
std::string_view legadoStrView ( função legado ( ) ) ;
std::cout << 'Visualização de string herdada:' << legadoStrView << std::endl;
retornar 0 ;
}
Começamos definindo uma função legada chamada “legacyFunction()” que retorna um ponteiro “const char” que representa uma string rotulada como “Legacy String”. Para incorporar perfeitamente esses dados legados em nosso programa C++ moderno, empregamos o “std::string_view”. Na função main(), especificamente, criamos uma instância de “std::string_view” chamada “legacyStrView” e inicializamos com o resultado da função legada. Essa instanciação nos permite encapsular e trabalhar de forma eficiente com o ponteiro legado “const char”.
Como resultado, podemos acessar e manipular a string legada sem recorrer a cópias desnecessárias de dados, preservando a eficiência e a compatibilidade. A etapa final do código envolve a utilização de “std::cout” para imprimir o conteúdo da visualização de string herdada.
A saída executada é:
Exemplo 3: Manipulação aprimorada de literais de string
Literais de string em C++ são tradicionalmente representados como matrizes de caracteres. O “std::string_view” simplifica o trabalho com literais de string, fornecendo uma interface conveniente. Ao permitir um acesso direto ao array de caracteres subjacente sem a necessidade de conversões explícitas, “std::string_view” agiliza as operações em literais de string.
#include#include
principal interno ( ) {
const caractere * meuLiteral = 'Olá, visualização de cordas!' ;
std::string_view literalView ( meuLiteral ) ;
std::cout << 'Primeiro personagem:' << literalView [ 0 ] << std::endl;
size_t posição = literalView.find ( 'Corda' ) ;
std::cout << 'Posição da substring:' << posição << std::endl;
retornar 0 ;
}
Neste exemplo, um “Hello, String View!” string literal é atribuída ao ponteiro “myLiteral”. A introdução de “std::string_view” facilita uma representação mais eficiente desta string sem a necessidade de copiar seu conteúdo. O objeto “literalView” é criado usando o ponteiro “myLiteral” que nos permite visualizar e manipular a sequência de caracteres subjacente.
O uso de “std::string_view” fornece acesso fácil a caracteres individuais dentro da string. No trecho de código, “literalView[0]” recupera e imprime o primeiro caractere da string, mostrando a simplicidade e a franqueza de acesso aos elementos. O método “find” de “std::string_view” é empregado para determinar a posição da substring “String” dentro da string original.
Exemplo 4: Extração de Substring
A tarefa de extração de substring envolve recuperar uma parte de uma determinada string com base em critérios especificados, como a posição de um delimitador. A capacidade de extrair facilmente as substrings é um recurso poderoso de “std::string_view”. Considere um cenário onde precisamos extrair uma parte de uma string com base em um delimitador:
#include#include
principal interno ( ) {
std::string string completa = 'maçã-laranja-banana' ;
size_t delimitadorPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , delimitadorPos ) ;
std::cout << 'Substring extraída:' << subString << std::endl;
retornar 0 ;
}
Neste trecho de código, começamos com a declaração de uma string original, “fullString”, que é inicializada com o valor “apple-orange-banana”. Nosso objetivo é realizar a extração da substring. Para conseguir isso, empregamos a função “find” fornecida pela biblioteca padrão C++.
Uma vez identificada a posição do delimitador dentro do “fullString”, armazenado na variável “delimiterPos”, extraímos a substring desejada. A função “substr” é chamada na string original, especificando a posição inicial (0) e o comprimento da substring que é precisamente a posição do delimitador. Esta operação resulta na criação de “std::string_view” denominado “subString” que representa a parte da string original desde o início até o delimitador.
Exemplo 5: Estruturas de dados com eficiência de memória
O “std::string_view” desempenha um papel crucial no projeto de estruturas de dados com uso eficiente de memória. Em vez de armazenar múltiplas cópias de strings, as estruturas de dados podem armazenar as instâncias “std::string_view”, reduzindo assim a sobrecarga de memória.
#include#include
registro de estrutura {
std::string_view nome;
idade interna;
} ;
principal interno ( ) {
Pessoa registrada = { 'John Doe' , 30 } ;
std::cout << 'Nome: ' << pessoa.nome << ', Idade: ' << personagem << std::endl;
retornar 0 ;
}
Neste trecho de código, mostramos a utilização de “std::string_view” em uma estrutura de dados com uso eficiente de memória. Definimos uma estrutura “Record” que compreende um membro “std::string_view” denominado “nome” e um membro inteiro denominado “idade”. O uso de “std::string_view” neste contexto nos permite criar uma representação leve de uma string sem a necessidade de alocação de memória adicional.
Na função “main”, instanciamos um objeto “Record” chamado “person” com o nome “John Doe” e a idade de 30 anos. O membro “std::string_view” “name” serve como uma visão não proprietária de os dados de caracteres correspondentes ao nome, eliminando a necessidade de duplicar o conteúdo da string. O “std::cout << “Nome: ” << person.name << “, Idade: ” << person.age << std::endl;” A instrução gera o nome e a idade da pessoa que estão armazenados no objeto “Record”.
Conclusão
No cenário em constante evolução do desenvolvimento C++, “std::string_view” se destaca como uma adição valiosa ao kit de ferramentas do programador. As instâncias ilustradas neste artigo destacam a adaptabilidade e a utilidade de “std::string_view” no domínio da programação C++. Da manipulação eficiente de strings e interoperabilidade perfeita com código legado até estruturas de dados com uso eficiente de memória, “std::string_view” é valioso para desenvolvedores que buscam desempenho aprimorado e código otimizado em diversos cenários. Esses cenários do mundo real demonstram como “std::string_view” pode otimizar o código, reduzir a sobrecarga desnecessária de memória e contribuir para a eficiência geral dos aplicativos C++.