Linguagem C: Manipulação de Strings

A linguagem C nos permite manipular um vetor de caracteres que, em outras linguagens, são chamados de Strings. Então, podemos afirmar que a linguagem C também existe esse tipo de dado. Sendo assim, há na linguagem C diversas funções que nos auxiliam a manipular as Strings, evitando a necessidade do uso de grande quantidade de linhas de códigos.
Sendo assim, há na linguagem C diversas funções que nos auxiliam a manipular as Strings, evitando a necessidade do uso de grande quantidade de linhas de códigos.

FUNÇÃO STRLEN

A função strlen é acrônimo de String Length, e como o próprio nome sugere usamos essa função para encontrar o tamanho de uma string, ou seja, a quantidade de caracteres.
A função strlen retorna um valor inteiro referente à quantidade de caracteres da função. Essa contagem é feita passando caractere por caractere da string até chegarmos ao caractere ‘\0’ que, na linguagem C, é o nulo (NULL). É importante sabermos que todas as strings são terminadas com nulo, ou seja, enquanto o caractere nulo (‘\0’) não for encontrado é incrementado 1 (um) ao contador e é passado para o próximo caractere.
A função strlen tem várias aplicações, podemos usar como exemplo a necessidade de contar a quantidade de caracteres para verificar se o usuário informou corretamente um documento como o CPF que tem sempre 11 (onze) caracteres. Chamada da função: strlen(vetor); que o usuárioeja contar. Para melhor entendimento veja a aplicação da função strlen:

main()
{
    char *teste = "Manipulaçao de Strings";
    int tam = strlen(teste);
    printf("%d\n",tam);
    getch();
}

Esse programa conta a quantidade de caracteres de teste e imprime na tela 22.
Abaixo vemos uma função com o mesmo funcionamento da função strlen:

int tamstr(char *str)
{
    int i = 0;
    while(*(str+i) != '\0') i++; 
    return i; 
}

FUNÇÃO STRCAT

main()
{
    char teste[] = "Manipulacao de Strings", teste2[] = " - strcat";
    printf("%x\n", teste);
    strcat(teste,teste2);
    puts(teste);
    getch();
}

No programa acima concatenamos a string “teste” com a string teste2 informando a função “strcat(teste,teste2);”. A concatenação é feita no primeiro vetor (teste = “Manipulacao de Strings - strcat”) e o segundo vetor permanece com o mesmo conteúdo (teste2 = “- strcat”).

FUNÇÃO STRCMP

A função strcmp é acrônimo de String Comparison, e como o próprio nome sugere usamos essa função para comparar duas strings. A função STRCMP compara as strings, e devolve apenas 2 valores, 0 caso forem iguais (verdadeiro), um valor maior que zero que as strings não são iguais e que o primeiro caractere que não é igual entre elas é maior na primeira string, já um valor abaixo de zero o caractere diferente é maior na segunda string. A comparação termina após a função encontrar o NULO na string ou ao encontrar algum caractere diferente.
Exemplo 1:

main()
{
    char teste[] = "Manipulacao de Strings", teste2[] = "Manipulacao de Strings";
    strc== 0 ? puts("iguais") : puts("Sao diferentes");
 getch();
}

No exemplo acima o retorno é 0, ou seja, as strings são iguais.

Exemplo 2:

main()
{
    char teste[] = "Manipulacao de Strings", teste2[] = "Manipulacao de strings";
    printf("\n\n%d \n\n", strcmp(teste,teste2));
    strcmp(teste,teste2) == 0 ? puts("Sao iguais") : puts("Sao diferentes");
    getch();
}

Observe que a letra 's' de uma das string está em maiúsculo e da outra em minusculo. Sendo assim, nesse segundo exemplo o retorno é -1, por que S < s, que equivalem a a 83 e 115 na tabela ASCII respectivamente.

FUNÇÃO STRCPY

A função strcpy é acrônimo de String Copy, e como o próprio nome sugere usamos essa função para copiar o conteúdo de uma string para outra. A função pode vir a ser muito útil podendo copiar todo o conteúdo de uma string para a outra, ou podemos também copiar strings a partir de posições específicas, mas deve-se estar atento em seu tring é copiadra outro lugar, esta pode se sobrepor em outra, ou pode não ter espaço suficiente para esta, o que pode acabar ocorrendo um comportamento não definido. Em seguida veja um exemplo de seu uso:

main()
{
    char teste[] = "Manipulacao de Strings", teste2[] = "strcpy - ";
    strcpy(&teste2[9],&teste[15]);
    puts(teste2);
    getch();
}

Neste programa a string teste está sendo copiada para a string teste2, no entanto está sendo indicado de qual posição isso deve ser feito, então, observe que está sendo copiado de teste2 todo o conteúdo a partir da posição 15 para a string teste a partir da posição 9, logo o resultado deste programa é “strcpy – Strings”.

FUNÇÃO TOLOWER

A função tolower pa uma string uum para minúsculo desde que este pertença as letras de A-Z.
A função retorna o caractere convertido para minúsculo. Essa função pode ser usada para padronizar os dados de um programa tornando qualquer caractere maiúsculo digitado pelo usuário em um caractere minúsculo. Exemplo:

main()
{
    char teste[] = "MANIPULACAO DE STRINGS";
    int i;
    puts(teseste[i] != '\0+)
        putchar(tolower(teste[i])); 
    getch();
}

A saída desse programa será: manipulação de strings.
A implementação dessa função é simples e se faz com o auxílio da tabela ASCII:

char Mtom(char st){
    if((st >= 65)&&(st <= 90)){
        return(st + 32);
    return(st);
    }
}

FUNÇÃO STRLWR

Além da função tolower, existe outra função com o objetivo semelhante. A função strring inteira nvés de fazer caractere por caractere.
Exemplo:

main()
{
    char str[] = "MANIPULACAO DE STRINGS!";
    strlwr(str);
    puts(str);
    getch();
    return 0;
}

A saída será "manipulacao de strings!".

FUNÇÃO TOUPPER

A função toupper passa caracteres de uma string um a um para maiúsculo desde que este pertença as letras de a-z.
A função retorna o caractere convertido para maiúsculo. Essa função pode ser usada para padronizar os dados de um programa tornando qualquer caractere minúsculo digitado pelo usuário em um caractere maiúsculo. Exemplo:

main()
{
    char teste[] = "manipulacao de strings";
    int i;
    puts(teste);
    for(i=0;teste[i] != '\0';i++)
        putchar(tolower(teste[i])); 
    getch();
}

FUNÇÃO STRUPR

Além da função toupper, existe outra função com o objetivo semelhante. A função strupr converte a string inteira para maiúsculo ao invés de fazer caractere por caractere.
Exemplo:

main()
{
    char str[] = "manipulacao de strings!";
    strupr(str);
    puts(str);
    getch();
    return 0;
}

A saída será "MANIPULACAO DE STRINGS!".

FUNÇÃO STRSTR

strstr(string1, string2);

A função strstr deve ser chamada com 2 parâmetros do tipo string, e procura a primeira ocorrência de string1 em string2. Se não for encontrado é retornado NULL e se encontrado é retornado um ponteiro apontando para a primeira ocorrência de string2 em string1.

Exemplo:

#include 
main()
{
    char str1[] = "strings", str2[] = "Manipulacao de strings!";
    if(strstr(str2, str1) == NULL)
        printf("Nao ha ocorrencia.\n");
    else
        printf("Endereco HEX: %x\n",strstr(str2, str1));
    getch();
    return 0;
}

Linguagem C: Laço de repetição do / while

A diferença do "do/while" para o laço "while" é que a condição e verificada no final de sua estrutura. Dessa forma ele sempre vai executar, pelo menos, uma vez.
Exemplo:

main()
{
      int i = 10;
      do{
          printf("O laco do-while eh executado pelo menos uma vez.");
      }while(i < 10);
      getch();
      return 0;
}

Observe no código acima que mesmo o contador "i" já estando em 10 o laço ainda imprimiu a linha uma vez (Observe sua condição no final da estrutura na linha 6).
Um exemplo muito útil é um menu em linguagem C. O menu deve aparecer na tela independente da condição, obviamente, e o usuário escolhe a seguir a opção que deseja executar:

main()
{
      char op;
      do{
          system("cls"); //limpar tela (windows)
          printf("1- Opcao 1 \n2- Opcao 2 \n3- Opcao 3 \n0- Sair\n");
          op = getch();
          switch(op)
          {
               case '1': 
                    system("cls");
                    printf("Voce escolheu a opcao 1\n");
                    getch(); break;
               case '2': 
                    system("cls");
                    printf("Voce escolheu a opcao 2\n"); 
                    getch(); break;
               case '3': 
                    system("cls");
                    printf("Voce escolheu a opcao 3\n"); 
                    getch(); break;
               case '0': return 0;
               default: printf("Opcao invalida!\n");
          }
      }while(op != 0);
      getch();
      return 0;
}

Obviamente as dentro de cada caso do switch deveríamos substituir pelas instruções da opção escolhida pelo usuário. Faça o teste: substitua no código acima as instruções para criar uma calculadora que faça soma, divisão, subtração e multiplicação. Crie as variáveis necessárias e substitua o nome das opções.

Linguagem C: Laço de repetição while

O laço de repetição "while" é semelhante ao laço for. A diferença é que em sua sintaxe informamos apenas a condição:

main()
{
    int i = 0;
    while(i < 10)
    {
        printf("%d, ", i);
        i++;
    }
    getch();
    return 0;
}

Devemos ter cuidado para não criar laços de repetição que nunca atingirão a condição.
Observe que esse simples laço de repetição acima pode ser criado também com for.
Então, quando usar o "while" e quando usar o "for"?
Como observamos, no "while" não definimos o valor de um contador e seu fim. Isso será definido através dos comandos e cálculos que serão executados dentro de sua estrutura ou que serão informados pelo usuário. Por ter essa característica, podemos usa-lo quando não conhecemos o fim da execução do laço.
Exemplo:
Criar um programa que diga para o usuário quantos meses ele precisará para guardar uma determinada quantia de dinheiro.

main()
{
    float qnttotal, qntmes;
    int totalmeses = 1;
    printf("Informe o total que deseja guardar: ");
    scanf("%f",&qnttotal);
    printf("Informe quanto ira guardar por mes: ");
    scanf("%f",&qntmes);
    while((qntmes * totalmeses) < qnttotal)
        totalmeses++;
    printf("Sera necessario %d meses", totalmeses);
    getch();
    return 0;
}

Linguagem C: Laço de repetição for

Com o laço de repetição "for" podemos criar um bloco que será repetido enquanto uma determinada condição não for alcançada.
Podemos dessa forma evitar digitar código extensos. Imaginem, por exemplo, que você precisa digitar 20 vezes a mesma linha. Digitar 20 vezes o printf() com a linha que quer imprimir não é a melhor solução. Aumente isso para 50, pra 100, nada viável digitar tantas linhas para fazer a mesma coisa.
Podemos fazer com que o mesmo bloco repita pela quantidade de vezes que desejamos:

main()
{
    int i;
    for(i = 0; i < 20; i++)
        printf("Linha %d\n", i+1);
    getch();
    return 0;
}

No exemplo acima sera impresso:
"Linha 1"
Como o contador ainda não chegou em seu limite é incrementado 1 ao valor de i e impresso:
"Linha 2"
"Linha 3"
...
"Linha 20"
No momento da impressão é somando 1 ao valor do contador i por que ele começa em 0. O laço é executado de 0 a 19.
O laço for é formado por três partes:
for(inicio da variável ; enquanto <condição> ; incremento)
Podemos ler o for(i = 0; i < 20; i++) da seguinte forma:
para( i começando em 0 ; enquanto i for menor que 20 ; incrementar i de 1 em 1)
Deve-se tomar muito cuidado ao usar laços de repetições, pois pode-se criar laços infinitos. Ou seja, nunca será atingida a condição para parada do laço.
Quando o for possuir mais de uma linha em sua estrutura há a necessidade de inserir chaves para definir o inicio e o fim da estrutura do for. Exemplo:

main()
{
    int i;
    for(i = 0; i < 20; i++)
    {
        if((i+1) % 2 == 0)
            printf("Linha %d\n", i+1);
    }
    getch();
    return 0;
}

Laço for aninhado

For aninhado é o uso de um for dentro de outro. Quando isso ocorre o laço que está mais interno é executado até o fim para depois voltar a mais externo e repetir o laço interno novamente. De modo mais simples, oque estaremos fazer é repetir uma repetição.

Exemplo:

main()
{
    int i, j;
    for(i = 0; i < 5; i++)
        for(j = 0; j < 3; j++)
            printf("i=%d E j=%d\n", i, j);
    getch();
    return 0;
}

Ao entrar no primeiro for o i é 0 (i=0) logo em seguida o programa já entra em outro laço de repetição onde o j é 0 (j=0) e imprime:
i=0 E j=0
E volta para o for mais interno e incremento 1 no j (j=1) e imprime:
i=0 E j=1
Observe que não saímos da primeira repetição do for do contador i. Será feita toda repetição do for do contato j para depois incrementar em e i e novamente fazer o for do contador j de 0 a 2 e assim até finalizar as 5 repetições do primeiro for.
Veja o resultado:

Bastar multiplicar a quantidade de repetições do primeiro laço (5) com a quantidade de repetições do segundo (3) e descobrimos quantas vezes será executada a instrução: 5 * 3 = 15.

Estrutura condicional switch / case

Além da estrutura condicional if/else podemos utilizar o switch/case para avaliar condições.
Essa estrutura trabalha com uma variável, que, para cada valor vai gerar um caso (case).
Exemplo:

main()
{
    int op = 1;
    switch(op)
    {
        case 1: printf("Um"); break;
        case 2: printf("Dois"); break;
    }
    getch();
}

Na linha 4 é passada a variável que será avaliada e entre as chaves na linha 6 e 7 vemos 2 casos possíveis.
Caso "op" tenha o valor 1 será impresso "Um", caso "op" tenha o valor 2 será impresso "Dois". Devemos colocar o break ao final de cada caso.
Se "op" estiver com um valor não tratado nos casos nada será executado. Podemos tratar isso colocando o default que é executado se o valor não existe em nenhum dos casos.

main()
{
    int op = 3;
    switch(op)
    {
        case ((1) || (2)): printf("Um ou dois"); break;
        case 0: printf("Zero"); break;
        default: printf("Invalido.");
    }
    getch();
}

Observe que essa estrutura switch/case é muito parecida com o if/else, porém, mais organizado.
Porém, switch/case trata uma única variável, sendo assim, o if/else não é dispensado, devemos analisar qual das duas estruturas deve ser utilizada.d
Observe que neste segundo exemplo ainda foi utilizado na linha 6 o operador lógico OR (||). Caso seja 1 ou 2 será impresso "Um ou dois".

Calculadora de operações básicas com switch / case:

int main()
{
    float a, b, r;
    char op;
    printf("+: soma \t-: subtracao \t/: divisao \t*: multiplicacao\n");
    printf("Digite a operacao: ");
    scanf("%f %c %f", &a, &op, &b);
    switch(op)
    {
        case '+' : r = a + b; break;
        case '-' : r = a - b; break;
        case '*' : r = a * b; break;
        case '/' :
            {
                if(b != 0)
                    r = a / b;
                else
                {
                    printf("#ERRO# DIVISAO POR 0.");
                    return 1;
                }
                break;
            }
    }
    printf("Resultado: %.2f", r);
    getch();
    return 0;
}