Resumo_String

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

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!
--------------------------------------//--------------------------------------------