Métodos de acabamento em string c ++
- "Ou '\ 040': espaço pressionando a tecla da barra de espaço
- '\ n': Feed de linha
- '\ r': retorno de carruagem
- 'f': FORME FEED
- '\ t': guia horizontal
- '\ v': guia vertical
C ++ não tem função para aparar uma string. Há um assunto em programação de computadores chamada Expressões regulares, Regex abreviado. Este sujeito possui esquemas, que permitem ao programador procurar uma sub-string em uma string de destino e substituir a sub-string encontrada. A sub-string encontrada pode ser substituída por nada, e assim apagá-la.
A idéia de pesquisa e substituição com nada pode ser usada para aparar uma string. Então procure todos os personagens do espaço branco na frente da corda e todos os personagens do espaço branco atrás da corda e substitua-os por nada. Felizmente, o C ++ tem uma biblioteca regex, que deve ser incluída no programa para fazer isso.
Conteúdo do artigo
- Introdução - Veja acima
- Resumo das expressões regulares
- Pesquise e substitua
- Aparando adequado
- Conclusão
Resumo das expressões regulares
Regex
Considere a string:
"É isso para o show"
Os quatro primeiros caracteres desta string formam a sub-cordão, "this". Os últimos quatro caracteres da string formam a última sub-string, "Show".
Agora, toda a string é chamada de string de destino ou simplesmente alvo. A sub-cordão "this" ou "show" é chamada de expressão regular ou simplesmente, regex.
Coincidindo
Se "isso" for pesquisado e localizado no alvo, a correspondência te ocorreu. Se "show" for pesquisado e localizado, a correspondência ainda se diz ter ocorrido. A correspondência ocorre para qualquer string de destino quando uma sub-string é encontrada. A sub-cordão pode ser substituída. Por exemplo, "isso" pode ser substituído por "aqui" e "show" pode ser substituído por "jogo" para ter o novo alvo,
"Aqui está para o jogo"
Se a primeira e as últimas palavras não fossem desejadas, elas poderiam ser substituídas por nada, para ter,
"É para o"
Esse último resultado é um corte não convencional, que infelizmente ainda termina com um espaço no início, e outro espaço no final.
Padrão
Uma sub-string contundente ("this" ou "show"), como ilustrado acima, é um padrão simples. Considere o seguinte alvo:
"Ei, isso é um morcego no meio da estrada."
O programador pode querer saber se é um rato, gato ou morcego, pois essas três palavras são semelhantes em som. Ele precisa de um padrão para identificar a palavra "gato" ou "rato" ou "morcego". Observe que cada uma dessas palavras termina com "at", mas começa com 'b' ou 'c' ou 'r'. O padrão, para combinar com qualquer uma dessas três palavras, é
[BCR] em
Isso significa que corresponde 'B' ou 'C' ou 'R', seguido de “em”.
Repetição
x*: significa corresponder 'x' 0 ou mais vezes, eu.e., qualquer número de vezes.
Exemplos correspondentes
O programa a seguir produz uma correspondência para "morcego" na sequência de destino, usando o objeto regex, reg ("[bcr] em"), cujo padrão é [bcr] em.
#incluir
#incluir
usando namespace std;
int main ()
regex reg ("[bcr] em");
if (regex_search ("Ei, isso é um morcego no meio da estrada.", reg))
cout << "matched" << endl;
outro
cout << "not matched" << endl;
retornar 0;
A saída é: correspondente.
A biblioteca regex está incluída com "#include". O objeto regex é instanciado com a declaração,
regex reg ("[bcr] em");
[/cc]
A função regex_search () da biblioteca leva dois argumentos aqui. O primeiro é a corda de destino. O segundo é o objeto regex. O padrão, [bcr] em "Bat" correspondente e assim a função regex_search () retornou true. Caso contrário, teria voltado, falso.
O programa a seguir ilustra uma correspondência do padrão, bo*k para "livro":
#incluir
#incluir
usando namespace std;
int main ()
regex reg ("bo*k");
if (regex_search ("o livro é bom.", reg))
cout << "matched" << endl;
outro
cout << "not matched" << endl;
retornar 0;
A saída é: correspondente. o* significa, combine 'O', zero ou mais vezes. Na verdade, correspondeu a 'O', duas vezes em “livro”.
Combinando o início da string alvo
Para corresponder ao início de uma sequência de alvo, o padrão começou, ^ . O programa a seguir corresponde a "isso" no início da string de destino, "é isso para o show".
#incluir
#incluir
usando namespace std;
int main ()
regex reg ("^this");
if (regex_search ("Isso é para o show", reg))
cout << "matched" << endl;
outro
cout << "not matched" << endl;
retornar 0;
A saída é: correspondente. Observe o regex literal, "^this" .
Fim correspondente da string de destino
Para corresponder ao final de uma string de destino, o padrão deve terminar com $. O programa a seguir corresponde a "show" no final da string de destino, "é isso para o show".
#incluir
#incluir
usando namespace std;
int main ()
regex reg ("show $");
if (regex_search ("Isso é para o show", reg))
cout << "matched" << endl;
outro
cout << "not matched" << endl;
retornar 0;
A saída é: correspondente. Observe o regex literal, "mostre $" .
Alternativas correspondentes
Para corresponder à sub-cordão inicial ou à sub-string final, o | meta-caractere deve separar os padrões iniciais e finais no padrão geral. O programa a seguir ilustra o seguinte:
#incluir
#incluir
usando namespace std;
int main ()
regex reg ("^this | show $");
if (regex_search ("Isso é para o show", reg))
cout << "matched" << endl;
outro
cout << "not matched" << endl;
retornar 0;
A saída é: correspondente. Observe o regex literal, "^this | show $" .
Agora, a função regex_search () normalmente corresponde à primeira opção de padrão e para. Este caso corresponde a "isso" no início do alvo e para sem continuar a corresponder "ao show" no final do alvo.
Felizmente, a função regex_replace () da biblioteca C ++ regex substitui todas as alternativas em qualquer lugar da sequência de destino no seu modo padrão. E assim, esta função regex_replace () é adequada para aparar strings. Ou seja, procure o espaço branco total na frente da corda e procure o espaço branco total por trás da corda e substitua ambos por nada.
Pesquise e substitua
O programa a seguir substitui as primeiras e as últimas palavras, da string de destino, com a palavra "cachorro":
#incluir
#incluir
#incluir
usando namespace std;
int main ()
char str [] = "É isso para o show";
String newstr = regex_replace (str, regex ("^this | show $"), "cão");
cout << newStr << endl;
retornar 0;
A saída é:
Cachorro é para o cachorro
O programa usa a função regex_replace (). O primeiro argumento é a sequência de destino. O segundo argumento é o objeto regex. O terceiro argumento é a substituição de string literal. A sequência de retorno é o objeto String modificado. Então a classe String teve que ser incluída.
Aparando adequado
Considere a string:
"Eu quero democracia! \ n "
Dois caracteres de espaço branco, '\ t' e ", estão na frente do texto útil. Outros dois personagens de espaço branco, "e '\ t', estão por trás do texto útil. A corte significa remover todos os personagens do espaço branco na frente do texto e remover todos os personagens do espaço branco por trás do texto.
Para corresponder aos dois primeiros personagens aqui, o padrão é “\ t | “, Isto é, '\ t' ou um espaço. Para combinar com os dois últimos caracteres aqui, o padrão é "| \ t", ou seja, um espaço ou '\ t'. No entanto, o programador geralmente não sabe o que é um espaço em branco em particular. Portanto, a melhor coisa a fazer é explicar todas as combinações possíveis para todos os caracteres do espaço branco, com o padrão ”| \ t | \ n | \ r | \ v | \ f”. Observe o uso do regex ou operador, | .
Ainda há um problema. O padrão, ”| \ t | \ n | \ r | \ v | \ f” corresponderia a apenas um caractere de espaço branco no início da corda e corresponderia a apenas um caractere de espaço branco no final da corda. Isto é por causa do | operadores. Portanto, esse padrão deve ser modificado para combinar com todos os caracteres do espaço branco no início da string ou no final da string. Portanto, qualquer personagem possível deve ser combinado zero ou mais vezes da sintaxe, x* . E o padrão final para combinar com os caracteres consecutivos de espaço em branco é
"[| \ t | \ n | \ r | \ v | \ f]*"
Para combinar caracteres consecutivos em espaço branco no início da string, use,
"^[| \ t | \ n | \ r | \ v | \ f]*"
Observe a presença e a posição de ^ .
Para combinar caracteres consecutivos em espaço branco no final da string, use,
"[| \ t | \ n | \ r | \ v | \ f]*$"
Observe a presença e a posição de $ . E para combinar com caracteres consecutivos de espaço branco no início ou no final da string, use,
"^[| \ t | \ n | \ r | \ v | \ f]*| [| \ t | \ n | \ r | \ v | \ f]*$"
Observe o uso de | no meio do padrão geral.
Após a correspondência, todos os caracteres de espaço branco são substituídos por nada, ou seja, “”, a corda vazia. Lembre-se de que a função regex_replace () substitui todas as ocorrências de sub-strings correspondidas ao padrão em toda a string de destino.
O programa a seguir, apara a sequência de destino, “\ T quero democracia! \ n "para" eu quero democracia!”:
#incluir
#incluir
#incluir
usando namespace std;
int main ()
char str [] = "\ t eu quero democracia! \ n ";
string retstr = regex_replace (str, regex ("^[| \ t | \ n | \ r | \ v | \ f]*| [| \ t | \ n | \ r | \ v | \ f]*$" ), "");
cout << retStr << endl;
retornar 0;
A saída é:
Eu quero democracia!
Conclusão
Aparar uma corda significa remover os espaços brancos na frente e atrás da corda. Um espaço branco consiste em caracteres em espaço branco. Os personagens do espaço em branco são ", '\ n', '\ r', 'f', '\ t" \ v'. Para aparar uma string em c ++, incluindo a biblioteca regex, e use a função regex_replace () para pesquisar e substituir. Substitua qualquer espaço branco no início e/ou no final da corda com a corda vazia.