Pular para o conteúdo principal

BG_ESCREVA_FMT · ESCREVA_FMT

Página gerada do fonte

Gerada por tools/gerar_documentacao.py. Definição: include/basicgol.h:285.

Acesso direto a printf para formatação de múltiplos valores.

Tipo: macro de objeto · Módulo/categoria: Entrada e saída.

Nomes equivalentes: ESCREVA_FMT. Os testes de qualquer um desses nomes são reunidos nesta página.

Assinatura e expansão​

#define BG_ESCREVA_FMT(...) printf(__VA_ARGS__)

Corpo da macro:

printf(__VA_ARGS__)

Como funciona​

Encaminha VA_ARGS a printf; exige pelo menos o formato.

Contrato e armadilhas
  • Formato e argumentos são responsabilidade do chamador; não passe formato externo sem validação.

Como este símbolo aparece nos testes​

76 ocorrência(s) em 21 arquivo(s) de teste. Os links apontam para linhas exatas; os trechos mostram o contexto local. Uma menção não prova que todos os ramos foi executado.

tests/casos/02_basico/b03_real/programa.c​

Contexto: b03_real. Linhas: 13, 14, 15, 16. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 11–18 · abrir contexto
REAL tres = 3.0;

ESCREVA_FMT("%.2f\n", dez / tres);
ESCREVA_FMT("%.5f\n", dez / tres);
ESCREVA_FMT("%g\n", dez / tres);
ESCREVA_FMT("%.0f\n", 2.5 + 2.5);

// 0.1 + 0.2 != 0.3 em binario: a comparacao correta usa tolerancia

Ver no GitHub

tests/casos/03_controle/c23_para_passo_negativo/programa.c​

Contexto: c23_para_passo_negativo. Linhas: 7, 12. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 5–14 · abrir contexto
INTEIRO i = 0;
PARA_PASSO (i, 5, 1, -2) {
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA();

PARA_PASSO (i, 0, 4, 2) {
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA();

Ver no GitHub

tests/casos/03_controle/c25_limites_inclusivos/programa.c​

Contexto: c25_limites_inclusivos. Linhas: 15, 20, 25, 30, 35. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 13–37 · abrir contexto

PARA (i, 1, 3) { // extremos incluídos
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA(); // 1 2 3

PARA_PASSO (i, 1, 10, 4) { // 10 não é alcançado: 1, 5, 9
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA(); // 1 5 9

PARA_PASSO (i, 0, 10, 5) { // o fim cai no passo: 0, 5, 10
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA(); // 0 5 10

PARA_PASSO (i, 10, 0, -5) { // descendo, o fim também é incluído
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA(); // 10 5 0

PARA (i, -2, 1) { // faixa que cruza zero
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA(); // -2 -1 0 1

Ver no GitHub

tests/casos/03_controle/c34_faixas_senao_se/programa.c​

Contexto: c34_faixas_senao_se. Linhas: 7. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 5–9 · abrir contexto
INTEIRO nota = 0;
PARA (nota, 4, 10) {
ESCREVA_FMT("%d: ", nota);
SE nota < 5 ENTAO
ESCREVAL("reprovado");

Ver no GitHub

tests/casos/03_controle/c40_passo_sem_sinal/programa.c​

Contexto: c40_passo_sem_sinal. Linhas: 9. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 7–11 · abrir contexto
NATURAL passo = 2;
PARA_PASSO (i, 0, 6, passo) {
ESCREVA_FMT("%d ", i);
}
ESCREVA_LINHA();

Ver no GitHub

tests/casos/04_estruturas/e04_registro/programa.c​

Contexto: e04_registro. Linhas: 11, 13, 22. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 9–15 · abrir contexto
PROCEDIMENTO imprime(Ponto p) {
ESCREVA("(");
ESCREVA_FMT("%.1f", p.x);
ESCREVA(", ");
ESCREVA_FMT("%.1f", p.y);
ESCREVAL(")");
}

Ver no GitHub

Linhas 20–23 · abrir contexto
p.y = -2.0;
imprime(p);
ESCREVA_FMT("%.1f\n", p.x + p.y);
FIM

Ver no GitHub

tests/casos/04_estruturas/e06_vetor_registros/programa.c​

Contexto: e06_vetor_registros. Linhas: 21, 24. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 19–25 · abrir contexto
ESCREVA_TEXTO(turma[i].nome);
ESCREVA(": ");
ESCREVA_FMT("%.1f\n", turma[i].nota);
total = total + turma[i].nota;
}
ESCREVA_FMT("media %.2f\n", total / 3.0);
FIM

Ver no GitHub

tests/casos/05_entrada_saida/i03_fmt/programa.c​

Contexto: i03_fmt. Linhas: 5, 6, 7, 8, 9, 10. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 3–11 · abrir contexto

INICIO
ESCREVA_FMT("[%5d]\n", 42);
ESCREVA_FMT("[%-5d]\n", 42);
ESCREVA_FMT("[%05.2f]\n", 3.14159);
ESCREVA_FMT("[%x]\n", 255);
ESCREVA_FMT("[%c%c]\n", 'o', 'k');
ESCREVA_FMT("%s tem %d letras\n", "abc", 3);
FIM

Ver no GitHub

tests/casos/05_entrada_saida/i04_leia_tipos/programa.c​

Contexto: i04_leia_tipos. Linhas: 14. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 12–16 · abrir contexto
FIM_SE
SE LEIA_OK(r) ENTAO
ESCREVA_FMT("real %.2f\n", r);
FIM_SE
SE LEIA_OK(c) ENTAO

Ver no GitHub

tests/casos/05_entrada_saida/i10_conversoes/programa.c​

Contexto: i10_conversoes. Linhas: 20, 23. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 18–24 · abrir contexto

ESCREVAL(TEXTO_PARA_REAL("2.75", &r)); // 1
ESCREVA_FMT("%.2f\n", r);
ESCREVAL(TEXTO_PARA_REAL("2,75", &r)); // 0 (locale C)
ESCREVAL(TEXTO_PARA_REAL("1e3", &r)); // 1
ESCREVA_FMT("%.0f\n", r);
FIM

Ver no GitHub

tests/casos/05_entrada_saida/i15_leia_caractere_apos_numero/programa.c​

Contexto: i15_leia_caractere_apos_numero. Linhas: 12. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 10–14 · abrir contexto
ESCREVA("letra: ");
SE LEIA_OK(c) ENTAO
ESCREVA_FMT("lido %d e '%c'\n", n, c);
SENAO
ESCREVAL("sem letra");

Ver no GitHub

tests/casos/07_multiarquivo/m01_modulos/matematica.c​

Contexto: m01_modulos. Linhas: 37. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 35–39 · abrir contexto
INTEIRO i = 0;
PARA (i, 1, 5) {
ESCREVA_FMT("%d x %d = %d\n", n, i, n * i);
}
}

Ver no GitHub

tests/casos/08_aplicacao/app_acervo/principal.c​

Contexto: app_acervo. Linhas: 54, 83, 86, 89, 91, 97, 99, 112, 116. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 52–56 · abrir contexto
carrega_acervo();
ordena_por_ano();
ESCREVA_FMT("cota: %d emprestimo(s), fator %.2f, capacidade %d\n",
quota, fator, ACERVO_MAX);

Ver no GitHub

Linhas 81–93 · abrir contexto
recusados = recusados + 1;
SENAO_SE busca(id) < 0 ENTAO
ESCREVA_FMT("recusado: livro %d inexistente\n", id);
recusados = recusados + 1;
SENAO_SE emprestados() >= quota ENTAO
ESCREVA_FMT("recusado: cota de %d atingida\n", quota);
recusados = recusados + 1;
SENAO_SE empresta(id) ENTAO
ESCREVA_FMT("emprestado: %d\n", id);
SENAO
ESCREVA_FMT("recusado: livro %d ja emprestado\n", id);
recusados = recusados + 1;
FIM_SE

Ver no GitHub

Linhas 95–101 · abrir contexto
CASO 'd':
SE devolve(id) ENTAO
ESCREVA_FMT("devolvido: %d\n", id);
SENAO
ESCREVA_FMT("recusado: livro %d nao estava emprestado\n", id);
recusados = recusados + 1;
FIM_SE

Ver no GitHub

Linhas 110–118 · abrir contexto
INTEIRO k = 0;
PARA_PASSO (k, quantidade() - 1, 0, -1) {
ESCREVA_FMT(" %d", acervo_id(k));
}
ESCREVA_LINHA();

ESCREVA_FMT("fim: %d livro(s), %d emprestado(s), %d recusa(s)\n",
quantidade(), emprestados(), recusados);
AFIRME(quantidade() > 0, "o acervo nao pode terminar vazio");

Ver no GitHub

tests/casos/08_aplicacao/app_acervo/relatorio.c​

Contexto: app_acervo. Linhas: 8, 9, 16, 21, 22, 23, 32, 40. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 6–11 · abrir contexto
INTEIRO emp = emprestados();

ESCREVA_FMT("=== acervo: %d livros (capacidade %d) ===\n", quantidade(), ACERVO_MAX);
ESCREVA_FMT("%-3s %-22s %-18s %-5s %s\n", "id", "titulo", "autor", "ano", "situacao");

PARA (i, 0, quantidade() - 1) {

Ver no GitHub

Linhas 14–25 · abrir contexto
PROSSIGA;
FIM_SE
ESCREVA_FMT("%-3d %-22s %-18s %-5d %s\n",
acervo_id(i), acervo_titulo(i), acervo_autor(i),
acervo_ano(i), nome_situacao(acervo_situacao(i)));
}

ESCREVA_FMT("emprestados: %d de %d\n", emp, quantidade());
ESCREVA_FMT("media de ano: %.2f\n", media_ano());
ESCREVA_FMT("raridade: %d (fator %.2f)\n", indice_raridade(fator), fator);

SE quantidade() > 0 ENTAO

Ver no GitHub

Linhas 30–34 · abrir contexto
maior = MAXIMO(maior, acervo_ano(i));
}
ESCREVA_FMT("faixa de anos: %d..%d (amplitude %d)\n",
menor, maior, ABS(maior - menor));

Ver no GitHub

Linhas 38–42 · abrir contexto
SE JUNTA_TEXTO(parcial, 64, acervo_titulo(0), " - ") E
JUNTA_TEXTO(rotulo, 64, parcial, acervo_autor(0)) ENTAO
ESCREVA_FMT("primeiro da lista: %s\n", rotulo);
FIM_SE
FIM_SE

Ver no GitHub

tests/casos/09_tipos_expr/t02_reais/programa.c​

Contexto: t02_reais. Linhas: 17, 20, 21, 22, 40, 41, 42. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 15–24 · abrir contexto
ESCREVAL(soma == 0.3);
ESCREVAL(ABS(soma - 0.3) < EPSILON_REAL);
ESCREVA_FMT("%.2f\n", soma);

// impressão: %g usa 6 algarismos significativos
ESCREVA_FMT("%.3f\n", 1.0 / 3.0);
ESCREVA_FMT("%.0f\n", 2.6);
ESCREVA_FMT("%.0f\n", -2.6);

ESCREVAL(f);

Ver no GitHub

Linhas 38–43 · abrir contexto

// ABS/MINIMO/MAXIMO preservam o tipo real
ESCREVA_FMT("%.1f\n", ABS(-2.5));
ESCREVA_FMT("%.1f\n", MINIMO(2.5, 3.5));
ESCREVA_FMT("%.1f\n", MAXIMO(2.5, 3.5));
FIM

Ver no GitHub

tests/casos/09_tipos_expr/t06_conversoes/programa.c​

Contexto: t06_conversoes. Linhas: 47, 52. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 45–54 · abrir contexto
ESCREVAL(TEXTO_PARA_REAL("1e999", &d));
ESCREVAL(TEXTO_PARA_REAL("1e-999", &d));
ESCREVA_FMT("%.1f\n", d);

// texto -> REAL aceita o que o strtod aceita: "inf" e "nan" são valores
// representáveis (não são erro de faixa); "%f" imprime o que veio
ESCREVAL(TEXTO_PARA_REAL("inf", &d));
ESCREVA_FMT("%.1f\n", d);
ESCREVAL(TEXTO_PARA_REAL("nan", &d));
ESCREVAL(d == d); // 0: NaN não é igual a si mesmo

Ver no GitHub

tests/casos/09_tipos_expr/t07_divisao/programa.c​

Contexto: t07_divisao. Linhas: 17, 18. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 15–20 · abrir contexto
ESCREVAL(DIVIDE(7LL, 2LL));
ESCREVAL(RESTO(7u, 2u));
ESCREVA_FMT("%.2f\n", DIVIDE(7.0, 2.0));
ESCREVA_FMT("%.2f\n", DIVIDE(-7.0, 2.0));

// MINIMO_INTEIRO / 1 é válido; / -1 é indefinido se o quociente não couber (caso t10)

Ver no GitHub

tests/casos/09_tipos_expr/t12_leia_numeros/programa.c​

Contexto: t12_leia_numeros. Linhas: 28, 34, 40. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 26–30 · abrir contexto

SE LEIA_REAL(r) ENTAO
ESCREVA_FMT("%.1f\n", r);
SENAO
ESCREVAL("real 1 falhou");

Ver no GitHub

Linhas 32–36 · abrir contexto

SE LEIA_REAL(r) ENTAO // "2,5": locale C recusa a vírgula
ESCREVA_FMT("%.1f\n", r);
SENAO
ESCREVAL("real 2 falhou");

Ver no GitHub

Linhas 38–42 · abrir contexto

SE LEIA_REAL(r) ENTAO // "1e999": estouro de faixa
ESCREVA_FMT("%.1f\n", r);
SENAO
ESCREVAL("real 3 falhou");

Ver no GitHub

tests/portabilidade/cabecalhos_principal.c​

Contexto: cabecalhos_principal.c. Linhas: 34. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 32–35 · abrir contexto
AFIRME(c == 7, "TU3 (BG_SEM_APELIDOS) devolveu 7");

ESCREVA_FMT("cabecalhos: ok (%d %d %d)\n", a, b, c);
FIM

Ver no GitHub

tests/portabilidade/entrada.c​

Contexto: entrada.c. Linhas: 23, 27, 32, 36, 41, 45, 49, 53, 58, 62, 66, 71, 73, 75. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 21–77 · abrir contexto
/* 1. número válido: LEIA_OK devolve verdadeiro */
ok = LEIA_OK(n);
ESCREVA_FMT("1 ok=%d n=%d\n", (int) ok, n);

/* 2. LEIA_TEXTO depois de LEIA consome o \n pendente e lê a linha seguinte */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("2 ok=%d linha=[%s]\n", (int) ok, linha);

/* 3. texto onde se esperava número: falha e o destino NÃO muda */
n = 123;
ok = LEIA_OK(n);
ESCREVA_FMT("3 ok=%d n=%d\n", (int) ok, n);

/* 4. recuperação: a linha inválida continua no fluxo e é consumida aqui */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("4 ok=%d linha=[%s]\n", (int) ok, linha);

/* 5. LEIA (scanf) lê o número e deixa o resto da linha no fluxo */
n = -1;
LEIA(n);
ESCREVA_FMT("5 n=%d\n", n);

/* 6. o resto da linha é lido como texto, com o espaço à frente */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("6 ok=%d linha=[%s]\n", (int) ok, linha);

/* 7. LEIA_REAL */
ok = LEIA_REAL(r);
ESCREVA_FMT("7 ok=%d r=%g\n", (int) ok, r);

/* 8. LEIA de CARACTERE depois de uma leitura numérica (i15) */
LEIA(c);
ESCREVA_FMT("8 c=%c\n", c);

/* 9. LEIA_INTEIRO com lixo depois dos dígitos: recusa a linha inteira */
n = 77;
ok = LEIA_INTEIRO(n);
ESCREVA_FMT("9 ok=%d n=%d\n", (int) ok, n);

/* 10. LEIA_TEXTO com buffer pequeno: falha, destino vazio, resto consumido */
ok = LEIA_TEXTO(curto, TAMANHO_DE(curto));
ESCREVA_FMT("10 ok=%d curto=[%s]\n", (int) ok, curto);

/* 11. e o fluxo continua sincronizado na linha seguinte */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("11 ok=%d linha=[%s]\n", (int) ok, linha);

/* 12. EOF: falha em vez de repetir a última leitura */
n = 5;
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("12 ok=%d linha=[%s]\n", (int) ok, linha);
ok = LEIA_INTEIRO(n);
ESCREVA_FMT("13 ok=%d n=%d\n", (int) ok, n);
LEIA(n);
ESCREVA_FMT("14 n=%d\n", n);

ESCREVAL("entrada: ok");

Ver no GitHub

tests/portabilidade/fronteira.c​

Contexto: fronteira.c. Linhas: 301. Tipo de evidência: código; via ESCREVA_FMT.

Linhas 299–302 · abrir contexto
}

ESCREVA_FMT("%d verificacoes)\n", verificacoes);
FIM

Ver no GitHub

Evidência indireta​

Estes símbolos chamam/encaminham para este nome. As referências deles ajudam a rastrear o caminho, mas não substituem um teste específico deste símbolo.

Compiladores, padrão C e sistema operacional​

Condições que envolvem a definição:

  • defined(BASICGOL_H) (fonte)
Não confunda implementação com certificação

A matriz histórica distingue executado, compilado, avaliado e não testado. Consulte a matriz, os compiladores e os logs atuais dos workflows antes de chamar um alvo de suportado.

Checklist de integração​

  • Compile com C11: o cabeçalho seleciona formatos e divisões com _Generic, e C99/C89 são recusados com mensagem explícita.
  • A forma curta ESCREVA_FMT e a forma canônica BG_ESCREVA_FMT são a mesma macro; escolha uma por arquivo para não misturar estilos.
  • Rode make test (ou make test-biblioteca para a biblioteca) antes de integrar.
make
cc -std=c11 -Wall -Wextra -Wformat=2 -I include programa.c \
build/libbasicgol.a -lm -o programa

Perguntas frequentes​

Perguntas reunidas a partir da definição, do contrato editorial e dos testes de BG_ESCREVA_FMT. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.

Em uma frase, o que BG_ESCREVA_FMT faz?​

Acesso direto a printf para formatação de múltiplos valores.

Para que exatamente BG_ESCREVA_FMT expande?​

O pré-processador substitui BG_ESCREVA_FMT pelo texto abaixo, sem criar função nem avaliar argumentos por conta própria.

printf(__VA_ARGS__)

Como BG_ESCREVA_FMT aparece em código real deste repositório?​

Uso extraído de tests/casos/02_basico/b03_real/programa.c:11, com as linhas vizinhas preservadas:

REAL tres = 3.0;

ESCREVA_FMT("%.2f\n", dez / tres);
ESCREVA_FMT("%.5f\n", dez / tres);
ESCREVA_FMT("%g\n", dez / tres);

Onde BG_ESCREVA_FMT é exercitado nos testes?​

Há 76 ocorrência(s) em 21 arquivo(s): tests/casos/02_basico/b03_real/programa.c, tests/casos/03_controle/c23_para_passo_negativo/programa.c, tests/casos/03_controle/c25_limites_inclusivos/programa.c, tests/casos/03_controle/c34_faixas_senao_se/programa.c, tests/casos/03_controle/c40_passo_sem_sinal/programa.c …. Os links da seção de evidência apontam para a linha exata; uma menção não prova que todos os ramos foram executados.

BG_ESCREVA_FMT depende de compilador, padrão C ou sistema operacional?​

BG_ESCREVA_FMT exige C11 como o restante da linguagem; largura de tipo, libc e CRT continuam sendo os do alvo.

Quais armadilhas preciso evitar ao usar BG_ESCREVA_FMT?​

O contrato editorial registra: “Formato e argumentos são responsabilidade do chamador; não passe formato externo sem validação.”