[INF1007] ResumoString

Prévia do material em texto

Programação II 
Monitor: André Vicente Pessanha 
Resumo String: 
 
*************************************************************************************************** 
 
OBS:​ Essa matéria “"só"” cai na P1, P2 e P3! :D 
 
************************************************************************************************** 
 
- Definição: 
 
String é um conjunto de caracteres ou simplesmente um vetor de char que >>SEMPRE<< 
termina no caracter >> '\0' <<! (Contrabarra zero) 
 
É exatamente essa a diferença entre um vetor de número e um vetor de char. 
Pra ser uma string não basta ter um conjunto de letras, precisa >> obrigatoriamente 
terminar << (na última posição) com >> '\0' <<! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Como declarar e ler uma string? 
 
int main (void){ 
 char nome[21]; 
 
 puts("Digite um nome: "); 
 scanf("%[^\n], nome); 
 
OBS:​ MUITO cuidado ao ler String, notou que não usei o & no scanf? 
Leitura de String é uma das exceções (A outra é quando recebemos um ponteiro por 
parâmetro e usamos o scanf na função!) em todo o resto continue usando &. 
 
OBS2: ​Recomendo sempre usar o formato %[^\n] em leitura de string! 
 
Lembra que o enter é representado pelo \n ? Quando o usuário termina de digitar um nome 
por exemplo, ele dá enter no final né? 
 
Por isso que temos que colocar dentro dos colchetes esse %[^\n], pois dessa forma o scanf 
vai fazer a leitura de tudo que o usuário digitar >ATÉ< que ele digite o enter, e só assim a 
leitura é encerrada. 
 
 
 
 
 
 
Mas existe mais um pequeno problema: 
 
Lembra que podemos ler string usando o formato %s? Mas por que não é recomendado 
usar o %s? 
 
scanf("%s",nome); 
 
Porque ele só funciona se o usuário digitar palavras simples! Se ele digitar palavras 
compostas como por exemplo: "Rio de janeiro", o scanf só vai ler "Rio"! 
Isso acontece porque o %s > NÃO < lê caracteres brancos (o espaço). 
 
Pra resolver isso, novamente, é só usar o formato %[^\n] que além de aceitar palavras 
compostas, não teremos problemas com o enter. 
 
scanf("%[^\n]",nome); 
 
Se o usuário digitar "Rio de Janeiro", dessa vez vai ser armazenado "Rio de Janeiro". 
 
 
Resumindo: >> SEMPRE << use o formato %[^\n] para ler strings! :D 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Como prevenir que o usuário não ultrapasse a quantidade máxima de caracteres 
especificado no enunciado? 
 
Exemplo: O Enunciado pede que o usuário digite um nome com no máximo 10 caracteres. 
 
#define TAM 11 
 
int main(void){ 
 char nome[TAM]; 
 
 puts("Digite um nome:") 
 scanf("%[^\n]",nome); 
 
Observe que mesmo definindo TAM como 11 pra ter no mínimo um espaço pro '\0' , isso 
não impede que o usuário enlouqueça e digite 30 caracteres né? Haha 
Pra impedir isso, é só especificar no próprio scanf a quantidade limite! 
 
scanf("%10[^\n]",nome); 
 
 
Dessa forma, mesmo se o usuário louco digitar 30 caracteres, o scanf só vai ler até 10 
caracteres e vai ignorar os outros! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Funções Importantes de String: 
 
 
strcmp (string1, string2): Recebe duas strings como parâmetro e retorna: 
 
 
- Um número maior que zero se a primeira string vem >>DEPOIS<< na ordem alfabética 
que a segunda! 
 
- Um número menor que zero se a primeira string vem >>ANTES<< na ordem alfabética que 
a segunda! 
 
- Zero se forem iguais! 
 
OBS:​ Um erro comum é achar que a strcmp retorna -1, 0 ou 1! (Apesar de algumas versões 
do Visual Studio retornarem sempre esses valores) 
 
Cada caracter possui uma numeração na Tabela ASCII. 
 
Tabela: https://linabanovec.files.wordpress.com/2011/11/ascii.png 
 
O que a função strcmp faz é simplesmente diminuir caracteres! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- strlen (string): Recebe uma string por parâmetro e retorna o seu tamanho. (Sem contar 
com o '\0'! ) 
 
EX: 
 
char s1[] = "Pombo"; 
int tam; 
 
tam = strlen(s1); 
printf("Tamanho: %d\n", tam); 
 
OBS:​ Será impresso "Tamanho: 5"! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- strcpy (string1, string2): Recebe duas strings por parâmetro e copia o conteúdo da 
segunda para a primeira. 
 
Ex: 
 
char s1[] = "Batata"; 
char s2[] = "Fritas"; 
 
strcpy(s1, s2); 
printf("%s %s\n", s1, s2); 
 
OBS:​ Será impresso "Fritas Fritas"! :) 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- strcat (string1, string2): Recebe duas strings como parâmetro e faz a junção da segunda 
no final da primeira. 
 
EX: 
 
char s1[21] = "Pombo "; 
char s2[] = "Voador"; 
 
strcat (s1, s2); 
printf("%s\n", s1); 
 
Será impresso "Pombo Voador"! :D 
 
OBS:​ Strings declaradas dessa forma >> s2[] = "Voador" << são conhecidas como 
Estáticas, pois não podemos fazer nenhuma alteração! 
E Como nesse processo de concatenação, estamos alterando a primeira string, ela 
>>NÃO<< pode ser declarada na forma estática! Por isso especifiquei um tamanho na 
declaração! char s1[21] = "Pombo !"; 
 
OBS2:​ O resultado da junção já ficou com um espaço no meio porque a string "Pombo " já 
tinha um espaço no final! É importante observar isso, pois em algumas questões da P1 é 
preciso concatenar primeiro com o espaço e só depois com a palavra que queremos juntar! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
Funções novas: ( Protótipo: #include <ctype.h> ) 
 
 
- islower(char): Recebe um char como parâmetro e verifica se ele é minúsculo. Retorna 0 se 
isso for > Falso < ou um valor diferente de zero para verdadeiro. (Geralmente 1) 
 
EX: 
 
char s1[] = "Pombo"; 
printf("%d\n", isupper(s1[2])); 
 
OBS:​ Como > m < é uma letra minúscula, a função retorna 1! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- isupper(char): Recebe um char como parâmetro e verifica se ele é maiúsculo. Retorna 0 
se for Falso e um valor diferente de zero se for verdadeiro. 
 
EX: 
 
char s1[] = "Pombo"; 
printf("%d\n", isupper(s1[0])); 
 
OBS:​ Como > P < é uma letra maiúscula, a função retorna 1! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- toupper(char): Recebe um char como parâmetro e o converte pra maiúsculo. 
 
EX: 
 
char s1[] = "Fritas"; 
printf("%c\n", toupper(s1[2])); 
 
Converte o i minúsculo para > I <! 
 
OBS:​ Precisa armazenar em alguma variável se for utilizar depois! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- tolower(char): Exatamente o contrário da função toupper! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- isalpha(char): Recebe um char como parâmetro e verifica se é uma letra. 
 
EX: 
 
char s1[] = "10"; 
printf("%d\n", isalpha(s1[0])); 
 
OBS:​ Como > 1 < não é uma letra, a função retorna 0! 
 
------------------------------------------------------- // ------------------------------------------------------------