22 - Capítulo 19 - A Classe String e o Processamento em Streams de Strings

Prévia do material em texto

19 
A classe string e o processamento em stream 
de strings 
 Objetivos 
• Usar a classe string da biblioteca padrão de C++ para 
que possamos tratar strings como objetos no pleno sentido 
 • Ser capaz de atribuir, concatenar, comparar, pesquisar e 
 intercambiar (swap) strings 
• Ser capaz de determinar as características de um string 
• Ser capaz de encontrar, substituir e inserir caracteres em 
um string 
• Ser capaz de converter strings ao estilo de strings de C 
• Ser capaz de usar iteradores de strings 
• Ser capaz de executar entrada e saída de strings na 
memória 
A dftrença entre a palavra certa e a quase certa é realmente 
uma questão importante - é a diferença entre um vaga-lume 
e um relâmpago. 
Mark Twain, Carta a George Bainton (15 de outubro de 1888) 
Escrevi uma carta longa demais, pois 
me faltou tempo para escrevê-la mais curta. 
Biaise Pascal 
Silenciosa é a palavra. 
Miguel de Cervantes, Don Quixote de Ia Mancha 
Que a ação sirva à palavra, e a palavra, à ação; com essa observação particulai que você não transgrida a modéstia da natureza. 
William Shakespeare, Hamlet 
890 C++ COMO PROGRAMAR 
Visão Geral 
19.1 Introdução 
19.2 Atribuição e concatenação de strings 
19.3 Comparando stríngs 
19.4 Substrings 
19.5 Intercambiando strings 
19.6 Características de stríng 
19.7 Encontrando caracteres em um string 
19.8 Substituindo caracteres em um string 
19.9 Inserindo caracteres em um string 
19.10 Conversão para strings char* no estilo da linguagem C 
19.11 Iteradores 
19.12 Processamento de strings em streams 
Resumo• Terminologia Erros comuns de programação Boa prática de programação • Dica de desempenho • Dica de teste e depura ção • Exercícios de auto-revisão Respostas aos exercícios de auto-revisão• Exercícios 
19.1 Introdução 
A classe gabarito basic string de C++ fornece operações típicas de manipulação de strings, tais como cópia, pesquisa, etc. A definição do gabarito e de todos os recursos de apoio estão no namespace std estas incluem o comando typedef 
typedef basic_string< char > string; 
que cria o tipo alias (nome alternativo) string para basicstrirzg< char >. Também é fornecido um typedef para o tipo wchar_t. O tipo wchar_t armazena caracteres (por exemplo, caracteres de 2 bytes, caracteres de 4 bytes, etc.) para suportar outros conjuntos de caracteres. Em todo este capítulo, usamos exclusivamente string. Para usar strings. inclua o arquivo de cabeçalho <string> da biblioteca padrão de C++. [Nota: o tipo wchart é comumente usado para representar Unicode, que tem caracteres de 16 bits, mas o tamanho da wchat_t não é fixado pelo padrão.j 
Um objeto string pode ser inicializado com um argumento para o construtor tal como 
string sl( “Bom dia!” ); 1/ cria um string a partir de um const char* 
que cria um string contendo os caracteres em “Bom dia! “ exceto, talvez, o caractere de terminação ‘\0 , ou com dois argumentos como em 
string s2( 8, ‘x’ ); 1/ string de 8 caracteres ‘x’ 
que cria um string contendo oito caracteres ‘x’ . A classe strng também fornece um construtor default e um construtor de cópia. 
Um string também pode ser inicializado através da sintaxe alternativa de construção na definição de um string, como em 
string mês = “março”; // o mesmo que: string mês( “março” ); 
Lembre-se de que o operador = na declaração precedente não é uma atribuição, mas sim uma chamada para o construtor de cópia da classe string, o qual faz a conversão implicitamente. 
1 
1 
CAPÍTULO 19 - A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 891 
Note que a classe string não fornece conversões de int ou char para string em uma definição de 
string. Por exemplo, as definições 
string errorl= ‘c’; 
string error2( u’ ); 
string error3 = 22; 
string error4( 8 ); 
resultam em erros de sintaxe. Note que atribuir um único caractere a um objeto string é permitido em um comando de atribuição, como em 
s = 
Erro comum de programação 19.1 
Tentar converter um int ou um char para um string através de uma atribuição em uma declaração 
ou através de um argumento para um construtor é um erro de sintaxe. 
Erro comum de programação 19.2 
Construir um string que é longo demais para ser representado dispara uma exceção lengtherror. 
Diferentemente dos strings char* ao estilo de C, strings não são necessariamente terminados por um caractere nulo. O comprimento de um string é armazenado no objeto string e pode ser acessado com a função membro lenght. O operador subscrito, [ ] , pode ser usado com strings para acessar caracteres individuais. Como strings ao estilo de C, strings têm um primeiro subscrito O e um último subscrito de length-1. Note que um string não é um ponteiro - a expressão &s [ O 1 não é equivalente a s quando s é um string. 
A maioria das funções membro de string aceitam como argumentos uma posição inicial dada por um 
subscrito e o número de caracteres sobre os quais operar. 
Tentar passar para uma função membro de string um valor maior do que o comprimento do string (como o número de caracteres a serem processados) resulta no valor sendo feito igual à diferença entre o valor passado e o comprimento do string. Por exemplo, passar 2 (subscrito inicial) e 100 (número de caracteres) para uma função que opera sobre um string de tamanho 50 resulta em 48 (50-2) sendo usado para o número de caracteres. 
O operador de extração de stream (»)é sobrecarregado para suportar strings. O comando 
string stringObject; 
cm » stringObject; 
lê um string do dispositivo padrão de entrada. A entrada é delimitada por caracteres em branco. A função getline (do arquivo de cabeçalho <string>) também é sobrecarregada para strings. O comando 
string s; 
getline( cm, s ); 
lê um string a partir do teclado para s. A entrada é delimitada por um caractere de nova linha (‘ \n’). 
19.2 Atribuição e concatenação de strings 
O programa da Fig. 19.1 demonstra a atribuição e concatenação de strings. 
Fig. 19.1 Demonstrando a atribuição e concatenação de string (parte 1 de 2). 
1 
// Fig. 19.1: figl9Ol.cpp 
2 
II Demonstrando a atribuição e concatenação de strings 
3 
#include <iostream> 
4 
5 
using std::cout; 
892 C++ COMO PROGRAMAR 
6 using std: :endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 { 
14 string sl( “cat” ) , s2, s3; 
15 
16 s2 = si; /1 atribui si a s2 com = 
17 s3.assign( si ) ; II atribui si a s3 com assigri() 
i8 cout « “si: ‘ « si « “\ns2: “ « s2 « “\ns3: 
19 « s3 « “\n\n”; 
20 
21 II modifica s2 e s3 
22 s2[0]=s3[2)=’r’; 
23 
24 cout « “Após a modificação de s2 e s3:\n’ 
25 « “si: “ « si « ‘\ns2: “ « s2 « “\ns3: “; 
26 
27 II demonstrando a função membro atO 
28 int ien = s3.1ength 
29 for ( int x = 0; x < len; ++x 
30 cout « s3.at( x ); 
31 
32 II concatenação 
33 string s4( si + ‘apuit” ), s5; II declara s4 e s5 
34 
35 II + sobrecarregado 
36 s3 += “pet”; II cria “carpet” 
37 si.append( “acomb” ); II cria “catacomb” 
38 
39 II acrescenta as posições com subscritos 4 até o fim de si 
40 II para criar o string “conib” (inicialmente, s5 estava vazio) 
41 s5.append( si, 4, si.size() ); 
42 
43 cout « \n\nApós a concatenação:\n « “si: “ « si 
44 « “\ns2: “ « s2 « ‘\ns3: “ « s3 « ‘\ns4: “ « s4 
45 « “\ns5: “ « s5 « endi; 
46 
47 return 0; 
48 } 
si: cat 
s2: cat 
s3: cat 
Após a modificação de s2 e s3: 
si: cat 
s2: rat 
s3: car 
Após a concatenação: 
si: catacomb 
s2: rat 
s3: carpet 
s4: catapult 
s5: comb 
Fig. 19.1 Demonstrando a atribuição e concatenação de string (parte 2 de 2). 
CAPÍTULO 19 - A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 893 
A linha 8 inclui o cabeçalho string à classe string. Três strings si, s2 e s3 são criados na linha 14. A linha 
16 
s2 = si; II atribui si a s2 com = 
atribui o string si para s2. Após ocorrer a atribuição, s2 é uma cópia de si, mas s2 não está vinculado a si de nenhuma maneira. A linha 17 
s3.assign( si ) ; II atribui si a s3 com assign() 
usa a função membro assign para copiar si a s3. É feita uma cópia separada (i. e., si e s3 são objetos independentes). A classe string também fornece uma versão sobrecarregadada função assign, que copia um número especificado de caracteres, como em 
meuString.assign( s, inicio, numeroDeCaracteres); 
onde s é o string a ser copiado, inicio é o subscrito inicial e numeroDeCaracteres é o número de caracteres a serem copiados. 
A linha 22 
s2[ O 1 = s3[ 2 1 = 
usa o operador subscrito para atribuir r’ para s 3 [ 2 ) (formando car ‘) e para atribuir T r’ a s2 [ O 1 (formando “rat”). Os strings são então exibidos. 
As linhas 28 a 30 
int len = s3.iengthO; 
for ( int x = O; x < len; ++x 
cout « s3.at( x 
usam um laço for para exibir o conteúdo de s3 um caractere por vez, usando a função at. A função at fornece um acesso com verificação de intervalo, i.e., ultrapassar o fim do string dispara uma exceção out of range (ver o Capítulo 13 para uma discussão detalhada do tratamento de exceções). Note que o operador subscrito, [ J, não fornece um acesso com verificação de intervalo. Isto é consistente com o uso de arrays. 
Erro comum de programação 19.3 
Acessar um subscrito de string fora dos limites do string usando afunção at dispara uma exceção out_of_range. 
Erro comum de programação 19.4 
Acessar um elemento além do tamanho de um string usando o operador subscrito é um erro de lógica. 
O string s4 é declarado (linha 33) e inicializado com o resultado da concatenação de si e “apuit” usando o operador de adição, +, sobrecarregado, o qual para a classe string indica concatenação. A linha 36 
s3 += “pet”; II cria carpet” 
usa o operador adição de atribuição, +=, para concatenar s3 e “pet’. 
A linha 37 
si.append( “acoznb” ); // cria “catacomb” 
usa a função append para concatenar si e “acomb”. A linha 41 
s5.append( si, 4, si.size() ); 
anexa caracteres de si a s5. Os caracteres do quarto ao último elemento de si são concatenados a s5. A função size retorna o número de caracteres no string si. 
894 C++ COMO PROGRAMAR 
19.3 Comparando strings 
A classe string fornece funções para comparar strings. O programa da Fig. 19.2 demonstra os recursos para comparação de strings. 
1 II Fig. 19.2: figi9_02.cpp 
2 II Demonstrando os recursos para comparação de strings 
3 #include <iostream> 
4 
5 using std::cout; 
6 using std::endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 { 
14 string si( “Testando as funções de comparação.”), 
15 s2(Hello” ), s3( “stinger’ ), zi( s2 ); 
16 
17 cout « “si: “ « si « “\ns2: « s2 
18 « “\ns3: “ « s3 « \nzi: ‘ « zi « “\n\n”; 
19 
20 II comparing si and zi 
21 if(si==zi) 
22 cout « “si == zi\n”; 
23 else { // si != zi 
24 if(sl>zl) 
25 cout « “si > zi\n’; 
26 else // si < zi 
27 cout « “si < zi\n”; 
28 ) 
29 
30 II comparing si and s2 
31 int f = si.compare( s2 ); 
32 
33 if (f==0) 
34 cout « “si.compare( s2 ) == 0\n”; 
35 elseif ( f>0 
36 cout « “sl.compare( s2 ) > 0\n”; 
37 else // f< O 
38 cout « “si.compare( s2 ) < 0\n”; 
39 
40 II cornparing si (elements 2 - 5) and s3 (elements O - 5) 
41 f = si.compare( 2, 5, s3, 0, 5 ); 
42 
43 if(f==0) 
44 cout « “si.compare( 2, 5, s3, 0, 5 ) == 0\n”; 
45 elseif ( f>0 
46 cout « ‘sl.compare( 2, 5, s3, 0, 5 ) > 0\n”; 
47 else // f<0 
48 cout « “sl.compare( 2, 5, s3, 0, 5 ) < 0\n”; 
49 
50 II comparing s2 and zi 
51 f = zi.compare( 0, s2.size(), s2 ); 
Fig. 19.2 Comparando strings (parte 1 de 2). 
CAPÍTULO 19- A CLASSE string E O PROCESSAMENTO EM STREAM DE STRÍNGS 895 
52 
53 if (f==0) 
54 cout « zi.compare( 0, s2.sizeO, s2 ) 0 « endi; 
55 elseif ( f>0 
56 cout « ‘zi.compare( 0, s2.size(), s2 ) > 0 « endi; 
57 else // f< O 
58 cout « “zl.compare( 0, s2.size(), s2 ) < 0” « endi; 
59 
60 return 0; 
61 } 
si: Testando as funções de comparação. 
s2: Helio 
s3: stinger 
zi: Heilo 
si > zi 
si.compare( s2 ) > O 
sl.compare( 2, 5, s3, 0, 5 ) == O 
zi.compare( 0, s2.size, s2 ) == O 
Fig. 19.2 Comparando strings (parte 2 de 2). 
O programa compara quatro strings com as linhas 14 e 15 
string sl( “Testando as funções de comparação.” 
s2(”Hello” ), s3( stinger’ ), zi( s2 ); 
e envia para a saída cada string (linhas 17 e 18). A condição 
si == zi 
na linha 21 testa se si é igual a zi. Se a condição é true, “si == zi” é exibido. Se a condição é faise, a condição 
si > zi 
na linha 24 é testada. Todas as funções de operador sobrecarregadas demonstradas aqui, bem como as não demonstradas aqui (!=, <, >= e <=) retornam valores booi. 
A linha 31 
int f = sl.compare( s2 ); 
usa a função compare de string para comparar si com s2. A variável fé declarada e recebe O se os strings são equivalentes, um número positivo se si é lexicograficamente maior que s2 ou um número negativo se si é lexicograficamente menor que s2. 
A linha 41 
f = sl.compare( 2, 5, s3, 0, 5 ); 
usa uma versão sobrecarregada da função compare. para comparar partes de si e s3. Os dois primeiros argumentos (2 e 5) especificam o subscrito inicial e o comprimento da parte de si a ser comparada com s3. O terceiro argumento é o string de comparação. Os últimos dois argumentos (0 e 5) são o subscrito inicial e o comprimento da parte do string de comparação a ser comparada. O valor atribuído a f é O para igualdade, um número positivo se si é lexicograficamente maior que s3 ou um número negativo se si é lexicograficamente menor que s3. Um string é então impresso com base no valor de f. 
A linha 5 1 
f = zi.compare( 0, s2.sizeO, s2 ); 
896 C++ COMO PROGRAMAR 
usa outra versão sobrecarregada da função compare para comparar zl e s2. O primeiro argumento especifica o subscrito inicial de zi na comparação. O segundo argumento especifica o comprimento da parte de zi usada na comparação. A função size retorna o número de caracteres no string especificado. O último argumento é o string de comparação. O valor atribuído a f é ou O para igualdade, um número positivo se zi é lexicograticamente maior que s2 ou um número negativo se zi é lexicograficamente menor que s2. Um string é então impresso com base no valor de f. 
19.4 Substrings 
A classe string fornece a função substr para recuperar um substring de um string. O programa da Fig. 19.3 demonstra substr. 
1 II Fig. 19.3: figl9_03.cpp 
2 // Demonstrando a função substr 
3 #include <iostream> 
4 
5 using std::cout; 
6 using std::endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 
14 string s ( “O aeroplano desapareceu no horizonte.” 
15 
16 // procura o substring “plano”, que começa 
17 // no subscrito 6 e consiste em 5 elementos 
18 cout « s.substr( 6, 5 ) « endi; 
19 
20 return 0; 
21} 
plano 
Fig. 19.3 Demonstrando a função substr. 
O programa declara e inicializa um string na linha 18. A linha 
cout « s.substr( 6, 5 ) « endi; 
usa a função substr para recuperar um substring de s. O primeiro argumento especifica o subscrito onde começa o substring. O último argumento especifica o número de caracteres a extrair. 
19.5 Intercambiando strings 
A classe string fornece a função swap para intercambiar strings. O programa da Fig. 19.4 intercambia dois strings. 
1 II Fig. 19.4: figl9_04.cpp 
2 // Usando a função swap para intercambiar dois strings 
3 #include <iostream> 
Fig. 19.4 Usando a função swap para intercambiar dois strings (parte 1 de 2). 
CAPÍTULO 19- A CLASSE String E o PROCESSAMENTO EM STREAM DE STRINGS 897 
4 
5 using std::cout; 
6 using std: :endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 
14 string first( “um” ), second( “dois” ); 
15 
16 cout « “Antes de swap:\nprimeiro: “ « first 
17 « “\n segundo: “ « second; 
18 first.swap( second ); 
19 cout « “\n\nDepois de swap:\nprimeiro: “ « first 
20 « “\n segundo: “ « second « endi; 
21 
22 return 0; 
23 } 
Antes de swap: 
primeiro: um 
segundo: dois 
Depois de swap: 
primeiro: dois 
segundo: um 
Fig. 19.4 Usando a função swap para intercambiar dois strings (parte 2 de 2). 
A linha 14 declara e inicializa os strings first e second. Cada string é então exibido. A linha 18 
first.swap( second ); 
usa a função swap para permutar os valores de first e second. Os dois strings são novamente impressos para confirmar que eles foram de fato trocados. 
19.6 Características de string 
A classe string fornecefunções para coletar informações sobre o tamanho de um string, seu comprimento, capacidade, comprimento máximo e outras características. O tamanho ou comprimento de um string é o número de caracteres comumente armazenados no string. A capacidade de um string é o número total de elementos que podem ser armazenados no string sem aumentar a capacidade de memória do string. O tamanho máximo do string é o tamanho do maior string que pode ser armazenado em um objeto string. O programa da Fig. 19.5 demonstra as funções da classe string para encontrar o tamanho, o comprimento e outras características de um string. 
Fig. 19.5 Imprimindo características de um string (parte 1 de 3). 
1 
II Fig. 19.5: figl9_05.cpp 
2 
II Demonstrando funções 
relacionadas a tamanho e capacidade 
3 
#include <iostream> 
4 
5 
using std: :cout; 
6 
using std::endl; 
89S C++ COMO PROGRAMAR 
7 using std::cin; 
8 
9 #include <string> 
10 
11 using std::string; 
12 
13 void printStats ( const string & ); 
14 
15 int main() 
16 
17 string s; 
18 
19 cout « “Características antes da leitura:\n; 
20 printStats( s 
21 
22 cout « “\n\nDigite um string: 
23 cm » s; /1 delimitado por espaço em branco 
24 cout « “O string digitado era: “ « s; 
25 
26 cout « “\nCaracterísticas depois da leitura:\n’; 
27 printStats( s 
28 
29 s.resize( s.length() + 10 ); 
30 cout « “\n\nCaracterísticas após redimensionar com (length+l0):\n”; 
31 printStats ( s ); 
32 
33 cout « endl; 
34 return 0; 
35 } 
36 
37 void printStats( const string &str 
38 
39 cout « “capacity: “ « str.capacity() 
40 « \nmaxsize: « str.maxsize() 
41 « “\nsize: « str.size() 
42 « “\nlength: “ « str.length() 
43 « “\nempty: « ( str.empty() ? true: “false” ); 
44 } 
Características antes da leitura: 
capacity: O 
max size: 4294967293 
size: O 
length: O 
empty: true 
Digite uni strirxg: tomates secos 
O string digitado era: tomates 
Características depois da leitura: 
capacity: 31 
maz size: 4294967293 
size: 6 
length: 6 
empty: false 
Características após redimensionar com (length + 10) 
capacity: 31 
Fig. 19.5 Imprimindo características de um string (parte 2 de 3). 
CAPÍTULO 19 - A CLASSE Striflg E O PROCESSAMENTO EM STREAM DE STRINGS 899 
max size: 4294967293 
size: 16 
length: 16 
empty: false 
Fig. 19.5 Imprimindo características de um string (parte 2 de 2). 
O programa declara o string vazio s (linha 17) e passa o mesmo para a função print_Stats (linha 20). Um string vazio é um string que não contém nenhum caractere, O string “tomates” é lido do teclado. Note que strings são delimitados por brancos, o que evita que o string remanescente seja lido. 
A função printStats recebe como argumento uma referência para um string const e exibe a sua capacidade (usando a função capacity), seu tamanho máximo (usando a função max size), seu tamanho (usando a função size), seu comprimento (usando a função lenght) e indica se o string está ou não vazio (usando a função empty). A chamada inicial para printStats indica que os valores iniciais para a capacidade, o tamanho e o comprimento de s são 0. Como a capacidade inicial é 0, quando forem colocados caracteres em s será necessário alocar memória para acomodar os novos caracteres. O tamanho e o comprimento O indicam que no momento não há caracteres armazenados em s. O tamanho e o comprimento são sempre idênticos. O tamanho máximo para esta implementação é 4294967293. O string s é um string vazio, assim a função empty retorna true. 
A linha 23 lê um string para s. Note que o operador de extração de stream, », é usado. A linha 29 
s.resize( s.length() + 10 
usa a função resize para aumentar o comprimento de s em 10 caracteres. 
19.7 Encontrando caracteres em um string 
A classe string fornece funções para encontrar strings e caracteres em um string. O programa da Fig. 19.6 demonstra as funções de procurafind. Todas as funções de procura são const. 
1 II Fig. 19.6: figl9O6.cpp 
2 // Demonstrando as funções de procura em strings 
3 #include <iostream> 
4 
5 using std::cout; 
6 using std::endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 
14 // o compilador concatena todas as partes em uma só constante string 
15 string s( “The values in any left subtree” 
16 “\nare less than the value in the’ 
17 “\nparent node and the values in” 
18 ‘\nany right subtree are greater 
19 “\nthan the value in the parent node” ); 
20 
Fig. 19.6 Demonstrando as funções de procura em um string f ind (parte 1 de 2). 
900 C++ COMO PROGRAMAR 
21 // encontra “subtree” nas posições 23 e 102 
22 cout « “String original:\n” « s 
23 « “\n\n(find) \“subtree\” foi encontrado na posição: 
24 « s.find( “subtree” 
25 « “\n(rfind) \“subtree\” foi encontrado na posição: 
26 « s.rfind( “subtre&’ ); 
27 
28 II encontra ‘p’ de “parent’ nas posições 62 e 144 
29 cout « “\n(findfirstof) primeiro caractere de \‘qpxz\” na posição: 
30 « s.find_first_of( “qpxz” 
31 « “\n(findlastof) último caractere de \“qpxz\” na posição: 
32 « s.findlastof( “qpxz” ); 
33 
34 II encontra ‘b na posição 25 
35 cout « “\n(find_first_not_of) primeiro caractere não\n” 
36 contido em \‘heTv lusinodrpayft\: 
37 « s.findfirstnotof( ‘heTv lusinodrpayft” ); 
38 
39 II encontra \n na posição 121 
40 cout « ‘\n(findlastnotof) último caractere não\n’ 
41 contido em \‘heTv lusinodrpayft\”: 
42 « s.findlastnotof( “heTv lusinodrpayft” ) « endi; 
43 
44 return 0; 
45 
String original: 
The values in any left subtree 
are less than the value in the 
parent node and the values in 
any right subtree are greater 
than the value in the parent node 
(find) “subtree” foi encontrado na posição: 23 
(rfind) “subtree” foi encontrado na posição: 102 
(findfirst_of) primeiro caractere de “qpxz na posição: 62 
(findlastof) ultimo caractere de ‘qpxz’ na posição: 144 
(find_first_not_of) primeiro caractere não 
contido em “heTv lusinodrpayft’: 25 
(findlastnotof) último caractere não 
contido em “heTv lusinodrpayft”: 121 
Fig. 19.6 Demonstrando as funções de procura em um string find (parte 2 de 2). 
O string s é declarado e inicializado na linha 15. O compilador concatena todos os cinco literais strings em um único literal. Para evitar erros de sintaxe, o final de cada string deve ser fechado com aspas antes de passar para a linha seguinte e começar outro string. 
Erro comum de programa çõo 19.5 
Não terminar um string com aspas é um erro de sintaxe. 
A linha 24, que faz parte da operação de inserção 
« s . find ( “subtree” 
CAPÍTULO 19 - A CLASSE string E O PROCESSAMENTO EM STREAM DE STR!NGS 901 
tenta encontrar o string “subtree” no string s usando a função f ind. Se o string é encontrado, o subscrito da posição inicial daquele string é retornado. Se o string não é encontrado, é retornado o valor string: : npos (uma constante public static definida na classe string). Este valor é retornado pelas funções de procura em string relacionadas, para indicar que um substring ou caractere não foi encontrado no string. 
O último item exibido com a inserção no siream na linha 26 
s.rfind( “subtree” ) II procura reversa 
usa a função rfind para pesquisar o string s de trás para diante. Se o string procurado é encontrado, a posição do subscrito é retornada. Se o string não é encontrado, string: : npos é retornado. (Nota: as demais funções apresentadas nesta seção retornam o mesmo tipo de valor, salvo observação em contrário). Note que a constante string: : npos também é usada em um contexto diferente - para indicar todos os elementos de um string. 
A chamada 
« s.find_first_of( “xz” 
na linha 30 usa a função find_first_of para encontrar a primeira ocorrência no string s de qualquer caractere de “qpxz ‘. A busca é feita a partir do início de s. O caractere ‘p’ é encontrado na posição 62. 
A chamada 
« s.find_last_of( “apxz ); 
na linha 32 usa a função find last of para encontrar a última ocorrência no string s de qualquer caractere de “xz ‘. A busca é feita a partir do fim de s. O caracter ‘p’ é encontrado na posição 144. 
A chamada 
« s.find_first_not_of( “heTv lusinodrpayft” ); 
na linha 37 usa a função find_first_not_ofpara encontrar o primeiro caractere no string s não contido em “heTv lusinodrpayft’. A busca é feita a partir do início de s. 
A chamada 
« s.find_last_not_of( ‘heTv lusinodrpayft” ) « endi; 
na linha 42 usa a função find last not of para encontrar o primeiro caractere não contido em “heTv lusinodrpayft’, mas com a busca sendo feita a partir do fim de s. 
19.8 Substituindo caracteres em um string 
A Fig. 19.7 demonstra as funções string para substituição e eliminação de caracteres. 
Fig. 19.7 Demonstrando as funções erase e replace (parte 1 de 2). 
1 
II Fig. 19.7: figl9_07.cpp 
2 
// Demonstrando as 
funções erase e replace 
3 
#include <iostream> 
4 
5 
using std::cout; 
6 
using std::endl; 
7 
8 
#include <string> 
902 C++ COMO PROGRAMAR 
9 
10 using std::string; 
1] 
int main() 
/1 o compilador concatena todas as partes em um só string 
string s( “The values in any left subtree 
“\nare less than the value in the” 
\nparent node and the values in” 
“\nany right subtree are greater” 
“\nthan the value in the parent node ); 
// remove todos os caracteres, 
// da posição 62 até o fim de s 
s.erase( 62 ); 
// exibe o novo string 
cout « String original depois de executar erase:\n” « s 
« “\n\nDepois da primeira substituição:\n”; 
// substitui todos os espaços por um ponto 
int x = s.find( “ “ 
while ( x < string: :npos 
s.replace( x, 1, “.“ 
x = s . f ind (““, x + 1 
36 cout « s « “\n\nDepois da segunda substituição:\n”; 
37 
// substitui todos os pontos por dois ponto-e-vírgulas 
// NOTA: isto vai escrever em cima de outros caracteres 
x = s. f ind ( “.“ ) 
while ( x < string::npos 
s.replace( x, 2, “xxxxx;;yyy”, 5, 2 ); 
x = s.find( “.“, x + 1 ); 
String original depois de executar erase: 
The values in any left subtree 
are less than the value in the 
Depois da primeira substituição: 
The . values . in . any. left. subtree 
are. less . than. the . value . iri. the 
Depois da segunda substituição: 
The; ;alues; ;n; ;ny; ;eft; ;ubtree 
are; ;ess; ;han; ;he; ;alue; ;n; ;he 
Fig. 19.7 Demonstrando as funções erase e replace (parte 2 de 2). 
4 
12 
13 
14 
15 
16 
17 
18 
19 
20 
21 
22 
23 
22 
25 
26 
27 
28 
29 
30 
31 
32 
33 
34 
35 
} 
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 
48 
cout « s « endl; return 0; 
O programa declara e inicializa o string s. A linha 23 
s.erase( 62 ); 
CAPÍTULO 19 - A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 903 
usa a função erase para eliminar todos os caracteres, do elemento 62 até o fim de s. 
As linhas 30 a 34 
int x s.f ind 
while ( x < string: :npos 
s.replace( x, 1, 
x = s f ind (““, x + 1 
usam a função f ind para encontrar cada ocorrência do caractere espaço. Cada espaço é então substituído por um ponto através de uma chamada para a função replace. A função replace recebe três argumentos, o subscrito inicial, o número de caracteres a serem substituídos e o string para substituição. A constante string: : npos representa o máximo comprimento do string. A função f ind retorna s tring: : npos quando o fim de s é atingido. 
As linhas 40 a 44 
x = s . find ( “.“ 
while ( x < string: :npos ) { 
s.replace( x, 2, “xxxxx;;yyy”, 5, 2 ); 
x = s.find( “.“, x + 1 ); 
usam a função f ind para encontrar cada ponto e a função replace para substituir cada ponto e seu caractere subseqüente por dois ponto-e-vírgulas. Os argumentos passados para replace são o subscrito do elemento onde começa a operação de substituição, o número de caracteres a substituir, um string de caracteres de substituição do qual um substring é usado para substituir caracteres, o elemento no string de caracteres onde começa o substring de substituição e o número de caracteres, no string de caracteres usado para substituição, que serão usados. 
19.9 Inserindo caracteres em um string 
A classe string fornece funções para inserir caracteres em um string. O programa da Fig. 19.8 demonstra os recursos de insert de string. 
1 II Fig. 19.8: figl9O8.cpp 
2 /1 Demonstrando as funções de inserção em strings. 
3 #include <iostream> 
4 
5 using std::cout; 
6 using std: :endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 { 
14 string si( “início fim” ), 
15 s2 ( “meio “ ) , s3 ( “12345678” ) , s4 ( “xx” 
16 
17 cout « “Strings iniciais:\nsi: “ « si 
18 « “\ns2: “ « s2 « “\ns3: “ « s3 
19 « “\ns4: “ « s4 « “\n\n”; 
20 
21 II insere “meio “ na posição 7 de si 
22 si.insert( 7, s2 ); 
Fig. 19.8 Demonstrando as funções insert de string (parte 1 de 2). 
904 C++ COMO PROGRAMAR 
23 
24 II insere ‘xx” na posição 3 de s3 
25 s3.insert( 3, s4, 0, string::npos ); 
26 
27 cout « “Strings depois da inserção:\nsi: “ « si 
28 « “\ns2: “ « s2 « “\ns3: “ « s3 
29 « ‘\ns4: “ « s4 « endi; 
30 
31 return 0; 
32 
Strings iniciais: 
si: inicio fim 
s2: meio 
s3: i2345678 
s4: xx 
Strings depois da inserção: 
si: inicio meio fim 
s2: meio 
s3: 123xx45678 
s4: xx 
Fig. 19.8 Demonstrando as funções insert de string (parte 2 de 2). 
O programa declara e inicializa quatro strings si, s2, s3, e s4. Cada string é então exibido. A linha 22 sl.insert( 7, s2 ); 
usa a função insert para inserir o string s2 antes do elemento 7. 
A linha 25 
s3.insert( 3, s4, 0, string::npos ); 
usa insert para inserir s4 antes do terceiro elemento de s3. Os dois últimos argumentos especificam o elemento de início de s4 e o número de caracteres de s4 que devem ser inseridos. 
1 Dica de desempenho 19.1 
f Operações de inserção podem resultar em operações adicionais de administração de memória que podem diminuir o desempenho. 
19.10 Conversões para strings char* no estilo da llnguagem C 
A classe string fornece funções para a conversão de strings para o estilo de strings usado na linguagem C. Como mencionado anteriormente, diferentemente de strings no estilo da linguagem C, strings não são necessariamente terminados com nulos. Estas funções são úteis quando uma determinada função recebe um string no estilo de C como argumento. O programa da Fig. 19.9 demonstra a conversão de strings para o estilo de strings usado em C. 
Fig. 19.9 Convertendo strings para strings e arrays de caracteres no estilo de C (parte 1 de 2). 
i 
// Fig. 19.9: figl9O9.cpp 
2 
II Convertendo para 
strings ao estilo de C. 
3 
#include <iostream> 
4 
5 
using std::cout; 
CAPÍTULO 19-A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 905 
6 using std: :endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 int main() 
13 
14 string s( “STRINGS” ); 
15 const char *ptrl = 0; 
16 int len = s.lengthO); 
17 char *ptr2 = new char[ len + 1 1; // incluindo o nulo 
18 
19 II copia caracteres do string para a memória alocada por new 
20 s.copy( ptr2, len, O 
21 ptr2[ len ] = 0; II acrescenta terminador nulo 
22 
23 II output 
24 cout « “O string s é “ « s 
25 « “\ns convertido para um string ao estilo de C é 
26 « s.c_str() « “\nptrl é “; 
27 
28 II Atribui o const char * retornado pela função data O) 
29 II ao pointeiro ptrl. NOTA: esta é uma atribuição 
30 II potencialmente perigosa. Se o string for modificado, 
31 // o ponteiro ptrl pode se tornar inválido. 
32 ptrl = s.data 
33 
34 for ( int k = 0; k < len; ++k 
35 cout « ( ptrl + k ); II usa aritmética de ponteiros 
36 
37 cout « “\nptr2 é “ « ptr2 « endl; 
38 delete [1 ptr2; 
39 return 0; 
40 } 
O string s é STRINGS 
s convertido para um string ao estilo de C e’ STRINGS 
ptrl é STRINGS 
ptr2 é STRINGS 
Fig. 19.9 Convertendo strings para strings e arrays de caracteres no estilo de C (parte 2 de 2). 
O programa declara s tring como int, e dois ponteiros. O string s é inicializado com “STRINGS”, ptrl é inicializado com O, e len é inicializado com o comprimento de s. A memória é alocada dinamicamente e associada ao ponteiro ptr2. 
A linha 20 
s.copy( ptr2, len, O ); 
usa a função copy para copiar s para o array apontado por ptr2. A conversão de string para um string de caracteres no estilo de C é implícita. A linha 21 coloca um caractere nulo de terminação no array ptr2. 
A primeira inserção em stream da linha 26 
« s.cstr() 
exibe o const char* terminado em nulo retornado de c_str quando ostring s é convertido. 
906 C++ COMO PROGRAMAR 
A linha 32 
ptrl s.dataO; 
atribui um array de caracteres const char* no estilo de C retornado por data, não terminado em nulo, ao ponteiro ptrl. Note que neste exemplo não modificamos o string s. Se o string s fosse modificado. ptrl se tornaria inválido - o que levaria a resultados imprevisíveis. 
Note que o array de caracteres retornado por data e o string no estilo de C retornado por cstr têm tempo 
de vida limitado. Eles são possuídos pela class string e não devem ser eliminados com delete. 
As linhas 34 e 35 usam aritmética de ponteiros para exibir o array apontado por ptrl. Nas linhas 37 e 38, o 
string no estilo de C apontado por ptr2 é exibido e a memória alocada para ptr2 é deletada para evitar “perda de memória”. 
Erro comum de programação 19.6 
Não terminar com um caractere nulo o array de caracteres retornado por data ou copy pode levar a 
erros durante a execução. 
Boa prática de programação 19.1 
Sempre que possível, use strings, porque são mais robustos que os strings no estilo de C. Err comum de programação 19.7 
Converter um s tring que contém um ou mais caracteres nulos para um string no estilo de Cpode causar erros de lógica. Os caracteres nulos são interpretados como terminadores para strings no estilo de C. 
19.11 Iteradores 
A classe string fornece iteradores para percorrer strings para frente e para trás. Os iteradores fornecem acesso caracteres individuais com uma sintaxe que é semelhante à das operações com ponteiros. Iteradores não são testados quanto à validade do intervalo. Note que nesta seção damos “exemplos mecânicos” para demonstrar o uso de iteradores. Discutiremos usos mais robustos de iteradores no próximo capítulo. O programa da Fig. 19.10 demonstra os iteradores. 
As linhas 14 e 15 
string s( “Testando iteradores” ); 
string::const_iterator ii = s.begin(); 
declara string s e string: constiterator ii. Um const_iterator é um iterador que não pode modificar o contêiner -através do qual ele está iterando. O iterador ii é inicializado para o início de s com a função begin da classe string. Existem duas versões de begin, uma versão que retorna um iterator para iterar através de um string não-const e uma versão const que retorna um const iterator para iterar através de um string const. O string s é então exibido. 
1 II Fig. 19.10: figl9_10.cpp 
2 II Usando um iterador para exibir um string. 
3 #include <iostrearn> 
4 
5 using std::cout; 
6 using std::endl; 
7 
8 #include <string> 
Fig. 19.10 Usando um iterador para exibir um string (parte 1 de 2). 
CAPÍTULO 19- A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 907 
9 
10 using std::string; 
11 
12 int main() 
13 
14 string s( ‘Testando iteradores” ); 
15 string::const_iterator ii = s.begin 
16 
17 cout « “s = “ « s 
18 « “\n(Usando o iterador ii) s é: 
19 
20 while ( ii != s.end() ) { 
21 cout « i1; II derreferencia o iterador para obter caractere 
22 ++il; II avança o iterador para o próximo caractere 
23 
24 
25 cout « endi; 
26 return 0; 
27 
s = Testando iteradores 
(Usando o iterador ii) s é: Testando iteradores 
Fig. 19.10 Usando um iterador para exibir um string (parte 2 de 2). 
As linhas 20 a 23 
while ( ii != s.end() ) 
cout « i1; II derreferencia o iterador para obter caractere 
++il; II avança o iterador para o próximo caractere 
usam o iterador ii para “percorrer” s. A função end retorna um iterador para a primeira posição após o último elemento de s. Os conteúdos de cada posição são impressos primeiramente derreferenciando o iterador, de forma semelhante à que usamos para derreferenciar um ponteiro, e o iterador é então avançado uma posição, usando o operador ++. 
A classe string fornece as funções membro rend e rbegin para acessar caracteres individuais do s tring em ordem inversa, do fim do string para o começo do string. As funções membro rend e rbegin podem retornar reverse iterators e const reverse iterators (dependendo de se o string é ou não const). Pedimos ao leitor para demonstrar isto nos exercícios. Usaremos mais iterators e reverse iterators no Capítulo 20. 
® Dica de teste e depura çõo 19.1 
Use a função membro at de string (ao invés de iteradores) quando você quiser que seja testada a 
validade do intervalo. 
19.12 Processamento de strings em streams 
Além da EIS em streams padrão e da EIS em streams de arquivos, a EIS em streams de C++ inclui recursos para ler de strings na memória e escrever em strings na memória. Estes recursos são freqüentemente chamados de EI S na memória ou processamento de strings em streams. 
908 C++ COMO PROGRAMAR 
A leitura a partir de um string é suportada pela classe istringstream. A saída para um string é 
suportada pela classe ostringstream. Os nomes istringstream e ostringstreain são na realidade aliases (nomes alternativos). Estes nomes são definidos com os typedefs 
typedef basic_istringstream< char > istringstream; 
typedef basic_ostringstream< char > ostringstream; 
As classes basic istringstream e basic ostringstream fornecem a mesma funcionalidade das classes is tream e os tream mais Outras funções membro específicas para a formatação na memória. Os programas que usam formatação na memória devem incluir os arquivos de cabeçalho <sstream> e <iostreain>. 
Uma aplicação destas técnicas é a validação de dados. Um programa pode ler uma linha inteira de uma vez só do stream de entrada para um string. Em seguida, um rotina de validação pode examinar o conteúdo do string e, se necessário, corrigir os dados. Então, o programa pode continuar a fazer a entrada a partir do string, sabendo que os dados de entrada estão no formato adequado. 
Fazer saída para um string é uma maneira interessante de tirar partido dos poderosos recursos de formamção de streams de C++. Os dados podem ser preparados em um string para imitar o formato editado na tela. Aquele string pode, então, ser gravado em um arquivo em disco para preservar a imagem da tela. 
Um objeto ostringstream usa um objeto string para armazenar os dados que são enviados para a 
saída. A função membro str de ostringstream retorna uma cópia string do string. 
A Figura 19.11 demonstra um objeto ostringstream. O programa cria o objeto outputString de 
ostringstream (linha 18) e usa o operador de inserção em stream para fazer a saída de uma série de strings e valores numéricos para o objeto. 
1 II Fig. 19.11: figl9ll.cpp 
2 /1 Usando um objeto ostringstream alocado dina.micamente. 
3 #include <iostream> 
4 
5 using std:;cout; 
6 using std::endl; 
7 
8 #jnclude <string> 
9 
10 using std::string; 
11 
12 #include <sstream> 
13 
14 using std::ostringstream; 
15 
16 int main() 
17 
18 ostringstream outputString; 
19 string si ( “Saída de diversos tipos de dados “ 
20 s2( “usando um objeto ostringstream:” ), 
21 s3( “\n double: “ 
22 s4( “\n int: “ 
23 s5( “\nendereço de int: “ 
24 double d = 123.4567; 
25 inti22; 
26 
27 outputString « si « s2 « s3 « d « s4 « i « s5 « &i; 
28 cout « “outputString contém:\n” « outputString.strO; 
29 
30 outputString « “\nmais caracteres adicionados”; 
31 cout « “\n\napós as inserções adicionais no stream,\n” 
Fig. 19.11 Usando um objeto ostringstream alocado dinamicamente (parte 1 de 2). 
CAPÍTULO 19 - A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 909 
32 « “outputString contém:\n” « outputString.str() 
[e 33 « endi; 
32 
35 return O; 
36 
Fig. 19.11 Usando um objeto ostringstreain alocado dinamicamente (parte 2 de 2). 
A linha 27 
outputString « si « s2 « s3 « d « s4 « i « s5 « &i; 
faz a saída de string si. string s2, string s3, doubie d, string s4. int i, string s5 e do endereço de int i, todos para outputString na memória. A linha 28 
cout « “outputString contém:\n” « outputString.str 
usa a chamada outputString. str ( ) para exibir uma cópia do string criado na linha 27. A linha 30 demonstra que mais dados podem ser anexados ao string na memória, simplesmente aplicando-se o operador de inserção em stream a outputString. A linha 32 exibe o string outputString após a anexação de caracteres adicionais. 
Um objeto istringstreamlê dados de um string na memória para variáveis do programa. Os dados são armazenados em um objeto istrings tream como caracteres. A entrada do objeto istrings tream funciona de maneira idêntica à entrada de dados de um arquivo qualquer, em geral, ou da entrada padrão em particular. O fim do string é interpretado pelo objeto istringstreain como um fim de arquivo. 
A Fig. 19.12 demonstra a entrada de um objeto istringstream. 
As linhas l8e 19 
string input( Testando leitura 123 4.7 A” ); 
istringstream inputString( input ); 
criam o string input contendo os dados e o objeto inputString de istringstream construído para conter os dados no string input. O string input contém os dados 
Testando leitura 123 4.7 A 
os quais, quando lidos como entrada para o programa, consistem em dois strings (“Testando”e “leitura”), um valor int (123), um valor double (4.7) e um valor char (‘A’). Estes caracteres são extraídos para as variáveis stringi. string2, i. de c, respectivamente na linha 25. 
inputString » stringi » string2 » i » d » c; 
A saída dos dados é então feita nas linhas 27 a 33. O programa tenta ler novamente do inputString com o 
comando if/else da linha 38. Como não há mais dados, a condição do if (linha 40) é avaliada como false e 
a parte eise da estrutura if/eise é executada. 
outputString contém: 
Saída de diversos tipos de dados 
usando 
um 
objeto 
ostringstream: 
doubie: 123.457 
int: 22 
endereço de int: OO68FDOC 
após as inserções adicionais no 
streain, 
outputString contém: 
Saida de diversos tipos de dados 
usando 
um 
objeto 
ostringstreani: 
doubie: 123.457 
int: 22 
endereço de int: OO68FDOC 
mais caracteres adicionados 
910 C++ COMO PROGRAMAR 
1 II Fig. 19.12: figl9_12.cpp 
2 II Demonstrando a entrada de dados a partir de um objeto istringstream. 
3 #include <iostream> 
4 
5 using std::cout; 
6 using std::endl; 
7 
8 #include <string> 
9 
10 using std::string; 
11 
12 #include <sstream> 
13 
14 using std::istringstream; 
15 
16 int main() 
17 
18 string input( “Testando leitura 123 4.7 A’ ); 
19 istringstream inputString( input ); 
20 string stringl, string2; 
21 int i; 
22 double d; 
23 char c; 
24 
25 inputString » stringl » string2 » i » d » e; 
26 
27 cout « “Os seguintes itens foram extraídos\n” 
28 « “do objeto istringstream:” 
29 « “\nstring: “ « stringl 
30 « “\nstring: « string2 
31 « ‘\n int: “ « i 
32 « “\ndouble: “ « d 
33 « “\n char: “ « c; 
34 
35 // tentativa de leitura de stream vazio 
36 long x; 
37 
38 inputString » x; 
39 
40 if ( inputString.good() 
41 cout « “\rz\nvalor long é: “ « x « endl; 
42 else 
43 cout « “\n\ninputString está vazio” « endl; 
44 
45 return 0; 
46 } 
Os seguintes itens foram extraídos 
do objeto istringstream: 
string: Testando 
string: leitura 
int: 123 
double: 4.7 
char: A 
inputString está vazio 
Fg. 19.12 Demonstrando a entrada de dados a partir de um objeto istringstream. 
CAPÍTULO 19- A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 911 
Resumo 
• O gabarito de classe basic string de C++ fornece operações típicas de manipulação de strings, tais como cópia, busca, etc. 
• O comando typedef 
typedef basic_string< char > string; 
cria o tipo string para basic string< char >. Também é fornecido um typedef para o tipo wchar_t. O tipo wchat_t normalmente armazena dois bytes (16 bits) para suportar outros conjuntos de caracteres. O tamanho de wchart não é fixado pelo padrão. 
• Para usar strings, inclua o arquivo de cabeçalho <string> da biblioteca padrão de C++. 
• A classe string não fornece conversões de int ou char para string. 
• É permitido atribuir um único caractere a um objeto string em um comando de atribuição. 
• strings não são necessariamente terminados por nulos. 
• O comprimento de um string é armazenado no objeto string e pode ser recuperado através da função membro lenght ou size. 
• A maioria das funções membro de string aceita como argumentos uma posição de subscrito inicial e o número de caracteres sobre os quais operar. 
• Tentar passar para uma função membro de string um valor maior que o comprimento do string. como o número de caracteres a serem processados, resulta no valor sendo redefinido como o comprimento do resto do string. 
• A classe string fornece o operator sobrecarregado e a função membro assign para atribuições de strings. 
• O operador subscrito, [ ], possibilita o acesso direto a qualquer elemento de um string. 
• A função at oferece um acesso verificado - ultrapassar qualquer dos limites do s tririg dispara uma exceção outof range. O operador subscrito, [ ], não oferece um acesso verificado. 
• A classe string fornece os operadores sobrecarregados + e = e a função membro append para realizar concatenação de strings. 
• A classe string fornece os operadores sobrecarregados ==, =, <, >, <=, >=, para comparação de strings. 
• A função compare de string compara dois strings (ou substrings) e retoma O se os stririgs são iguais, um número positivo se o primeiro string é lexicograficamente maior que o segundo ou um número negativo se o primeiro string é lexicograficamente menor que o segundo. 
• A função substr recupera um substring de um string. 
• A função swap permuta (troca) o conteúdo de dois strings. 
• As funções size e lenght retomam o tamanho ou comprimento de um string. (i.e, o número de caracteres correntemente armazenado no string). 
• A função capacity retoma o número total de elementos que podem ser armazenados no string sem aumentar os requisitos de memória do string. 
• A função max size retoma o tamanho do maior string possível que pode ser armazenado. 
• A função resize muda o comprimento do string. 
• As funções find da classe string, find, rfind, find first of, find last of, firid first not of e findlastnotof procuram strings ou caracteres em um stririg. 
• O valor string: : pos é freqüentemente usado para indicar o processamento de todos os elementos de um string em funções que requerem um número de caracteres a serem processados. 
• A função erase apaga elementos de um strirzg. 
• A função replace substitui caracteres em um string. 
912 C++ COMO PROGRAMAR 
• A função irisert insere caracteres em um string. 
• A função cstr retoma um const char * apontando para um string de caracteres terminado com nulo, no estilo de C, que contém todos os caracteres em um string. 
• A função data retorna um const char * apontando para um array de caracteres não-terminado com nulo, no estilo de C, que contém todos os caracteres em um string 
• A classe string fornece as funções membro end e begiri para acessar caracteres individuais. 
• A classe string fornece as funções membro rend e rbegin para acessar caracteres individuais em um string na ordem inversa, do fim de um string para o começo do mesmo. 
• A leitura de um string é suportada pelo tipo istringstream. A saída para um string é suportada pelo tipo os- trings tream. 
• Programas que usam formatação na memória devem incluir os arquivos de cabeçalho <sstream> e <iostream>. 
• A função membro str de ostringstream retorna uma cópia string do string. 
Terminologia 
acesso verificado função findfirstof 
arquivo de cabeçalho <sstream> função find_last_not_of 
arquivo de cabeçalho <string> função findlastof 
capacidade função getline 
caracteres largos função insert 
classe istringstream função lenght 
classe ostringstream função max_size 
classe string função membro siream de string str 
comprimento de um s tring função rbegin 
constiterator ftinção rend 
constreverseiterator função replace 
EIS in-core função resize 
E/S na memória função size 
exceção lenghterror função substr 
exceção out_of_range função swap 
exceção range_error funçõesflnd 
função access iterator 
função at namespace std 
função c_s tr operador subscrito, 
função capacity operadores de igualdade: =, = 
função compare operadores relacionais:>, <, >, < 
função copy operadores: +, +=. «, », E 1 
função data reverse_iterator 
função empty string vazio 
função erase tamanho máximo de um string 
função f ind ipo wchar_t 
função find_first_not_oftypedef basic_string<char> string 
Erros comuns de programação 
19.1 Tentar converter um ínt ou um char para um string através de uma atribuição em uma declaração ou através de um argumento para um construtor é um erro de sintaxe. 
19.2 Construir um string que é longo demais para ser representado dispara uma exceção length_error. 
19.3 Acessar um subscrito de stringfora dos limites do string usando a função at dispara uma exceção outof range. 
19.4 Acessar um elemento além do tamanho de um string usando o operador subscrito é um erro de lógica. 
19.5 Não terminar um string com aspas é um erro de sintaxe. 
CAPÍTULO 19 - A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 913 
19.6 Não terminar com um caractere nulo o array de caracteres retornado por data ou copy pode levar a erros durante a execução. 
19.7 Converter um string que contém um ou mais caracteres nulos para um string no estilo de C pode causar erros de lógica. Os caracteres nulos são interpretados como terminadores para strings no estilo de C. 
Boa prática de programação 
19.1 Sempre que possível, use strings, porque são mais robustos que os strings no estilo de C. 
Dica de desempenho 
19.1 Operações de inserção podem resultar em operações adicionais de administração de memória que podem diminuir o desempenho. 
Dica de teste e depura ção 
19.1 Use a função membro at de string (ao invés de iteradores) quando você quiser que seja testada a validade do intervalo. 
Exercícios de auto-revisão 
19.1 Preencha os espaços em branco em cada um dos seguintes itens: 
a) O cabeçalho deve ser incluído para a classe string. 
b) A classe string pertence ao namespace 
e) A função apaga caracteres de um string. 
d) A função encontra a primeira ocorrência de qualquer caractere de uma série de caracteres. 
19.2 Diga quais das seguintes afirmações são verdadeiras e quais são falsas. Se uma afirmação é falsa, explique porquê. 
a) A concatenação pode ser executada com o operador adição +=. 
b) Os caracteres em uni string começam no elemento O. 
e) O operador de atribuição, =. copia um string. 
d) Um string no estilo de C é um string. 
19.3 Encontre o(s) erro(s) em cada um dos seguintes itens e explique como corrigi-lo. 
a) string sv( 28 ); II construct sv 
string bc( ‘z’ ); // construct bc 
b) // assuma que o namespace std é conhecido 
const char *ptr = name.dataO; II name é “joe bob’ 
ptr[ 3 ) = 
cout « ptr « endi; 
Respostas aos exercícios de auto-revisão 
19.1 a)string b)std c)erase d)findfirstof 
19.2 a) Verdadeiro. 
b) Verdadeiro. 
e) Verdadeiro. 
d) Falso. Um string é um objeto que fornece muitos serviços diferentes. Um string no estilo de C não fornece serviços. Strings no estilo de C são terminados com nulo e strings não. 
19.3 a) Não existem construtores para os argumentos passados. Deveriam ser usados outros construtores válidos convertendo os argumentos para strings se necessário. 
b) A função data não adiciona um terminador nulo. Em seu lugar use c_str. 
914 C++ COMO PROGRAMAR 
Exercícios 19.14 1 
para mc 
19.4 Preencha os espaços em branco em cada um dos seguintes itens: 
a) As funções , , e convertem strings para strings no estilo de C. 19.15 1 
b) A função é usada para atribuição, uma sei 
c) é o tipo de retomo da função rbegin. 19.16 1 
d) A função é usada para recuperar um substring. que cad 
19.5 Diga quais das seguintes afirmações são verdadeiras e quais são falsas. Se uma afirmação é falsa, explique por quê. 
a) stririgs são terminados com nulos. d 
b) A função max size retorna o tamanho máximo para um string. po e se 
c) A função até capaz de disparar uma exceção outof range. 
d) Por default, strings são passados por referência. 
Note qu 
19.6 Encontre quaisquer erros em cada um dos seguintes itens e explique como corrigi-lo(s). etc 
a) std::cout « s.data() « std::endl; /1 s é “heilo” gadasn 
b) erase ( s . rfind( “x” ) , 1 ) ; // s é “xenon” 19 17 r 
c) string& foo( void ) teres.O 
se o usu 
string s ( “HelJ.o” ); 
1/ outros comandos da função 19.18 E 
return; é igual 1 
‘arar 
19.7 (Criptografia simples) Algumas informações na Internet podem ser cifradas com um algoritmo simples conhecido como 19.19 F 
“rotl3” - que “gira” cada caractere 13 posições no alfabeto. Assim, ‘a corresponde a ‘n e x corresponde a ‘k’.O rotl3 19.20 
é um exemplo de criptografia simétrica por chave. Com a criptografia simétrica por chave, tanto o encriptador como o decripta do usam a mesma chave. 19.2 1 E 
a) Escreva um programa que encripta uma mensagem usando o rotl3. 1922 E 
b) Escreva um programa que decripta mensagem embaralhada usando 13 como a chave. 
c) Após escrever o programa da parte a) e da parte b), responda sucintamente à seguinte questão: se você não sabe a strto 
chave para a parte b), quão difícil você pensa que seria decifrar o código usando quaisquer recursos disponíveis? O 19.23 E 
que aconteceria se você tivesse acesso a recursos computacionais muito poderosos (p. ex., supercomputadores Cray?) 
No Exercício 19.27, pediremos que você faça isso. 19.24 
19.8 Escreva um programa usando iteradores que demonstre ouso das funções rbegin e rend. 19.25 E 
19.9 Escreva suas próprias versões das funções data e c_str. 19.26 1 
19.10 Escreva um programa que lê vários strings e imprime somente aqueles terminando em “r” ou “ia. Somente devem ser levadas em conta letras minúsculas. 
19.11 Escreva um programa que demonstra passar um s tring tanto por referência como por valor. 
19.12 Escreva um programa que lê separadamente um nome e um sobrenome e então concatena ambos em um novo string. 
19.13 Escreva um programa que joga ojogo da forca. O programa deve pegar uma palavra (que está codificada no programa ou é lida de um arquivo-texto) e exibira seguinte: 
Adivinhe a palavra XXXXXX 
Cada X representa uma letra. Se o palpite do usuário estiver correto, o programa deve exibir: 
Parabéns’ Você adivinhou minha palavra. Quer jogar de novo? sim/não 
A resposta apropriada, sim ou não, deve ser lida. Se o palpite do usuário estiver incorreto, exiba a parte apropriada do corpo da 
pessoa na forca. 19.27 
Após sete palpites errados, o usuário deve estar enforcado. O display deve se parecer com decript 
mais fr 
/ 1 \ Escrevc 
encnpt 
/ \ 19.28 
Após cada palpite, você quer exibir todos os palpites do usuário. 
CAPÍTULO 19 - A CLASSE String E O PROCESSAMENTO EM STREAM DE STRINGS 915 
19.14 Escreva um programa que lê um string e imprime o string de trás para diante. Converta todas as letras maiúsculas para minúsculas e todas as minúsculas para maiúsculas. 
19.15 Escreva um programa que usa os recursos de comparação introduzidos neste capítulo para colocar em ordem alfabética uma série de nomes de animais. Somente letras maiúsculas devem ser usadas para as comparações. 
19.16 Escreva um programa que cria um criptograma a partir de um string. Um criptograma é uma mensagem ou palavra em que cada letra é substituída por outra letra. Por exemplo, o string 
The birds naxne was squawk 
pode ser embaralhado para formar 
xms kbypo zhqs fho obrhfu 
Note que os espaços não são embaralhados. Neste caso particular, ‘T’ foi substituído por x’ , cada ‘a’ foi substituído por ,etc. Letras maiúsculas e letras minúsculas deveriam ser tratadas da mesma forma. Use técnicas semelhantes àquelas empregadas no Exercício 19.7. 
19.17 Modifique o programa do exercício anterior para permitir que um usuário solucione o criptograma fornecendo dois caracteres. O primeiro caractere especifica a letra no criptograma e o segundo caractere especifica o palpite do usuário. Por exemplo, se o usuário digita r g. então o usuário está dando o palpite que a letra r é na verdade um g. 
19.18 Escreva um programa que lê uma sentença e conta o número de palíndromos na sentença. Um palíndromo é uma palavra que 
é igual tanto lida da esquerda para direita como da direita para a esquerda. Por exemplo, ‘amor” não é um palíndromo, mas 
“arara” é um palíndromo. 
19.19 Escreva um programa que conta o número de vogais em uma sentença. Exiba a freqüência de ocorrência de cada vogal. 
19.20 Escreva um programa que insereos caracteres exatamente no meio de um string. 
19.21 Escreva um programa que apaga as seqüências “por” e “POR” de um string 
19.22 Escreva um programa que lê uma linha de texto, substitui todos os sinais de pontuação por espaços e, então, usa a função strtok da biblioteca de strings da linguagem C para separar o string em palavras individuais. 
19.23 Escreva um programa que lê uma linha de texto e então imprime o texto ao contrário. Use iteradores na sua solução. 
19.24 Escreva uma versão recursiva do Exercício 19.23. 
19.25 Escreva um programa que demonstra o uso das funções erase que recebem iterators como argumentos. 
19.26 Escreva um programa que, a partir do stririg “abcdefghijklmnopqrstuvwxyz { “, gera o seguinte: 
a 
bcb 
cdedc 
defgfed 
efghihgfe 
fghijkj ihgf 
ghijklmlkjihg 
hijklmnonnilkjih 
ijklmriopqponmlkj i 
j klmnopqrsrqponmlkj 
klmnopqrs tutsrqponmlk 
lmnopqrs tuvwvutsrqponml 
mnopqrs tuvwxyxwvutsrqponxn 
nopqrstuvwxyz { zyxwvutsrqporz 
19.27 No Exercício 19.7, pedimos que você escrevesse um algoritmo simples de criptografia. Escreva um programa que tenta 
decriptar uma mensagem “rotl3” usando a substituição de freqüência simples (assuma que você não conhece a chave). As letras mais freqüentes na frase encriptada devem ser substituidas pelas letras mais comumente usadas em inglés (a,e,i,o,u,s,t,r,etc.). Escreva as possibilidades em um arquivo, O que tornou fácil decifrar o código? Como pode ser melhorado o mecanismo de encriptação? 
19.28 Escreva uma versão do bubble sort que classifica strings. Use a função swap na sua solução.