Author Archive

Palavras-chave: C, arquivo texto, linhas, leitura, getline

Como dito num post anterior, a glibc possui uma função para ler linhas de comprimento arbitrário de um arquivo texto. Mas como esta função é especifica a glibc, alguns leitores pediram uma versão que faça o mesmo em qualquer sistema. Uma das muitas formas de fazer isto é:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *pegalinha(FILE *f, char **buffer, size_t *buflen)
{
  char *ptr;
  char *tmp;
  int c;
  if (!*buffer || !*buflen)
  {
    *buflen= 32;
    *buffer= (char*)malloc(*buflen);
    if (!*buffer)
      return NULL;
  }

  ptr= *buffer;
  while ((c= fgetc(f)) != EOF) {
    *ptr++= c;
    if (c == '\\n') break;

    if (ptr - *buffer >= *buflen-1)
    {
      // aumenta o buffer um pouco mais
      tmp= (char*)realloc(*buffer, *buflen+32);
      if (!tmp)
        return NULL;
      // atualiza ptr para o caso do novo buffer estar em outro lugar
      ptr= tmp + (ptr - *buffer);
      *buflen+= 32;
      *buffer= tmp;
    }
  }
  *ptr= 0;
  return c==EOF ? NULL : *buffer;
}

int main(int argc, char **argv)
{
   FILE *file;
   char *linha= NULL;
   size_t tamlinha= 0;

   if (argc != 2) { printf("%s \\n", argv[0]); exit(1); }

   if (!(file= fopen(argv[1], "r"))) { perror(argv[1]); exit(1); }

   while (pegalinha(file, &linha, &tamlinha))
   {
     printf("%i:%s", tamlinha, linha);
   }
   if (linha)
     free(linha);
   fclose(file);
   return 0;
}

Palavras-chave: C, linkagem estática, undefined reference, referência indefinida

Ao linkar programas que usam bibliotecas estáticas que por usa vez usam outras bibliotecas estáticas, pode ocorrer de o linker reclamar da falta de símbolos de uma das bibliotecas, apesar de eles estarem comprovadamente definidos em uma delas. Isso pode ocorrer por causa da ordem errada em que as bibliotecas foram passadas ao linker.

Apesar de o linker se virar para encontrar símbolos em bibliotecas dinâmicas, para as estáticas é necessário passá-las em ordem de dependência. Por exemplo, se seu programa usa a libpng.a que usa a libz.a internamente, o comando correto para linká-lo é:

gcc programa.c -oprograma /usr/lib/libpng.a /usr/lib/libz.a

Mas se a ordem estivesse invertida:

$ gcc programa.c -oprograma /usr/lib/libz.a /usr/lib/libpng.a
/usr/lib/libpng.a(png.o): In function `png_reset_crc': undefined reference to `crc32'
/usr/lib/libpng.a(png.o): In function `png_calculate_crc': undefined reference to `crc32'
/usr/lib/libpng.a(png.o): In function `png_calculate_crc': undefined reference to `crc32'
/usr/lib/libpng.a(png.o): In function `png_reset_zstream': undefined reference to `inflateReset'
collect2: ld returned 1 exit status

Palavras-chave: C, gcc, cpp, macros, …, varargs, número de parâmetros variável, variadic macros

Para escrever macros de função com número variável de argumentos:

#define DPRINT(fmt, ...)   printf("DEBUG: "fmt"\\n", ## __VA_ARGS__)

__VA_ARGS__ será substituído pelos parâmetros dados. E o ## entre a vírgula e __VA_ARGS__ se encarregará de remover a vírgula quando o número de argumentos for 0.

Exemplo:

#include <stdio.h>
#define DPRINT(fmt, ...) printf("DEBUG: "fmt"\\n", ##__VA_ARGS__)

int main()
{
  int i= 0, j= 0;
  DPRINT("chegou aqui");
  DPRINT("valor de i = %i, j = %i", i, j);
  return 0;
}

Nota: O Visual C++, a partir da versão 2005, passou a incluir o mesmo recurso.

Palavras-chave: C, memória, otimização, arrays, vetores, bitmap, pixmap

Ao se escrever código para manipulação de strings ou imagens, é comum percorrer grandes vetores de bytes. A maneira óbvia de fazer isto é algo no estilo de:

char *ptr= buffer;
for (i= 0; i < fim; i++)
      *ptr++= 0;

Mas percorrer memória byte a byte é bastante lento, por questões de alinhamento de memória, o fato dela ser endereçada por palavra. Por exemplo, um int em i386 e long em x86_64.

O exemplo abaixo inclui código que percorre por byte e por int, mas pode ser facilmente modificado para percorrer por longs:

#include <sys/types.h>
int main()
{
    char buffer[1000];
    uint32_t *iptr;
    char *ptr;
    int i, j;
    int max= 973;
    for (j= 0; j < 100000; j++)
    {
#ifdef lento
        ptr= buffer;
        for (i= max-1; i>=0; --i)
            *ptr++= 0;
#else
        iptr= (uint32_t*)buffer;
        // processa o vetor de 4 em 4 bytes,
        // arredondando o número de elementos
        for (i= max>>2-1; i>=0; --i)
            *iptr++= 0;
        ptr= iptr;
        // processa os últimos bytes restantes
        switch (max&((1<<2)-1))
        {
            case 3: *ptr++= 0;  // sem break
            case 2: *ptr++= 0;  // sem break
            case 1: *ptr++= 0;
              break;
        }
#endif
    }
    return 0;
}

Os tempos de execução para o código com percorrimento por palavras de 8, 32 e 64bits em uma máquina x86_64, são de: 0.190s, 0.100s e 0.025s, uma melhora de até 800%(!).

Obviamente, neste caso, um memset() seria mais rápido mas o ponto é que este conceito pode ser estendido para casos em que o memset() não serve. Ainda há espaço para mais otimizações, mas isto é deixado como exercício ;)

Obs.: lembre-se que o comprimento de long varia de acordo com a arquitetura e é prudente colocar trechos que dependem disso dentro de #ifdefs.

Leia também um artigo relacionado, sobre o aproveitamento da memória cache nesta dica do Eduardo.

Palavras-chave: C, arquivo texto, fgets, linhas de comprimento arbitrário

O método típico para se ler um arquivo texto linha a linha é usando a função fgets() com um buffer estático. O problema é que nem sempre sabemos qual será o comprimento máximo das linhas e, de acordo com a Lei de Murphy, chutar um tamanho “grande o suficiente” pode não ser o suficiente na prática. Além da possibilidade de abusos ou conteúdo malicioso quando o arquivo é fornecido pelo usuário.

A maneira “correta” de se fazer isso é um pouco trabalhosa, mas felizmente a glibc possui a pouca conhecida função getline(). Esta função toma um buffer dinâmico e irá redimensioná-lo se necessário. É uma função específica da glibc, então se seu programa irá rodar em outras plataformas, não a utilize.

Exemplo:

#define _GNU_SOURCE // necessário porque getline() é extensão GNU
#include <stdio.h>
#include <stdlib.h>
int main()
{
  FILE *f= fopen("teste.txt", "r");
  size_t len= 100; // valor arbitrário
  char *linha= malloc(len);

if (!f)
  {
    perror("teste.txt");
    exit(1);
  }
  while (getline(&linha, &len, f) > 0)
  {
    printf("%s", linha);
  }
  if (linha)
    free(linha);
  fclose(f);
  return 0;
}

É uma pena que não seja uma função portável, mas é algo que pode economizar algumas linhas de código e neurônios quando escrevemos xu^Wprograminhas descartáveis em C.