Pesquisar no blog:

Mostrando postagens com marcador Ponteiros. Mostrar todas as postagens
Mostrando postagens com marcador Ponteiros. Mostrar todas as postagens

quinta-feira, 27 de junho de 2013

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;
}

segunda-feira, 7 de janeiro de 2013

Ponteiros - Linguagem C

Ponteiros são variáveis que permitem que você acesse outras variáveis sem referência-las diretamente.
Como o nome sugere, seu objetivo é apontar para uma variável. Mais especificamente para o endereço onde a variável apontada se encontra.
Os ponteiros dão a linguagem C grandes possibilidades para manipular endereços de memória e é representado por um asterisco (*) antes do nome da variável. Exemplo: *var

Como funcionam os ponteiros?
Exemplo: temos a variável x = 5 e a variável ponteiro *y = &x.
A variável x é uma variável comum com o valor 5 armazenado. Já a variável *y esta apontando para o endereço da variável x (&x).
O operador "&" na frente de uma variável sempre retornará seu endereço de memória, por isso que ao ler uma variável com a função "scanf" utilizamos as variáveis com este sinal na frente.
Neste caso, então, *y tem o endereço de x. Isso significa que se eu fizer a seguinte operação:
*y = 10
Estarei mudando o valor de x que era 5 para 10.

Exemplo:
main()
{
      int a = 3, b = 7, *pa = &a, *pb = &b, aux;
      printf("a = %d\nb =%d\n",a,b);
      printf("Invertendo...\n");
      system("pause");
      aux = a;
      *pa = b;
      *pb = aux;
      printf("a = %d\nb =%d\n",a,b);
      system("pause");
      return 0;
}

A tabela a seguir representa o conteúdo das variáveis usadas nesse simples programa.
Endereço
Variável
Conteúdo
0x0100
a
3
0x0101
b
7
0x0102
pa
0x0100
0x0103
pb
0x0101
0x0102
*pa
3
0x0103
*pb
7

Observe que o conteúdo dos ponteiros sem o asterisco (*) são endereços.
Mais quando colocamos o asterisco (*) estou indicando que ela deve apontar para o endereço. Então quando informo que *pa = b é a mesma coisa que dizer que o endereço de memória 0x0100 = b ou que a variável a = b.

Como ou quando usar os ponteiros?
Ponteiros são utilizado principalmente em funções, quando há a necessidade de retornar mais valores para o programa principal.
Se você não conhece funções na linguagem C acesse este link.
Sabemos que funções retornam apenas um valor por função. Sabemos também que as variáveis de uma função são destruídas depois que a função é executada. Então a solução para isso é mandar para uma função o endereço da variável que você deseja alterar, assim você estará alterando a variável do programa principal.

Exemplo: função para inverter valores de variáveis.
void troca(int *px, int *py)
{
     int aux;
     aux = *px;
     *px = *py;
     *py = aux;
}

main()
{
      int x = 3, y = 7;
      printf("x = %d\ny =%d\n",x,y);
      printf("Invetendo...\n");
      system("pause");
      troca(&x,&y);
      printf("x = %d\ny =%d\n",x,y);
      system("pause");
      return 0;
}

Na função "troca" foi criado dois ponteiros apontando para os endereços das variáveis do programa principal (x e y) e usando esses ponteiros invertemos os valores das variáveis do programa principal.
Essa inversão é muito utilizada em muitos algoritmos e essa seria uma solução para não precisar repetir essas linhas sempre que precisar inverter variáveis.
As matrizes são ponteiros representados de uma maneira diferente.
Se você não sabe o que são matrizes acesse esse link.
As matrizes são armazenadas em sequencia nas células de memórias. Sabemos que cada célula possui 1 Byte (8 bits), então se tivermos um valor do tipo inteiro armazenado em um ponteiro e somarmos 1 a esse endereço ele irá pular 4 células, ou seja, 4 Bytes onde está armazenado o valor da variável.
Aqui temos um programa que comprova isso:
main()
{
      int i, a[5] = {2000,2001,2002,2003,2004}, *pa = &a;
      for(i = 0; i < 5; i++)
           printf("Endereço atual: %d\nValor: %d\n",&a[i],*pa+i);
      system("pause");
      return 0;
}

Criamos um vetor (a) simples com 5 posições e percorremos ele com um ponteiro (*pa) sendo incrementado por i.
A cada vez que o ponteiro é incrementado é mostrado o endereço do vetor e seu valor, oque comprova que ao incrementar o ponteiro ele pula as 4 células (4 Bytes).
Veja o resultado na imagem abaixo: