Strings

Strings é uma matriz do tipo char que armazena um texto formado de caracteres e sempre terminado pelo caractere zero ('\0'). Em outras palavras, string é uma série de caractres, onde cada um ocupa um byte de memória, armazenados em sequência e terminados por um byte de valor zero. Cada caractere é um elemento independente da matriz e pode ser acessado por meio de um índice.

Visualizando uma String de C

Seu computador requer um byte de memória para armazenar um único caractere ASCII. Como você aprendeu uma string é uma seqüência de caracteres ASCII. Quando você declara uma constante de strings, C automaticamente atribui o caractere NULL. Quando seus programas criam suas próprias strings lendo caracteres do teclado, eles precisam colocar o caractere NULL no final da string para indicar onde ela termina. Portanto o melhor modo para visualizar uma string é como uma colocação de bytes terminados por um caractere NULL.

Como o Compilador representa uma String de Caracteres

Quando você usa uma constante de caracteres dentro de seu programa, o compilador C automaticamente coloca o caractere NULL (\0) no final da string.

Como C Armazena uma String de Caracteres

Para criar uma string de caracteres, você simplesmente declara uma matriz de caracteres, como mostrado aqui:

								
char string [256];

C criara uma string capaz de armazenar 256 caracteres, que C indexa de string[0] até string[255]. Como a string pode conter menos que 256 caracteres, C usa o caractere NULL (ASCII 0) para representar o último caractere da string. C tipicamente não coloca o caractere NULL após o último caractere na string. Em vez disso, funções tais com fgets ou gets colocam o caractere NULL no final da string. À medida que seus programas manipularem strings, é a sua responsabilidade garantir que o caractere NULL esteja presente. O programa a seguir define uma string de 256 caracteres, e, depois, atribui as letras maiúscula do alfabeto aos primeiros vinte e seis dígitos da string:

										
#include <stdio.h>
void main(void)
{
    char string[256];
    int i;
    for (i = 0; i < 26; i++)
        string[i] = ‘A’ + i;
    string[i] = NULL;
    printf ("A string contem %s\n",string);
}

O programa usa o laço for para atribuir as letras A até Z à string. O programa depois coloca o caractere NULL após a letra Z para indicar o final da string. A função printf então exibirá cada caractere na string até o caractere NULL. As funções que trabalham com strings usam o caractere NULL para determinar o final da string. O programa a seguir, também atribui as letras A até Z a uma string de caracteres. No entanto, depois o programa atribui o caractere NULL à string[10], que é a posição que segue imediatamente a letra J. Quando printf exibe o conteúdo da string, ele para na letra J:

										
#include <stdio.h>
void main(void)
{
   char string[256];
   int i;
   for (i = 0; i < 26; i++)
       string[i] = ‘A’ + i;
   string[10] = NULL;
   printf ("A string contem %s\n",string);
}

Nota: quando você trabalha com strings, sempre precisará incluir o caractere NULL para representar o final da string.

Aprendendo como 'A' Difere de "A"

Quando você trabalha com caracteres dentro de C, pode usar o valor ASCII numérico de um caractere ou pode colocar o caractere dentro de apóstrofes, tal como ‘A’ . Por outro lado, quando você usa aspas, tal com "A" , C cria uma string de caracteres que contém a letra especificada (ou letras), e finaliza a string com o caractere NULL. Como C as armazena de formas diferentes, as constantes de caracteres e strings não são iguais, e você precisará tratá-las de forma diferente dentro de seus programas.

Representando uma Aspas dentro de uma Constante de String

Dependendo dos seus programas, algumas vezes uma constante de string conterá um caractere aspas. Por exemplo, assuma que você queira representar a seguinte string:

		"Pare!", ele disse.

Como C usa as aspas para definir as constantes de strings, você precisará ter um modo de dizer ao compilador que quer incluir aspas dentro da string. Para fazer isso, use a seqüência de escape \" , como mostrado aqui:

		"\"Pare!\" ele disse."

O programa a seguir usa a seqüência de escape \" para colocar aspas dentro de uma constante de string:

								
#include <stdio.h>
void main(void)
{
    char string[]= "\"Pare!\" ele disse." ;
}

Determinando o Tamanho de uma String

Funções tais como fgets e cgets automaticamente atribuem o caractere NULL para indicar o final de uma string. O programa a seguir usa a função gets para ler uma string de caracteres do teclado. O programa depois usa um laço for para exibir os caracteres da string em de cada vez até que a condicional string[i] != NULL seja avaliada como falsa.

										
#include <stdio.h>
void main(void)
{
   char string[256]; // string digitada pelo usuário
   int i; // índice para a string
   printf ("Digite uma string de caracteres e pressione Enter: \n");
   gets(string);
   // Exibe cada string de caracteres até que NULL seja encontrado
   for (i = 0; string[i] != NULL; i++)
       printf ("O número de caracteres na string é %d\n", i);
}

Usando a Função Strlen

O formato da função strlen é como segue:

										
#include <string.h>
size_t strlen(const char string);

O programa a seguir ilustra como usar a função strlen:

										
#include <stdio.h>
#include <string.h>
void main(void)
{
    char titulo_livro[] = "Bíblia do programador C/C++, do Jamsa!"; 
    printf ("%s contém %d caracteres\n", titulo_livro,strlen(titulo_livro));
}

Quando você compilar e executar o programa sua tela exibirá o seguinte:

										
Bíblia do programador C/C++, do Jamsa! contém 38 caracteres

Copiando os Caracteres de uma String em Outra

A função strcpy , que copia os caracteres em uma string (o parâmetro origem) em outra string (o parâmetro destino):

					
#include <string.h>
char *strcpy(char *destino, const char *origem);

A função strcpy retorna um ponteiro para o início da string de destino. O programa a seguir ilustra como usar a função strcpy dentro de seus programas.

								
#include <stdio.h>
#include <string.h>
void main(void)
{
   char titulo[] = "Bíblia do programador C/C++, do Jamsa!";
   char livro[128];
   strcpy(livro, titulo);
   printf ("Nome do livro %s\n", livro);
}

Anexando o Conteúdo de uma String em Outra

A função strcat , que concatena (anexa) uma string de origem em uma string-alvo, como mostrado aqui:

								
#include <string.h>
char *strcat(char alvo, const char *origem);

O programa a seguir, ilustra como usar a função strcat:.

								
#include <stdio.h>
#include <string.h>
void main(void)
{
   char nome[64] = "Dálmata macho";
   strcat(nome,"Happy");
   printf ("O nome completo do Happy é %s\n", nome);
}

Quando você compilar e executar o programa sua tela exibirá o seguinte:

								
O nome completo do Happy é Dálmata macho Happy

Anexando N Caracteres a uma String

A função strNcat , que anexa os primeiros n caracteres de uma string de origem em uma string de destino, como mostrado aqui:

								
#include <string.h>
char *strncat(char *destino, const *origem,size_t n);

Se n especificar um número de caracteres maior que o número de caracteres na string origem, strncat copiará caracteres até o final da string e não mais. O programa a seguir ilustra como usar a função strncat:

								
#include <stdio.h>
#include <string.h>
void main(void)
{
   char nome[64] = "Fernando";
   strncat(nome,"e Rute",4);
   printf ("Você votou em %s \n",nome);
}

Quando você compilar e executar o programa sua tela exibirá o seguinte:

								
Você votou em Fernando e Ru

Não Ultrapasse o Tamanho de uma String

char string [10];

Se você atribuir mais de 10 caracteres à string, seu sistema operacional poderá não detectar o erro. Em vez disso, os caracteres que você queria atribuir à string podem sobrescrever as posições de memória que correspondem às outras variáveis. Corrigir um erro de sobrescrita é muito difícil, e o erro também pode fazer seu programa e o sistema operacional interromper a execução. Como regra, declare suas strings ligeiramente maiores do que você acha que será necessário. Fazendo isso, você reduz a possibilidade de sobrescrever uma string. Se seus programas experimentarem erros intermitentes, examine o código de seu programa para determinar se seu programa pode estar sobrescrevendo uma string de caracteres.

Determinando se Duas Strings São ou Não Iguais

	
int streql (char *str1, char *str2)
{
   while ((*str1 == * str2) && (*str1))
   {
       str1++;
       str2++;
   }
   return ((*str1 == NULL) && (*str2 == NULL));
}

A função streql retornará o valor 1 se as duas strings forem iguais, e 0 se as strings não forem iguais. O seguinte programa C, ilustra como usar a função streql:

								
#include <stdio.h>
void main(void)
{
   printf ("Testando Abc e Abc %d\n",streql("Abc","Abc"));
   printf ("Testando abc e Abc %d\n",streql("abc","Abc"));
   printf ("Testando abcd e abc %d\n",streql("abcd","abc"));
}

Quando você compilar e executar o programa, sua tela exibirá a seguinte saída:

								 
Testando Abc e Abc 1
Testando abc e Abc 0
Testando abcd e abc 0

Atenção: O compilador TCLite nao aceita a função streql e nem a strieql, portanto devemos substituí-las pelas funções strcmp e stricmp respectivamente. A função strcmp e a stricmp, retornam os seguintes valores:



< 0 se a string1 for menor que a string2
= 0 se a string1 for igual a string2
> 0 se a string1 for maior que a string 2

Ignorando a Caixa ao Determinar se as Strings São Iguais

Algumas vezes você pode querer comparar duas strings sem considerar a caixa. Para comparar strings sem considerar a caixa, você pode criar a função strieql, como mostrado aqui:

								
#include <stdio.h>
int strieql(char *srt1, char *str2)
{
    while ((toupper(*str1) == toupper(*str2))&& (*str1))
    {
        str1++;
        str2++;
    }
    return((*str1 == NULL) && (*str2 ==NULL));
}

Como você pode ver, a função strieql converte cada caractere em cada string para maiúscula antes de comparar as duas strings. O programa a seguir, ilustra como usar strieql:

								
#include <stdio.h>
#include <Ctype.h>
void main(void)
{
    printf ("Testando Abc e Abc %d\n",strieql("Abc","Abc"));
    printf ("Testando abc e Abc %d\n",strieql("abc","Abc"));
    printf ("Testando abcd e abc %d\n",strieql("abcd", "abc"));
}

Quando você compilar e executar o programa sua tela exibirá o seguinte:

								
Testando Abc e Abc 1
Testando abc e Abc 1
Testando abcd e abc 0

Atenção: O compilador TCLite nao aceita a função strieql, portanto devemos substituí-la pela função stricmp. A função stricmp, retorna os seguintes valores:


< 0 se a string1 for menor que a string2
= 0 se a string1 for igual a string2
> 0 se a string1 for maior que a string 2

Convertendo uma String de Caracteres para Maiúsculas ou Minúsculas

								
#include <string.h>
char *strlwr(char *string);
char *strupr(char (string));

O programa a seguir, ilustra como usar as funções strlwr e strupr:

               
#include <stdio.h>
#include <string.h>
void main(void)
{
    printf (strlwr ("Bíblia do programador C/C++, do Jamsa!\n"));
    printf (strupr ("Bíblia do programador C/C++, do Jamsa!\n"));
}

Convertendo a Representação em String de Caracteres de um Número

Funções da biblioteca de execução que seus programas podem usar para converter representações ASCII de um valor numérico.

O programa a seguir, ilustra como usar as funções de ASCII para numérico:

								
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
   int int_result;
   float float_result;
   long long_result;
   int_result = atoi("1234");
   float_result = atof("12345.678");
   long_result = atol("1234567L");
   printf("%d %f %ld\n", int_result, float_result, long_result);
	 printf("%d %f %ld\n", int_result, float_result, long_result);
}

Encontrando um Caractere da Primeira Ocorrência de um Determinado Conjunto

Dependendo da função que seu programa executar, algumas vezes você irá querer pesquisar em uma string a primeira ocorrência de qualquer caractere de um dado conjunto de caracteres. Para lhe ajudar a procurar em uma string qualquer caractere de um conjunto, a maioria dos compiladores C fornece a função strspn, como mostrado aqui:

								
#include <string.h>
size_t strspn(const char *s1, const char *s2);

Dentro da string s1, a função retorna o deslocamento do primeiro caractere não contido dentro da string s2. O programa a seguir, ilustra como usar a função strspn:

								
#include <stdio.h>
#include <string.h>
void main(void)
{
   printf("Procurando Abc em Abcdef %d\n",strspn("AbcDef", "Abc"));
   printf("Procurando cbA em AbcDef %d\n",strspn("AbcDef", "cbA"));
   printf("Procurando Def em AbcAbc %d\n",strspn("AbcAbc", "Def"));
}

Quando você compilar e executar o programa sua tela exibirá o seguinte:

								
Procurando Abc em AbcDef 3
Procurando cbA em AbcDef 3
Procurando Def em AbcAbc 0

Localizando uma Substring Dentro de uma String

À medida que seus programas trabalharem com strings, algumas vezes você precisará procurar uma substring específica dentro de uma string. Para lhe ajudar a procurar uma substring em uma string, a maioria dos compiladores C fornece uma função chamada strstr, como mostrado aqui:

								
#include <stdio.h>
strstr(string, substring);

Se a substring existir dentro da string, strstr retornará um ponteiro para a primeira ocorrência da string. Se strstr não encontrar a substring, a função retornará NULL. O programa a seguir, ilustra como usar strstr:

								
#include <stdio.h>
#include <string.h>
void main(void)
{
   printf ("Procurando Abc em AbcDef %s\n",(strstr("AbcDef", 
	 "Abc"))"Encontrado" : "Não encontrado");
   printf ("Procurando Abc em abcDef %s\n", (strstr("abcDef", 
	 "Abc"))"Encontrado" : "Não encontrado");
   printf ("Procurando Abc em AbcAbc %s\n", (strstr("AbcAbc", 
	 "Abc"))"Encontrado" : "Não encontrado");
}

Para lhe ajudar a compreender melhor strstr, considere a seguinte implementação:

								
char *strstr(const char *s1, const char *s2)
{
   int i, j, k;
   for (i = 0; s1[i]; i++)
       for (j = i, k = 0; s1[j] == s2[k]; j++, k++)
           if (! S2[k+1])
              return (s1 + i);
   return(NULL);
}

Contando o Número de Ocorrências da Substring

Você viu como usar a função strstr para localizar uma substring dentro de uma string. Em certas ocasiões, você poderá querer saber o número de vezes que uma substring aparece dentro de uma string. A seguinte função strstr_cnt, permite-lhe determinar quantas vezes uma determinada substring ocorre dentro de uma string.

								
int strstr_cnt (const char *string, const char *substring)
{
   int i, j, k, conta = 0;
   for (i = 0; string[i]; i++)
       for (j = i, k - =0; string[j] == substring[k];j++, k++)
           if (! substring[k+1])
              conta++;
   return(conta);
}

Obtendo um Índice para uma Substring

Você aprendeu como usar a função strstr para obter um ponteiro para uma substring dentro de uma string. Se você tratar as strings de caracteres como matrizes, em vez de usar ponteiros, algumas vezes irá querer saber o índice do caractere onde uma substring inicia dentro da string. Usando o valor que strstr retorna, você pode subtrair o endereço da string para produzir um índice:

								
indice = strstr(string, substr) – string;

Se strstr não encontra a substring, o valor do índice será igual ao tamanho da string. Além disso, seus programas podem usar a função substring_index para obter um índice para uma substring, como mostrado aqui:

								
int substring_index (const char *s1, const char *s2)
{
    int i, j, k;
    for (i = 0; s1[i]; i++)
        for (j = i, k = 0; s1[j] == s2[k]; j++, k++)
            if (! S2[k+1])
               return(i);
    return(i);
}

Determinando se um Caracter é Alfanumérico

Um caractere alfanumérico é uma letra ou um dígito. Em outras palavras, um caracter alfanumérico é uma letra maiúscula de A até Z, uma letra minúscula de a até z, ou um dígito de 0 até 9. Para ajudar seus programas a determinar se um caractere é alfanumérico, o arquivo de cabeçalho ctype.h contém uma macro chamada isalnum. A macro examinará uma letra e retornará o valor 0 se o caractere não for alfanumérico, e um valor diferente de zero para caracteres alfanuméricos, como mostrado aqui:

								
if (isalnum(letra))

Para compreender melhor a macro isalnum, considere implementação:

								
#define isalnum(c) ((toupper((c)) >= ‘A’ && (toupper((c)) 
<= ‘Z’ || ((c) >= ‘0’ && ((c) <= ‘9’))

Determinando se um Caractere é uma Letra

Á medida que seus programas trabalharem com caracteres dentro de strings, algumas vezes precisarão testar se um caracter contém uma letra do alfabeto (maiúscula ou minúscula). Para ajudar seus programas a determinar se um caractere é uma letra do alfabeto, o arquivo de cabeçalho ctype.h fornece a macro isalpha. A macro uma letra e retorna o valor 0 se o caractere não contém uma letra maiúscula de A até Z ou minúscula de a até z. Se o caractere contém uma letra do alfabeto, então a macro retorna um valor diferente de zero:

								
if (isalpha (caractere))

Para compreender melhor a macro isalpha, considere a seguinte implementação:

								
#define isalpha(c) (toupper((c)) >= ‘A’&& (toupper((c)) <= ‘Z’)

Determinando se um Caractere é Maiúsculo ou Minúsculo

À medida que seus programas forem trabalhando com caracteres dentro de uma string, algumas vezes você precisará saber se um caractere é uma letra maiúscula ou minúscula. Para ajudar seus programas a testar a caixa das letras, o arquivo de cabeçalho ctype.h fornece as macros islower e isupper. Essas macros examinam um caractere e retornam um valor 0 para caracteres que não são minúsculos (islower) ou minúsculos (isupper) e um valor diferente de 0 em caso contrário:

								
if (islower (caractere))
if (isupper (caractere))

Para compreender melhor as macros islower e isupper, considere as seguintes implementações:

								
#define islower (c) ((c) >= ‘a’ && (c) <=’z’)
#define isupper (c) ((c) >= ‘A’ && (c) <= ‘Z’)

Determinando se um Caractere Contém Espaço em Branco

O termo caracteres de espaço em branco inclui os seguintes caracteres: espaço, tabulação, retorno do carro, nova linha, tabulação vertical e alimentação de formulário. Quando seus programas efetuam saída de caracteres, algumas vezes você precisa testar se um caractere contém um espaço em branco. Para ajudar seus programas a testar o espaço em branco, o arquivo de cabeçalho ctype.h fornece a macro isspace. Essa macro examina um caractere e retorna um valor diferente de 0 para caracteres e espaço em branco, e um valor 0 para caracteres de não espaço em branco:

								
if (isspace (caractere))

Para compreender melhor a macro isspace, considere a seguinte implementação:

								
#define isspace (c) (((c) == 32) || ((c) == 9) || ((c) == 13)