Usando uma macro para comprimento de string no especificador de formato scanf () em C

O motivo pelo qual você obtém um erro strnão é uma função interna nem uma macro predefinida. Você pode definir strcomo uma macro e usar o operador de stringização #para realizar a substituição, mas é complicado e confuso: strdeve ser definido como uma macro que invoca outra macro xstr, que por sua vez stringize seu argumento com #x:

#define xstr(x)  #x
#define str(x)  xstr(x)

Observe, no entanto, que ambos os exemplos têm problemas:

• scanf("%" str(MAX_LENGTH) "%[^\n]s", str);tem um extra sno final do formato, que é inútil e indica uma confusão entre a %[...]conversão e %s, ambas requerem um prefixo de contagem de caracteres para evitar estouro de buffer. A segunda %também está incorreta. Além disso, você não deve usar o mesmo identificador strpara a macro e o array de destino: embora não seja um erro, torna o código confuso desnecessariamente. O código deve ser escrito:

    char buf[MAX_LENGTH + 1];
    scanf("%" str(MAX_LENGTH) "[^\n]", buf);
  

• scanf("%" str(MAX_LENGTH) "[^\n]%*c", str);tem a forma correta, mas consumirá incondicionalmente o próximo byte após a correspondência, que não é o caractere de nova linha se a linha tiver mais de MAX_LENGTHbytes antes da nova linha. Nenhuma indicação para isso é retornada ao chamador.

• %9[^\n]falhará em linhas de entrada vazias porque nenhum caractere corresponde à especificação de conversão. scanf()retornará 0e deixará a matriz de destino em um estado indeterminado.

Aqui está um pequeno exemplo:

#include <stdio.h>

#define MAX_LENGTH  9

#define xstr(x)  #x
#define str(x)  xstr(x)

int main(void) {
    char buf[MAX_LENGTH + 1];
    if (scanf("%" str(MAX_LENGTH) "[^\n]", buf) == 1) {
        printf("got |%s|\n", buf);
    } else {
        printf("invalid input\n");
    }
    return 0;
}

Se strfosse definido como #define str(x) #x, invocar str(MAX_LENGTH)seria expandido para "MAX_LENGTH". A segunda chamada de macro realiza sua substituição após primeiro expandir o argumento inicial da macro, portanto, str(MAX_LENGTH)expande para xstr(9), que se expande para "9".

Observe também que MAX_LENGTHnão é o comprimento da matriz de destino: você deve adicionar um caractere extra para o terminador nulo e não há verificação de consistência na invocação da macro: a consistência entre MAX_LENGTHe a definição de bufdependem inteiramente do programador.

Além disso, se a definição de MAX_LENGTHnão for uma constante inteira sem um sufixo, esse truque de expansão de macro não produzirá um scanfespecificador de conversão correto.

Uma abordagem mais confiável seria usada snprintfpara construir a scanf()string de formato:

#include <stdio.h>

#define MAX_LENGTH  9

int main(void) {
    char buf[MAX_LENGTH + 1];
    char format[20];
    snprintf(format, sizeof format, "%%%zu[^\n]", sizeof(buf) - 1);
    if (scanf(format, buf) == 1) {
        printf("got |%s|\n", buf);
    } else {
        printf("invalid input\n");
    }
    return 0;
}

Esta versão funciona melhor, mas tem suas próprias deficiências: impede que o compilador verifique a consistência entre a string de formato e os scanf()argumentos restantes, o que causará um aviso nos níveis de aviso recomendados ( -Wall -Wextra) e essa verificação de consistência é bastante útil, enquanto a string de formato para construir a string de formato é fácil errar.

No final, ambas as abordagens são complicadas e propensas a erros. É muito mais confiável usar fgets()para o seu propósito e remover manualmente a nova linha à direita:

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

#define MAX_LENGTH  9

int main(void) {
    char buf[MAX_LENGTH + 2];
    if (fgets(buf, sizeof buf, stdin)) {
        buf[strcspn(buf, "\n")] = '\0';
        printf("got |%s|\n", buf);
    } else {
        printf("no input\n");
    }
    return 0;
}

O comportamento é um pouco diferente: fgetsconsumirá a nova linha, a menos que a linha seja muito longa, o que dificulta a recuperação de erros.

Uma solução melhor em geral parece usar uma função personalizada:

#include <stdio.h>

#define MAX_LENGTH  9

/* read a line from a stream and truncate excess characters */
int get_line(char *dest, int size, FILE *fp) {
    int c;
    int i = 0;
    while ((c = getc(fp)) != EOF && c != '\n') {
        if (i + 1 < size)
            dest[i] = c;
        i++;
    }
    if (i < size) {
        dest[i] = '\0';
    } else
    if (size > 0) {
        dest[size - 1] = '\0';
    }
    return (i == 0 && c == EOF) ? -1 : i;
}

int main(void) {
    char buf[MAX_LENGTH + 1];
    if (get_line(buf, sizeof buf, stdin) == EOF) {
        printf("invalid input\n");
    } else {
        printf("got |%s|\n", buf);
    }
    return 0;
}

Observe que o comportamento ainda é sutilmente diferente da scanf()chamada original, mas potencialmente mais próximo de seus objetivos:

• get_linelê uma linha completa, incluindo a nova linha, os caracteres em excesso são descartados.
• get_linesempre armazena uma string C na matriz de destino se sizenão for 0, mesmo no final do arquivo onde bufhaverá uma string vazia. scanf()retornaria EOFno final do arquivo e deixaria bufinalterado.
• get_lineaceitará linhas vazias, enquanto scanf()falharia, retornaria 0e sairia bufem um estado indeterminado, uma limitação que você provavelmente não sabia.

Conclusão: scanf()é cheio de manias. Tentar evitar estouros de buffer com uma contagem de caracteres explícita é uma boa ideia, mas scanf()causará outros problemas que não são facilmente resolvidos. Muitas vezes, é necessário escrever um código personalizado para obter uma semântica precisa e consistente.

Você só pode usar a stringificação se a macro a ser expandida for um número simples (não uma expressão mais geral envolvendo adição ou subtração, por exemplo).

Você então tem que usar a dança normal de macro dupla para obter a macro expandida corretamente:

#define MAX_LENGTH 32
#define EXPAND_STR(x) #x
#define STR(x) EXPAND_STR(x)

e então:

char buffer[MAX_LENGTH + 1];

if (scanf("%" STR(MAX_LENGTH) "[^\n]", buffer) == 1)
    …success…