Strings em C e C++

Prévia do material em texto

Linguagem da Programação I
8º Aula
Strings
Objetivos de aprendizagem
Ao término desta aula, vocês serão capazes de: 
• ler textos através da programação C ou C++;
• comparar strings;
• ter conhecimento de funções que facilitarão na programação com strings;
• escolher quais tipos de vetores de caracteres para programar.
Olá pessoal, 
Sejam bem-vindos à nossa última aula. Nela trataremos de um vetor 
voltado para caracteres, ou seja, variáveis para armazenar nomes e frases. Nesta 
aula será apresentado como trabalhar com string em c e em c++, mostrandoa 
diferença entre os dois modelos.
Vamos lá!
Boa aula!
Bons estudos!
49
Seções de estudo
1 - String em C
1 - String em C
2 - Funções de caracteres úteis
3 - Cabeçalho de um programa com strings em C++
4 - Declarando e Inicializando uma String
5 - Leitura e Escrita de Strings na Tela
6 - Operações com Strings
7 - Biblioteca cctype: operações com caracteres
8 - Exemplos de como manipular strings em C++
9 - Convertendo C-string e número
Não falamos até agora de vetores de caracteres, apesar de 
já utilizá-las várias vezes. Um vetor de caracteres é normalmente 
chamada de “string” em linguagem de programação. Em C++, 
existem duas maneiras de se criar e trabalhar com strings. Um 
deles é o método antigo, já utilizado pela linguagem C, de se 
declarar e trabalhar com um vetor de caracteres do mesmo 
modo que trabalhamos com vetores numéricos. O outro 
método é utilizar as facilidades da biblioteca padrão de C++, 
que define um tipo de variável específico para strings, com 
várias operações e funções próprias. Neste guia de estudos 
trabalharemos com as strings do tipo C++, por serem elas mais 
simples e ao mesmo tempo apresentarem mais recursos do que 
as strings tipo C.
O uso de strings facilita a manipulação de palavras e 
textos. Strings são basicamente vetores do tipo char, porém 
diferentemente de simples vetores, strings são “terminados” 
por um caractere “ \0”. Utilize “%s” para ler e imprimir strings 
nas funções scanf e printf. Você pode utilizar strings constantes 
para carregar vetores de caracteres nas suas declarações. Uma 
constante do tipo string é definida por uma sequência de 
caracteres entre aspas duplas (lembre-se de que uma constante 
do tipo char e um caractere entre apostrofes). Para declarar 
uma string, podemos usar o seguinte formato geral:
char nome_da_string [tamanho];
Isso declara um vetor de caracteres (uma string) com 
número de posições igual a tamanho. Note que, como temos 
que reservar um caractere para ser o terminador nulo, temos 
que declarar o comprimento da string como sendo, no mínimo, 
um caractere maior que a maior string que pretendemos 
armazenar. Vamos supor que declaremos uma string de 8 
posições e coloquemos a palavra “casa” nela. Teremos:
C A S A \0
No caso acima, as duas células não usadas têm valores 
indeterminados. Isso acontece porque a linguagem C não 
inicializa variáveis, cabendo ao programador essa tarefa. 
Portanto, as únicas células que são inicializadas são as que 
contêm os caracteres ‘c’, ‘a’, ‘s’, ‘a’ e ‘\0’.
Atenção: Existe um detalhe muito importante quanto à 
leitura de strings pelo teclado. O identificador (nome) de um 
vetor/matriz retorna automaticamente o endereço inicial 
na memória que esse vetor está armazenado. Assim sendo, é 
errado utilizar o operador de endereço (&) junto ao nome do 
vetor (BUENO, 2002).
Por exemplo, quando fazemos referência ao vetor palavra 
do código abaixo, é equivalente a & palavra [0].
#include <stdio.h>
int main () /*Este código possui um ERRO!!! O & no 
scanf do vetor/string*/
{
char sPalavra [100];
printf (“Digite uma palavra: “);
scanf (“%s”, &sPalavra);
printf (“\n\n Você digitou %s”, sPalavra);
return (0);
}
Para que esse mesmo código fique correto, basta retirar o 
operador (&) que está junto ao nome da string, ficando então 
da seguinte forma:
#include <stdio.h>
int main ()
/*Este código ESTA CORRETO!! FOI RETIRADO O 
& no scanf do
vetor/string*/
{
char sPalavra [100];
printf (“Digite uma palavra: “);
scanf (“%s”, sPalavra);
sPalavra
printf (“\n\n Você digitou %s”, sPalavra);
return (0);
}
# Nesse programa acima, o tamanho máximo da string 
em C que você pode entrar é uma string de 99 caracteres.
Funções da biblioteca padrão
A biblioteca padrão fornece várias funções úteis para 
manipular strings. A seguir mostraremos algumas delas. Para 
usá-las, você deve incluir o cabeçalho string.h no início dos 
seus arquivos.
strlen
strlen retorna o tamanho, em caracteres, de uma string 
dada. Na verdade o strlen() procura o terminador de string e 
calcula a distância dele ao início da string. Por exemplo:
char nome [15] = “Maria da Silva”;
int s = strlen (nome);
// s conterá o valor 14
strcpy
strcpy copia o conteúdo de uma string para outra e 
coloca um terminador de string. Sua sintaxe é 
strcpy (destino, origem).
char nome[] = “Clarice Lispector”;
char nome2[] = “Oswald de Andrade”;
strcpy (nome, nome2);
// agora nome conterá “Oswald de Andrade”
Tome cuidado com strcpy(), pois se a string a ser copiada 
for maior que a string de destino, provavelmente você gravará 
dados em lugares indesejados ― um problema conhecido 
como estouro de buffer. Para evitar esse problema, use 
50Linguagem da Programação I
a função strncpy, que recebe um terceiro argumento que 
corresponde ao número máximo de caracteres a serem 
copiados (VICTORINE, 2005). 
char msg[] = “Bom dia!”;
char nome[] = “Maria da Silva”;
strncpy (msg, nome, strlen (msg));
// agora msg conterá “Maria da”
strcat
strcat concatena duas strings, adicionando o conteúdo 
da segunda ao final da primeira, além do terminador (\0). 
Note que a primeira string deve ter espaço suficiente para 
conter a segunda, para que não ocorra um “estouro de 
buffer”. Por exemplo:
char nome [50] = “Maria”;
char sobrenome[] = “ da Silva”;
strcat (nome, sobrenome);
// agora nome contém “Maria da Silva”
Analogamente à função strncpy, existe também a função 
strncat, onde o número máximo de caracteres a serem 
copiados é o terceiro argumento.
strcmp
Se você tentar criar duas strings com o mesmo conteúdo 
e compará-las como faria com números, verá que elas “não 
são iguais”. Isso ocorre porque, na verdade, o que está sendo 
comparado são os endereços de memória onde estão guardadas 
as strings. Para comparar o conteúdo de duas strings, você deve 
usar a função strcmp (ou suas variantes) (VICTORINE, 
2005). 
int strcmp (char *s1, char *s2);
O valor de retorno é:
• menor que zero se s1 for menor que s2;
• igual a zero se s1 e s2 são iguais;
• maior que zero se s1 for maior que s2.
Costuma parecer estranho dizer que uma string é menor 
ou maior que outra; na verdade essa comparação é entre a 
primeira letra que difere nas duas strings. Assim, se tivermos 
s1 = “abc” e s2 = “abcd”, diremos que s2 é maior que s1, pois 
na primeira posição em que as duas strings diferem, a letra em 
s2 é “maior”.
É importante notar que a comparação feita por strcmp 
distingue maiúsculas de minúsculas. Isto é, as strings “ABC” e 
“abc” não são iguais para essa função.
As variantes mais usadas de strcmp são:
• strncmp - compara apenas os n primeiros caracteres 
das duas strings, sendo n um terceiro argumento.
• stricmp - compara duas strings sem distinção entre 
maiúsculas e minúsculas. A sintaxe é igual à de strcmp. Essa 
função não faz parte da biblioteca padrão, mas é comumente 
encontrada como extensão particular de várias delas.
strrchr
strrchr retorna um ponteiro sobre a última ocorrência 
de c de uma string, apontada por s se não retorna NULL . Sua 
sintaxe é strrchr (const char *s, int c).
Exemplo:
char path [50] = “/teste/string”;
char *p = strrchr(path, ‘/’);
*p++;
Printf (“Resultado: %s \n”, p);
memcpy
Sintaxe:
#include <string.h>
void *memcpy (void *dest, const void *srce, size_t n);
Descrição: copiar um bloco de n octetos de srce para dest.
Atenção: 
Se as regiões de srce e dest se sobreporem, o 
comportamento da função é imprevisível.
Valor de retorno: memcpy retorna o valor dedest.
Ex:
#include <stdio.h>
#include <string.h>
int main() {
 int tab[2][5] = { { 1, 2, 3, 4, 5},
 {11, 12, 13, 14, 15} };
 int temp[2][5];
 memcpy (temp, tab, sizeof(tab));
 puts (“Resultado:\n”);
 printf (“temp[1][4] = %d\n”, temp[1][4]);
 return 0;
}
memset
Sintaxe:
#include <string.h>
 void *memset (void *buffer, int c, size_t n);
Descrição: memset inicializa n octetos do buffer com o 
inteiro c.
Valor de retorno: o valor do buffer.
Ex:
#include <stdio.h>
#include <string.h>
int main() {
 char buf[] = “W.I.K.I.”;
 printf (“Buf antes ‘memset’: %s\n”, buf);
sprintf
Descrição: A diferença entre printf e sprintf é que printf 
retorna o resultado para a saída padrão (tela), enquanto sprintf 
retorna o resultado em uma variável. Isso é muito conveniente, 
porque você pode simplesmente digitar a frase que você quer 
ter e sprintf lida com a própria conversão e coloca o resultado 
na string que você deseja (NORTON, 1994). 
Sintaxe:
#include <stdio.h>
 int sprint (char *s, const char *formato, ...);
Ex:
 #include <stdio.h> 
 #include <string.h> 
 
 int main() { 
 char var[256]; 
51
 char sobrenome[] = “Simpson”; 
 char nome[] = “Homer”; 
 
 int idade = 30; 
 
 sprintf (var, “%s %s tem %d anos”, sobrenome, 
nome, idade); 
 
 printf (“Resultado : %s\n”, var); 
 
 return 0; 
 }
2 - Funções de caracteres úteis
As seguintes funções estão no cabeçalho da biblioteca 
<cctype>
toupper() – (to+upper) retorna à maiúscula de uma 
letra. É uma função de um argumento – o caractere. No caso 
do argumento não ser uma letra, a função retorna o mesmo 
caractere que é argumento.
tolower() – (to+lower) o mesmo comportamento que 
toupper(), porém com o resultado em minúscula.
#include <iostream>
 #include <cctype>
 using namespace std;
 int main(void)
 {
 char ch;
 do {
 cout << “Pressionar S ou s para sair, \n qualquer 
outra tecla para continuar: “; 
 cin.get (ch);
 ch = toupper (ch);
 if (ch! = ‘\n’)
 cin.ignore();
 if (ch! = ‘S’)
 cout << “Deseja continuar?\n”;
 else
 cout << “Saindo...”;
 } while (ch! = ‘S’);
#ifdef WIN32
 system (“pause”);
#endif
 return 0;
 }
3 - Cabeçalho de um programa com 
strings em C++
4 - Declarando e Inicializando uma 
String
O modelo de string declarado como vetor apresentado 
acima é o estilo de strings usado pela linguagem C pura. Para 
manipular esse tipo de string é preciso ter certo cuidado, pois 
o vetor sempre tem um tamanho definido e caso façamos 
um acesso a um endereço fora do vetor, invadiremos outras 
áreas de memória que não temos como definir o que são e, 
portanto poderemos fazer o programa parar de funcionar. 
Em muitos sistemas pode também haver danos aos outros 
programas e até mesmo ao próprio sistema operacional. 
Porém, em sistemas operacionais mais sofisticados como o 
GNU/Linux, que possuem gerenciamento de memória com 
proteção de memória, apenas o programa que causou a falha 
irá parar de funcionar.
Para manipular esse tipo de string a biblioteca padrão da 
linguagem C dispõe de diversas funções.
Vale a pena ler o livro: Programar. Disponível em: 
<https://pt.wikibooks.org/wiki/Programar_em_C>. 
Acesso em: 25 de nov. 2017. 
No estilo C++, como era de se esperar, as strings são 
objetos, eles podem ser criados facilmente através da biblioteca 
padrão referenciada pelo arquivo de cabeçalho <string>. As 
strings são objetos com recursos que permitem manipular 
os seus caracteres com as funcionalidades das funções 
da linguagem C e mais algumas características próprias 
possibilitadas pela orientação a objetos (JAMSA, 1999).
Todo programa que utilize strings deve conter a seguinte 
linha de inclusão em seu cabeçalho:
#include <string>
#include <cstring>
#include <string.h>
Isso faz com que o compilador inclua no programa a 
biblioteca padrão de strings de C++, que contém todas as 
definições do tipo string, assim como as funções e facilidades 
relacionadas a esse tipo. Assim, o cabeçalho de um programa 
típico envolvendo strings será:
#include <iostream>
#include <string>
using namespace std;
A biblioteca C++ possui uma grande quantidade de 
funções que facilitam o uso do tipo string, tais como, separar 
um string, retornar somente uma parte da string e entre 
outros. 
Para saber mais sobre C++, veja os seguintes links: 
<C++ Reference> e <Cpluplus.com>. Acesso em: 25 de 
nov. 2017. 
Declaramos strings da mesma maneira que declaramos 
variáveis: explicitando o tipo da variável (no caso, string) e seu 
nome. Veja a sintaxe e o exemplo abaixo:
string <nome da string>;
string nacionalidade;
string sobrenome;
Uma string declarada dessa forma estará vazia até que um 
valor seja atribuído a ela, das maneiras já estudadas: através de 
uma atribuição, ou de uma entrada de dados do usuário, por 
exemplo.
C++ possui uma série de facilidades para a inicialização 
de strings. Cada um desses diferentes métodos é chamado de 
52Linguagem da Programação I
“inicializador” de uma string (Sonoda, 2006). Abaixo serão 
apresentados os quatro principais inicializadores de string():
string s1; - Cria uma string vazia, chamada s1. Esta é a 
inicialização default de uma string: toda string criada dessa forma está 
vazia.
string s2 (s1); - Cria a string s2 como uma cópia de outra string 
(nesse caso, s1).
string s2 (“Esta é uma string literal”); - Cria a string s2 como 
uma cópia da string literal entre os parênteses.
string s2 (x, ‘c’); - Cria a string s2, que contém x cópias do 
caractere entre aspas (no caso, c).
O programa abaixo exemplifica os métodos descritos 
acima:
#include <iostream>
#include <string>
using namespace std;
int main()
{
string vazia;
string ditado (“Casa de ferreiro, espeto de pau”);
string cópia_ditado (ditado);
string letra_z ( 42, ‘z’);
cout <<”Mostrando o conteúdo da string ‘vazia’:”<< 
endl;
cout << vazia;
cout <<”Mostrando o conteúdo da string ‘ditado’:”<< 
endl;
cout << ditado;
cout <<”Mostrando o conteúdo da string ‘cópia_
ditado’:”<< endl;
cout << cópia_ditado;
cout <<”Mostrando o conteúdo da string ‘letra_z’:”<< 
endl;
cout << letra_z;
system (“PAUSE > null”);
return 0;
}
5 - Leitura e Escrita de Strings na Tela
Utilizamos cin e cout para ler e escrever strings, assim 
como fazemos com variáveis simples. Basicamente, cin e cout 
tratam strings como se fossem variáveis simples, facilitando 
sua manipulação e seu uso em programas.
Já vimos no programa exemplo anterior que utilizamos 
cout para exibir strings inteiras na tela. O cout exibe todos os 
caracteres da string, e detecta automaticamente o fim dela.
Utiliza-se o comando cin para ler strings através do 
teclado. A sintaxe é a seguinte:
cin >> <nome da strin>;
Como já vimos, cin lerá os caracteres inseridos através 
do teclado até encontrar um espaço em branco (tecla barra 
de espaço) ou o fim da entrada (tecla Enter). Quando cin 
encontra um espaço em branco, todos os caracteres após 
este espaço são ignorados. O programa abaixo lê entradas 
do teclado para armazenar o nome e sobrenome do usuário 
dentro de strings.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string nome;
string sobrenome;
cout<<”Digite seu nome: “;
cin >> nome;
cout<<”Digite seu sobrenome: “;
cin >> sobrenome;
cout << “Seu nome é “<<nome<<” e seu sobrenome é 
“<<sobrenome<<”.”<<endl;
system (“PAUSE > null”);
return 0;
}
Esse programa apresenta alguns problemas quando 
o usuário possui mais de um nome ou sobrenome. Por 
exemplo, caso o nome “José Ricardo” seja inserido, a leitura 
do sobrenome será “ignorada” e o programa exibirá “José” 
como o nome e “Ricardo” como sobrenome. Da mesma 
forma, no caso da entrada de um sobrenome duplo, somente o 
primeiro sobrenome é guardado na string “sobrenome”, sendo 
o segundo “ignorado”. Isto acontece por causa da maneira que 
C++ trata os espaços em branco em uma entrada via teclado 
(JAMSA, 1999).Espaços em branco são considerados fim de entrada pelo 
comando cin; ao invés de descartar os caracteres que vierem 
após o espaço em branco, C++ os guarda em um buffer 
(uma espécie de “reserva” ou pilha de dados). Quando cin for 
chamado novamente, antes de ler a nova entrada do teclado, 
o programa primeiro utiliza os dados que estão nesse buffer. 
Assim, temos a impressão que a nova entrada de dados foi 
descartada pelo programa, mas na verdade ela foi jogada no 
buffer, esperando uma nova chamada de cin.
Dessa forma, cin não é o método recomendado para ler 
frases inteiras, com palavras separadas por espaços. Para esse 
objetivo, utilizamos o método cin.getline, que já estudamos no 
módulo 5, com algumas alterações.
O método cin.getline lê linhas inteiras de entrada através 
do teclado, sem se importar com os espaços em branco. Mas 
a sintaxe do método cin.getline é um pouco diferente, quando 
trabalhamos com strings:
getline (cin, <nome da string>);
Assim, esse método recebe todos os caracteres (incluindo 
os espaços em branco) entrados pelo usuário, até que ele aperte 
a tecla Enter. O programa abaixo é uma versão melhorada do 
programa anterior, utilizando o método cin.getline para receber 
os dados desejados.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string nome;
string sobrenome;
cout<<”Digite seu nome: “;
getline (cin, nome);
cout<<”Digite seu sobrenome: “;
53
getline (cin, sobrenome);
cout <<”Seu nome é “<<nome<<” e seu sobrenome é 
“<<sobrenome<<”.”<<endl;
system (“PAUSE > null”);
return 0;
}
6 - Operações com Strings
7 - Biblioteca cctype: operações com 
caracteres
C++ possui uma série de funções e operações próprias 
para strings. A tabela abaixo resume as operações mais utilizadas 
(s é uma string qualquer):
• s.empty ( ) - Função que retorna verdadeiro se a string 
está vazia, e falso caso contrário.
• s.size ( ) - Função que retorna o tamanho em caracteres 
da string.
• s [n] - Acessa um elemento da string. Funciona 
exatamente com um elemento de uma matriz.
• s1 + s2 - Concatena duas strings.
• s1 = s2 - Atribui o conteúdo de s2 na string s1.
• s1 == s2 - Testa a igualdade entre s1 e s2 (retorna 
verdadeiro se as duas strings forem iguais). Duas strings 
são consideradas iguais se elas tiverem o mesmo número de 
caracteres e seus caracteres forem iguais.
A primeira função, <string>.empty indica se uma string 
está vazia ou não. Essa função retorna um valor booleano 
verdadeiro (true ou 1) caso a string esteja vazia, caso contrário 
ela retorna falso (false ou 0).
A função <string>.size é bastante útil para trabalhar 
com strings entradas pelo usuário. Como não podemos saber 
exatamente o número de caracteres entrados pelo usuário, é 
útil ter uma função que nos retorne o tamanho de uma string.
A concatenação de strings é particularmente útil. Quando 
utilizamos o sinal de soma entre duas strings, estamos 
concatenando elas, ou seja, juntando o começo da segunda 
matriz com o final da primeira. Também é possível concatenar 
strings literais (frases entre aspas) junto com as variáveis string 
dessa forma. O programa abaixo ilustra a concatenação de 
strings.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string nome;
string sobrenome;
cout<<”Digite seu nome: “;
getline (cin, nome);
cout<<”Digite seu sobrenome: “;
getline (cin, sobrenome);
string concatena;
concatena = nome + sobrenome;
cout << “O seu nome completo é : “ + nome + “ “ + 
sobrenome << endl;
system (“PAUSE > null”);
return 0;
}
A biblioteca cctype é uma versão da biblioteca ctype 
da linguagem C, convertida para C++. Ela contém diversas 
funções que permitem processar os caracteres de uma string, 
um por um. Por exemplo, podemos precisar saber se um 
determinado carácter é uma letra ou um número, se está 
acentuado ou não, se é minúsculo ou maiúsculo, e transformar 
esse caractere. Para utilizar essa biblioteca, precisamos declará-
la no cabeçalho do programa, assim como fizemos com a 
biblioteca de strings. Para declará-la, a sintaxe é a seguinte:
#include <cctype>
Assim, o cabeçalho de um programa que utiliza strings e 
a biblioteca cctype ficaria da seguinte forma:
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
Abaixo serão apresentadas algumas das funções mais 
úteis desta biblioteca (x é um elemento de uma string, por 
exemplo, “sobrenome [4]”):
•isalnum (x) - Retorna verdadeiro (1) caso x for uma letra 
ou um número.
•isalpha (x) - Retorna verdadeiro (1) caso x for uma letra.
•iscntrl (x) - Retorna verdadeiro (1) caso x for um dígito 
de controle.
•isdigit (x) - Retorna verdadeiro (1) caso x for um número.
•isgraph (x) - Retorna verdadeiro (1) caso x não for um 
espaço.
•islower (x) - Retorna verdadeiro (1) caso x for uma letra 
minúscula.
•isprint (x) - Retorna verdadeiro (1) caso x for um 
caractere imprimível.
•ispunct (x) - Retorna verdadeiro (1) caso x for um 
caractere acentuado.
•isspace (x) - Retorna verdadeiro (1) caso x for um espaço 
em branco.
•isupper (x) - Retorna verdadeiro (1) caso x for uma letra 
maiúscula
•isxdigit (x) - Retorna verdadeiro (1) caso x for um 
número hexadecimal.
•tolower (x) - Transforma um caractere maiúsculo em 
minúsculo.
•toupper (x) - Transforma um caractere minúsculo em 
maiúsculo.
Com exceção das duas últimas funções que transformam 
caracteres, todas as outras testam os caracteres de uma string, 
retornando valores booleanos (true ou false, 1 ou 0). O 
programa abaixo mostra o uso de algumas dessas funções, 
através da leitura de uma string entrada pelo usuário. Note que 
também é feito o uso da função <string>.size para determinar 
o tamanho da string.
#include <iostream>
#include <string>
using namespace std;
int main()
54Linguagem da Programação I
{
string frase;
int letras = 0, maiúsculas = 0, minúsculas = 0, números 
= 0;
cout<<”Entre com uma frase qualquer, composta de 
letras maiúsculas, minúsculas e números: “<< endl;
getline (cin, frase);
letras = frase.size();
cout<<”Sua frase tem “<< letras<< “ letras.”<<endl;
for (int i = 0; i < letras; i++)
{
if (isdigit (frase[i])) números++;
if (islower (frase[i])) minúsculas++;
if (isupper (frase[i])) maiúsculas++;
}
cout<<”Sua frase tem “<< números<< “ 
números.”<<endl;
cout<<”Sua frase tem “<< minúsculas<< “ letras 
minúsculas.”<<endl;
cout<<”Sua frase tem “<< maiúsculas<< “ letras 
maiúsculas.”<<endl;
system (“PAUSE > null”);
return 0;
}
8 - Exemplos de como manipular 
strings em C++
erase - A função membro erase elimina parte de uma 
string. Os parâmetros passados para a função são a posição 
inicial e o número de caracteres a ser excluído. Veja um 
exemplo de uso abaixo:
#include<iostream>
 using std::cout;
 using std::endl;
 using std::cin;
#include<string>
 using std::string;
 using std::getline;
 int main(){
 string myText;
 cout << “Digite um texto qualquer” << endl;
 getline (cin, myText);
 myText.erase (7, 3);
 cout << myText << endl;
 return 0;
 }
8.1 - Comparando formas de operar 
strings em C e C++
Em C, temos diversas funções que são usadas para 
manipular strings, aqui faremos uma comparação dos modos 
de operar strings em C e C++. Algumas particularidades da 
linguagem C++ permitem uma operação mais intuitiva das 
strings e algumas novas formas de tratá-las. Vejamos como 
manipular esses dados tão comuns em qualquer programa 
(Sonoda, 2006).
Funções úteis para o uso de strings
No c++ temos duas funções similares na classe string que 
são o lenght() e size(). Estas funções não têm argumentos, pois 
reportam as informações sobre o objeto a quem pertencem, 
ambas retornam um inteiro que representa o tamanho das 
strings:
string s = “Maria Clara”;
 cout << s.length(); // mostra: 9
 cout << s.size(); // também mostra: 9
Copiando strings
Se tentássemos copiar strings desta maneira:
char* target = “Maria Clara”;
 char src[80] = “Micaela”;
 strcpy (target, src);
O que acontecia é que era a cópia do endereço de src para 
o ponteiro enão os caracteres que estão dentro do vetor.
No entanto, existe a função strcpy (estilo C) – ela aceita 
dois argumentos.
• O primeiro é para onde vai ser copiada e é passado o 
ponteiro desse array (não pode ser uma string literal).
• O segundo é a frase a ser copiada e pode ser um array, 
um ponteiro ou um string literal.
Note que essa operação é muito arriscada visto que, 
quando criamos target, a quantidade de caracteres que foi 
reservada para a string era de 9 caracteres mais o caractere nulo 
no final. Se fizermos uma cópia de uma string com mais de 
9 caracteres para esse endereço, representado por target, ele 
fatalmente causará uma violação de endereço.
Porém, em C++ podemos atribuir o valor de uma variável 
para outra da classe string da forma:
string target = “Maria Clara”;
 string src = “Micaela”;
 target = src;
Agora, reflitamos no que significam essas operações: 
Em primeiro lugar, “string” não é um tipo primitivo de dado, 
é uma classe, portanto é um tipo de dado mais “inteligente”. 
Uma das características dos objetos string é que eles são 
redimensionáveis, ou seja, quando atribuímos a uma string 
um dado maior que seu espaço interno de armazenamento ela 
aumenta o seu espaço interno para comportar o novo dado. 
Outra característica é que a operação “=” para a string é uma 
operação de atribuição de conteúdo, de forma que a string 
copia a outra quando usamos este operador e não apenas o 
ponteiro que referencia o endereço da string.
Unir strings
strcat() – (string+concatena-te) – une duas frases. Recebe 
2 argumentos, a frase primária – o ponteiro para esse array.
char target[80] = “Maria”;
 char* source= “ Clara”;
 strcat (target, source);
 cout << target; // Mostra “Maria Clara”
55
Deve-se observar que strcat é, potencialmente, uma das 
rotinas mais perigosas do C, por um motivo bem simples: 
a string de destino deve ser pré-dimensionada, e deve ter 
espaço suficiente para receber a string de origem. Um pequeno 
programa como:
char target[13] = “Regras do C!”;
 char* source = “ Mas pode dar resultados imprevisíveis”;
 strcat (target, source);
Escreverá bytes em regiões da memória que não foram 
previamente alocadas para a string. Em c++, esse problema é 
resolvido pelo uso de objetos string.
Ao estilo de c++ podemos fazer:
string target = “Regras do C++!\n”;
 string source = “Geralmente não dão resultados 
imprevisíveis.\n”;
 target += source;
 cout << target; // Mostra: Regras do C++!
 // Geralmente não dão resultados
Isso porque a classe string prevê o uso do operador “+=” 
de concatenação e nele está embutido um código de verificação 
de espaço e realocação dele para string, caso seja necessário.
Comparar frases,
se fizéssemos: 
char str1[80] = “Maria Clara”;
 char str2[80] = “Maria Clara”;
 if (str1 == str2)
 cout << “iguais”;
 else
 cout << “diferentes”;
O que acontecia é que estaríamos a comparar os endereços 
e não os valores.
 Temos a função strcmp (string+compare) (tem 2 
argumentos, retornar 0 se forem iguais).
char str1[80] = “Maria Clara”;
 char str2[80] = “Maria Clara”;
 if (!strcmp (str1, str2))
 cout << “iguais”;
 else
 cout << “diferentes”
Em C++ podemos comparar duas strings através da 
função membro da classe string: compare(), existem os 
seguintes formatos (assinaturas) para a função:
int compare ( const string& str2 ) const;
int compare ( const char* szc ) const;
int compare ( size_t pos1, size_t n1, const string& str2 
) const;
int compare ( size_t pos1, size_t n1, const char* szc) 
const;
int compare ( size_t pos1, size_t n1, const string& str2, 
size_t pos2, size_t n2 ) const;
int compare ( size_t pos1, size_t n1, const char* szc, 
size_t n2) const;
A função permite os seguintes modos de operação, 
respectivamente:
1. Comparar uma “string” de entrada (str2) com o 
conteúdo do objeto ao qual ela pertence.
2. Comparar uma “C-string” apontada por um ponteiro 
com o conteúdo do objeto a qual ela pertence.
3. Comparar uma seção começando em (pos1) do objeto, 
a qual contém (n1) caracteres, com a “string” de entrada (str2).
4. Comparar uma “C-string” apontada por um ponteiro 
(szc), com uma seção começando em (pos1), a qual contém 
(n1) caracteres do conteúdo do objeto ao qual ela pertence.
5. Comparar uma seção do objeto, iniciada em (pos1) 
com (n1) caracteres, com uma seção de (str2), iniciada em 
(pos2) com (n2) caracteres.
6. Comparar uma “C-string” apontada por um ponteiro 
(szc) de extensão (n2), com uma seção começando em (pos1), 
a qual contém (n1) caracteres do conteúdo do objeto a qual 
ela pertence.
O resultado é similar ao da função strcmp() em “C”, 
retornando uma referência de valor de acordo com o código 
ASCII.
Se estiver comparando duas strings outra opção, ainda 
mais natural, é utilizar os operadores de comparação < e ==.
using namespace std;
string str1 = “check”;
string str2 = “chess”;
if (str1 == str2)
 cout << “As palavras são iguais.” << endl; 
else if (str1 < str2) 
 cout << “A palavra “ << str1 << “ vem antes de “ << 
str2 << endl;
else
 cout << “A palavra “ << str1 << “ vem depois de “ 
<< str2 << endl;
9 - Convertendo C-string e número
No ficheiro (arquivo) cabeçalho da biblioteca cstdlib 
(c+std+lib) temos várias funções de conversão de números 
em tipo numérico.
atoi (acrônimo para “ASCII to integer”) recebe um 
argumento – c-string) e retorna o inteiro que a c-string 
representa. Não verifica se o argumento pode ser convertido:
int num = atoi (“7654”);
Programa exemplo:
#include <iostream>
 #include <cstdlib> // necessário para atoi
 #include <cstring>
 using namespace std;
 int main(void)
 {
 char input[80];
 int num;
 cout << “Enter an integer: “;
 cin >> input;
 for (int x = 0; x < strlen (input); x++)
 {
 if (x == 0)
56Linguagem da Programação I
 {
 if (!isdigit (input[x]) && input[x] != ‘-’)
 return 1;
 }
 else 
 {
 if (!isdigit(input[x]))
 return 2;
 }
 }
 num = atoi(input);
 cout << num;
#ifdef WIN32
 system (“pause”);
#endif
 return 0;
 }
Nesse exemplo temos a vantagem de o usuário inserir 
um dígito para o array de caracteres em vez de um inteiro, para 
evitar um “run-time error” ou “garbage data” que aconteceria 
se a entrada fosse não numérica. Depois o array é verificado 
para ver se representa um número. Se o número for negativo 
tem o caractere “–”.
Em C++ usamos objetos da classe stringstream 
(biblioteca sstream.h) para armazenar temporariamente os 
caracteres, depois usamos o operador “>>” para converter 
os caracteres em número, bastando para isso criar a variável 
no formato que desejamos receber o número. Mais uma vez 
temos o uso do polimorfismo para resolução de um problema 
comum de programação, a operação do “>>” é diferente 
para cada tipo de dado, selecionada automaticamente pelo 
compilador de acordo com o tipo de dado da variável destino.
string name = “123”;
 stringstream sst;
 int i;
 sst << name << endl;
 sst >> i;
Os passos acima armazenam o valor 123 na variável “i”, 
todo processo de conversão é feito pelo operador “>>”.
Retomando a aula
Parece que estamos indo bem. Então, para encerrar 
esta aula, vamos recordar:
Como vimos anteriormente, um vetor é um tipo de 
dado capaz de armazenar vários valores. A declaração de 
um vetor pode ser de qualquer tipo, seja número ou carácter. 
No entanto, são raras vezes que necessitamos de um único 
carácter, geralmente precisamos de um conjunto, por 
exemplo, a leitura de um nome. Nesse caso não precisamos 
de um char e sim de um conjunto de char[], dessa forma surge 
o conceito de strings. Vimos também que na linguagem C, 
realmente declaramos como um vetor de carácter e no C++ 
temos um tipo que representa esse vetor e nos traz uma gama 
de possibilidades, através de funções prontas do tipo string. 
O C++ assim como todas outras linguagens apresenta o tipo 
string para facilitar a nossa programação.
CARVALHO,Flávia PEREIRA de; Apostila de 
Programação II- Linguagem de Programação C, Faculdade de 
Informática de Taquara, Curso de Sistemas de Informação 
2008.
JAMSA, Kris; KLANDERM LARS; SANTOS, Jeremias 
René D. Pereira dos. Programando em C/C++: a bíblia. São 
Paulo: Makron Books do Brasil, 1999.
DELGADO, Armando Luiz; Linguagem C++; usp; 
2012.
NORTON, Peter; COSTA FILHO, Geraldo; AITKEN, 
Peter. et al. A Bíblia do programador. Rio de Janeiro: Campus, 
1994.
Vale a pena
Vale a pena ler
Disponível em: <http://www.dainf.ct.utfpr.edu.
br/~pbueno/Arquivos/Algoritmos.pdf>. Acesso em: 26 de 
nov. 2017.
Disponível em: <https://pt.wikibooks.org/wiki/
Programar_em_C%2B%2B/Manipulando_strings>. 
Acesso em: 26 de nov. 2017.
Disponível em: <http://www.cplusplus.com/
reference/string/string/>. Acesso em: 26 de nov. 2017. 
Vale a pena acessar
Programar em C - Introdução Strings | Vetores de 
Caracteres. Disponível em: <https://www.youtube.com/
watch?v=YaoW-c6pGTg>. Acesso em: 26 de nov. 2017.
C++ - Tratamento de Strings #23. Disponível em: 
<https://www.youtube.com/watch?v=raQq3Mhcq7o>. 
Acesso em: 26 de nov. 2017.
Vale a pena assistir
57
Referências
DEITEL H.M DEITEL, P.J. C++: Como Programar. 
Prentice-Hall, Inc., 5 a edition, 2012.
STANLEY B. LIPPMAN. C++ Primer. Addison-Wesley 
Publishing Company, 1991. ISBN: 0-201-54848-8.
VICTORINE Viviane Mizrahi. Treinamento em Linguagem 
C++. Prentice-Hall, Inc., 2 a edition, 2005.
WALTER Savitch. C++ Absoluto. Addison-Wesley 
Publishing Company, 2004. ISBN: 85-88639-09-2.
BJARNE Stroustrup. A Linguagem de Programação C++. 
Bookman, 2000.
DAVIS, Stephen R. Começando a programar em C++ para 
leigos. Rio de Janeiro: Alta Books, 2015.
ELLIS, Margaret A.; STROUSTRUP, Bjarne. C++, 
Manual de Referência Comentado. Editora Campus, 1993. 
VICTORINE Viviane Mizrahi; Treinamento em Linguagem 
C++ (Módulos 1 e 2). Makron Books Editora Ltda. São Paulo, 
1994.
NORTON, Peter; COSTA FILHO, Geraldo; AITKEN, 
Peter. et al. A Bíblia do programador. Rio de Janeiro: Campus, 
1994.
JAMSA, Kris; SANTOS, Jeremias R. D. P. Aprendendo 
C++. São Paulo: Makron Books do Brasil, 1999.
JAMSA, Kris; KLANDERM LARS; SANTOS, Jeremias 
René D. Pereira dos. Programando em C/C++: a bíblia. São 
Paulo: Makron Books do Brasil, 1999.
DELGADO, Armando Luiz; Linguagem C++; usp; 2012.
LAUREANO, Marcos. Programando em C para Linux, Unix 
e Windows / Marcos Laureano; Rio de Janeiro: Brasport; 2005.
BUENO, André Duarte; Apostila de Programação 
Orientada a Objeto em C++; NÚCLEO DE PESQUISA EM 
CONSTRUÇÃO; 2002.
CARVALHO, Flávia Pereira. Linguagem de Programação C; 
FIT - Faculdade de Informática de Taquara; 2008.
PINTO, Rossano Pablo. Introdução à Arquitetura e Linguagem 
Assembly de Processadores IA-32, Sistemas da Computação; 2007.
ARLEI, Adriano et all; A pré história da computação; 
Departamento de Ciência da Computação Informática e 
Sociedade; 2006.
DOLORES, Nemora; As 15 principais linguagens de 
programação do mundo!; Disponível em: <https://becode.com.
br/principais-linguagens-de-programacao/>. Acesso em: 
10/09/ 2017.
CARVALHO, Flávia Pereira. Apostila de Programação II- 
Linguagem de Programação C; Faculdade de Informática de 
Taquara; 2008.
CARVALHO, Victorio Albani de. Lógica De Programação; 
e-tec Brasil Colatina-es 2009.
SONODA, Eloíza; Programação em C; Disponível em: 
<https://www.ime.usp.br/~elo/IntroducaoComputacao/>. 
Acesso em: 23/06/2017.
Pereira, Fábio Nelson de Sousa; Curso de Linguagem C; 
UFMG; 2005.
MACIEL, Fabiano; Iniciando-em-c; Disponível em: <www.
linhadecodigo.com.br/artigo/346/serie-“iniciando-em-c”-
variaveis.aspx>. Acesso em: 04/05/2017.
TREVELIN, Enrique Camargo. Apostila de C++; 
UNIESP; 2007.
FILHO, Cláudio Rogério Carvalho. Operadores Lógicos Do 
C++; excript; 2015.
Minhas anotações
58Linguagem da Programação I