Especificadores de Formato TRO

Visão Geral

Os especificadores de formato são muito inspirados nos especificadores de formato padrões do C. Porém algumas adições, remoções e modificações foram feitas, então TODOS os especificadores de formatos estão devidamente documentados aqui!

Observação

Vale mencionar que nos exemplos daqui, é utilizada uma função fictícia com a assinatura:

char *fmt(const char *format, ...);

Para representar qualquer função que siga este padrão de especificação de formato.

Especificadores

Caracteres

O único especificador de formato é:

• %c que espera um tro_urune.

É possível usar as flags - e # (não ao mesmo tempo), sendo - para ajustar o lado de justificação e # para repetir o caractere, devem estar em conjunto com a largura do campo e funciona assim:

Formatação

fmt("[%c] [%4c] [%-4c] [%#4c]", U'🔋', U'🔋', U'🔋', U'🔋');

Resultado

"[🔋] [   🔋] [🔋   ] [🔋🔋🔋🔋]"

Embora %c espere um tro_urune e o exemplo acima usou um literal de caractere de 32-bits você pode tranquilamente usar o literal de caractere comum e o literal de caractere de 16-bits:

// Ambos erfeitamente possíveis.
fmt("%c", 'A'); // Literal comum.
fmt("%c", u'界'); // Literal de 16 bits.

Inclusive, variáveis que não são do tipo tro_urune ainda sim são promovidos quando passados como argumentos:

char ascii_a = 'a'; // Tipo menor que tro_urune.
fmt("%c", ascii_a); // Mesmo assim funciona.

Strings

Para formatação de strings, existem dois especificadores:

• %s para const char * (UTF-8);
• %S para const tro_char16 * (UTF-16).

É possível usar a flag - em conjunto com a largura do campo para criar coisas assim:

Formatação

fmt("[%s] [%6s] [%-6s]", "TRO", "TRO", "TRO");

Resultado

"[TRO] [   TRO] [TRO   ]"

Números Inteiros

Para formatação de números inteiros, há os seguintes especificadores:

• %d ou %i para decimal de inteiro com sinal;
• %u para decimal de inteiro sem sinal;
• %x para hexadecimal;
• %X também para hexiadecimal, porém com as letras maiúsculas;
• %o para octal.

Tabela de modificadores de tamanho em ordem crescente:

Modificador	Spec d/i	Spec u/x/X/o
hh	signed char	unsigned char
h	short (signed short)	unsigned short
nenhum	int (signed int)	unsigned int
l	long (signed long)	unsigned long
ll	long long (signed long long)	unsigned long long
j	intmax_t	uintmax_t
z	versão signed do size_t	size_t
t	ptrdiff_t	versão unsigned do

ptrdiff_t| E assim se utiliza:

Formatação

int d = 35;
unsigned long long llu = 321608040201ULL;
size_t zu = 17;
char hhX = -1;
 
fmt("%d %llu %zu %hhX", d, llu, zu, hhX);

Resultado

"35 321608040201 17 FF"

Existem as flags, +, - e 0 junto com com a largura do campo para personalizar a formatação dos números, sendo + para o número sempre apresentar sinal, - para para ajustar o lado de justificação e 0 para preencher os espaços em branco com '0' no lugar de ' ':

Formatação

fmt("[%+60] [%3d] [%-3d] [%03d]", 60, 60, 60, 60);

Resultado

"[+62] [ 62] [62 ] [062]"

Ou:

Formatação

size_t n = 65535;
 
fmt("%16zX %016zX", n, n);

Resultado

"        FFFFFFFF 00000000FFFFFFFF"

Números de Ponto Flutuante

Para formatação de números de ponto flutuante, há os seguintes especificadores:

• %f para número real;
• %e para número em notação E;
• %E para número em notação E em maiúsculo;
• %a ainda não documentado;
• %A ainda não documentado;
• %g ainda não documentado;
• %G ainda não documentado.

O único modificador de tamanho é L, sendo assim:

• nenhum para float e double;
• L para long double.

Também é possível especificar a precisão em casas decimais de fração usando . seguido por um número.

As flags disponíveis são +, -, # e 0, sendo:

• + para o número sempre apresentar sinal (e apresentar o sinal de NAN);
• - para ajustar o lado de justificação;
• 0 para preencher os espaços em branco com '0' no lugar de ' ';
• # para remover zeros extras à direita.

- e 0 trabalham em conjunto com a largura do campo.

Utiliza-se assim:

Formatações

// 1.
fmt("[%f] [%.2f] [%012f] [%-12f] [%06.2f]
[%-6.2f]", 3.5, 3.5, 3.5, 3.5, 3.5, 3.5);
// 2.
fmt("[%#f] [%#.2f] [%#8f] [%-#8f] [%#8.2f] [%0#8f]
[%0#8.2f]", 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5);
// 3.
fmt("%#f %#f %+#f %#f %#f %+#f %+#f", -0.0, 0.0, 0.0, NAN, -NAN, NAN, -NAN);

Resultados

// 1.
"[3.500000] [3.50] [00003.500000] [3.500000    ] [003.50] [3.50  ]"
// 2.
"[3.5] [3.5] [     3.5] [     3.5] [3.5     ] [000003.5] [000003.5]"
// 3.
"-0 0 +0 NaN NaN +NaN -NaN"

Appendice

Largura do Campo & Precisão

No lugar de um número, você pode usar um *, e a função usará um unsigend int passado como argumento para determinar o número da largura ou da precisão:

Formatações

// 1.
fmt("[%*s]", "TRO", 8);
// 2.
fmt("[%.*f]", 4.3, 2);

Resultados

// 1.
"[     TRO]"
// 2.
"[4.30]"

Erro

Quando uma função falha em formatar algo ela não vai indicar nenhum erro em retorno, em vez disso, ela substitui a parte desconhecida com o caractere u'␀' e segue normalmente:

Formatação

fmt("teste %llv %d", 3);

Resultado

"teste ␀ 3"