Exemplo 1:
Nesta situação, devemos trabalhar com strings e dados de entrada ou saída, para isso são fornecidos os arquivos de cabeçalho “iostream” e “string”. Portanto, esses arquivos de cabeçalho precisam ser incluídos aqui. Depois disso, não precisamos mais incluir este “std” com cada função independentemente em nosso código porque já incluímos o “namespace std” com o auxílio da palavra-chave “using”. Aqui, a função “main()” é então chamada. Então, a variável “string” chamada “originalString” é inicializada com alguma string. Em seguida, inicializamos outra variável “string” chamada “palavra” com C++.
Agora, abaixo disso, utilizamos o “cout” e imprimimos a string original. Após isso, declaramos o “int Result” e colocamos a função “contains()” para verificar se “originalString” contém a “palavra” ou não. Colocamos “se” abaixo dele. Passamos o “Resultado” para “se”. Se a string original contiver a substring, ela renderizará a instrução que adicionamos após “if”. No caso em que a string não contém a substring, a instrução apresentada após “else” é renderizada.
Código 1:
#include#incluir
usando namespace std ;
interno principal ( )
{
string originalString = 'Eu gosto de programação C++' ;
palavra de string = 'C++' ;
corte << 'A sequência é =' << String original << fim << fim ;
interno Resultado = String original. contém ( palavra ) ;
se ( Resultado )
{
corte << 'A palavra encontrada na string que é =' << palavra << fim ;
}
outro
{
corte << 'A palavra não encontrada na string' << fim ;
}
retornar 0 ;
}
Saída:
Este resultado mostra que a substring que encontramos na string original com a ajuda da função contains() é encontrada dentro da string original e é exibida aqui.
Exemplo 2:
O “iostream” e “string” são os arquivos de cabeçalho que importamos neste código. O namespace “std” também está incluído. Então, main() é chamado aqui. A seguir, inicializamos a variável “string” chamada “str_1” adicionando alguns dados de string. A seguir, inicializamos a variável “string” chamada “str_2” com “Rain”.
Abaixo disso, imprimimos a string original usando a função “cout”. Para determinar se “str_2” está ou não presente em “str_1”, declaramos o “int Outcome” e inserimos o método contains() aqui. Abaixo colocamos o “se” e passamos o “Resultado” para “se”. Adicionamos a instrução “cout” após “if” ser renderizado se a string original tiver a substring. Caso contrário, a instrução “cout” que vem depois de “else” será renderizada.
Código 2:
#include#incluir
usando namespace std ;
interno principal ( )
{
stringstr_1 = 'O tempo está fresco lá fora' ;
stringstr_2 = 'Chuva' ;
corte << 'A sequência é =' << str_1 << fim << fim ;
interno Resultado = str_1. contém ( str_2 ) ;
se ( Resultado )
{
corte << 'A palavra encontrada na string que é =' << str_2 << fim ;
}
outro
{
corte << 'A palavra não encontrada na string' << fim ;
}
retornar 0 ;
}
Saída:
Isso faz com que a substring que encontramos na string original com a ajuda da função contains() não seja encontrada dentro da string original e seja renderizada aqui como resultado.
Exemplo 3:
Importamos os arquivos de cabeçalho “iostream” e “string” neste código. Então, abaixo disso, usamos o “namespace std”. Então, main() é invocado aqui. Agora, inicializamos as duas variáveis do tipo de dados “string” com os nomes “myString_1” e “myString_2”, respectivamente, e atribuímos a string original da qual queremos encontrar a substring à variável “myString_1” e a substring é atribuída para a variável “myString_2”.
Depois disso, exibimos a string original colocando “myString_1” na instrução “cout” e depois colocando “if” na qual utilizamos o método “contains()” que verifica se a string fornecida contém a substring. Se a substring estiver presente na string original, com a ajuda de “cout”, renderizamos o resultado.
Colocamos duas instruções “cout” nas quais uma é colocada após “if” e a outra é adicionada após a parte “else”. Se a string original contiver a substring, o “cout” após “if” será renderizado. Se a substring não for encontrada ou a string original não tiver a substring, o “cout” após “else” será renderizado.
Código 3:
#include#incluir
usando namespace std ;
interno principal ( )
{
string minhaString_1 = 'Olá! Olá, mundo' ;
string minhaString_2 = 'Olá' ;
corte << 'A string completa é' << minhaString_1 << fim ;
se ( minhaString_1. contém ( minhaString_2 ) ) {
corte << 'A string encontrada =' << minhaString_2 << fim ;
}
outro {
corte << 'A String não encontrada aqui' << fim ;
}
retornar 0 ;
}
Saída:
Este resultado demonstra que a substring que pesquisamos na string original usando o método contains() está localizada na string original e é mostrada aqui.
Exemplo 4:
Os arquivos de cabeçalho “iostream” e “string” são importados para este código. A função main() é então chamada aqui depois de utilizarmos o “namespace std” abaixo. As inicializações das duas variáveis do tipo de dados “string” são denominadas “s_1” e “s_2”, respectivamente. A string original da qual desejamos descobrir a substring agora é atribuída à variável “s_1”, e a substring é dada à variável “s_2”. A string original é então mostrada inserindo “s_1” na instrução “cout”.
A seguir, adicionamos a cláusula “if” onde usamos o método contains() para determinar se a string fornecida contém a substring. Renderizamos a saída usando “cout” se a substring estiver presente na string original. Duas instruções “cout” são adicionadas, uma após “if” e outra após a parte “else” do código. O “cout” após “if” será renderizado se a substring estiver presente na string original. Caso contrário, o “cout” após “else” será renderizado se a substring não puder ser localizada na string original.
Código 4:
#include#incluir
usando namespace std ;
interno principal ( )
{
sequência s_1 = 'Oi! Sou Jack aqui'' ;
sequência s_2 = 'Peter' ;
corte << 'A string completa é =' << s_1 << fim ;
se ( s_1. contém ( s_2 ) ) {
corte << 'A string encontrada =' << s_2 << fim ;
}
outro {
corte << 'A String não encontrada =' << s_2 << fim ;
}
retornar 0 ;
}
Saída:
Como pode ser visto neste resultado, a substring que procuramos no texto original usando o método contains() não foi encontrada no código.
Exemplo 5:
Aqui, utilizaremos a biblioteca “boost” e descobriremos se a string contém a substring ou não. Neste método “boost”, também utilizamos a função contains(). Portanto, também incluímos o arquivo de cabeçalho “boost/algorithm/string.hpp” junto com os arquivos de cabeçalho “iostream” e “string” neste código. Em seguida, colocamos o “std” e invocamos o método main() aqui.
Em seguida, declaramos as variáveis que são “StringData1” e “StringData2” do tipo de dados “string” e inicializamos os dados da string aqui. A variável “c_result” do tipo de dados “bool” é inicializada com “boost::algorithm::contains()” e passamos “StringData1” e “StringData2” para esta função. Isso também encontra a substring na string original e armazena o resultado booleano na variável “c_result”.
Agora, colocamos “c_result==1” no “if” abaixo. Se o valor booleano de “c_result” for “1”, a instrução após “if” será exibida. Caso contrário, ele se move em direção à parte “else” e pula a instrução que está presente depois de “if” e renderiza a instrução da parte “else”.
Código 5:
#include#incluir
#include
usando namespace std ;
interno principal ( ) {
stringStringData1 = 'Meu primeiro programa' ;
stringStringData2 = 'primeiro' ;
bool c_result = impulsionar :: algoritmo :: contém ( StringData1 , StringData2 ) ;
se ( c_resultado == 1 )
{
corte << 'A corda ' << ''' << StringData1 << ''' << 'contém' << StringData2 << fim ;
}
outro
{
corte << 'A palavra fornecida não está presente na string.' ;
}
retornar 0 ;
}
Saída:
A substring agora é encontrada na string original que podemos ver neste resultado.
Conclusão
Exploramos detalhadamente o método contains() fornecido pela linguagem C++. Também mencionamos que a função contains() está disponível apenas em “C+++ 23”. Exploramos se a função contains() ajuda a encontrar a substring na string original ou se ajuda a verificar se a string contém a substring ou não e renderizamos o resultado de acordo.