Sie sind auf Seite 1von 93

DCC 119 Algoritmos

Cadeias de caracteres
Uma cadeia de caracteres é uma sequência de
caracteres justapostos e são fundamentais no
desenvolvimento de programas computacionais.

Exemplos de cadeias de caracteres (representadas


internamente num programa):
Mensagem de e-mail;
Texto de um programa;
Nome e endereço em cadastro de clientes, alunos, etc...
Sequencia genética. Um gene (ou o DNA de algum
organismo) é composto de sequencias dos caracteres A, T,
G e C (nucleotídeos)

2
Caracteres - Revisão
Uma variável usada para armazenar um caractere é representada
da seguinte maneira:
caracter letra; //a variável letra do tipo caracter
letra a ; // atribuída a letra a a variável letra

Se em uma variável do tipo caracter podemos armazenar somente


um caractere, então para armazenar vários caracteres (ex: jose ,
carro ) é necessário utilizar as cadeias de caracteres,
representadas por vetores do tipo caracter.

3
Caracteres - Revisão
Observe a declaração abaixo:
caracter cidade[12] ;
A variável cidade é um vetor de caracteres (cadeia
de caracteres)
A variável cidade pode armazenar qualquer cadeia
de até 12 caracteres

0 1 2 3 4 5 6 7 8 9 10 11

cidade J u i z d e F o r a

4
Cadeias de Caracteres (Strings)

Sintaxe para declaração de cadeia de


caracteres
caracter identificador[qtde caracteres];

Exemplo:
caracter nome[30];
caracter profissao[20];

5
Cadeias de Caracteres (Strings)

Manipulação de cadeias de caracteres


Vamos atribuir a variável nome, criada
anteriormente, o nome Jose.
nome Jose ;
Observe a presença das aspas duplas na palavra
Jose.
Podemos ainda, obter um caracter qualquer da
cadeia de caracteres da seguinte maneira:
caracter letra nome[1];
// letra receberá a letra da posição 1 da cadeia de
caracteres, ou seja, o .
6
Cadeia de caracteres (Strings)

Exemplo:
principal
{
caracter s[20];
imprima ( Digite uma string: ) ;
leia (s);
imprima ( String digitada: ,s);
}

7
Caracteres em C
Os caracteres em C são representados internamente
por códigos numéricos (ASCII);
Alguns caracteres visíveis (podem ser impressos)
0 1 2 3 4 5 6 7 8 9

30 sp ! " # $ % & '


40 ( ) * + , - . / 0 1
50 2 3 4 5 6 7 8 9 : ;
60 < = > ? @ A B C D E
70 F G H I J K L M N O
80 P Q R S T U V W X Y
90 Z [ \ ] ^ _ ` a b c
100 d e f g h i j k l m
110 n o p q r s t u v w
120 x y z { | } sp: espaço em branco
8
Caracteres em C
A diferença entre caracteres e inteiros está apenas na
maneira como são tratados, por exemplo, o código

char c = 97;
printf("int : %d char : %c\n", c, c);

Imprimirá

int : 97 char : a

O conteúdo da variável c é impressa em dois


formatos distintos: %d (int) e %c (char).

9
Caracteres em C
Por questão de portabilidade, não se deve usar
diretamente, no programa, o código de caracteres;
Ao invés, usa-se uma constante caractere: caractere
entre apóstrofe. Reescrevendo o fragmento de código
anterior:

char c = 'a';
printf("int : %d char: %c\n", c, c);
Imprimirá
int : 97 char : a

Pode-se trocar char c por int c: o resultado será o


mesmo. 10
Caracteres em C
Entrada/Saída de caracteres em C:
ch = getchar();
armazena um caractere digitado em ch até que ENTER seja
pressionado;
putchar(ch);
Imprime o caractere ch na tela do computador;

Exemplo:
int main()
{
char ch;
ch = getchar();
putchar(ch);
return 0;
}
11
Cadeias de caracteres e Strings

Cadeias de caracteres são similares em C e


em pseudolinguagem:

char graus[ 5] = { A', B', C', A , D'} ;

char bin[ 8] = { 0', 1', 0', 1', 1', 1', 0', 1'} ;

12
Strings
Strings são tipos especiais de cadeias de caracter em
C e são terminadas, obrigatoriamente, pelo
caractere nulo: \0 (\zero). Portanto, deve-se
reservar uma posição para este caractere de fim de
cadeia.

Em pseudolinguagem, cadeias de caracteres e strings


são semelhantes. Desta forma, para fins de
implementação, trataremos o assunto apenas em C.

13
Strings
Exemplos de strings em C:
char cidade[ 4] = { 'R', 'i', 'o', \ 0'};
char disc[40] = {'A','l','g', 'o', 'r', 'i', 't', 'm', 'o', '\ 0'};

Outras formas de inicializarmos strings em C:

char cidade[4] = "Rio";


char disc[40] = "Algoritmo";

14
Strings
Para ilustrar a declaração e a inicialização de strings,
consideremos as seguintes declarações:
char s1[] = "" ; //2 aspas sem espaços entre elas
char s2[] = "Rio de Janeiro";
char s3[81];
char s4[81] = "Rio";

s1 armazena uma string vazia. Tem um único elemento: \0 ;


s2 representa um vetor com 15 elementos (caracteres);
s3 representa uma cadeia de caracteres com até 80 caracteres e
não é inicializada;
s4 também é dimensionada para conter até 80 caracteres e é
inicializada com a cadeia Rio .

15
Strings
Leitura de strings (scanf).
int main()
{
char s[20];
printf("Digite uma string: ");
scanf("%s",s); //sem & antes de s
printf("String digitada: %s",s);
return 0;
}
Neste caso, a leitura será feita até encontrar um caractere branco:
espaço (' '), tabulação ( \t') ou nova linha ( \n'). Assim, se digitarmos
Rio de Janeiro , s conterá apenas Rio ;
Não é necessário o & antes da variável s em scanf.

16
Strings
Leitura/Impressão de strings (gets/puts).
int main()
{
char s[20];
printf("Digite uma string: ");
gets(s);
printf("String digitada: ");
puts(s);
return 0;
}

Neste caso, se digitarmos Rio de Janeiro , s conterá Rio de


Janeiro ;
gets(s): lê a string s a partir do teclado;
puts(s): imprime uma string na tela seguida de nova linha.
17
Strings
Exemplo: o programa a seguir imprime uma cadeia de
caracteres, caractere por caractere:
int main()
{
char s[30];
int i;
printf("Digite uma string: ");
gets(s);
//imprime cada caractere da cadeia lida
for(i=0; s[i]!='\0'; i++)
printf("%c",s[i]);
return 0;
}
O for acima equivale a printf("%s",s);

18
Strings
Exemplo: o programa a seguir calcula e imprime o
comprimento (numero de caracteres) de uma cadeia:

int main()
{
char s[30];
int i, n = 0;
printf("Digite uma string: ");
gets(s);

for(i=0; s[i]!='\0'; i++)


n++;
printf("\nO tamanho de \"%s\" eh: %d",s,n);
return 0;
}
19
Strings
Exemplo: o programa a seguir faz uma copia de uma
cadeia, fornecida pelo usuário, para outra:
int main()
{
char dest[50], //string destino
orig[50]; //string origem
int i;
printf("Digite uma string: ");
gets(orig);
//copia cada caractere de orig para dest
for(i=0; orig[i]!='\0'; i++)
dest[i] = orig[i];
//coloca o caractere nulo para marcar o fim da string
dest[i] = '\0';
puts(dest);
return 0;
}
20
Funções para manipulação de Strings

Existem várias funções em C para


manipulação de strings. Essas funções estão
declaradas no arquivo string.h. Entre elas
pode-se destacar:
strcpy(char destino[ ], char origem[ ])
copia a string origem na string destino
strlen(char str[ ])
retorna o tamanho da string str
strcat(char destino[ ], char origem[ ])
Faz concatenação (junção) da string origem com
a string destino. O resultado é armazenado na
string destino
21
Exercício resolvido 1

Criar uma função que receba como parâmetro


uma cadeia de caracteres (cadeia), seu tamanho
(tam) e um segundo caractere (procurado). A
função deverá retornar a quantidade que o
caractere procurado foi encontrado na cadeia.

Solução:
Precisamos varrer a cadeia de caracteres (estrutura de
repetição) e contar quantos são iguais ao caractere
procurado, caractere a caractere.

22
Solução proposta em pseudolinguagem

inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )


{
inteiro encontrados, i;
i 0;
encontrados 0;

enquanto ( i < tam ) faça


{
se (cadeia[i] = procurado)
{
encontrados encontrados + 1;
}
i i + 1;
}
retorne encontrados;
}

23
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
}
i i + 1;
}
retorne encontrados;
}

24
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; Função é chamada supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}

25
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i; Variáveis são
i 0; criadas e O teste será realizado
encontrados 0; inicializadas supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Variáveis:
i =0
encontrados = 0
26
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1; Estrutura de repetição
} onde será a feita a t
retorne encontrados; busca é iniciada
}
Variáveis:
i =0
encontrados = 0
27
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1; Testa primeiro
} caractere da cadeira t
retorne encontrados; com o procurado
}
Variáveis:
i =0
encontrados = 0
28
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1; Como teste é válido,


} incrementa contador t
retorne encontrados;
}
Variáveis:
i =0
encontrados = 1
29
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Vai para o próximo
indice da cadeia
Variáveis:
i =1
encontrados = 1
30
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Continua na estrutura
de repetição
Variáveis:
i =1
encontrados = 1
31
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Testa segundo
caractere e falha!
Variáveis:
i =1
encontrados = 1
32
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Vai para o próximo
indice da cadeia
Variáveis:
i =2
encontrados = 1
33
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Continua na estrutura
de repetição
Variáveis:
i =2
encontrados = 1
34
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Testa terceiro
caractere e falha!
Variáveis:
i =2
encontrados = 1
35
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Vai para o próximo
índice da cadeia
Variáveis:
i =3
encontrados = 1
36
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Continua na estrutura
de repetição
Variáveis:
i =3
encontrados = 1
37
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Testa quarto
caractere...
Variáveis:
i =3
encontrados = 1
38
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1; Como teste é válido,


} incrementa contador t
retorne encontrados;
}
Variáveis:
i =3
encontrados = 2
39
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Vai para o próximo
indice da cadeia
Variáveis:
i =4
encontrados = 2
40
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Continua na estrutura
de repetição
Variáveis:
i =4
encontrados = 2
41
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Testa terceiro
caractere e falha!
Variáveis:
i =4
encontrados = 2
42
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Vai para o próximo
índice da cadeia
Variáveis:
i =5
encontrados = 2
43
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Falha o teste da
estrutura de repetição
Variáveis:
i =5
encontrados = 2
44
inteiro conta( caracter cadeia[], inteiro tam, caracter procurado )
{
inteiro encontrados, i;
i 0; O teste será realizado
encontrados 0; supondo que:

enquanto ( i < tam ) faça cadeia = teste


{ tam = 5
se (cadeia[i] = procurado)
{ procurado = t
encontrados encontrados + 1;
} t e s t e

i i + 1;
} t
retorne encontrados;
}
Variáveis:
Retorna o número de i =5
caracteres encontrados: 2
encontrados = 2
45
Exercício resolvido 2:
Busca em Strings em C
Criar uma função para verificar se a string
s2 está contida na string s1. A função
deverá retornar 1 se encontrar a string ou 0,
caso contrário.
Ex.: Se s1 fosse Ana Maria Silva e s2 fosse
Maria , a função retornaria 1, pois s2 está
contido em s1.

46
int buscaString(char s1[], char s2[])
O teste será realizado
{
int i,j,aux, tam1, tam2; supondo que:
tam1 = strlen(s1); s1 = Este é um teste
tam2 = strlen(s2);
for(i=0;i<tam1;i++) s2 = um
{
aux=i;
for(j=0;j<tam2 && aux<tam1;j++)
{
if (s2[j] != s1[aux])
break;
aux++;
}
if (j == tam2)
return 1;
}
return 0;
}

47
int buscaString(char s1[], char s2[])
Função é chamada passando-
{
se s1 e s2 como parâmetro
int i,j,aux, tam1, tam2;
tam1 = strlen(s1);
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break;
aux++;
}
if (j == tam2)
return 1;
}
return 0;
}

48
int buscaString(char s1[], char s2[])
Variáveis são criadas e inicializadas.
{
tam1 recebe o tamanho de s1 e
int i,j,aux, tam1, tam2;
tam2 recebe o tamanho de s2.
tam1 = strlen(s1);
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =
if (j == tam2)
return 1; j =
}
aux =
return 0;
} tam1 = 15
tam2 = 2 49
int buscaString(char s1[], char s2[])
A idéia central é varrer s1
{
comparando com s2, caracter a
int i,j,aux, tam1, tam2;
caracter.
tam1 = strlen(s1);
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =0
if (j == tam2)
return 1; j =
}
aux =
return 0;
} tam1 = 15
tam2 = 2 50
int buscaString(char s1[], char s2[])
{ Para fazer a comparação, uma
int i,j,aux, tam1, tam2; variável auxiliar (aux) será utilizada.
tam1 = strlen(s1);
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =0
if (j == tam2)
return 1; j =0
}
aux = 0
return 0;
} tam1 = 15
tam2 = 2 51
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Como caracteres não são
tam1 = strlen(s1); iguais, executa o break!
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =0
if (j == tam2)
return 1; j =0
}
aux = 0
return 0;
} tam1 = 15
tam2 = 2 52
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Falha nessa condição e
tam1 = strlen(s1); continua no loop externo
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =0
if (j == tam2)
return 1; j =0
}
aux = 0
return 0;
} tam1 = 15
tam2 = 2 53
int buscaString(char s1[], char s2[])
{ Vai para a próxima iteração
int i,j,aux, tam1, tam2; do loop externo!
tam1 = strlen(s1);
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =1
if (j == tam2)
return 1; j =0
}
aux = 0
return 0;
} tam1 = 15
tam2 = 2 54
int buscaString(char s1[], char s2[])
{ Busca agora começa do segundo
int i,j,aux, tam1, tam2; caracter de s1 em relação ao
tam1 = strlen(s1); primeiro de s2 e falha.
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =1
if (j == tam2)
return 1; j =0
}
aux = 1
return 0;
} tam1 = 15
tam2 = 2 55
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Falha nessa condição e
tam1 = strlen(s1); continua no loop externo
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =1
if (j == tam2)
return 1; j =0
}
aux = 1
return 0;
} tam1 = 15
tam2 = 2 56
int buscaString(char s1[], char s2[])
{ Testando os próximos
int i,j,aux, tam1, tam2; elementos em busca de
tam1 = strlen(s1); um válido
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =2
if (j == tam2)
return 1; j =0
}
aux = 2
return 0;
} tam1 = 15
tam2 = 2 57
int buscaString(char s1[], char s2[])
{ Testando os próximos
int i,j,aux, tam1, tam2; elementos em busca de
tam1 = strlen(s1); um válido
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =3
if (j == tam2)
return 1; j =0
}
aux = 3
return 0;
} tam1 = 15
tam2 = 2 58
int buscaString(char s1[], char s2[])
{ Testando os próximos
int i,j,aux, tam1, tam2; elementos em busca de
tam1 = strlen(s1); um válido
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e _ é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =4
if (j == tam2)
return 1; j =0
}
aux = 4
return 0;
} tam1 = 15
tam2 = 2 59
int buscaString(char s1[], char s2[])
{ Testando os próximos
int i,j,aux, tam1, tam2; elementos em busca de
tam1 = strlen(s1); um válido
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =5
if (j == tam2)
return 1; j =0
}
aux = 5
return 0;
} tam1 = 15
tam2 = 2 60
int buscaString(char s1[], char s2[])
{ Testando os próximos
int i,j,aux, tam1, tam2; elementos em busca de
tam1 = strlen(s1); um válido
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é _ u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =6
if (j == tam2)
return 1; j =0
}
aux = 6
return 0;
} tam1 = 15
tam2 = 2 61
int buscaString(char s1[], char s2[])
{ Testando os próximos
int i,j,aux, tam1, tam2; elementos em busca de
tam1 = strlen(s1); um válido
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =7
if (j == tam2)
return 1; j =0
}
aux = 7
return 0;
} tam1 = 15
tam2 = 2 62
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Teste falha e incrementa
tam1 = strlen(s1); variável aux.
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =7
if (j == tam2)
return 1; j =0
}
aux = 8
return 0;
} tam1 = 15
tam2 = 2 63
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Passa para a próxima
tam1 = strlen(s1); iteração do loop interno
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =7
if (j == tam2)
return 1; j =1
}
aux = 8
return 0;
} tam1 = 15
tam2 = 2 64
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Teste falha novamente e
tam1 = strlen(s1); aux é incrementado
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =7
if (j == tam2)
return 1; j =1
}
aux = 9
return 0;
} tam1 = 15
tam2 = 2 65
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; j é incrementado e sai
tam1 = strlen(s1); do laço pois a condição
tam2 = strlen(s2); j < tam2 falha
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =7
if (j == tam2)
return 1; j =2
}
aux = 9
return 0;
} tam1 = 15
tam2 = 2 66
int buscaString(char s1[], char s2[])
{
int i,j,aux, tam1, tam2; Como j = tam2, sai da
tam1 = strlen(s1); função retornando 1.
tam2 = strlen(s2);
for(i=0;i<tam1;i++)
{ E s t e é u m t e s t e
aux=i;
for(j=0;j<tam2 && aux<tam1;j++) u m
{
if (s2[j] != s1[aux])
break; Variáveis:
aux++;
} i =7
if (j == tam2)
return 1; j =2
}
aux = 9
return 0;
} tam1 = 15
tam2 = 2 67
Programa Completo

#include <stdio.h>
#include <string.h> int main()
{
int buscaString(char s1[], char s2[]) char s1[100], s2[100];
{ gets(s1);
int i,j,aux, tam1, tam2; gets(s2);
tam1 = strlen(s1); int resultado = buscaString(s1, s2);
tam2 =strlen(s2); if(resultado)
for(i=0;i<tam1;i++) printf("Encontrou a string");
{ else
aux=i; printf("Não encontrou a string");
for(j=0;j<tam2 && aux<tam1;j++) return 0;
{ }
if (s2[j] != s1[aux])
break;
aux++;
}
if (j == tam2)
return 1;
}
return 0;
}

68
Exercícios
1)Fazer um programa para contar o número de espaços em brancos
de uma string.

2) Refaça o programa anterior criando uma função que receberá


como parâmetro a string e retornará o número de espaços em
branco que a string contem.

3) Fazer um programa para contar o número de vogais numa cadeia


de caractere.

4) Refaça o programa anterior criando uma função que receberá


como parâmetro a string e retornará o número de vogais que a
string contem.

69
Exercícios
5) Escrever um programa para ler uma string (com mais de uma
palavra) e faça com que a primeira letra de cada palavra fique em
maiúscula. Para isso, basta subtrair 32 do elemento que deseja
alterar para maiúsculo. chrNome[ 0] = chrNome[ 0] 32;
Exemplo:
Entrada: lab. de linguagem de programacao
Saída: Lab. De Linguagem De Programacao

6)Escreva uma função que receba uma string, conte quantos


caracteres desta string são iguais a 'a' e substitua os que forem
iguais a 'a' por 'b'. A função deverá retornar o número de
caracteres modificados.

70
Cadeias de caracteres (strings)
7) Crie um procedimento que receba uma frase e a exiba na tela de
forma soletrada, ou seja, cada letra deve ser exibida na tela
separada por hífen.

8) Crie um procedimento que receba uma string de no máximo 50


caracteres e inverta a ordem da string digitada;
Exemplo:
Entrada: Teste
Saída: etseT

9)Fazer um programa para determinar e imprimir uma string que será


a concatenação de duas outras strings lidas.

71
DCC120
Caracteres em C
Os caracteres em C são representados internamente
por códigos numéricos (ASCII);
Alguns caracteres visíveis (podem ser impressos)
0 1 2 3 4 5 6 7 8 9

30 sp ! " # $ % & '


40 ( ) * + , - . / 0 1
50 2 3 4 5 6 7 8 9 : ;
60 < = > ? @ A B C D E
70 F G H I J K L M N O
80 P Q R S T U V W X Y
90 Z [ \ ] ^ _ ` a b c
100 d e f g h i j k l m
110 n o p q r s t u v w
120 x y z { | } sp: espaço em branco
73
Caracteres em C
A diferença entre caracteres e inteiros está apenas na
maneira como são tratados, por exemplo, o código

char c = 97;
printf("int : %d char : %c\n", c, c);

Imprimirá

int : 97 char : a

O conteúdo da variável c é impressa em dois


formatos distintos: %d (int) e %c (char).

74
Caracteres em C
Por questão de portabilidade, não se deve usar
diretamente, no programa, o código de caracteres;
Ao invés, usa-se uma constante caractere: caractere
entre apóstrofe. Reescrevendo o fragmento de código
anterior:

char c = 'a';
printf("int : %d char: %c\n", c, c);
Imprimirá
int : 97 char : a

Pode-se trocar char c por int c: o resultado será o


mesmo. 75
Caracteres em C
Entrada/Saída de caracteres em C:
ch = getchar();
armazena um caractere digitado em ch até que ENTER seja
pressionado;
putchar(ch);
Imprime o caractere ch na tela do computador;

Exemplo:
int main()
{
char ch;
ch = getchar();
putchar(ch);
return 0;
}
76
Caracteres em C
Exemplo: programa para verificar se um dado
caractere c é um dígito (aproveita o fato de os dígitos
estarem em sequência na tabela ASCII):
int main()
{
char c;
printf("Digite uma letra ou numero: ");
c = getchar();
if((c >= '0') && (c<='9'))
printf("Eh um digito");
else
printf("Nao eh um digito");
return 0;
}

77
Caracteres em C
Exemplo: programa para converter uma letra
(caractere) minúscula para maiúsculo (aproveita o
fato de os caracteres estarem em sequência na
tabela ASCII):
int main()
{
char c;
printf("Digite uma letra: ");
c = getchar();
//verifica se é letra minúscula
if(c >= 'a' && c<='z')
//imprime c em letra maiuscula
putchar(c - 'a' + 'A');
return 0;
}
78
Cadeias de caracteres e Strings

Cadeias de caracteres em C são representadas por


vetores do tipo char.

char graus[ 5] = { A', B', C', A , D'} ;

char bin[ 8] = { 0', 1', 0', 1', 1', 1', 0', 1'} ;

79
Strings
Strings são cadeias de caracter terminadas,
obrigatoriamente, pelo caractere nulo: \0 (\zero).
Portanto, deve-se reservar uma posição para este
caractere de fim de cadeia.
Exemplos:
char cidade[ 4] = { 'R', 'i', 'o', \ 0'};
char disc[40] = {'A','l','g', 'o', 'r', 'i', 't', 'm', 'o', '\ 0'};

Equivale:
char cidade[4] = "Rio";
char disc[40] = "Algoritmo";

80
Strings
Para ilustrar a declaração e a inicialização de strings,
consideremos as seguintes declarações:
char s1[] = "" ; //2 aspas sem espaços entre elas
char s2[] = "Rio de Janeiro";
char s3[81];
char s4[81] = "Rio";

s1 armazena uma string vazia. Tem um único elemento: \0 ;


s2 representa um vetor com 15 elementos (caracteres);
s3 representa uma cadeia de caracteres com até 80 caracteres e
não é inicializada;
s4 também é dimensionada para conter até 80 caracteres e é
inicializada com a cadeia Rio .

81
Strings
Leitura de strings (scanf).
int main()
{
char s[20];
printf("Digite uma string: ");
scanf("%s",s); //sem & antes de s
printf("String digitada: %s",s);
return 0;
}
Neste caso, a leitura será feita até encontrar um caractere branco:
espaço (' '), tabulação ( \t') ou nova linha ( \n'). Assim, se digitarmos
Rio de Janeiro , s conterá apenas Rio ;
Não é necessário o & antes da variável s em scanf.

82
Strings
Leitura/Impressão de strings (gets/puts).
int main()
{
char s[20];
printf("Digite uma string: ");
gets(s);
printf("String digitada: ");
puts(s);
return 0;
}

Neste caso, se digitarmos Rio de Janeiro , s conterá Rio de


Janeiro ;
gets(s): lê a string s a partir do teclado;
puts(s): imprime uma string na tela seguida de nova linha.
83
Strings
Exemplo: o programa a seguir imprime uma cadeia de
caracteres, caractere por caractere:
int main()
{
char s[30];
int i;
printf("Digite uma string: ");
gets(s);
//imprime cada caractere da cadeia lida
for(i=0; s[i]!='\0'; i++)
printf("%c",s[i]);
return 0;
}
O for acima equivale a printf("%s",s);

84
Strings
Exemplo: o programa a seguir calcula e imprime o
comprimento (numero de caracteres) de uma cadeia:
int main()
{
char s[30];
int i, n = 0;
printf("Digite uma string: ");
gets(s);

for(i=0; s[i]!='\0'; i++)


n++;
printf("\nO tamanho de \"%s\" eh: %d",s,n);
return 0;
}

85
Strings
Exemplo: o programa a seguir faz uma copia de uma
cadeia, fornecida pelo usuário, para outra:
int main()
{
char dest[50], //string destino
orig[50]; //string origem
int i;
printf("Digite uma string: ");
gets(orig);
//copia cada caractere de orig para dest
for(i=0; orig[i]!='\0'; i++)
dest[i] = orig[i];
//coloca o caractere nulo para marcar o fim da string
dest[i] = '\0';
puts(dest);
return 0;
}
86
Funções para manipulação de Strings

Existem várias funções em C para


manipulação de strings. Essas funções estão
declaradas no arquivo string.h. Entre elas
pode-se destacar:
strcpy(char destino[ ], char origem[ ])
copia a string origem na string destino
strlen(char str[ ])
retorna o tamanho da string str
strcat(char destino[ ], char origem[ ])
Faz concatenação (junção) da string origem com
a string destino. O resultado é armazenado na
string destino 87
Exercícios
1)Fazer um procedimento para imprimir uma string recebida como
parâmetro sem os espaços em branco.

2)Fazer um procedimento para receber uma string do usuário (máx.


50 caracteres) e imprimir uma estatística dos caracteres digitados.
Isto é, imprimir o número de vogais, consoantes e outros
caracteres.

3)Fazer um programa para ler uma string e transfira as consoantes


para um vetor e as vogais para outro. Depois mostre cada um dos
vetores.

88
Exercícios
4)Faça uma função que receba uma string do usuário (máx. 20
caracteres) e um caractere qualquer. A função deverá remover
todas as ocorrências do caractere da string e retornar o número de
remoções.

5)Escreva uma função que receba uma cadeia de caracteres de


tamanho máximo 100, e retornar 1 se esta cadeia é uma
palíndrome e zero caso contrário. Uma palavra é dita ser
palíndrome se a seqüência de seus caracteres da esquerda para a
direita é igual a seqüência de seus caracteres da direita para a
esquerda. Ex.: arara, asa.

89
Exercícios
6)Um dos sistemas de encriptação mais antigos é atribuído a Júlio
César: se uma letra a ser encriptada é a letra de número N do
alfabeto, substitua-a com a letra (N+K), onde K é um número
inteiro constante (César utilizava K = 3). Dessa forma, para K = 1 a
mensagem Ataque ao amanhecer se torna bubrfabpabnboifdfs .
Faça um programa que receba como entrada uma mensagem e
um valor de K e retorne a mensagem criptografada pelo código de
César.

90
DESAFIO!!!

7) Montar uma biblioteca com funções para manipular strings.

IDEIA: Uma biblioteca é um conjunto de subrotinas e tipos de dados que


você pode incluir no seu programa sem a necessidade de digitar
novamente o código.

Exemplo: #include <stdio.h> // biblioteca do sistema!

Podemos criar nossas próprias bibliotecas!

91
Como fazer:
1) No seu Projeto, crie e inclua um novo arquivo chamado biblio.h ,
onde iremos colocar somente os protótipos das subrotinas da nossa
biblioteca.
2) Crie e inclua no mesmo Projeto o arquivo biblio.c , onde iremos
colocar a implementação das subrotinas prototipadas no arquivo
biblio.h
3) No arquivo main.c do seu projeto, basta fazer referência à biblioteca
criada (#include biblio.h ). Observe que você não utilizou os
sinais de maior e menor para indicar a biblioteca, mas sim aspas.
Isso indica que a biblioteca está no mesmo diretório do projeto.

92
Agora, construa sua biblioteca que forneça os principais recursos para a
manipulação de strings. Sendo as funcionalidades propostas:
Copia(): copia uma string para outra
Compara(): compara duas strings
Minusculo(): transforma os caracteres em minúsculo
Maiusculo(): transforma os caracteres em maiúsculo
Sentenca(): organiza a string como sentença
Pessoa(): coloca os caracteres iniciais em maiúsculo
Soma(): soma duas strings
ProcuraTrecho(): procura uma string em outra
ProcuraCaracter(): procura o ocorrência de caracteres na string

93

Das könnte Ihnen auch gefallen