Strings e Matrizes
Strings
Vetores
Vetores são considerados matrizes unidimensionais.
Sendo uma matriz, todos os seus elementos devem ter o mesmo tipo de dado,
por exemplo, um vetor char, int, float, e outros tipos.
No exemplo abaixo é mostrada a sintaxe para a declaração de um vetor:
Sintaxe
tipo_de_dado nome_da_variavel[tamanho];
Quando um vetor é declarado, é reservado na memória um espaço que seja suficiente para guardar o número de células desse vetor. O número de células corresponde ao tamanho que foi especificado entre colchetes depois do nome da variável. A indexação de um vetor em C começa sempre de 0, então, se um vetor possui tamanho 10, as posições onde os dados serão indexados irá de 0 a 9. Para acessar uma posição específica de um vetor, deve-se escrever o nome do vetor e entre colchetes a posição que se quer acessar, como ilustrado no exemplo abaixo.
int vetor_de_inteiros[5] = {1,2,3,4,5};
printf(“O valor da posição de índice 1 do vetor é: %d.”, vetor_de_inteiros[1]);
O resultado do quadro acima que será impresso na tela é o seguinte:
O valor da posição de index 1 do vetor é: 2.
Porém, deve-se ter atenção para não acessar um índice que não existe, pois, o C não verifica em tempo de compilação se o índice que está sendo passado para acesso existe ou não. Caso você tente acessar ou adicionar valores em índices inexistentes que não foram alocados em memória, diversos erros em tempo de execução poderão surgir.
Strings
Na linguagem C, uma string é um vetor de caracteres que obrigatoriamente sempre termina com o caractere nulo,
que por sua vez, é um caractere que possui valor 0 na tabela ASCII e pode ser escrito usando a convenção da barra invertida na forma ‘\0’.
O exemplo abaixo mostra a forma como uma string deve ser declarada. Primeiro é colocado o tipo de dado, que seria o tipo char seguido do nome da variável e logo após, entre colchetes, deve ser indicado o tamanho do vetor.
char nome_da_string[tamanho];
Então, para armazenar a string “cachorro” deve-se declarar um vetor de char que tenha o tamanho de no mínimo 9 posições como demonstrado abaixo.
char animal[9] = “cachorro”;
A palavra “cachorro” possui 8 caracteres, porém, ainda tem o caractere nulo,
por isso o tamanho deve ser de pelo menos 9 posições como ilustrado acima.
inicialização de strings
A linguagem C não inicializa as variáveis por si só, isso deve ser feito pelo programador.
Considere uma string de 11 posições inicializada com a palavra “cachorro” como no exemplo abaixo.
char animal[11] = “cachorro”;
A partir da posição de indexação 9, as células não serão inicializadas e terão assim valores indeterminados, como ilustrado no vetor acima.
Manipulando strings
A manipulação de strings em C possui algumas particularidades, uma delas é quando se quer igualar duas strings, que geralmente, para outros tipos de variáveis, é feito da seguinte forma:
var1 = var2;
Nunca faça isso com strings, a razão será explicada na seção de ponteiros. Para atribuir o valor de uma string para outra deve-se fazer a atribuição de elemento por elemento para a variável de destino. A figura 61 mostra um código que atribui de forma errônea o valor da string cor1 para a string cor2. A marca vermelha na linha 8 indica o erro de compilação que é descrito com mais detalhes na figura 62. Pode-se observar que
Para exemplificar a cópia ou atribuição do valor de uma variável para outra, observe o código da figura 63 onde são declaradas duas strings cor1 e cor2, respectivamente com valores “azul” e “rosa”, nas linhas 5 e 6.
Depois da declaração, as strings são impressas na tela na linha 10 e 11, antes de ser feita a atribuição ou cópia. Então o valor da string cor2 é atribuído para a string cor1 através da iteração do comando for na linha 13. Nessa iteração, a variável i é inicializada com o valor 0 e é incrementada de 1 em 1 enquanto seu valor é menor que 5, ou seja, ela é incrementada de 0 até 4, que corresponde aos mesmos índices das variáveis cor1 e cor2, contabilizando o caractere nulo.
Dessa forma, a cada iteração, um elemento da variável cor2 é atribuído ao elemento da mesma posição na variável cor1, como pode ser observado na linha 14, e no fim da iteração, a variável cor1 possui os mesmos elementos da variável cor2, e consequentemente, as variáveis possuem agora o mesmo valor.
// STRINGS
#include <stdio.h>
int main()
{
char cor1[5]="azul";
char cor2[5]="rosa";
int i;
printf("Antes da copia... \n");
printf("Cor 1: %s \n", cor1);
printf("cor 2: %s \n", cor2);
for(i=0; 1<5; i++){
cor1[i]=cor2[i];
}
printf("Depois da copia... \n");
printf("Cor1: %s \n", cor1);
printf("Cor2: %s \n", cor2);
}
Comando STRCPY
A função strcpy faz basicamente o que acabou de ser feito no exemplo de atribuição de valores de strings da seção anterior.
Ele copia o valor de uma string de origem para uma string de destino e o valor da string de origem é retornado.
O exemplo abaixo mostra a sintaxe do comando, onde esse comando já foi usado no exemplo da seção “Operador ternário” sobre o operador ternário.
Sintaxe
strcpy (string_destino, string_origem);
Existe também a função strncpy, que é uma variação da strcpy, cuja a única diferença é que nela você deve especificar um terceiro parâmetro indicando o número de caracteres da string de origem que serão copiados para a string de destino. O exemplo abaixo ilustra a sintaxe dessa variação.
Sintaxe
strncpy (string_destino, string_origem, num_caracteres);
Não necessariamente o caractere nulo (\0) da string de origem será copiado para a string de destino,
isso só acontecerá se o terceiro argumento for igual ao tamanho da string de origem mais o seu caractere nulo.
É importante se certificar que a string de destino tenha o tamanho suficiente para receber a string de origem.
A figura 65 mostra o mesmo código da figura 63 da seção anterior, porém, agora usando a função strcpy para fazer a atribuição do valor de uma string para outra. Veja que na linha 13 o comando for foi substituído pela função strcpy.
// **********************************************************
// STRINGS, com STRCPY
// **********************************************************
#include <stdio.h>
#include <string.h>
int main()
{
char cor1[5] = "azul";
char cor2[5] = "rosa";
printf("Antes da copia... \n");
printf("Cor 1: %s \n", cor1);
printf("Cor 2: %s \n", cor2);
strcpy(cor1, cor2);
printf("Depois da copia... \n");
printf("Cor 1: %s \n", cor1);
printf("Cor 2: %s \n", cor2);
}
Comando STRCAT
A função strcat é utilizada para concatenar uma string a outra. O exemplo abaixo mostra a sintaxe da função. Quando ela é usada, o parâmetro aqui chamado de string_a_concatenar é concatenado na string passada como parâmetro, chamada string_ftnal.
Sintaxe
strcat (string_final,string_concatenar);
O valor nulo da primeira string passada como parâmetro é sobrescrito pelo caractere da primeira posição da segunda string,
e o valor da string_final alterada é retornado pela função. Assim como a função strcpy, a função strcat também possui uma variação onde é possível informar o número de caracteres da string passada como segundo argumento que serão concatenados na string passada como primeiro argumento. Essa variação é a função strncat, onde sua sintaxe pode ser observada abaixo.
strncat (string_final,string_concatenar, num_caracteres);
Quando a função strncat é usada, também não há garantias que o caractere nulo da string_concatenar será concatenado na string_ftnal, isso também só ocorrerá se o parâmetro num_caracteres for pelo menos igual ao tamanho mais um da string_ concatenar. É importante se certificar que a string final tenha o tamanho suficiente para ser concatenada com a string do segundo argumento.
A figura 67 mostra o mesmo código da figura 65 da seção anterior, porém, agora usando a função strcat para fazer a concatenação de duas strings. Veja que na linha 13, o comando strcpy foi substuído pela função strcat.
// **********************************************************
// STRINGS, com STRCAT, concatenação
// **********************************************************
#include <stdio.h>
#include <string.h>
int main()
{
char cor1[10] = "azul";
char cor2[10] = "rosa";
printf("Antes da concatenação... \n");
printf("cor 1: %s \n", cor1);
printf("cor 2: %s \n", cor2);
strcat(cor1, cor2);
printf("Depois da concatenação... \n");
printf("cor 1: %s \n", cor1);
printf("cor 2: %s \n", cor2);
}
Resultado na tela co computador:
Antes da concatenaτπo...
cor 1: azul
cor 2: rosa
Depois da concatenaτπo...
cor 1: azulrosa
cor 2: rosa
--------------------------------
Process exited after 0.2016 seconds with return value 0
Pressione qualquer tecla para continuar. . .
Comando STRLEN
A função strlen retorna o comprimento da string excluindo da contagem o valor nulo
(‘\0’). O exemplo abaixo ilustra a sintaxe dessa função.
Sintaxe
strlen (nome_da_string);
código de exemplo do uso da função strlen, onde ele retorna para a variável tamanho na linha 9 o comprimento da string cor1, cujo seu valor é “azul”, ou seja, ele possui 4 letras. A figura 70 ilustra o resultado da execução do exemplo da figura 69. Observe que é escrito na tela a frase: “A palavra azul possui o tamanho 4”. Exatamente o valor do comprimento retornado pela função strlen.
// **********************************************************
// STRINGS, com STRLEN, retorna tamanho da string
// **********************************************************
#include <stdio.h>
#include <string.h>
int main()
{
char cor1[10] = "azul";
char cor2 [5] = "rosa";
int tamanho = strlen (cor1);
printf("A palavra azul possui o tamanho: %d \n", tamanho);
}
Comando STRCMP
A função strcmp faz a comparação de duas strings. O exemplo abaixo mostra a sintaxe dessa função que recebe dois argumentos, chamados de string_1 e string_2. A função strcmp compara os caracteres da string_1 com os caracteres da string_2.
Se eles forem iguais, a função retorna 0, caso contrário,
se ela for maior em relação ao código ASCII, ela retornará um valor maior que 0,
e retornará menor que 0 caso a comparação do código ASCII for menor.
strcmp (string_1, string_2);
Essa função também possui uma variação que é a strncmp que recebe um terceiro argumento que indica o número de caracteres que devem ser comparados. O exemplo abaixo apresenta a sintaxe dessa variação:
Sintaxe
strncmp (string_1, string_2, num_caracteres);
A figura 71 mostra um exemplo de programa com o uso da função strcmp, onde é comparado a string cor1 e cor2, na linha 9. A figura 72 mostra a execução do programa que imprime a string “cor1 e cor2 são diferentes!”, uma vez que a função retornou um valor diferente de 0, já que as elas são diferentes.
// **********************************************************
// STRINGS, com STRCMP, e STRNCMP, compara strings
// **********************************************************
#include <stdio.h>
#include <string.h>
int main()
{
char cor1[10] = "azul";
char cor2[5] = "rosa";
if(strcmp(cor1,cor2)){
puts("cor1 e cor2 sao diferentes!");
// aqui vai retornar valor 0, porque azul e rosa sao valores diferentes
}
else{
puts("cor1 e cor2 sao iguais!");
}
}
Comando GETS
gets (nome_da_string);
A função gets é utilizada para ler uma string do teclado parecido com a função scanf.
Sintaxe
gets (nome_da_string);
// **********************************************************
// STRINGS, com GETS, entra com dados digitados
// **********************************************************
#include <stdio.h>
#include <string.h>
int main()
{
char cor[10];
puts("Digite uma cor:");
gets(cor);
printf("A cor digitada foi: %s.", cor);
return 0;
}
Comando PUTS
A função puts é bastante parecida com a função printf, onde ela também é usada para
escrever na tela, porém ela adiciona ao final da string uma quebra de linha (‘\n’).
Sintaxe
puts (string);
Abixo um programa que receba uma string e retorne ao usuário o seu comprimento,
porém, isso feito sem a utilização da função strlen.
// **********************************************************
// STRINGS,
// Abaixo prog.recebe string e retorna ao usuário o seu comprimento,
// porém, sem uso da função strlen.
// **********************************************************
#include <stdio.h>
#include <string.h>
int main()
{
char palavra[100], letra;
int i;
printf("Digite uma palavra: \n");
gets(palavra);
i=0;
letra = ' ';
while(letra != '\0'){
letra = palavra[i];
i++;
}
printf("A palavra %s tem o tamanho %d", palavra, i-1);
return(0);
}
// **************************************************************************
// STRINGS, troca de letras dentro de um string com FOR
// Programa que recebe do usuário uma string e duas letras,
// a primeira letra informada deve ser substituída pela segunda letra
// na string passada. Apresentdo na tela o resultado para o usuário.
// A função getch é usada para pegar os caracteres digitados pelo usuário,
// essa função é uma variação da função getchar,
// a diferença é que com ela não é necessário pressionar a tecla enter
// e o caractere digitado não aparece na tela.
// **************************************************************************
#include <stdio.h>
#include <string.h>
#include <conio.h>
int main()
{
char palavra[12];
int i, letra1, letra2;
printf("Digite uma palavra:\n");
gets(palavra);
printf("Digite uma letra:\n");
letra1 = getch();
printf("Digite outra letra:\n");
letra2 = getch();
for(i = 0; i < strlen(palavra); i++ ){
if(palavra[i] == letra1)
palavra[i] = letra2;
}
printf("A palavra alterada eh: %s", palavra);
return(0);
}