Cadeias de carateres;

Cadeias de carateres

Podemos usar variáveis indexadas de carateres para representar cadeias de texto
Tal como outras variável indexadas, devemos declarar com um tamanho:

char text[100];  // 100 carateres máximo

Para facilitar modificações podemos usar uma macro:

#define MAX_SIZE  100
...
char text[MAX_SIZE];

Cadeias de carateres

As cadeias em C são terminadas com um carater de código zero (representado como '\0')
- a cadeia "Abba" é \(\begin{array}{|c|c|c|c|c|c|}\hline \texttt{A} & \texttt{b} & \texttt{b} & \texttt{a} & \texttt{\0} \\\hline \end{array}\)
- a cadeia vazia “” é \(\begin{array}{|c|}\hline \texttt{\0} \\\hline \end{array}\)
O carater '\0' é um terminador que marca o final da cadeia
- não faz parte do texto
O comprimento da cadeia é determinado pela posição do terminador

Inicialização de cadeias

Inicializar usando constantes de carateres:

char text[6] = { 'H','e','l','l','o','\0' };

Podemos também inicializar com os carateres entre aspas:

char text[6] = "Hello";

Da segunda forma o terminador '\0 é automaticamente introduzido no final

Inicialização (cont.)

Podemos declarar um tamanho superior ao necessário:

char text[100] = "Hello";
  // os carateres restantes são '\0'

Se omitirmos o tamanho, o compilador reserva apenas o necessário

char text[] = "Hello";  // tamanho 6

Imprimir cadeias

Para imprimir uma cadeia podemos usar:

a função puts;
ou printf com o formato "%s"

#include <stdio.h>

char text[] = "Hello, world";
puts(text);

Alternativa:

printf("%s\n", text);

Ler cadeias

Podemos usar fgets() para ler cadeias de carateres.

#include <stdio.h>
#define MAX_SIZE   100
...
char text[MAX_SIZE];
fgets(text, MAX_SIZE, stdin);

O segundo argumento especifica o tamanho máximo
O terceiro argumento especifica o canal de entrada (stdin é a entrada padrão)

Processar cadeias de carateres

Vamos definir pequenas funções para processar cadeias de carateres.

Exemplo 1: contar o comprimento

Uma função para calcular o comprimento de uma cadeia:

  unsigned comprimento(char str[]);

Existe uma função semelhante na biblioteca-padrão (declarada em <string.h>):

   size_t strlen(char str[]);

size_t é um inteiro sem sinal (porque o comprimento nunca é negativo)

Contar comprimento

unsigned comprimento(char str[])
{
   unsigned i = 0;

   while(str[i] != '\0')
      i++;

   return i;
}

Exemplo 2: contar espaços

Vamos definir uma função que conta o número de espaços numa cadeia de carateres.

  unsigned contar_espacos(char str[]);

Não necessitamos de passar o comprimento como argumento porque o fim da cadeia é marcado por '\0'

Contar espaços

unsigned contar_espacos(char str[])
{
    unsigned espacos = 0;

    for(int i=0; str[i]!='\0'; i++)
    {
       if(str[i] == ' ')
         espacos ++;
    }
    return espacos;
}

Exemplo 3: inverter uma cadeia

Vamos definir uma função para inverter a ordem de carateres numa cadeia
- "abc123" deve ser transformado em "321cba"
Vamos modificar a cadeia passada como argumento:

  void inverter(char str[]);

A função inverter não retorna qualquer valor

Algoritmo

Dois índices \(i\), \(j\) sobre a cadeia
Inicialmente: \(i\) contém o índice do primeiro carater e \(j\) contém o índice do último carater
Repetir enquanto \(i < j\):
1. trocar os carateres das posições \(i\) com \(j\)
2. incrementar \(i\) e decrementar \(j\)

Cuidados:

deve funcionar para comprimento par ou ímpar
e com cadeias pequenas (com 0 ou 1 carateres)

Inverter uma cadeia

void inverter(char str[])
{
   int i = 0, j;
   j = comprimento(str) - 1; 
     // atenção: j pode ser negativo!
   while (i < j) {
      char ch = str[i];
      str[i] = str[j];
      str[j] = ch;
      i ++;
      j --;
   }
}

Programa principal

#include <stdio.h>

#define MAX_SIZE 1000    // tamanho máximo

int main(void) {
  char text[MAX_SIZE];
  
  fgets(text, MAX_SIZE, stdin);  // ler 
  puts(text);      // imprimir original
  inverter(text);  // inverter
  puts(text);      // imprimir invertido
}

Processamento de cadeias

Vamos definir pequenas funções em C para operar sobre cadeias de carateres: - calcular o comprimento - copiar - concatenar - procurar carateres - comparar - ler/escrever
Existem funções da bibloteca-padrão de C para estas operações (veremos mais tarde)

Calcular o comprimento

unsigned comprimento(char str[]);

Contar o número de carateres até ao terminador '\0'.

Exemplos de uso:

char str1[] = {'A', 'B', '\0'};
char str2[] = "Hello";
n = comprimento(str1);
m = comprimento(str2);
   // n igual a 2,  m igual a 5

Comprimento

Solução apresentada anteriormente.

unsigned comprimento(char str[])  {
  unsigned i = 0;
  while(str[i] != '\0') 
    i++;
  return i;
}

Execute passo-a-passo para ver que funciona com cadeias “pequenas” (e.g. de comprimento 1 ou 0)

Copiar

void copiar(char dest[], char origem[]);

Copiar os carateres da cadeia origem para dest
Modifica os carateres da variável dest
Supomos que dest tem espaço suficiente

Exemplo de uso:

char mesg[] = "Hello!!!";
char texto[100];
copiar(texto, mesg);
  // agora texto contém "Hello!!!"

Copiar (1ª versão)

void copiar(char dest[], char origem[]) {
  int i = 0;
  while(origem[i] != '\0') {
    dest[i] = origem[i];
    i++;
  }
  dest[i] = '\0';  // colocar o terminador
}

No ciclo: i é o índice do próximo carater a copiar
No final do ciclo colocamos o terminador na última posição

Copiar (2ª versão)

void copiar(char dest[], char origem[]) {
  int i = 0;
  while((dest[i]=origem[i]) != '\0') 
    i++;
}

Note que desta forma o terminador '\0' é colocado no teste de condição do ciclo.

Concatenar

void concat(char dest[], char origem[]);

Copiar os carateres de origem após o final da cadeia dest
Supomos que dest tem espaço suficiente

Exemplo de uso:

char texto1[50] = "ABC";
char texto2[50] = "1234";
concat(texto1, texto2);
  // texto1 fica "ABC1234"
  // texto2 continua "1234" (inalterado)

Concatenar (1ª versão)

void concat(char dest[], char origem[]) {
  int i, j;
  i = 0;
  j = comprimento(dest);  // índice do final
  while(origem[i] != '\0') {
    dest[j] = origem[i];
    i ++;
    j ++;
  }
  dest[j] = '\0'; // colocar o terminador
}

Concatenar (2ª versão)

void concat(char dest[], char origem[]) {
  int i, j;
  i = 0;
  j = comprimento(dest);  // índice do final
  while((dest[j]=origem[i]) != '\0') {
    i ++;
    j ++;
  }
}

Desta forma colocamos o terminador no teste da condição do ciclo.

Procurar um carater

int procurar(char str[], char ch);

Procura a primeira ocorrência do charater ch na cadeia
Se encontrar, retorna o seu índice
Caso contrário, retorna um índice inválido (-1)

Exemplo de uso:

char msg[] = "ABABCA";
i = procurar(msg, 'C');
j = procurar(msg, 'D');
 // i igual a 4, j igual a -1

Procurar

int procurar(char str[], char ch)  {
  int i;
  for (i = 0; str[i] != '\0'; i++) {
    if(str[i] == ch) 
      return i; // encontrou
  }
  return -1;    // não encontrou
}

Comparar cadeias

int comparar(char str1[], char str2[]);

Testar se duas cadeias contém os mesmos carateres pela mesma ordem
Resultado: 1 em caso afirmativo, 0 em caso negativo

Exemplo de uso:

char texto1[] = "ABC";
char texto2[] = "ABC123";
c = comparar(texto1, texto2);
 // resultado 0 (diferentes)

Comparar cadeias

Note que comparar com == não produz o efeito desejado: compara os endereços das variáveis indexadas, não os conteúdos:

char texto1[] = "ABC";
char texto2[] = "ABC";
printf("%d", comparar(texto1, texto2));
  // imprime 1 (conteúdos iguais)
printf("%d", texto1 == texto2);
  // imprime 0 (endereços diferentes)

Comparar cadeias

int comparar(char str1[], char str2[]) {
  int i = 0;
  while(str1[i] != '\0' && str1[i] == str2[i])
    i++;
  return (str1[i] == str2[i]);
}

O ciclo termina quando:

str1[i] == '\0' (terminar a 1ª cadeia);
str1[i] != str2[i] (encontrar um carater diferente).

Em qualquer caso: as cadeias são iguais se e só se str1[i] == str2[i].

Imprimir uma linha

void imprimir(char str[]);

Imprimir todos os carateres seguido de \n
Semelhante à função puts da biblioteca padrão
Usar putchar para imprimir um carater de cada vez

Imprimir uma linha

void imprimir(char str[]) {
    int i = 0;
    while(str[i] != '\0') {
        putchar(str[i]);
        i++;
    }
    putchar('\n');
}

Ler uma linha

int ler_linha(char str[], int max_size);

Ler carateres da entrada padrão até \n ou EOF
Guardar na cadeia str e terminar com \0
Ler no máximo max_size-1 carateres (por causa do terminador)
Retorna o número de carateres guardado

Exemplo de uso:

char texto[100];
n = ler_linha(texto, 100);

Ler uma linha

int ler_linha(char str[], int max_size) {
  int i = 0, ch;
  max_size--;  // máximo carateres a colocar
               // subtrai 1 para o terminador
  while(max_size > 0) {
    ch = getchar();
    if(ch == EOF || ch == '\n')  // fim?
      break;
    str[i++] = ch;
    max_size--;
  }
  str[i] = '\0';  // coloca terminador
  return i; // número de carateres colocado
}