Category Archive

Palavras-chave: C, pré-processador, macros, macro, define, gcc

O pré-processador do GCC define uma série de macros por default. Muitas delas podem lhe ser útil, caso se deseje que um determinado bloco de código seja compilado para apenas uma determinada arquitetura, por exemplo. Para conhecer estas macros, basta perguntar ao pré-processador:

$ echo foo |gcc -dM -E -
(...)
#define __VERSION__ "4.1.2 20061115 (prerelease) (Debian 4.1.1-21)"
#define i386 1
#define __linux__ 1
#define __gnu_linux__ 1
#define __i486__ 1
#define unix 1
#define __i386__ 1
#define __SIZE_TYPE__ unsigned int
#define __ELF__ 1
#define __FLT_HAS_QUIET_NAN__ 1
#define __FLT_MAX_10_EXP__ 38
#define __LONG_MAX__ 2147483647L
#define __FLT_HAS_INFINITY__ 1
#define linux 1
(...)
$

A saída acima, mostra algumas das macros definidas pelo pré-processador i386-linux do Debian Etch. No pré-processador para a arquitetura arm-palmos temos as seguintes macros:

$ echo foo |arm-palmos-gcc -dM -E -
(...)
#define __palmos__ 1
#define __FLT_MIN__ 1.17549435e-38F
#define __CHAR_BIT__ 8
#define __WCHAR_MAX__ 2147483647
#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
#define __FLT_EVAL_METHOD__ 0
#define __SIZE_TYPE__ long unsigned int
#define __ELF__ 1
#define __DBL_MIN_10_EXP__ (-307)
#define __FINITE_MATH_ONLY__ 0
#define __ARMEL__ 1
#define __GNUC_PATCHLEVEL__ 1
#define __FLT_RADIX__ 2
(...)
$

Palavras-chave: stdout, stderr, verbose, terminal, console, /dev/null Uma forma de impedir que seu programa imprima na tela, seja por linkar com uma biblioteca que abusa da verbosidade ou para garantir que um daemon não polua seu terminal quando for para background, é fechando a saída padrão (stdout) e a saída de erro (stderr), como mostrado no exemplo seguinte:

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main(void)
{
        int fd = open("/dev/null", O_WRONLY);

        close(1); // stdout
        close(2); // stderr
        dup(fd);  // Duplica o descritor fd que corresponde a /dev/null
        dup(fd);  // usando o menor numero disponivel, no caso, 1 e 2

        printf("No verbosity anymore!\\n"); // Nao imprime nada na tela
        return 0;
}

Apenas fechar as saídas não é o bastante, senão um printf ou um cout (C++), que por padrão escrevem em stdout, iriam escrever em um descritor inválido. Direcionar a saída para o /dev/null é uma boa opção, já que ele descarta tudo que é escrito nele. Vale observar que a implementação mostrada nesta dica não é thread-safe.

Palavras-chave: warning, unused parameter, variable

Em alguns casos temos que implementar uma função (na maioria dos casos uma callback) cujo o protótipo já é definido pela API utilizada. Alguns parâmetros podem ser desnecessários, mas geram warnings de compilação caso não forem utilizados. O exemplo a seguir gera um warning quando compilado com o gcc:

void my_callback(char *data, int size)
{
        printf("Size is %d\n", size);
        return;
}

foo.c:2: warning: unused parameter 'data'

Podemos contornar esta situação de duas formas. A primeira e mais portável é fazer um cast para o tipo void:

void my_callback(char *data, int size)
{
        (void) data;
        printf("Size is %d\n", size);
        return;
}

A segunda forma é usar uma extensão do gcc:

void my_callback(char *data __attribute__((unused)), int size)
{
        printf("Size is %d\n", size);
        return;
}

Palavras-chave: non-constant initializers, dynamic stack allocation

Muitas vezes alocamos memória para um buffer baseado em um tamanho que é passado como parâmetro para a função. Como no seguinte exemplo:

void foobar (size_t size)
{
        char *buffer = malloc(size * 2);

No gcc existe uma extensão pouco conhecida, mas bastante útil, chamada non-constant initializers. Usando este recurso, a função poderia ser simplificada para:

void foobar (size_t size)
{
        char buffer[size * 2];

A variável é alocada na pilha com um tamanho dinâmico que depende do valor passado como parâmetro e a desalocação do buffer é feita no retorno da função.

Palavras-chave: C, C++, varargs, argumentos variáveis

Para escrever funções que aceitam quantidade variável de parâmetros, usa-se o mecanismo de stdargs do C. Para isso coloca-se “…” como último parâmetro na declaração da função e depois usa-se as funções de stdarg.h para acessar os valores passados quando a funcão é chamada.

• É obrigatório a inclusão de pelo menos um parâmetro normal antes da parte variável. (ex.: char *concat(const char *s, …))

• Qualquer tipo de valor pode ser passado como parâmetro, mas é impossível determinar em runtime o tipo dos valores que uma função recebeu. Porém é possível criar formas de o código que chama a funcão comunicar os tipos dos valores passados. Por exemplo, a função printf() determina os tipos dos parâmetros recebidos pela string de formatação (%s para char*, %i para int etc); a função concat() no exemplo espera que todos os parâmetros recebidos sejam strings e assim por diante.

• O número de parâmetros recebido também não pode ser determinado explicitamente. É necessário usar artifícios adicionais como passar uma variável extra com o número de valores sendo passados, usar o valor NULL como indicador de último parâmetro ou derivar a quantidade de valores a partir da string de formatação, como no caso do printf() e similares.

Exemplo:

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

char *concat(const char *s, ...)
{
  va_list args;
  char *tmp;
  char *res;
  size_t len= strlen(s);

  // pega um handle ao início da lista de parâmetros
  va_start(args, s);

  // calcula o tamanho total de todas as strings
  // pega o próximo parâmetro da lista, até chegar no NULL
  while ((tmp= va_arg(args, char*)))  {
     len+= strlen(tmp);
  }

  va_end(args);
  res= malloc(len+1);
  if (!res) return NULL;

  // cria a string concatenada
  strcpy(res, s);
  va_start(args, s);

  // pega o próximo parâmetro da lista, até chegar no NULL
  while ((tmp= va_arg(args, char*)))  {
     strcat(res, tmp);
  }
  va_end(args);

  return res;
}

int main()
{
  char *s= concat("hello", " ", "world", "!!!!", NULL);
  puts(s);
  free(s);
  return 0;
}

Se você quer usar macros com número de parâmetros variável (por exemplo, uma macro que chama uma função com stdargs), veja o post sobre o assunto.

Palavras-chave: C, C++, CPP, macro, string, identificador

Para transformar o nome de um macro ou identificador em string:

#define STR(s)  #s

Para transformar o valor de um macro ou identificador em string:

#define STRV(s)  STR(s)

O seguinte exemplo ilustra a diferença:

#define STRV(s) STR(s)
#define STR(s) #s

int main()
{
  puts("1: "STR(puts));
  puts("2: "STR(123));
  puts("3: "STR(__LINE__));
  puts("4: "STRV(__LINE__));
  return 0;
}

Resultado:

1: puts
2: 123
3: __LINE__
4: 9

Note como STR() retorna um string com o nome do macro, enquanto que STRV() retorna o valor.