Arquivo do Autor

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.