C

MANUAL

Autor: Henrique Santos Silva

ORGANIZAÇÃO 5

PARTE I 6

ANOTAÇÃO 1: VISÃO GLOBAL 7

ANOTAÇÃO 2: VARIÁVEIS 21

ANOTAÇÃO 3: OPERADORES 42

ANOTAÇÃO 4: INSTRUÇÕES 48

ANOTAÇÃO 5: EXPRESSÕES 58

ANOTAÇÃO 6: FUNÇÕES 62

ANOTAÇÃO 7: OUTROS TIPOS 66

ANOTAÇÃO 8: PRÉ-PROCESSADOR 72

ANOTAÇÃO 9: ENTRADA E SAÍDA 82

ANOTAÇÃO 10: ENTRADA E SAÍDA: DISPOSITIVOS PADRÃO 95

BIBLIOTECA 1: ASSERT.H 104

BIBLIOTECA 2: COMPLEX.H 106

BIBLIOTECA 3: CTYPE.H 112

BIBLIOTECA 4: ERRNO.H 114

BIBLIOTECA 5: FENV.H 116

BIBLIOTECA 6: FLOAT.H 123

BIBLIOTECA 7: INTTYPES.H 126

BIBLIOTECA 8: ISSO646.H 129

BIBLIOTECA 9: LIMITS.H 130

BIBLIOTECA 10: LOCALE.H 132

BIBLIOTECA 11: MATH.H 136

BIBLIOTECA 12: SETJMP.H 166

BIBLIOTECA 13: SIGNAL.H 167

BIBLIOTECA 14: STDALIGN.H 169

BIBLIOTECA 15: STDARG.H 170

BIBLIOTECA 16: STDATOMIC.H 171

BIBLIOTECA 17: STDBIT.H 178

BIBLIOTECA 18: STDBOOL.H 179

BIBLIOTECA 19: STDCKDINT.H 180

BIBLIOTECA 20: STDDEF.H 181

BIBLIOTECA 21: STDINT.H 182

BIBLIOTECA 22: STDIO.H 185

BIBLIOTECA 23: STDLIB.H 186

BIBLIOTECA 24: STDNORETURN.H 195

BIBLIOTECA 25: STRING.H 196

BIBLIOTECA 26: TGMATH.H 202

BIBLIOTECA 27: THREADS.H 204

BIBLIOTECA 28: TIME.H 211

BIBLIOTECA 29: UCHAR.H 217

BIBLIOTECA 30: WCHAR.H 219

BIBLIOTECA 31: WCTYPE.H 226

PARTE III 230

ESPECIALIZAÇÃO 1: PROGRAMAS EM C 231

ESPECIALIZAÇÃO 2: APLICAÇÕES 234

 Organização
Nas tabelas aqui listadas, é utilizado um sombreamento das linhas para indicar em que referente
padronização a característica em questão foi incluída: laranja para C95, amarelo para C99,
verde para C11, cinza para C17 e azul para C23. Quando a linha aparece sem um
sombreamento: a característica já existia na pseudo padronização K&R ou foi adicionada na
padronização C89/C90.

Segue referência:
Padronização K&R C89 C90 C95 C99 C11 C17 C23
PARTE I
 Anotação 1: Visão Global
“C is a general-purpose programming language
which features economy of expression,
modern control flow and data structures,
and a rich set of operators.
C is not a "very high level" language,
nor a "big" one, and is not specialized
to any particular area of application.”
The C Programming Language - 2nd Edition

História
A linguagem de programação C foi criada e desenvolvida por Dennis Ritchie em 1972 nos
laboratórios da AT&T Bell Labs, foi implementada em um PDP-11 e utilizada para o
desenvolvimento do sistema operacional Unix — sistema esse antes construído com o uso do
Assembly.

O desenvolvimento inicial do C ocorreu entre 1969 e 1973, e de acordo com Ritchie, o período
mais criativo ocorreu em 1972. A linguagem foi chamada de "C", porque suas características
foram obtidas a partir de uma linguagem anteriormente chamada de "B", sendo essa última
criada por Ken Thompson e baseada em outra linguagem anterior chamada de BCPL.

Sem uma padronização — um manual de regras — até então, em 1978 foi lançado um livro
chamado de The C Programming Language, escrito por Brian Kernighan e Dennis Ritchie, esse
livro serviu como uma padronização informal para a linguagem, até 1989, quando a ANSI
(American National Standards Institute) padronizou as especificações da linguagem C.

C é uma linguagem imperativa e procedural. Seus pontos de design foram criados, para ser
uma linguagem compilada, que forneça acesso irrestrito a memória e tenha baixos
requerimentos do hardware. Também foi desenvolvida para ser uma linguagem de alto nível, e
para ter maior reaproveitamento do código. C foi útil para muitas aplicações que foram
codificadas originalmente em Assembly, sendo reescritas com o uso do C.

Características
• Programação imperativa

• Programação procedural

• Programação estruturada

• Tipagem estática

• Tipagem fraca

• Modular

• Compilada
Programação imperativa
Esse paradigma, permite que o código seja feito de forma estrita, sendo a linguagem
representada através de comandos ou enunciados para o computador. Esses comandos
expressam “oque” e “como” o computador deve fazer algo; tais ordens são escritas e
executadas de forma sequencial.

Programação procedural
Um paradigma de programação, derivado do paradigma imperativo. Esse paradigma permite
que os comandos sejam agrupados em procedimentos, sendo que os mesmos podem chamar
e executas outros procedimentos que por sua vez agrupam outros comandos. Geralmente esses
procedimentos são chamados de rotinas ou sub-rotinas, métodos ou funções.

Programação estruturada
O paradigma de programação estruturada permite a construção de blocos de códigos e de
sub-rotinas herdado do paradigma procedural, juntamente com a execução em sequência,
porém, também permite a criação de desvios de fluxo, tomadas de decisões e iterações a partir
de um teste logico. Cada linguagem de programação que segue esse paradigma determina
como representar o início e o fim de um bloco.

Entretanto, C não pode ser considerada uma linguagem totalmente estruturada, pois não
permite a criação de sub-rotinas aninhadas — uma sub-rotina contendo outra sub-rotina e assim
por diante — sendo essa característica o que faz uma linguagem ser totalmente estruturada.

Tipagem estática
Característica que permite que as linguagens de programação possuam uma verificação de
tipo, onde seus tipos de dados são definidos em tempo de compilação — antes do programa
ser devidamente executado — garantindo assim que um objeto qualquer seja sempre tratado
de acordo com seu determinado tipo.

Um exemplo de tipagem estática na linguagem C ocorre quando: uma variável do tipo inteiro
só pode armazenar números inteiros e não sendo permitido que a variável seja tratada como
sendo uma variável de tipo de ponto flutuante.

O oposto da tipagem estática é a tipagem dinâmica, onde, a verificação do tipo de dado da

variável ocorre em tempo de execução — enquanto o programa está sendo executado.

Tipagem fraca
Característica que permite que um determinado tipo de dado seja associado com um objeto
que representa um outro tipo de dado.

Na linguagem C pode ser citado o uso da tipagem fraca o fato de que: as variáveis inteiras
podem ser atribuídas a valores decimais. Apesar de dessa atribuição, as variáveis inteiras ainda
são tratadas como variáveis inteiras, pois esse é o princípio da tipagem estática.

O oposto da tipagem fraca é a tipagem forte, onde, a associação de um objeto com uma
variável fica restrita ao tipo da variável.
Observe que tipagem fraca não é a mesma coisa que polimorfismo, sendo que, polimorfismo é
um conceito existente dentro do paradigma de programação orientada a objetos, tal
paradigma não se aplica a linguagem C.

Modular
Característica que permite organizar e separar o programa em vários módulos ou arquivos.
Cada módulo ou arquivo, pode conter trechos de códigos que podem ser compilados de forma
separada e individual e posteriormente ser integrados no programa como um todo. A forma
como a modularização funciona em determinada linguagem, vai depender da própria
linguagem.

Compilada
Característica que permite que o código fonte escrito em uma determinada linguagem de
programação, seja “transformado” em um “objeto” contendo uma outra linguagem de baixo
nível. O resultado da compilação é o programa que será executado no computador.

O “oposto” da linguagem compilada é a linguagem interpretada, onde, essa transformação

ocorre com o uso de uma aplicação que faz o intermédio entre o programa e o usuário.

Componentes
Um programa de computador nada mais é que uma série de instruções que dizem a máquina
como executar uma determinada tarefa, sendo que a linguagem C é uma das várias maneiras
existentes para a criação desses programas.

O processo de criação de um programa com a linguagem C, se estende com seu início sendo
a escrita do código fonte, geralmente junto com a escrita do cabeçalho, até a criação de um
executável contendo instruções de máquina. Nisso são englobados geralmente quatro
componentes: arquivo fonte, cabeçalho, arquivo objeto e o executável.

Código fonte
Um programa em C é escrito em texto plano, esse texto é chamado de código fonte — source
code —, e geralmente é gravado em um arquivo com a extensão .c, o mesmo é passado para
um compilador C que analisa e compila o código fonte em uma linguagem de máquina, ou
seja, o compilador C é um programa que transforma o código C em um outro código.

O arquivo que contém o código fonte é chamado de arquivo fonte —source file.

A saída do compilador C é um código escrito com a linguagem Assembly, sendo esse código
por sua vez passado para um compilador Assembly, conhecido como assembler. a saída do
compilador assembler é um código objeto — object code —, gravado em um arquivo chamado
de arquivo objeto — object file.

O arquivo objeto tem como conteúdo, um código objeto contendo instruções de máquina —
machine code —, essas instruções são dependentes da arquitetura do computador e são as
que de fato serão executadas pelo computador, através do módulo de execução de instruções
do processador da máquina.
O processo que engloba a transformação do código fonte para código objeto é chamado de
compilação.

Cabeçalho
O arquivo de cabeçalho geralmente é um arquivo com a extensão .h, onde em sua maioria
possui instruções de declarações, além de definições de macros e de condicionais de
compilação.

É um arquivo que faz parte do contexto do pré-processador, e geralmente são incluídos de

forma verbatim em arquivos fontes através da diretiva de inclusão de cabeçalho.

Código objeto
O código objeto resultante da compilação de cada módulo reside em um arquivo objeto para
cada módulo compilado, esse arquivo contém instruções de máquina, porém, ainda não
podem ser executadas diretamente, devido à falta das resoluções de referência, como por
exemplo: funções e variáveis que estão em outros módulos; e a carência do startup code: um
bloco de código Assembly dependente do sistema operacional e com a função de prepara o
código para a execução em seu determinado ambiente. Cabe ao linker — uma aplicação do
contexto do sistema operacional —, fazer a resolução das referências e a inserção do startup
code.

O código objeto é passado para o linker, um utilitário que faz a ligação entre os módulos que o
programa necessita através das referências no código objeto. Esse é o processo que faz do C
uma linguagem modular.

A saída do linker é um arquivo executável contendo instruções de maquinas possíveis de serem

executadas, este arquivo é carregado na memória principal pelo loader do sistema operacional
e executado pelo computador.

O processo que engloba a utilização do linker é chamado de ligação também conhecido

como linking.

Executável
É o arquivo que o sistema operacional carrega na memória principal para o processador
executar suas instruções; o formato desse arquivo é dependente do sistema operacional para
que o programa foi projetado, por exemplo: em um sistema Windows a sua extensão é .exe, no
Linux por sua vez geralmente é um arquivo .out.

Programação
A transformação de um código fonte para um programa executável geralmente é feita em três
etapas: pré-processamento, compilação e ligamento. Usualmente é utilizado um programa
front-end que faz todo o processo de pré-processamento, compilação e ligação. Porém alguns
softwares possibilitam a execução individual de etapas específicas.

Pré-processador
Software responsável por fazer a tradução do arquivo fonte, usando o código fonte como
entrada para gerar um outro código fonte através de análise de textos, a saída desse software
é chamada de unidade de tradução — translation unit.

Esse software faz somente simples substituições de textos no código fonte, seguindo uma ou mais
condições especificas, que geralmente estão no arquivo de cabeçalho.

Antes da execução do compilador C, o código fonte é passado para um pré-processador para

a expansão de macros e execuções de diretivas, entre outras tarefas. A saída do pré-
processador é o arquivo que realmente será encaminhado para o processo de compilação.

Compilador
Um compilador é o software responsável pela implementação de facto da linguagem C, tanto
no âmbito léxico quanto lógico, ele deve seguir as regras propostas nas padronizações da
linguagem, além de fornecer um documento que especifica suas características individuais.

Linker
Geralmente o linker é “associado” ao compilador, porém alguns sistemas o distribuem de forma
stand-alone, sendo assim associado ao sistema operacional.

Ele é um software responsável por transformar o código objeto, em um código totalmente

funcional, para que o mesmo possa ser executado em um sistema operacional específico.

Passo-a-passo do processo de construção de uma aplicação C:

A linguagem C
Assim como qualquer tipo de linguagem, o C também possui regras, tanto sintáxicas como
semânticas, para assim haver compatibilidade entre os códigos escritos em C, não importando
em que maquina esse código foi escrito — pelo menos na teoria. Para esse fim, existem
documentos de padronização que descrevem essas regras, eles são mantidos por suas
instituições de origem.

Padronizações
Segue abaixo uma lista de padronizações publicadas até a o momento de escrita.

Versão Padrão Data da publicação

K&R 22-02-1978
C89 ANSI X3.159-1989 14-02-1989
C90 ISO/IEC 9899:1990 20-12-1990
C95 ISO/IEC 9899/AMD1:1995 30-03-1995
C99 ISO/IEC 9899:1999 16-12-1999
C11 ISO/IEC 9899:2011 15-12-2011
C17 ISO/IEC 9899:2018 06-2018
C23 - -

A versão K&R foi uma padronização informal para a linguagem, não passada por um comitê de
aprovação. Muitos compiladores da época seguiam suas próprias regras, e a portabilidade do
código em tal época foi quase como um milagre; muitos desses compiladores então adotaram
as regras propostas no livro chamado de The C Programming Language, e a nomearam como
padronização K&R.

C89 foi a primeira padronização oficial da linguagem, feita pelo instituto Norte-Americano
(ANSI), foi articulada por um comitê chamado de X3J11, e trouxe várias mudanças significativas
para a linguagem: novas palavras-chaves, alteração na declaração e definição de funções, o
tipo void entre outras alterações.

C90 e C95 foi uma breve alteração no padrão ANSI, porém o processo de padronização foi
adotado pela Organização Internacional para Padronização, ISO (), que cria um grupo de
trabalho para cuidar da especificação da linguagem, denominado WG14. Esse grupo é o
responsável pelas padronizações posteriores da linguagem.

C99 foi uma alteração significativa na linguagem, diferente dos dois padrões anteriores a este,
o C99 trouxe novas características a linguagem e novas bibliotecas padrões.

C11 assim como o C99 foi uma padronização relevante da linguagem, trouxe modificações
tanto léxicas como semânticas.

C17 foi uma breve revisão da padronização C11, e não houve nenhuma característica nova
introduzida na linguagem.

Ressalta-se que a próxima padronização relevante da linguagem C, está planejada para ser
chamada de C23, informalmente conhecida como C2x. Um rascunho de proposta foi lançado
em 2020, porém ainda continua sem aprovação. Entretanto os textos desse documento já
entram em concordância com a padronização C23, seguindo os rascunhos de propostas
lançados até o momento de escrita.

Palavras chaves
Palavras chaves são tokens específicos, cujo possuem um significado especial para o
compilador, no caso, são instruções que dizem ao computador para fazer algo, elas não devem
ser usadas como identificadores, como por exemplo: nomes de variáveis, pois possuem um
significado especial para a linguagem, resultando assim em um erro sintáxico.

Segue abaixo a lista de palavras chaves adicionadas por padronização.

K&R:
auto double int struct
break else long switch
case extern register typedef
char float return union
continue for short unsigned
default goto sizeof while
do if static

C89:
const enum
signed void
volatile

C99:
_Bool _Complex
_Imaginary inline
restrict

C11:
_Alignas _Static_assert
_Alignof _Atomic
_Generic _Noreturn
_Thread_local

C23:
alignas true
alignof typeof
bool typeof_unqual
constexpr _BitInt
false _Decimal32
nullptr _Decimal64
static_assert _Decimal128
thread_local

A partir do C23 foram introduzidas algumas palavras-chave que substituem palavras-chave já

existentes, sendo assim, algumas palavras-chave passaram a ser referidas com uma nova grafia,
e a antiga grafia passou a ser uma forma alternada de se referir a uma determinada palavra-
chave.
Segue abaixo a palavra-chave com sua forma alternada correspondente:

Palavra-chave Forma alternada – Palavra-chave no pré C23

alignas _Alignas
alignof _Alignof
bool _Bool
static_assert _Static_assert
thread_local _Thread_local
A padronização C23 deprecia essas formas alternadas.

Diferenças entre padronizações

Segue abaixo uma pequena lista ressaltando as principais alterações entre uma padronização
e sua subsequente. A lista tem como ponto de entrada a padronização informal K&R.

K&R para C89

• Características adicionadas:

o Tipo void.

o Tipo escalar enum.

o Modificador signed.

o Qualificadores volatile e const.

o Prototipação de função.

o Nova forma de definição de funções.

C89 para C99

• Características adicionadas:

o Funções inline.

o Qualificador restrict.

o Tipo primitivo _Bool.

o Tipo primitivo _Complex e _Imaginary.

o Tipo long long int.

o Variable-lenght arrays.

o Comentários de única linha.

o Forma livre de código.

o Declaração de variáveis dentro de uma instrução for.

o Literais compostos.

o Flexible array struct members.

o Inicializador especifico — designated initializer.

 o Identificador __func__.

o Forma livre de código.

• Características removidas:

o Implicit int rule.

o Declaração implícita de funções.

C99 para C11

• Características adicionadas:

o Especificação de alinhamento.

o Funções _Noreturn.

o Expressões genéricas.

o Classe de armazenamento _Thread_local.

o Tipo atômico.

o Estruturas e uniões anônimas.

o Asserções estáticas.

o Suporte a Unicode.

o Strings UTF-8.

• Características removidas:

o Função gets.

C11 para C23

• Características adicionadas:

o Novos tipos de ponto flutuante: _Decimal32, _Decimal64, e _Decimal128.

o Novo tipo inteiro com precisão de bits: _BigInt(N).

o Constantes inteiras binárias.

o Especificações de atributos.

o _Static_assert pode possuir somente um argumento.

o Parâmetros não nomeados.

o Novas diretivas do contexto do pré-processador — #elifdef, #elifndef, #warning e

#embed.

o Caracteres UTF-8.

o Separador de dígitos numéricos.

o Um tipo e uma constante para ponteiro nulos: nullptr_t e nullptr.

• Características removidas:
 o Definições de funções no estilo K&R.

o Depreciação dos macros de testes: __STDC__IEC_559__ e

__STDC__IEC_559_COMPLEX.

o Remoção dos macros: __alignof_is_defined e __alignas_is_defined.

Texto
Um código C é escrito em texto plano, utilizando os caracteres que compreendem a tabela
ASCII. Sendo que toda unidade de tradução — texto analisado e formatado pelo pré-
processador —, da linguagem C deve/pode conter declarações, definições de objetos,
expressões, instruções e diretivas específicas para o compilador.

Espaços em Branco
Espaços em branco — caractere espaço, tabulação horizontal, tabulação vertical,
alimentação de formulário e nova linha —, na linguagem C são ignorados. Podendo haver
qualquer quantidade de espaços em brancos entre fragmentos léxicos da linguagem C.

Somente em casos específicos, como por exemplo: diretivas de pré-processamento; os espaços

em brancos são considerados.

Comentários
Existe duas formas de comentários na linguagem C, o comentário de única linha e o comentário
de multilinhas.

O de única linha é utilizado o token: //; sendo implementado a partir da padronização C99.

O de multilinha é utilizado o token: /*, com o terminador: */; existente na linguagem desde de
sua primeira implementação.

Vale ressaltar que o comentário de multilinha não pode ser aninhado.

Os comentários são manipulados durante a etapa de pré-processamento do código, sendo

que, o comentário de multilinhas geralmente é substituído por um caractere espaço, enquanto
o comentário de única linha geralmente é ignorado.

Exemplo:

int main(){
// isso é um comentário de única linha
/* isso é um comentário
multilinha*/
return 0;
}

Conjunto de caracteres
Existe dois tipos de conjunto de caracteres na linguagem C.

O conjunto de caracteres do código fonte: source character set, e o conjunto de caracteres

de execução: execution character set. Cada conjunto é dividido em um conjunto básico,
chamado de basic character set, e um conjunto estendido, chamado de extended characters
set.

A padronização somente especifica o conjunto básico dos conjuntos fonte e de execução, o

conjunto estendido são definidos pela implementação.

O conjunto básico do source character set são os caracteres que são escritos no código fonte,
logo, são os caracteres que o compilador reconhece e aceita para a programação em C.
Sendo o conjunto composto pelas letras do alfabeto Latim, os dígitos decimais, 29 caracteres
gráficos e 5 caracteres de espaço em branco.

A partir do C23, foram adicionados 3 novos caracteres ao conjunto básico do source character:
@ (arroba), $ (cifrão) e ` (acento grave); totalizando assim 32 caracteres gráficos.

Conjunto listado abaixo:

Basic Source Character Set

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z
0 1 2 3 4 5 6 7 8 9
! “ # % & ‘ ( ) * + , - . / : ; < = > ? [ \ ] ^ _ {
| } ~ @ $ `
Tabulação Tabulação Nova
Espaço Alimentação de formulário
horizontal vertical linha
Padronização K&R C89 C90 C95 C99 C11 C17 C23

O conjunto básico do execution character set são os caracteres que o programa interpreta
durante sua execução, e é dependente do ambiente em que o programa está executando.
Porém a padronização define que os caracteres desse conjunto devem ser os mesmos do
conjunto básico do source characters set, além dos caracteres definidos abaixo.

Nullcharacter Alert Backspace Carriage return.

Padronização K&R C89 C90 C95 C99 C11 C17 C23

A partir do C99, o C tem suporte para Unicode tanto no conjunto do código fonte como no
conjunto de execução, sendo assim, foi criado um novo conjunto, chamado de conjunto
estendido, esse conjunto é definido como sendo um conjunto pai dos conjuntos básicos de
fonte e de execução, sendo um conjunto estendido para cada um dos dois conjuntos base,
logo: conjunto estendido fonte e conjunto estendido de execução.

O extended character set ou conjunto estendido, tem um comportamento defino como:

implementation-defined behavior, como ele acrescenta mais caracteres tanto para o conjunto
básico do source characters set quanto para execution character set, a padronização fornece
uma maneira de representar esses caracteres usando as sequências: \u e \U.

Exemplo válido a partir do C99:

int main(){
char \u03b1 = 'a';
return 0;
}
Dígrafos e trígrafos
A linguagem C permite combinações especificas de dois ou três caracteres para representar
somente um caractere.

Os dígrafos foram inseridos a partir da padronização C95, e fazem parte do core da linguagem
C.

Os trígrafos são componentes do contexto do pré-processador, e são analisados antes da etapa

de substituição dos comentários e dos literais do tipo string, foram removidos a partir da
padronização C23.

Segue abaixo uma lista dos dígrafos.

Dígrafo Equivalente
<: [
:> ]
<% {
%> }
%: #
%:%: ##
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Segue abaixo uma lista dos trígrafos — removidos a partir do C23.

Trígrafo Equivalente
??( [
??) ]
??< {
??> }
??= #
??/ \
??! |
??’ ^
??- ~
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Os Trígrafos, diferentemente dos dígrafos, como são substituídos pelo pré-processador, eles possuem a
particularidade de que não importa onde apareçam: strings, comentários, etc. eles sempre serão
substituídos.

Exemplo usando dígrafos, válido a partir do C95:

int main()<%
char \u03b1 = 'a';
return 0;
%>

Continuação de linha
Qualquer backslash (\) seguindo por um caractere de nova linha, é deletado pelo pré-
processador, fazendo assim a próxima linha seguinte ao caractere backslash ser a continuação
da linha corrente.
Geralmente esse processo é utilizado para definições de diretivas.

Exemplo válido:

int m\
ain(){
char c = 'a';
return 0;
}

Biblioteca padrão
Todo compilador C deve vir com uma biblioteca padrão, cujo o conteúdo da mesma é
especificada de acordo com a padronização. O compilador deve ser capaz de saber de
forma implícita, onde sua biblioteca padrão está localizada.

Conteúdo extras, como por exemplo: uma biblioteca gráfica, podem vir inclusos na biblioteca
implementada por um compilador, porém seu conteúdo não é padronizado.

Segue abaixo as bibliotecas definidas por padronização.

Cabeçalho Descrição Padronização

<assert.h> Tratamento de erro C89
<complex.h> Aritmética de números complexos C99
<ctype.h> Manipulação de caracteres C89
<errno.h> Manipulação de erro C89
<fenv.h> Ambiente de ponto flutuante C99
<float.h> Limites dos tipos de ponto flutuante C89
<inttypes.h> Formato de conversão de inteiros C99
<iso646.h> Padronização ISO 646 C95
<limits.h> Tamanhos dos tipos básicos C89
<locale.h> Utilitários de localização C89
<math.h> Funções matemáticas C89
<setjmp.h> Desvio através de pulos não locais C89
<signal.h> Manipulação de sinais C89
<stdalign.h> Macros alignas e alignof C11
<stdarg.h> Argumentos variáveis C89
<stdatomic.h> Tipos atômicos C11
<stdbit.h> Utilidades para bits e bytes C23
<stdbool.h> Tipo booleano C99
<stdckdint.h> Aritmética de inteiros checada C23
<stddef.h> Definições de macros C89
<stdint.h> Tipos inteiros de tamanho fixos C99
<stdio.h> Entrada/Saída C89
<stdlib.h> Utilitários gerais C89
<stdnoreturn.h> Macro noreturn C11
<string.h> Manipulação de strings C89
<tgmath.h> Funções matemáticas C99
<threads.h> Biblioteca de threads C11
<time.h> Utilitários de data e hora C89
<uchar.h> Utilitários UTF-16 e UTF-32 C11
Utilitários para multibyte e wide
<wchar.h> C95
characters
 <wctype.h> Manipulação de wide characters C95
Padronização K&R C89 C90 C95 C99 C11 C17 C23
 Anotação 2: Variáveis
A definição técnica do termo: variáveis, geralmente é aceita como sendo uma espécie de
“container”, contendo dados de bits que especificam seu valor, sendo que tal valor pode ser
mudado com o tempo. De um ponto de vista da linguagem C, variáveis, são espaços na
memória principal reservados para a leitura e/ou escrita de dados. Como esses dados são
armazenados na memória principal, logo possuem um endereço utilizado para o acesso,
felizmente em C, o programador pode rotular o espaço da variável, no caso, dá um nome a
mesma, tal rótulo é chamado de identificador, e é através deste identificador ou nome, que o
acesso a variável é feito durante a escrita do programa, descartando assim a necessidade de
referenciar a variável pelo seu endereço absoluto, apesar que, o C também permite o acesso
das variáveis diretamente pelos seus endereços.

Declaração de variáveis
Uma declaração, assim como as instruções, é um construto intrínseco da linguagem C, elas
servem para introduzir um ou mais identificadores no programa, especificando significados e
propriedades para esse identificador. Uma declaração pode ocorrer tanto para variáveis, como
para tipos e funções.

Para uma variável ser declarada em C, primeiro é necessário dizer ao compilador qual é seu
tipo, para assim o mesmo saber quais operações e dados serão permitidos para variável.

A sintaxe para a declaração de uma variável é:

[classe de armazenamento] [qualificador de tipo] [modificador de tipo] <tipo> <nome>;

Sendo que as partes de uma declaração pode ser definida em qualquer ordem, exceto o
identificador, que deve ser obrigatoriamente a última parte a ser definida.

A forma mais simples de declaração de uma variável consta em somente seu tipo e
identificador.
Exemplo: char letra;

A partir do C23, toda declaração pode possuir opcionalmente um especificador de atributos

antes da mesma.
Sintaxe: [[attrib]] declaração-da-variável
Exemplo: [[deprecated]] extern int num;

Quando se isola uma declaração, e se retira o tipo e os especificadores opcionais dessa

declaração, o resultado dessa isolação é chamando de declarator, nome esse usado em
documentações da linguagem C. Esse comportamento também se aplica a declarações e
definições de funções. Logo:
const long int valor;

Possui seu declarator sendo: valor.

Somente a partir do C99 se tornou possível a mistura livre entre instruções e declarações, anterior
a essa padronização, todas as declarações deviam aparecer antes da primeira instrução a ser
executada. Esse tipo de organização é chamado de free source form, antônima da fixed source
form.
Exemplo válido de uma declaração a parti do C99.

int main(){
if(0) ;
static const char letra = 'a';
return 0;
}

Identificador
Um identificador é um nome relacionando e associado a um objeto ou um requerimento da
linguagem C, como um rótulo. Para que um identificado seja conhecido pelo programa, e
possa ser usado para o acesso do objeto associado, o mesmo deve ser previamente declarado.

Um identificador válido para a linguagem C, deve seguir as seguintes regras:

• Não pode ser uma palavra-chave.

• Não pode começar com números, porém pode conter números ao longo de seu nome.

• Não pode conter caracteres especiais ou caracteres em brancos, exceto o under-score:

(_).

• Deve conter somente letras do conjunto de caracteres fonte — source character set.

• É permitido caracteres da codificação Unicode presente no extended character set (a

partir do C99).

o Um caractere em Unicode usado em identificadores não devem ser:

▪ Menores que 00A0, exceto por 0024 ($), 0040(@), ou 0060 (`).

▪ Entre os pontos D800 e DFFF.

▪ Maiores que 10FFFF — Especificação do C23.

Exemplos válidos:
arquivo1, minha_variavel, __funcao__, \u03b1

Exemplos inválidos:
1variavel, %arquivo_1, variável

Observe que o ultimo identificador: varivável, é dependente da implementação, podendo ser

um identificado valido de acordo com sua codificação, porém devido a essa ambiguidade,
geralmente esses identificadores são tratados como inválidos.

A partir da padronização C99, a linguagem C tem um identificador que é implicitamente

declarado após cada delimitador de início de função, esse identificador é nomeado de:
__func__, ele é expandido para um ponteiro para o tipo char — um tipo string —, que representa
o nome da atual função em execução.

Sua definição implícita é a seguinte:

static const char __func_[] = “function-name”;
Tipos De Dados
O C, assim como outras linguagens, possui o conceito de tipos de dados primitivos, chamados
assim, porque não são dependentes de nenhum outro tipo base para existirem, e são intrínsecos
na implementação da linguagem, logo, são nativos dentro da linguagem C. Esses tipos são
padronizados e não são definidos pelo programador, em relação a operações e tamanho de
dados que comporta. Os tipos de dados definidos pelo programador, chamados de tipos
definidos pelos usuários, não são considerados tipos de dados primitivos, porém são
dependentes deles.

Sendo assim, originalmente o C — especificamente a padronização não formal: K&R — define

quatros tipos de dados primitivos básicos, intrínsecos dentro da linguagem C: char, int, double e
float.

Com a padronização C89, a linguagem ficou padronizada com cinco tipos de dados básicos:
char, int, double, float, e um novo tipo, o tipo void.

A partir do C99 foram introduzidos os novos tipos primitivos: _Bool, _Complex e _Imaginary. Os
tipos _Complex e _Imaginary são dependentes e utilizados em conjunto com os tipos float,
double ou long double.

O C23 define quatro novos tipos de dados, três para pontos flutuantes: _Decimal32, _Decimal64
e _Decimal128, e um novo tipo para inteiros: _BitInt(N).

O tamanho e o alcance dos dados que esses tipos conseguem armazenar, podem variar de
implementação para implementação, pois somente seu alcance mínimo é padronizado, sendo
assim, é dever da implementação documentar o comportamento dos tamanhos e alcance dos
tipos de dados. Porém a maioria das implementações seguem um consenso geral.

Segue abaixo uma tabela com os tamanhos e os intervalos comumente implementados.

Tipo Tamanho em bytes Intervalo em base 10

char 1 -128 a 127
int 2 *1 -32 768 a 32 767
int 4 *1 -2 147 483 648 a 2 147 483 647
float 4 3.4*10-38 a 3.4*1038
double 8 1.7*10-308 a 1.7*10308
void - -
_Bool 1 -128 a 127
_Complex *2 *2

_Imaginary *3 *3

_Decimal32 4 1-95 a 9.99999996

_Decimal64 8 1-383
a 9.999999999999999384
1-6143 a
_Decimal128 16
9.9999999999999999999999999999999996144
_BitInt(N) *4 *4

Padronização K&R C89 C90 C95 C99 C11 C17 C23

*1: O tamanho do tipo int é dependente da arquitetura do compilador que está sendo executado. Para
arquiteturas 16 bits o tamanho do int é 2 bytes, para 32 bits e 64 bits o tamanho é 4 bytes.
*2: O tamanho e intervalo do tipo _Complex depende de qual tipo de ponto flutuante for usado: float —
8 bytes, double — 16 bytes, long double — 24 bytes. Opcional a partir do C11.
*3: O tamanho e intervalo do tipo _Imaginary depende de qual tipo de ponto flutuante foi usado: float —
8 bytes, double — 16 bytes, long double — 24 bytes. Os tipos imaginários são opcionais.
*4: O tamanho e intervalo do tipo _BitInt vai depender de quantos bits de precisão N o tipo comporta.
O caractere vírgula pode ser usado para mais de uma declaração por vez, porém somente
para variáveis do mesmo tipo.

int main(){
char letra1, letra2, letra3;
return 0;
}

Grupos de tipos
Cada tipo da linguagem C pode ser classificado como sendo de um ou mais grupos. Os
membros desses grupos compartilham caraterísticas em comum.

Grupo Tipos Características em comum

Qualquer tipo que não seja uma Representam um objeto na memória
Tipo objeto
função principal.
Representam um caractere do
Tipo caractere char, signed char e unsigned char
conjunto básico fonte.
char, inteiros com sinal, inteiros Representam números do conjunto
Tipo inteiro
sem sinal, enumerações numérico natural.
Representam números inteiros e
Tipo aritmético Inteiros e pontos flutuantes
decimais.
Possuem somente um único valor
Tipo escalar Tipos aritméticos e ponteiros
associado.
Possuem uma lista de valores
Tipo agregado Arrays e tipos de estruturas
associados.
Tipos derivados, possuindo como base
Tipos derivado Arrays, funções e ponteiros
os tipos primitivos.

void
O tipo void, é um tipo especial da linguagem C, introduzido na padronização C89, ele não é
usado para declarar nenhuma variável — com exceção dos ponteiros de tipo void — ele serve
quase que exclusivamente para declarar funções que não retornam nenhum valor.
Exemplo: void func-name(); void * pointer-name;

Tipos escalares
Os tipos escalares é um grupo de tipos que compreende os tipos que aceita somente um único
valor como dado associado a esse tipo.

Sendo:

• Tipos primitivos — exceto void.

• Modificadores de tipos.

• Ponteiros.

Tipos agregados
São tipos que podem ser associados a mais de um valor. Esses tipos funcionam como uma
coleção de outros tipos.

Sendo:

• Estruturas.

• Uniões.

• Arrays.

Tipos inteiros
Os tipos inteiros são usados para representar números inteiros com e sem sinal, e são:

• char — Usado para representar um único caractere do conjunto básico fonte. Como
caracteres são tratados como sendo números inteiros internamente pela linguagem, uma
variável do tipo char pode ser associada a qualquer número no alcance de 1 byte.

• int — Usado para representar um número do conjunto numérico inteiro. Podendo ser um
número com ou sem sinal.

• _Bool — Usado para representar um valor verdadeiro ou falso, apesar de ser definido
como um inteiro, ele só comporta os valores zero e um. A parti do C23 esse tipo deve ser
usado com os valores true e false.

• _BitInt — Usado para representar um inteiro com uma precisão exata de bits em seu
tamanho.

o Ele deve sempre ser acompanhado de uma constante inteira que determinará a
precisão do tipo — o número de bits. Possui a seguinte forma de declaração:
BitInt(N) onde N é a constante inteira.

o Quando _BitInt(N) é modificado com unsigned, N deve ser maior ou igual a 1.

Tipos de ponto flutuante

• float – Usado para representar um número fracionário com uma precisão simples.

• double – Usado para representar um número fracionário com uma precisão dupla.

• _Complex – Usado para representar um número do conjunto numérico complexo, não

pode ser usado como um tipo por si só, deve ser representado como uns dos tipos abaixo:

o float _Complex – Representa um número complexo com uma precisão simples.

o double _Complex – Representa um número complexo com uma precisão dupla.

• _Imaginary – Usado para representar a parte imaginária de um número complexo, não

pode ser usado como um tipo por si só, deve ser representado como uns dos tipos abaixo:

o float _Imaginary – Representa um número imaginário com uma precisão simples.

o double _Imaginary – Representa um número imaginário com uma precisão dupla.

• _Decimal32 – Usado para representar um número fracionário de precisão decimal de 32

bits.
 • _Decimal64 – Usado para representar um número fracionário de precisão decimal de 64
bits.

• _Decimal128 – Usado para representar um número fracionário de precisão decimal de

128 bits.

Observe que os tipos complexos são opcionais. Os tipos complexos que representam a parte
imaginária de seu número — família _Imaginary — são opcionais a partir do C99, a partir do C11
todo o conteúdo de aritmética complexa, incluindo a família _Complex é opcional.

Da mesma forma, no C23 todo o conteúdo no que diz respeito a pontos flutuantes decimais:
_Decimal32, _Decimal64 e _Decimal128 é opcional.

Para mais sobre características opcionais: macros de testes.

Tipos atômico
Representa um tipo indivisível com o uso da palavra-chave _Atomic, esse tipo implementa uma
concorrência no contexto de threads. Logo somente uma operação de escrita/leitura pode ser
feita no tipo por uma entidade de cada vez.
Exemplo de declaração: _Atomic(int) num;

Esse tipo está disponível a partir do C11.

Modificadores De Tipos
Modificadores de tipos, são palavras-chave que quando usadas na declaração de um tipo,
elas alteram o tamanho e a representação de certos tipos, consequentemente alteram o
alcance dos tipos modificados, devido ao fato de aumentarem ou diminuírem o espaço usado
para a alocação dos tipos em que atuam. Os modificadores as vezes são considerados como
tipos primitivos.

Assim como ocorrem com os tipos primitivos, os modificadores de tipos também podem ser
chamados de especificadores de tipos.

Segue abaixo uma tabela dos modificadores.

Modificador Usado com Adicionado em

short int K&R
int, double, long (C99), _Complex (C99), K&R – Modificado em
long
_Imaginary(C99) C99
signed Qualquer tipo primitivo inteiro C89
unsigned Qualquer tipo primitivo inteiro K&R

short
O modificar short é usado somente com o tipo int, ele serve para garantir que o tipo inteiro
modificado por ele seja de um tamanho de 2 bytes.

long
O modificador long é usado nos tipos int, double, double _Complex e double _Imaginary.
Quando usado com um int ele garante que seu tamanho tenha 4 bytes.

Quando usado com um double sendo um tipo decimal, complexo ou imaginário, ele garante
que o tamanho e precisão seja maior que um double de seus respectivos tipos.

A partir do C99 é possível usar o modificador long para modificar um outro long int, garantindo
assim que o tipo long long int tenha 8 bytes.

signed
O modificador signed foi introduzido como palavra-chave no C89, ele modifica a
representação do seu tipo para uma representação de um número com sinal, e só pode ser
utilizado com qualquer tipo primitivo inteiro, exceto o tipo _Bool — descartando assim: float,
double, _Complex, _Imaginary, _Decimal32, _Decimal64 e _Decimal128. Pode ser usado em
conjunto com os modificadores short, long ou long long.

Implicitamente toda variável declarada, quando não possui um modificador de tipo signed ou
unsigned, por padrão é do tipo signed, devido ao fato que as variáveis geralmente são
representadas utilizando o complemento de dois para os tipos inteiros. Porém em alguns
compiladores o tipo char geralmente é declarado como sendo implicitamente unsigned, por
razão da função do tipo de representar um caractere do conjunto básico.

Variáveis decimais geralmente seguem o padrão IEEE 754 para os tipos de ponto flutuante,
devido a isso não podem ser declaradas explicitamente como sendo signed.

unsigned
Esse modificador altera a forma como os tipos são representados, para uma representação de
um inteiro sem sinal — representação de um inteiro positivo —, e pode ser usado em qualquer
tipo primitivo inteiro, exceto o tipo _Bool — descartando assim: float, double, _Complex,
_Imaginary, _Decimal32, _Decimal64 e _Decimal128. Pode ser usado em conjunto com os
modificadores short, long ou long long. Esse modificador é usado para representar um valor sem
sinal, não seguindo o complemento de dois.

Lista de tipos
Segue abaixo uma tabela com todas combinações possível de modificadores de tipo.

Tipo Tamanho (em bytes) Intervalo numérico

signed char 1 -128 a 127
unsigned char 1 0 a 255
signed short int 2 -32 768 a 32 767
unsigned short int 2 0 a 65 535
signed int 4 -2 147 483 648 a 2147 483 647
unsigned int 4 0 a 4 294 967 295
signed long int 4 -2 147 483 648 a 2 147 483 647
unsigned long int 4 0 a 4 294 967 295
-9 223 372 036 854 775 808
signed long long int 8
a 9 223 372 036 854 775 807
unsigned long long int 8 0 a 18 446 744 073 709 551 615
signed _BitInt(N) Aproximadamente N/8 -(2N-1) a (2N-1 )-1
unsigned _BitInt(N) Aproximadamente N/8 0 a (2N )-1
 implementation-defined
long double -
behavior
implementation-defined
long double _Complex -
behavior
implementation-defined
long double _Imaginary -
behavior
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Os modificadores long, short e long long quando usados com o tipo int, a palavra-chave int
pode opcionalmente ser omitida, sendo assim a declaração: short int, long int e long long int é
respectivamente equivalente a short, long e long long.

Inicialização
Na linguagem C existe duas formas de iniciar um objeto.

• Com o uso de uma expressão — Sintaxe: = expression

Uma expressão seja ela lvalue ou rvalue, pode inicializar objetos somente classificados
como escalares.

Essa expressão pode ser opcionalmente envolvida entre chaves: {}.

• Com um uso de uma lista de inicializadores — Sintaxe: = { initializer-list }

Uma lista de inicializadores é usada para inicializar objetos agregados, e cada

inicializador deve ser separado por vírgula, a lista é delimitada por um par de chaves: {}.

Uma lista pode ser vazia, inicializa objetos agregados para um valor nulo.

A partir do C99 uma lista de inicializadores pode conter uma inicialização designada para
objetos agregados, inicializando assim membros específicos desse objeto.

• Um inicializador vazio — Sintaxe: = {} — Somente a partir do C23

Essa inicialização server para inicializar qualquer objeto, de qualquer tipo, para um valor
nulo, anterior a padronização C23, uma lista vazia inicializa com o valor nulo, somente
objetos agregados.

Constante
Uma constante é um valor ou um objeto que durante todo seu tempo de vida não tem seu valor
alterado.

Sabendo disso podemos classificar as constantes como: constante definidas em tempo de

compilação e em tempo de execução.

A forma para definir uma constante em tempo de compilação é a utilização dos literais, ou
macros. A partir do C23 uma nova classe de armazenamento: constexpr, foi adicionada a
linguagem, com ela é possível definir constante nomeadas em tempo de compilação, algo que
não ocorre com literais e macros.

Já as outras constates, são definidas em tempo de execução, e geralmente não são classificas
como constantes “verdadeiras”, visto que, seu conteúdo é especificado enquanto o programa
roda. A forma para definir uma constante em tempo de execução é a utilização do qualificador
const em variáveis.

Observe que, sempre que a padronização menciona o termo constante, ela implicitamente se
refere as constantes em tempo de compilação. Isso se aplica pro exemplo na padronização de
sintaxes da linguagem C.

Literal
Literais são valores imediatos que aparecem no código C, sendo que cada literal tem um tipo
de dado associado. São expressões avaliadas em tempo de compilação em que o programa
não aloca memória para seu uso — exceto o literal para variáveis de string.

Literais inteiros
O literal para inteiros são somente números do conjunto matemático dos inteiros. Implicitamente
esses números são tipo como sendo do tipo int.

Eles podem ser representados utilizado a base numérica decimal, hexadecimal ou octal. A
padronização C23 permite o uso da base numérica binária.

Para a base decimal o número não pode começar com zero.

Para a base hexadecimal usa-se o prefixo 0x ou 0X.

Para base octal o número deve começar com zero.

Para base binária usa-se o prefixo 0b ou OB — somente a partir do C23.

Exemplo:

int main(){
int a1 = 10, a2 = 0XA, a3 = 012, a4 = 0b1010;
return 0;
}

Cada variável é inicializada para o número 10 usando a base decimal, hexadecimal, octal e
binária respectivamente.

A partir do C23 quando definidos literais de tipos numéricos — inteiros e pontos flutuante —,
pode ser usado o caractere de aspas simples como um separador numérico.
Sintaxe: int x = 1’000’000;

Literal do tipo long e long long

Um literal inteiro implicitamente é tido como sendo do tipo int, para especificar um literal inteiro
como sendo de um outro tipo, faz o uso de sufixos.

Para um literal inteiro ser do tipo long usa-se o sufixo l ou L no final do literal, e para o long long
usa-se ll ou LL, também no final do sufixo.

Lembrando que o tipo long long só está disponível a partir do C99.

Exemplo:

int main(){
long a1 = 100l;
long long a2 = 100ll;
return 0;
}

Literal do tipo _BitInt

Para o tipo _BitInt usa-se o sufixo wb ou WB, o tipo avaliado será um _BingInt(N), onde N será o
menor inteiro maior que 1 que pode ser usado para representar o número com um tipo _BingInt,
podendo acomodar o valor e o bit de sinal se houver algum.

Lembrando que o tipo _BitInt só está disponível a partir do C23.

Exemplo:

int main(){
_BigInt(8) v = 127wb;
return 0;
}

Literal do tipo unsigned

Para o tipo unsigned utiliza um literal inteiro, com o sufixo u ou U no final.

O sufixo para unsigned pode ser usado com outros sufixos de notação inteira. Segue abaixo dois
exemplos de literais escritos em hexadecimal, seus valores são 255, e seus tipos são unsigned int,
e unsigned long int respectivamente.
Exemplo: 0xFFu; 0xFFul;

Literal do tipo signed

Todo literal inteiro sem o sufixo: u ou U, é tido como um literal do tipo signed, a não ser em casos
específicos em que o compilador implemente um determinado literal inteiro como sendo
unsigned; caso isso ocorra, é dever do compilador mencionar isso em sua documentação.

Literal de ponto flutuante

O literal para ponto flutuante são números decimais. Esses números representam frações, e são
escritos com uma parte inteira, e uma parte fracionaria. Implicitamente todo literal de ponto
flutuante é tido como sendo do tipo double.

Na linguagem C o caractere ponto (.) é usado para separação da parte decimal.

Esses literais também podem ser escritos usando notação cientifica sendo um número inteiro
vezes uma potência de 10 que é representada com a letra e ou E, sendo seu expoente o número
a seguir.
Segue abaixo um código onde as variáveis a1 e a2 são inicializadas para 0,5.

int main(){
double a1 = 0.5, a2 = 5e-1;
return 0;
}

A partir do C99 é possível definir um literal de ponto flutuante usando uma notação
hexadecimal.
Sintaxe: 0xh1.h2p[-]e

Onde: h1 e h2 deve ser substituído por uma constante hexadecimal, e e por um número inteiro.

O literal é calculado da seguinte forma: (h1+h2/16)*2^e.

Exemplo abaixo inicializa a1 para 3,0 em notação hexadecimal.

int main(){
double a1 = 0x1.8p1;
return 0;
}

Literal do tipo float

Assim como ocorre para inteiros que não são int, para pontos flutuantes que não são double,
há a necessidade do uso de sufixo em seus literais.

Usa-se os sufixos f ou F no final de um número de ponto flutuante, para dizer que esse literal é um
float.

Segue abaixo um código onde as variáveis a1, a2 e a3 são inicializadas para 0,5.

int main(){
float a1 = 0.5f, a2 = 5e-1f, a3 = 0x0.4p1f;
return 0;
}

Literal do tipo long double

Os sufixos l ou L no final de um literal de ponto flutuante, fazem desse literal, um literal de um tipo
long double.

Segue abaixo um código onde as variáveis a1, a2 e a3 são inicializadas para 0,5.

int main(){
long double a1 = 0.5l, a2 = 5e-1l, a3 = 0x0.4p1l;
return 0;
}
Literal dos tipos: _Decimal32, _Decimal64 e _Decimal128
Usa-se os sufixos df ou DF, dd ou DD e dl ou DL no final de um número em ponto flutuante para
_Decimal32, _Decimal64 e _Decimal128 respectivamente.

Assim como os outros tipos de ponto flutuante, valores para os tipos decimais podem ser
especificados em notação normal e científica, exceto, a notação de ponto flutuante em
hexadecimal.

Segue abaixo um código onde as variáveis a1, a2 e a3 são inicializadas para 0,2.

int main(){
_Decilmal32 a1 = 0.2df;
_Decilmal64 a2 = 0.2dd;
_Decilmal128 a3 = 0.2dl;
return 0;
}

Literal para o tipo char

Literais do tipo char representam um único caractere.

Eles são encapsulados em aspas simples.

Exemplo: char minha_variavel = ‘X’;

Alguns caracteres devem ser expressados de maneira especial, esses caracteres são chamados
de caracteres de escape.

Segue uma lista abaixo dos caracteres de escape.

Sequência de escape Valor Ação

\' Printa aspas simples
\” Printa aspas duplas
\? Printa ponto de interrogação
\\ Printa um backslash
\a Alert Gere um sinal audível
\b Backspace Volta o cursor um caractere
Move o curso para o início da próxima
\f Form feed
pagina
Move o curso para o início da próxima
\n Newline
linha
Move o curso para o início da atual
\r Carriage return
linha
\t Horizontal tab Printa uma tabulação horizontal
\v Vertical tab Printa uma tabulação vertical
\o, \oo, or \ooo Printa um caractere escrito em octal
Printa um caractere escrito em
\xh[h]
hexadecimal
\uhhhh (C99) Printa um caractere Unicode
\Uhhhhhhhh (C99) Printa um caractere Unicode
Padronização K&R C89 C90 C95 C99 C11 C17 C23

A partir do C95, a linguagem C teve suporte para wide characters e multibytes characters.
Para esse suporte, foi adicionado o uso de um prefixo antes dos literais do tipo char, veja que os
tipos de dados dos literais com esses prefixos, não correspondem a tipos primitivos da linguagem,
e sim, a tipos definidos na biblioteca padrão da linguagem.

Wide characters são definidos como sendo do tipo wchar_t — definido no cabeçalho stddef.h
—, e podem ter 2 ou 4 bytes de comprimento, mas tem seu tamanho fixo. Para definir um wide
character é o usado o prefixo L: L‘x’.

Multibytes characters tem um tamanho variável, podendo ter um ou mais bytes de tamanho
por caractere.

A partir do C11 foi adicionado os novos prefixos para char: u (UTF-16) e U (UTF-32), e também os
tipos char16_t e char32_t — definidos no cabeçalho uchar.h.

No C23 foi adicionado uma representação para UTF-8, usando o prefixo u8, essa representação
corresponde ao tipo char8_t — definido no cabeçalho uchar.h.

Segue abaixo uma tabela de referência:

Prefixo Exemplo Tipo

‘a’ char
u8 u8‘w’ unsigned char
L L’x’ wchar_t
u u’y’ char16_t
U U’z’ char32_t
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Literal do tipo string

Strings na linguagem C não é um tipo primitivo, em vez disso são somente arrays de caracteres
com um terminador nulo, sendo esse determinador o caractere: \0.

O literal string é escrito entre aspas duplas.

Exemplo: “string”;

String do tipo wchart_t (C95) são escritas com o prefixo L, da mesma forma que se usa com
caracteres.
Exemplo: L“string”;

O mesmo corre com strings para char16_t e char32_t.

Exemplo: u“string”;
Exemplo: U“string”;

Para strings multibytes, elas são dependentes da implementação.

A partir do C11 pode-se usar o prefixo u8 para strings multibytes UTF-8.

Exemplo: u8“string”;

Para caracteres o prefixo u8 só é possível a partir do C23.

Em um literal do tipo string não é necessário a adição do terminador nulo, pois a linguagem faz
isso automaticamente.

Diferente dos outro literais, o uso de strings no C pode acarretar na necessidade de alocação
de memória para armazenar a string desejada, caso necessária essa alocação, isso ocorre de
forma automática.
Para os literais do tipo string são aplicadas alocações especiais, fora das regras de alocações
gerais de variáveis da linguagem: ALOCAÇÕES DE STRINGS

Literais do tipo _Bool

A partir do C23 o tipo _Bool possui duas constantes literais para verdadeiro e falso: true e false.
Diferente dos outros literais, essas constantes são palavras-chave da linguagem.

Elas são avaliadas em 0 e 1 respectivamente.

Exemplo:

int main(){
_Bool t = false;
return 0;
}

Literal para ponteiro

Assim como o tipo _Bool, no C23 uma nova constante literal foi introduzida: nullptr, ela representa
um ponteiro nulo, e pode ser usada com qualquer tipo ponteiro. Assim como as constantes para
o tipo _Bool, nullptr é uma palavra-chave da linguagem.

Exemplo:

int main(){
void * ptr = nullptr;
return 0;
}

O tipo avaliado para a constante nullptr é do tipo nullptr_t, tipo esse definido no cabeçalho <stddef.h>.

Resumo
Segue abaixo uma tabela de referência com os tipos da linguagem.

Tipo Literal
_Bool true ou false
int 10
unsigned int 10U
long int 10L
unsigned long int 10UL
long long int 10LL
unsigned long long int 10ULL
float 10.0F
double 10.0
long double 10.0L
_Decimal32 10.0DF
_Decimal64 10.0DD
_Decimal128 10.0DL
char ‘A’
wchar_t (stddef.h) L‘A’
 char16_t (uchar.h) u’A’
char32_t (uchar.h) U’A’
unsigned char – implementation defined u8’8’
string “texto”
wide string L“texto”
string UTF-16 u“texto”
string UTF-32 U“texto”
string UTF-8 u8“texto”
<Ponteiros> nullptr
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Escopo, tempo de vida, ligação e alocação

Toda as variáveis declaradas em um programa C tem um escopo, um tempo de vida, um tipo
de alocação e um tipo de ligação.

Seu escopo, tempo de vida e alocação dependem de onde são declaradas, e se algum
palavra-chave específica foi usada em sua declaração.

Elas, as variáveis, assim como as funções possuem uma ligação, que pode ser externa ou interna,
ou como em alguns casos nenhuma ligação, essa ligação é que define se elas são ou não
visíveis fora de seus módulos de declarações.

Escopo
Existe quatros escopos em um programa C:

• Escopo de arquivo

Variáveis deste escopo são declaradas fora dos blocos que delimitam as funções e são
chamadas de globais, pois podem ser acessadas em qualquer parte ou escopo dentro do
modulo de arquivo, e em qualquer parte do programa se não alterada seu comportamento.
Elas são alocadas em uma região de especial da memória principal e são destruídas
somente com a finalização do programa.

• Escopo de função

Variáveis deste escopo são declaradas nos parâmetros formais da função, e são acessíveis
somente dentro da função em que foram declaradas, sendo seu acesso disponível em
qualquer parte da função. Essas variáveis são locais a função e são alocadas na pilha da
função, são destruídas quando a função é terminda de ser executado — execução da
instrução return.

• Escopo local

Variáveis declaradas dentro do bloco de uma função. Acessíveis somente dentro do bloco
da função, porém não antes de sua declaração. São alocadas na pilha da função, e assim
como as variáveis dos parâmetros da função, são destruídas com a finalização da execução
da função.

• Escopo de bloco.

Variáveis declaradas dentro de um bloco de código, sendo esse último um escopo recursivo.
O acesso a objetos desse escopo só é possível dentro do escopo. São alocadas na pilha da
 função, como são de um bloco aninhado ao bloco da função, elas são destruídas no final
do bloco aninhado, e não do bloco da função.

Como dito, o escopo define qual é visibilidade de uma variável: global ou local.

Variáveis globais são acessíveis por todo o programa, e são declaradas fora dos blocos de
funções, sendo declaradas no escopo do arquivo. Seus inicializadores, se possuírem, devem ser
obrigatoriamente constantes.

Variáveis locais são variáveis do escopo de uma função, do escopo local ou do escopo de
bloco, e são acessíveis somente dentro do escopo em que foram declaradas.

Exemplo:

int g; // Variável Global

int main(){
int l; // Variável Local
return 0;
}

Tempo de vida
O tempo de vida específica qual a duração de uma variável, em relação ao momento que a
mesma é criada até o momento que será destruída, as variáveis tem seu tempo de vida
classificadas em permanentes, onde possuem um tempo de vida estático, e classificadas
também em temporárias, onde possuem um tempo de vida automático. A parti do C11 com a
adição de concorrência nas especificações, foi adicionado o tempo de vida associado a
thread.

Variáveis permanentes ou com o tempo de vida estático, existem durante todo o programa e
geralmente são alocadas em uma região especial da memória — segmento .bss e .data, sendo
destruídas com a finalização do programa. São inicializados somente uma vez, antes da
inicialização do programa.

Todas variáveis globais, que não são associadas a threads, e variáveis locais modificadas com
a palavra-chave static, possuem um tempo de vida estático, e não podem ser alteradas para
um tempo de vida temporário.

Já as variáveis locais são por padrão temporárias e existem somente enquanto a função ou o
bloco associado a elas existir, sendo no final destruídas e desalocadas da memória, porém,
como dito anteriormente, as mesmas podem se tornarem permanente com o uso da palavra-
chave static.

Variáveis associadas a thread existem enquanto a thread existir, possuindo um tempo de vida
de thread, elas são inicializadas quando a thread associadas é criada, e podem ser alocadas
tanto no segmento para variáveis estáticas ou na pilha da thread, dependendo do escopo de
onde foram declaradas. Essas variáveis são declaradas com o uso da palavra-chave
_Thread_local.

Ligação
Na ligação de módulos, a referência entre objetos de diferentes módulos depende do tipo de
ligação dos objetos envolvidos entre essas referências. O tipo de ligação é o que determina se
um modulo pode ter ou não acesso a um objeto de outro modulo.

A ligação externa permite que a variável seja acessada fora de seu módulo, já a ligação interna
não permite a visibilidade fora de seu módulo.

Variáveis globais possuem por padrão uma ligação externa, sendo visíveis fora de seu módulo,
para alterar esse comportamento para uma ligação interna usa-se a palavra-chave static.

Variáveis locais não possuem nenhum tipo de ligação, logo não são visíveis fora de seus
módulos. Como não são acessadas fora de seu escopo, elas não podem ganhar nenhum tipo
de ligação, nem mesmo variáveis locais com tempo de vida permanente.

Alocação
Há três tipos de alocação para variáveis:

• Alocação automática: São variáveis alocadas na pilha da função em que pertencem, e

são por definição lógica, as variáveis locais, de função e de bloco. Possuem um tempo
de vida automático.

• Alocação Estática: São variáveis alocadas quando o programa inicia, tendo um espaço
especial de alocação, por definição lógica, são variáveis globais e locais modificadas
com static. Possuem um tempo de vida estático.

• Alocação Dinâmica: São variáveis alocadas em tempo de execução, e por definição

lógica, são alocadas no heap de memória.

Qualificadores de tipos
São palavras-chave que alteram como os dados podem ser escritos ou lidos em um
determinado objeto. Essas palavras-chave devem ser usadas durante a declaração de um
objeto.

A partir do C99 os qualificadores tem propriedades idempotêntes.

const
Esse qualificador faz com que o objeto declarado não possa ter seu valor alterado pelo
programa, transformando a variável em uma constante em tempo de execução. Pode ser que
o compilador guarde o objeto em uma memória do tipo de somente leitura.

É obrigatório inicializar variáveis consts.

Sintaxe: const type var-name = initializer;

volatile
Esse qualificador diz ao compilador que o objeto pode sofre uma escrita não planejada, como
por exemplo: objetos que depende de hardware.

Uma variável pode ser const volatile ao mesmo tempo.

 Sintaxe: volatile type var-name;

restrict
O C99 apresenta um novo qualificador usado somente para tipos ponteiros, que serve para
pedir ao compilador para realizar uma otimização no ponteiro.

Esse qualificador significa apenas uma requisição, não significa que o objeto irá ser otimizado.
Sintaxe: type * restrict var-name;

_Atomic
Esse qualificador foi introduzido no C11, ele serve para fazer um objeto ser do tipo atômico,
livrando o objeto das data races. Esse qualificador geralmente é associado a threads.
Sintaxe: _Atomic type var-name;

Esse qualificador tem sua implementação opcional, e possui uma versão para especificação
de tipos, caso a implementação não o suporte, seu uso não deve acontecer.

Classes de armazenamento
São palavras-chave que alteram a forma como o objeto é alocado/ligado durante sua
declaração.

auto
Variáveis declaradas com a palavra-chave auto, tem uma alocação automática, ou seja, são
alocadas na pilha do programa. Por padrão todas variáveis locais são auto, então é
redundante usar essa palavra-chave.

Não pode ser usada em variáveis globais.

A partir do C23 essa palavra-chave pode ser usada para inferência de tipo.

static
Quando usada em variáveis locais, fazem a mesma preservar o seu valor durante as chamadas
de funções, ou seja, são alteradas para um tempo de vida permanente, com alocação
estática. Geralmente são alocadas no mesmo espaço de alocação para variáveis globais.

Quando usada em variáveis globais e em funções, alteram a ligação desses objetos de externa
para interna, fazendo delas visíveis somente no escopo do arquivo.

extern
Faz com que o objeto seja declarado, mas não alocado, nesse caso a sua definição, ou seja
alocação, está fora de seu escopo de declaração, fazendo o compilador procurar sua
definição no escopo acima do escopo da declaração, geralmente em outros módulos do
programa.
O uso dessa palavra chave-para variáveis locais é opcional quando a declaração referência
uma definição que está no escopo do arquivo de mesmo módulo.

Quando uma declaração extern possui ao mesmo tempo uma definição — geralmente uma
inicialização —, o objeto é alocado normalmente.

register
Originalmente era um modificador que poderia ser aplicado somente em variáveis int e char,
fazendo-as ser armazenadas em registradores.

A partir do C89 qualquer tipo primitivo pode ser do tipo register, pois, a partir dessa padronização
as variáveis register são estabelecidas como: “podem ser armazenadas em registradores”,
especificando somente que o acesso delas será o mais rápido possível, e não que serão
armazenadas em registradores.

Por questões lógicas não se pode obter o endereço de uma variável register.

constexpr
Palavra-chave introduzida no C23, server para fazer da variável uma constante avaliada em
tempo de compilação, fazendo dela um identificador para uma constante nomeada. Todas as
características aplicadas a variáveis modificas com o qualificador const, se aplicam também a
variáveis constexpr, com a diferença que: variáveis constexpr podem aparecer onde uma
expressão constante é solicitada, e sua inicialização deve ser feita por outra expressão
constante.

Diferente das variáveis const, variáveis constexpr são garantidamente inicializadas em tempo
de compilação.

Caso não explícito, todas variáveis constexpr são modificadas com const.

_Thread_local
Presente a partir do C11, essa é uma classe de armazenamento define que o objeto possui uma
existência associada a thread de execução. Sua inicialização ocorre quando a thread é criada,
e a variável “existe” enquanto a thread existir. A alocação é dependente do escopo, podendo
ser variáveis locais e globais.

Variáveis estáticas modificadas com essa classe de armazenamento, faz com que cada thread
possua uma instancia especifica do objeto modificado com _Thread_local, porém, seu acesso
ocorre com o mesmo nome nas thread que referenciam o objeto, apesar de várias threads
acessarem o “mesmo” objeto por um único identificador, seu acesso real ocorre em objetos
diferente que são locais a thread. Essa implementação usa o método thread-local storage (TLS).

Restrições
Segundo a padronização essas são as restrições das classes de armazenamento:

• _Thread_local pode aparecer com static ou extern.

• constexpr pode aparecer com auto, register ou static.

 • Caso um objeto com escopo de bloco seja especificado com _Thread_local, o mesmo
deve incluir static ou extern.

• auto pode aparecer com qualquer classe de armazenamento, e em qualquer escopo,

desde de que seja usado para inferência de tipo.

Especificadores de tipos
Especificadores de tipos são palavras-chave que servem para determinar o tipo do objeto. Elas
são usadas em sua declaração para especificar o tamanho e alcance do objeto, além das
operações que os mesmos podem realizar.

Todas as palavras-chave usadas para declarar um tipo de dados se enquadram nessas

categorias. Com a adição das palavras-chave abaixo.

_Alignas
Introduzido no C11, esse especificador de alinhamento é usado na definição de variáveis para
especificar o padding de memória na alocação da variável.
Sintaxe: _Alignas(integer-constant) var; _Alignas(type-name) var;

O valor de alinhamento dever ser uma potência de base 2.

Por questões lógicas não pode ser usado em conjunto com a classe de armazenamento register,
com elementos de bit-fields, em parâmetros formais de uma função ou uma declaração
typedef.

_Atomic
Esse especificador foi introduzido no C11, ele serve para fazer um objeto ser do tipo atômico,
livrando o objeto das data races, diferente de sua versão como qualificador, a versão de
especificador cria um novo tipo.
Sintaxe: _Atomic(type) var-name;

Assim como seu qualificador esse especificador é opcional, onde seu uso não deve ocorre se a
padronização não o implementar.

typeof
Essa palavras-chave é implementada na padronização C23, é usada no lugar de um
especificador de tipo. Ela avalia uma expressão, ou um nome de um especificador de tipo, e
declara o especificador com o tipo avaliado através de seu operando.
Sintaxe: typeof(expr | type-name) name;

Pode ser usado em qualquer lugar que um especificador de tipos é solicitado, exceto para
designar um membro bit-field.

typeof_unqual
Funciona da mesma forma que typeof, com a diferença que os qualificadores de tipos usados
na avaliação são descartados.
Sintaxe: typeof_unqual(expr | type-name) name;

Inferência de tipo
A padronização C23, adiciona uma nova funcionalidade a palavra-chave auto. Quando usado
no lugar de um especificador de tipo, o tipo da variável será inferido através de seu inicializador.
Sintaxe: auto var = initializer;

Obrigatoriamente para o tipo ser inferido, o objeto a ser alocado deve conter um inicializador.
 Anotação 3: Operadores
Operadores, são tokens com significados especiais para a linguagem, eles executam uma ação
específica em cima de um ou mais operandos, gerando assim um resultado. O tipo do retorno
e o valor do resultado de uma operação com operadores é dependente do tipo do operador
e dos valores dos operandos.

Na linguagem C existem vários tipos de operadores: aritméticos, relacionais, lógicos, bit a bit,
coerção, etc.

Os operadores podem ser classificados como sendo unários: que aceitam somente um
operando; binários: que aceitam dois operandos e ternários: que aceitam três operandos. Todos
operadores também possuem uma direção de associação e uma ordem de precedência.

Operadores
Todo operador deve ser usado com um ou mais operandos, a quantidade irá variar de cada
operador. Os operandos podem ser constantes, variáveis, chamadas de funções, etc., qualquer
valor lvalue ou rvalue, desde que o mesmo seja admitido em uma expressão e seja valido seu
uso com o operador.

Aritméticos: Operadores Binários

Operador Finalidade Exemplo Resultado
+ Adição 5+2 7
- Subtração 5–2 3
* Multiplicação 5*2 10
/ Divisão (Quociente) 5/2 2
% Divisão Euclidiana (Resto) 30 % 7 2

São operadores utilizados em expressões com os tipos inteiros e de pontos-flutuante,

resumidamente, ele é utilizado com valores que representam números.

Caso seja utilizado em uma expressão de inteiros o retorno também será inteiro, se houver algum
ponto flutuante na expressão o retorno será em ponto flutuante. O tipo especifico de qual inteiro
ou ponto flutuante retornado, se dá pelo tipo do inteiro ou ponto flutuante com maior ranking
na expressão.

Aritméticos: Operadores Unários

Operador Finalidade Exemplo Resultado
+ Positivo +5 5
- Negativo -2 -2

Esses operadores fazem de seus números valores positivos ou negativos.

O operador unário positivo é opcional para uma constante literal ou variável.

Relacionais: Operadores Binários

 Operador Significado Exemplo Resultado
> Maior que 1>2 Falso
< Menor que 5<5 Falso
>= Maior ou igual à 1>=1 Verdadeiro
<= Menor ou igual à 4<=5 Verdadeiro
== Igual a 2==5 Falso
!= Diferente de 1!=2 Verdadeiro

Operadores relacionais retornam um valor verdadeiro ou falso, e geralmente são usados em

instruções que requerem uma condição.

Lógicos: Operadores Binários. Operador Unário. Short Circuit

Operador Significado Exemplo Resultado
&& E 1>2 && 2>1 Falso
|| OU Inclusivo 5<5 || 1==1 Verdadeiro
! Negação !1>=1 Falso

Assim como os operadores relacionais, os lógicos retornam um valor verdadeiro ou falso, e

geralmente trabalham em conjuntos com os operadores relacionais, o resultado de seu retorno
é determinado pela álgebra booleana.

Os operadores lógicos no C são de circuito curto – short circuit —; isso significa que em uma
operação E, caso o primeiro operando seja avaliado em falso o compilador não irá avaliar o
segundo operando; e no caso da operação OU, caso o primeiro operando seja avaliado em
verdadeiro o compilador não irá avaliar o segundo operando. Isso pode impactar sua previsão
de resultado, como por exemplo: o uso de chamadas de funções como operando.

Não existem um operador lógico de OU exclusivo na linguagem C.

O operador de negação é um operador unário.

Bit a Bit: Operadores Binários. Operador unário

Operador Ação lógica Exemplo Resultado
& AND (E) 2&3 2
¦ OR (OU inclusivo) 4|2 6
^ XOR (OU exclusivo) 6^1 7
~ NOT (Negação) ~-1 0
>> Deslocamento de bits à direita 2 >> 1 1
<< Deslocamento de bits à esquerda 2 >> 1 4

O operador de bit a bit efetua uma álgebra booleana nos operandos usando sua
representação binária, retornando também uma representação binária.

Os operadores de deslocamento movem os bits n vezes de seu primeiro operando na direção

correspondente de acordo com o operador, vale ressaltar que o operador de deslocamento a
direita preenche os bits de mais alta ordem — high-orde bits —, com zeros.

O operador de negação é um operador unário.

Esses operadores só funcionam em tipos inteiros.

Atribuição: Operadores Binários
Exceto a atribuição simples, a utilização destes operadores é uma forma abreviada para fazer
uma operação numa variável e armazena o resultado na mesma.
Exemplo: a = a + 1; pode ser escrito a +=1;

Esses operadores só podem ser usados com variáveis ou qualquer outro modifiable lvalue.

Na tabela abaixo presuma que o valor da variável a seja 2.

Operador Significado Exemplo Resultado

= Atribuição simples a=2 2
*= Atribuição de multiplicação a*=3 6
/= Atribuição de divisão a/=1 2
%= Atribuição restante a%=2 0
+= Atribuição de adição a+=8 10
-= Atribuição de subtração a-=4 -2
<<= Atribuição de shift esquerda a<<=1 4
>>= Atribuição de shift direita a>>=1 1
&= Atribuição AND bit a bit a&=2 2
^= Atribuição OR exclusivo bit a bit a^=1 3
|= Atribuição OR inclusivo bit a bit a|=1 3

Incremento e Decremento: Operadores Unários

Operador Significado Exemplo Resultado
++ +=1 a++ OU ++a a+=1
-- -=1 a-- OU --a a-=1

Os operadores de incremento fazem uma adição, ou subtração naa variável em que atuam
com o número um, armazenado seu valor de retorno na variável.

O operado de decremento e incremento podem ser escritos de duas formas, antes da variável
ou depois; quando o operador aparece antes, é chamado de prefixado (prefix) e quando
aparece depois é chamado de pós-fixado (posfix).

A principal diferença está se a variável é ou não retornada primeira, no caso do prefixado a

variável é incrementada ou decrementada primeiro, para depois ser retornada, no pós-fixado
o inverso é feito.

Exemplo: Tendo b o valor de 2.

variavel = ++b;
variavel = b++;

No primeiro exemplo variavel irá valer 3, no segundo exemplo variavel será 2.

Ternário: Operador Ternário

O operador ternário recebe uma expressão como seu primeiro operando, essa expressão será
avaliada em verdadeira ou falsa, caso seja verdadeira, a expressão que se encontra antes dos
dois pontos será retornada caso contrário, a expressão depois dos dois pontos será então
retornada.

Operador Exemplo Resultado

?: 1>2 ? 10 : 20 20

Outros Operadores

Operador de endereço: & Operador Unário

O operador & é um operador unário que retorna o endereço em que o objeto se encontra na
memória principal.
Sintaxe: &var-name;

Operador de derreferência: * Operador Unário

Este operador é usado somente em ponteiros não nulos, ele recupera os dados no endereço
em que o ponteiro aponta. Não confundir com o operador de multiplicação.
Sintaxe: *pointer-name;

Operador de lista: ,
O operador lista executa as expressões na ordem em que as mesmas aparecem, sendo que as
expressões a esquerda são avaliadas em nulas ou void. A expressão mais à direita retornada.
Exemplo: a = 1>2, 5^2, func(), 2>1;

No exemplo acima o retorno dessa expressão será verdadeiro, e convertida para o tipo int, pois
a última expressão a ser avaliada será 2>1, sendo o resultado da mesma retornada.

Operador de tamanho: sizeof Operador Unário

O operador sizeof retorna o tamanho em bytes de uma variável ou de um tipo de dado.
Exemplo: sizeof(int);

Quando usado com um objeto os parênteses podem ser omitidos.

Exemplo: sizeof var;

Esse operador retorna um inteiro do tipo size_t — tipo implementado na biblioteca stddef.h.

Operador de alinhamento: _Alignof Operador Unário

Retorna um inteiro, mais especificamente um inteiro do tipo size_t, que representa o alinhamento
em bytes do tipo da expressão analisada, podendo ser usado ainda com tipos completos.
Exemplo: _Alignof(int);
Exemplo: _Alignof var;

Foi implementado a partir do C11 e quando usado com um objeto os parênteses podem ser
omitidos.
Operador de coerção: (tipo) Operador Unário
O operador de coerção também chamado de casting, é um operador que converte um tipo
de dado em outro, por trabalhar com tipos de dados, e devido ao fato de a linguagem C ser
uma linguagem de tipagem estática, o operador de coerção por lógica opera em
implementation-defined behavior.

Os tipos usados tanto na entrada como para a saída do operador devem ser compatíveis entre
si.
Exemplo: int a = (int) 1.0;

A linguagem C por padrão faz algumas coerções implícitas, no exemplo acima a coerção para
int a partir do literal double é tido como opcional.

Segundo a padronização uma operação de coerção possui as seguintes restrições:

• Exceto quando o tipo especificado seja void, um tipo especificado dever ser escalar,
sendo, atômico, qualificado, ou não qualificado. O operando também dever ser um tipo
escalar.

• Coerções que envolvem ponteiros, excetos as permitidas através das conversões

implícitas entre ponteiros do tipo void, devem ter uma coerção explicita.

• Um tipo ponteiro não deve ser convertido para um tipo de ponto flutuante, o inverso
também não deve ocorre. C23: O tipo nullptr_t não deve ser convertido para nenhum
tipo exceto void, bool ou outro tipo ponteiro. Somente nullptr_t pode ser convertido para
nullptr_t.

Operador de membro: . Operador seta: -> Operador Unário

O operador de membro e o operador seta, são usados para acessar um membro a partir de
uma variável de tipo struct ou union.

A diferença entre o os dois operadores é que o operador seta acessa o membro através de um
ponteiro, fazendo assim a derreferência do ponteiro em questão, enquanto o operador ponto
acessa o membro diretamente através do objeto.

As duas expressões abaixo são equivalentes:

var->membro;
(*var).membro;

Operador de index: [] Operador Unário

O operador de index é usado para acessar um elemento específico dentro de uma coleção —
espaços sequenciais na memória — baseando-se em um índice que atuará como um offset, o
tipo do elemento retornado se dá pelo tipo base da coleção.

Ele pode ser usado em vetores ou ponteiros.

Sintaxe: array[index]; index[array];

Operador de chamada de função: () Operador Unário

Operador usado para fazer as invocações de funções.
Sintaxe: func-name();

Precedência e associação
Assim como na matemática, os operadores na linguagem C tem uma precedência de qual
operador é executado primeiro em uma expressão.

Eles também possuem uma associação, que corresponde a: em que ordem o operador irá
executar, da esquerda para direita ou da direita para esquerda.

Segue abaixo uma lista de todos operadores presente na linguagem C e sua ordem de
precedência e associação.

A lista foi organizada de forma descendente e da esquerda para direita, sendo o operador de
maior precedência no topo da lista na parte mais a esquerda.

Operador Associação
() [] -> . Esquerda para direita
- ++ -- ! & * ~ (tipo) sizeof _Alignof Direita para esquerda
* / % Esquerda para direita
+ - Esquerda para direita
<< >> Esquerda para direita
< <= >= > Esquerda para direita
== != Esquerda para direita
& Esquerda para direita
^ Esquerda para direita
| Esquerda para direita
&& Esquerda para direita
|| Esquerda para direita
?: Direita para esquerda
= op= Direita para esquerda
, Esquerda para direita
 Anotação 4: Instruções
Instruções ou statements, são o core de uma linguagem de programação, em seu aspecto mais
técnico, instruções são comandos que dizem ao computador o que fazer, logo são executados
pelo processador por intermédio do compilador ou interpretador de uma linguagem de
programação, não diferente, na linguagem C, instruções são diretivas dentro do algoritmo do
programa, que em sua maioria são executadas em sequência.

Certas palavras chaves na linguagem C tem significados e funções específicas, como por
exemplo a palavra-chave if: uma instrução que realiza um teste lógico e dependendo do
resultado, executa ou não um bloco de código. Cada instrução tem sua finalidade e sintaxe,
sendo que cada linguagem de programação tem seu conjunto de instruções.

As instruções na linguagem C podem ser agrupadas de acordo com suas características.

No C há seis tipos de instruções:

• Instruções compostas ou de bloco (compound statements)

• Instruções de expressões (expression statements)

• Instruções de seleção (selection statements)

• Instruções de interação (interation statements)

• Instruções de desvio (jump statements)

• Instrução nula (null statement)

Rótulo
Qualquer instrução pode ser rotulada com um label — rótulo —, e geralmente serve para ser:
um alvo para uma instrução goto, um rótulo do tipo case ou um rótulo do tipo default. Sendo
que o rótulo é qualquer identificador válido seguido por dois pontos.
Sintaxe: label: instruction

A partir do C23 os rótulos podem ser seguidos por uma declaração.

Instrução nula
Consiste em um único ponto e vírgula, onde informa ao compilador que essa instrução não faz
nada.

Instruções compostas
São blocos de códigos delimitadas por pares de abertura e fechamento de chaves.
Sintaxe: {statement | declaration}
Uma instrução composta agrupa várias outras instruções, além de declarações, e pode ser
usada em qualquer lugar onde é esperado uma instrução.

Toda instrução composta introduz seu escopo próprio escopo, chamado de escopo de bloco.
Instruções de expressões
São instruções seguidas por um ponto e vírgula, que por sua vez retornam um resultado e
possuem um tipo associado.

Essas instruções são alvos de avaliação pode compilador, e são computadas para um resultado.

Toda expressão pode ser classificada em lvalue e rvalue.

Instruções de iteração
Também chamadas de estruturas de repetição, são instruções que permitem que um
determinado bloco de código seja executado n vezes de acordo com determinada condição,
fazendo assim um loop.

Abaixo uma lista das palavras-chave que compõem as estruturas de interação.

for while do

for
Sintaxe:
for ([instrução inicial] ; [condição lógica] ; [incremento])
bloco de instruções

Como funciona:

Quando a instrução for começa a executar, o compilador primeiro executa o código da

instrução inicial, que geralmente contém declarações de variáveis de controle do for, depois
testa se a condição lógica é verdadeira, se verdadeira então o compilador executa o bloco
de instruções, quando o bloco termina de ser executado, então o incremento é executado e a
condição lógica é testada novamente, caso continue verdadeira os passos antes descritos são
repetidos, exceto a execução da instrução inicial, caso falsa, a próxima instrução depois do
bloco de instruções é executada.

Exemplo:

#include <stdio.h>
int main(){
for( int a = 0 ; a < 10 ; a++){
printf("Fui executado\n");
}
return 0;
}

A declaração de variáveis dentro da instrução inicial de um bloco for só é possível a partir da

padronização C99.

while
Sintaxe:
while (<condição lógica>)
bloco de instruções
Como funciona:

O bloco de instruções é executado somente enquanto a condição lógica for verdadeira.

Primeiro é feito um teste, se verdadeiro então o bloco de instruções é executado, depois de

executado os passos acima se repetem.

Exemplo:

#include <stdio.h>
int main(){
int a = 0;
while (a < 10){
printf("Fui executado 10 vezes\n");
a++;
}
return 0;
}

do... while
Sintaxe:
do
bloco de instruções
while(<condição lógica>);

Como funciona:

O bloco de instruções será executado enquanto a condição lógica for verdadeira, porém essa
estrutura garante que pelo menos uma vez o bloco de instruções será executado, ou seja, assim
que o compilador executa a instrução do while o bloco de instruções será executado
independente da condição lógica.

#include <stdio.h>
int main(){
int a = 0;
do{
printf("Fui executado\n");
a++;
}while (a < 10);
return 0;
}

Exemplo:

Instruções de seleção
As estruturas de seleção, são construtos da linguagem C que executam uma certa instrução, ou
um bloco de códigos a partir de um teste lógico.

São elas:

switch if else
As estruturas de desvio if e else, também são chamadas de estruturas de decisão, pois depende
de um teste lógico.

if
Sintaxe:
if (<condição lógica>)
bloco de instruções

Como funciona:

O if é uma instrução de desvio condicional, isso significa que o bloco de instruções será
executado somente se a condição lógica for verdadeira, se falsa é executada a próxima
instrução depois do bloco de instrução.

#include <stdio.h>
int main(){
if(1<2){
printf("Vou ser executado\n");
}
return 0;
}

Exemplo:

else
Sintaxe:
if (<condição lógica>)
bloco de instruções
else
bloco de instruções

Como funciona:

A instrução else trabalha em conjunto com a instrução if, a condição lógica nessa estrutura
quando falsa, não faz ser executada a próxima instrução depois do if, e sim o bloco de instruções
associado ao else.

Exemplo:

#include <stdio.h>
int main(){
if(1<2){
printf("Vou ser executado\n");
}else{
printf("Não vou ser executado\n");
}
return 0;
}
else if
Sintaxe:
if (<condição lógica>)
bloco de instruções
else if(<condição lógica>)
bloco de instruções
...
[estrutura else]

Como funciona:

A instrução else if trabalha em conjunto com a instrução if, se a primeira condição lógica for
falsa, então a próxima condição lógica é testada, se verdadeira o bloco associado a esse if é
executado.

Nesse tipo de estruturas você pode aninhar vários else if e opcionalmente pode colocar uma
estrutura else final.

Exemplo:

#include <stdio.h>
int main(){
int a = 2;
if(a==1){
printf("Não vou ser executado\n");
}else if(a==2){
printf("Vou ser executado\n");
}
return 0;
}

switch
Sintaxe:
switch (<expressão avaliada em inteiro>){
case <constante inteira>:
bloco de intruções
[break]
...
[ default :
bloco de intruções ]
}

Como funciona:

O switch desvia o fluxo de execução para um rótulo baseando-se na expressão que o

compilador avalia dentro do construto switch, já os case são constantes inteiras que o marcam
um ponto onde será desviado o fluxo para essa constante específica, somente se essa
expressão for igual a constante inteira desse rótulo.
As instruções break são opcionais e servem para desviar para a próxima instrução depois da
estrutura switch, e o rótulo default é um desvio que acontece caso nenhuma expressão seja
igual a alguma constante inteira.

Exemplo:

#include <stdio.h>
int main(){
int a = 2;
switch(a){
case 1:
printf("Não vou ser executado\n");
break;
case 2:
printf("Vou ser executado\n");
break;
case 3:
printf("Não vou ser executado\n");
break;
}
return 0;
}

Instruções de desvio
Um programa em C tem sua execução sequencial, isso significa que cada linha é executada
uma por vez e em sequência — uma após a outra.

Porém a linguagem apresenta instruções que podem alterar esse fluxo, as quais são listadas
abaixo.

goto break
continue return

goto
Sintaxe:
goto <rótulo>;

Como funciona:

A instrução goto faz um jump — desvio —, incondicional até a próxima instrução para ser
executada, onde se encontra a instrução que é determinada pelo rótulo.

Essa instrução pode desviar para qualquer posição dentro do escopo da função a qual
pertence, não podendo desviar para fora do escopo da função, porém pode desviar para fora
do escopo de bloco que a envolve; o rótulo pode ser definido antes ou depois da instrução
goto.
Exemplo:

#include <stdio.h>
int main(){
int a = 0;
loop: if(a<2){
printf("Oi\n");
a++;
goto loop;
}
return 0;
}

break
Sintaxe:
estrutura de iteração | estrutura switch
bloco de instruções com o comando break

Como funciona:

O break dentro de uma estrutura de iteração, faz o desvio para a próxima instrução após a
instrução associada a estrutura de iteração, sem a necessidade do teste lógico, ignorando as
próximas instruções, caso houver, que aparecem depois da instrução break.

O break também pode ser usado dentro de uma estrutura switch, para sair da mesma.

Exemplo:

#include <stdio.h>
int main(){
for(int a = 0 ; a < 10 ; a++){
printf("Fui executado somente uma vez\n");
break;
printf("Não fui executado\n");
}
return 0;
}

continue
Sintaxe:
estrutura de iteração | estrutura switch
bloco de instruções com o comando continue

Como funciona:

O continue dentro de uma estrutura de iteração, faz um desvio para o início dessa estrutura,
ignorando as próximas instruções depois do continue caso houver; após o desvio, o incremento
— caso seja uma estrutura for — e a condição lógica são novamente testadas e executadas.
Exemplo:

#include <stdio.h>
int main(){
for(int a = 0 ; a < 10 ; a++){
printf("Fui executado varias vezes\n");
continue;
printf("Não fui executado\n");
}
return 0;
}

return
Sintaxe:
return [valor a ser retornado]

Como funciona:

Só pode ser utilizado dentro do escopo da função, e desvia o fluxo para a próxima instrução
depois da chamada da função, podendo a função retornar ou não um valor.

Instruções miscelâneas
_Static_assert
Instrução introduzida no C11 com a finalidade de fazer um teste de asserções em tempo de
compilação.
Sintaxe: _Static_assert(interger expression, string);

A expressão a ser avaliada deve ser uma constante inteira, e caso a mesma seja avaliada em
falsa, um erro de compilação é gerado com a mensagem indicada pela string e a compilação
interrompida, caso contrário, nada ocorre e a instrução de asserção é ignorada.

A partir do C23 a string é opcional.

Sintaxe: _Static_assert(interger expression);

Uso de asserções.

int main(){
_Static_assert(1!=2, "Essa asserção não causa erro, pois 1 é diferente de 2");
_Static_assert(1==2, "Já essa gera um erro, pois 1 não é igual a 2");
return 0;
}

Essa instrução funciona de forma semelhante a função-macro assert da biblioteca <assert.h>.

Para mais sobre asserções: BIBLIOTECA <assert.h>

Atributos
Atributos é uma sintaxe unificada para extensões da linguagem, é um conceito implementation-
defined behavior, e foi definido a partir do C23.

Um atributo pode ser usado em quase qualquer lugar de um código, e possui a seguinte sintaxe:
Sintaxe: [[ attribute-list ]]

Onde attribute-list pode ser separado por vírgula para especificar mais de um, e deve ser um
atributo com uma das seguintes sintaxes:
[[standard-attribute]]
[[standard-attribute ( argument-list )]]
[[attribute-prefix :: identifier]]
[[attribute-prefix :: identifier ( argument-list )]]

Onde as duas primeiras sintaxes dizem respeitos a atributos especificados pela padronização, e
as duas últimas sintaxes, são atributos definidos pela implementação.

Apesar da padronizar documentar alguns atributos, se a padronização implementa ou não

esses atributos são opcionais.

Segue uma lista de atributos padronizados.

Token Atributo Valor

deprecated [[deprecated]] 201904L
fallthrough [[fallthrough]] 201904L
maybe_unused [[maybe_unused]] 201904L
nodiscard [[nodiscard]] 202003L
noreturn [[noreturn]] 202202L
_Noreturn – Depreciado no C23 [[_Noreturn]] – Depreciado no C23 202202L
unsequenced [[unsequenced]] 202207L
reproducible [[reproducible]] 202207L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Atributo Descrição Onde aplicar

[[deprecated]] Indica que o uso da entidade é
Declarações variadas
[[deprecated("reason")]] permitido, mas desencorajado.
Indica que o fallthrough de um case
[[fallthrough]] Dentro de uma estrutura switch
é intencional.
Encoraja o compilador a lançar Declaração de funções, ou
[[nodiscard]]
um warning se o valor de retorno definições de estruturas, uniões
[[nodiscard("reason")]]
é descartado. ou enumerações
Suprime os warning em
[[maybe_unused]] Declarações variadas
entidades não usadas
Indica que a função não faz
[[noreturn]] Declarações de funções
executa seu retorno de fluxo
Indica que a função não faz
[[_Noreturn]] Declarações de funções
executa seu retorno de fluxo
Indica que a função é Declarações de funções e
[[unsequenced]]
candidata para otimizações ponteiros para funções
Indica que a função sempre Declarações de funções e
[[reproducible]]
retornará o mesmo valor ponteiros para funções
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Todos os nomes dos atributos padrões possuem a forma alternativa: __attr__
Caso um token de atributo não seja suportado, o mesmo é ignorado pela implementação.

Os tokens de atributos podem ser usados com o operador do contexto do pré-processador

__has_c_attribute, para um teste de checagem para os atributos.
 Anotação 5: Expressões
Expressões em C podem ser definidas como uma oração que é avaliada para um resultado
com um tipo e um valor, sendo o resultado dependente da expressão avaliada.

Essas expressões podem ser compostas por um ou mais operandos (variáveis, literais, retornos de
funções ou outras expressões) e podem ter ou não um ou mais operadores (aritméticos,
relacionais, entre outros) — os operadores usados sozinhos não formam uma expressão, pois o
cerne da expressão são os operandos.

Apesar das expressões poderem ser construídas com um ou mais tokens, elas só podem ser
avaliadas para um único valor e tipo.

A ordem em que as expressões são avaliadas depende de como são escritas e de seus
operadores, pois são avaliadas pela sua ordem de associação e de precedência.

Uma expressão sem operadores também é válida, podendo por exemplo ser: uma variável, uma
chamada de função ou qualquer rvalue, como um literal.

Toda expressão pode ser classificada em: lvalue, rvalue ou fuction designator.

lvalue, rvalue e function desginator

Coloquialmente falando, uma expressão lvalue é qualquer expressão que pode aparecer do
lado esquerdo do operador de atribuição, apesar dessa definição legado, os lvalues são
melhores definidos como objetos que podem possuir um identificador, ou possuem um
endereço — exceto quando o objeto é um bit-field ou seja qualificado com a palavra-chave
register. Como sendo objetos, os valores dos lvalues podem ser modificados, com algumas
exceções, por exemplo um objeto qualificado com a palavra-chave const ou constexpr, ou um
compound literal. Para isso foi adotado a terminologia modifiable lvalue, para objetos lvalues
que podem ter seus valores alterados — a padronização sugere o termo object locator value.

Qualquer expressão que não seja um lvalue, logo é um non-lvalue, coloquialmente conhecido
como rvalue, sendo esse último constituído geralmente por constantes e operações com as
mesmas.

Todo lvalue pode ser usado no lugar de um rvalue, mas não o contrário.
Sintaxe: lvalue = rvalue; lvalue = lvalue;

Function designator é o identificador de uma função depois da mesma ser declarada e

definida, todo function designator irá ser avaliado em um rvalue que constitui no endereço da
função, logo será do tipo de um ponteiro para função.
void func(){ ; }
func

O identificador func acima será avaliado para o tipo: void (*)().

Constante
Constantes são valores que não permitem ser alterados, a linguagem C trabalha com
constantes conhecidas em tempo de compilação, fazendo nesse caso que o compilador possa
saber qual é o valor representado antes do programa começar a ser executado. Uma expressão
formada somente por constantes é chamada de constant expression.
Na linguagem C são consideradas constantes:

• Literais

• Resultado do operador sizeof.

• Resultado do operador _Alignof.

• Uma constante de enumeração – enumerator.

• Resultado do operador de coerção quando usado com outras constantes.

• Uma constante macro.

Variáveis qualificadas com a palavra-chave: const, não são por definição constantes em tempo
de compilação, e sim, constante em tempo de execução, e operações com as mesmas não
são consideradas constant expression. Porém a partir do C23 variáveis podem ser consideradas
constantes em tempo de compilação quando modificadas com a palavra-chave constexpr, e
por ventura, são consideradas constat expression.

Expressão constante inteira

Uma expressão constante inteira é uma expressão que consiste somente em constantes inteiras,
permitindo assim que o valor da expressão seja conhecido durante o tempo de compilação,
mas principalmente, seja avaliada em um inteiro.

Ela é usada para:

• O tamanho de uma array.

• O valor de uma enumeração.

• O tamanho de um campo de bit — bit-field.

• O alinhamento de um objeto usando o _Alignas (C11).

• O valor de uma constante case em um switch.

Expressões verdadeiras e falsas

No C pré C23, não existia constantes para verdadeiro e falso, para representar esses valores era
utilizados o valor zero para falso, e qualquer valor avaliado em não-zero para verdadeiro.
Geralmente eram os valores 0 e 1 para falso e verdadeiro respectivamente.

A parti do C23, houve a adição das palavras chaves true e false, que representam os valores
de verdadeiro e falso respectivamente, eliminado a necessidade dos conceitos de zero e não-
zero.

Expressões void
É possível fazer uma coerção de qualquer expressão para void, fazendo assim que seu resultado
seja descartado.
Exemplo: (void) (1+2);
Expressões _Generic
A partir do C11 é possível controla o valor em que uma expressão será avaliada a partir de seu
tipo.

Usa-se a palavra-chave _Generic.

Sintaxe: _Generic(expressão, tipo: valor [, tipo: valor]);

Essa expressão _Generic é avaliada em tempo de compilação, sendo o valor retornado

baseado no tipo da expressão, é também possível usar um “tipo” default, caso nenhuma
correspondência seja encontrada.
Sintaxe: _Generic(expressão, tipo: valor, default: valor);

Valores escalares e agregados

Expressões escalares são aquelas expressões que são avaliadas em somente um valor.

Expressões agregadas são avaliadas em vários valores.

Os tipos são escalares são:

• Os tipos primitivos.

• Enumerações.

• Ponteiros.

• Literais.

• Expressões avaliadas em verdadeiro ou falso.

Os tipos são escalares são:

• Estruturas.

• Uniões

• Coleções.

Coerções implícitas
Quando uma expressão em C usa valores de tipos diferentes, porém compatíveis entre si, o
compilador C tenta fazer uma coerção implícita entre os tipos.

Tipos aritméticos
A coerção entre tipos aritméticos é dependente de seus rankings, o compilador sempre fará a
coerção para o tipo de mais alto ranking na expressão.

Segue o ranking abaixo:

_Bool < char < short < int < long < long long < float < float _Imaginary < float _Complex < double
< double _Imaginary < double _Complex < long double < long double _Imaginary < long
double _Complex < _Decimal32 < _Decimal64 < _Decimal126

Exemplo: numa expressão de adição entre um int e um float, devido ao float ter um ranking mais
alto que o int, o resultado da expressão será do tipo float.

Ressalta-se que:

• O tipo float tem um ranking maior que qualquer inteiro.

• O tipo _Decimal32 tem um ranking maior que qualquer inteiro ou ponto flutuante binário.

• Tipos signed tem o mesmo ranking que o unsigned do mesmo tipo.

• Os rankings do tipo _BitInt vai depender de quantos bits o mesmo comporta. Isso se aplica
quando um _BitInt é usado tanto com outro _BingInt, quanto usado com um inteiro
qualquer da linguagem, nesses casos os tamanhos dos bits dos tipos são comparados,
tendo maior ranking aquele que tiver maior tamanho de bits.

Integer promotion
Toda expressão que usar um valor de um tipo possuindo um ranking menor que o tipo int, o
compilador durante a avaliação da expressão tentará converter implicitamente esse valor para
o tipo int que represente o valor dessa expressão. Nesse caso os tipos: _Bool, char, short e _BitInt
com o tamanho de bits menores que int,

Caso o valor não seja capaz de ser representado em um int então a expressão é convertida
para unsigned int.

Ponteiros
Um ponteiro do tipo void é convertido implicitamente para o tipo alvo, desde que o tipo alvo
também seja um tipo ponteiro qualquer.

O contrário também ocorre; um ponteiro void pode apontar para qualquer outro tipo ponteiro.

Logo coerções implícitas entre ponteiros, ocorre somente se alguns dos envolvidos forem do tipo
void.
 Anotação 6: Funções
Funções são um conjunto de instruções, que são executadas mediante a uma chamada de
função, elas devem retornar um valor, no caso de não retornarem nenhum valor o seu retorno
é do tipo void, e podem ter ou não parâmetros.

Declaração
Assim como as variáveis, as funções são chamadas através de um identificador, e para isso
devemos declarar esse identificador através de uma declaração. Para declarar uma função
usa a sintaxe abaixo.
Sintaxe: tipo nome();

Sendo que a definição da função, ou alocação, deve existir para a mesma ser chamada. Para
definir uma função usa a sintaxe abaixo:
Sintaxe: tipo nome ([parâmetros]){ instruções };

Uma função pode ser declarada/definida juntamente com a palavra-chave static, mudando
assim a ligação da função de externa para interna.

A definição de uma função pode ser usada como sua declaração ou prototipação, devendo
aparecer antes da mesma ser utilizada.

Quando a função não é devidamente declarada, ocorre então uma declaração implícita.

O suporte para declarações implícitas de funções foi removido na padronização C99.

K&R style – Funções

Antes da primeira padronização da linguagem C as sintaxes para a definições de funções eram
diferentes, mais especificamente a definições de seus parâmetros formais.
Sintaxe: tipo nome ([parâmetros sem um tipo])[tipo];{intruções}

Alguns compiladores ainda suportam essa sintaxe para modo de portabilidade, porém a partir
da padronização C23 essa sintaxe foi removida.

Exemplo:

int foo(s, f, b)
char* s;
float f;
struct Baz * b;
{
return 5;
}

Parâmetros
Os parâmetros de uma função são variáveis locais ordinárias com um escopo de função, e são
atribuídas a um valor durante a chamada de função, através dos argumentos.
Como qualquer variável local, a declaração dos parâmetros ocorre seguindo as mesmas regras
de declarações de variáveis comum, com a exceção que cada variáveis é separada por
virgula, e sua declaração de tipo não pode ser encadeada.
Sintaxe: type name, type name2...

A partir do C23 foi permitido o uso de parâmetros sem nome durante uma definição de função.
Sintaxe: void func(int, int){}

Por questões semânticas o parâmetro não nomeado não pode ser acesso dentro da função.

Protótipos de funções
Para uma função ser chamada ela deve ser anteriormente declarada, lembrando que, antes
da padronização C ANSI, a linguagem C não tinha checagem de passagem de argumentos
para as funções.

Para resolver esse problema foi implementados protótipos, um mecanismo que atua como uma
declaração, que informa para o compilador a quantidade e os tipos dos parâmetros de uma
função.
Sintaxe: type func([[type [name]] [, type [name]]]);

A prototipação ocorre durante a declaração de uma função, e foi implementado no C89.

Para informa o compilador que a função não recebe argumentos deve-se usar a palavra-chave
void na prototipação, sem seu uso, o compilador entende que não houver prototipação,
fazendo assim a não checagem dos parâmetros, ou seja, não havendo prototipação, somente
uma declaração.
Sintaxe: type func(); // sem prototipação
Sintaxe: type func(void); //com prototipação

Porém no C23 esse comportamento foi alterando, sendo uma lista de parâmetros vazias, tratada
da mesma forma que declarada com a palavra-chave void; sendo assim, os exemplos acima
são equivalentes a partir do C23.

Função main
A função main() é a porta de entrada do seu programa, e todo programa padrão C deve
defini-la.

Porém em um sistema embarcado por exemplo, a função a qual será executada primeira
depende da implementação.

Parâmetros de main
O padrão C define dois parâmetros para a função main(), cujo os valores dos mesmos serão
passados pelo sistema operacional.
Sintaxe: int main(int argc, char *argv[]);

Esses parâmetros são usados para linha de comando, o argc indica quantos argumentos foram
passados por CLI, e o array de ponteiros argv aponta para as strings passadas pelo CLI.
Ao menos um argumento será sempre passado por CLI para main(), sendo esse o nome da
aplicação usada no CLI.

Apresar de não ser padronizado, e por razões históricas, alguns compiladores suportam um
terceiro parâmetro: char *envp[], um array que contém strings das variáveis de ambiente no
formato: variavel=valor.

Linkage de uma função

Por padrão todas as funções tem uma ligação externa, portanto, são visíveis fora de seu módulo,
para alterar esse comportamento usa-se a palavra-chave static, fazendo assim uma ligação
interna.

Toda função é implicitamente declarada através de sua prototipação com a classe de

armazenamento extern, sendo redundante declarar a mesma sendo extern.

Implicit int
Antes da padronização C ANSI, não existia o tipo void, devido a isso as funções “voids” eram
escritas sem um tipo de retorno e não possuíam uma instrução de retorno, para assim
especificarem que não retornavam nada.

Porém, mesmo assim a função retornava um inteiro com lixo de memória, esse inteiro ficou
conhecido como implicit int.

Devido a isso, quando uma função é chamada sem ter sido previamente declarada, o
compilador supõe que ela retorna um int, isso também faz parte do implicit int.

A partir do C99, o C não tem mais suporte ao implicit int.

Funções _Noreturn
A palavra-chave _Noreturn introduzida no C11, e depreciada no C23, serve para informa ao
compilador que a função declarada não tem e nem faz um retorno — não tem instrução return
e não completa seu bloco de código —, podendo encerrar o programa de uma maneira
abrupta.

Isso faz com que o compilador otimize sua chamada, e não faz o push de seu endereço de
retorno na stack.

Uma função declarada como _Noreturn caso retorne, tem seu comportamento como
undefined behavior.
Sintaxe: _Noreturn void func-name([args]);

Uma função _Noreturn deve ser declarada como sendo void.

A partir do C23 esse especificador foi depreciado, devendo ser utilizado o atributo [[noreturn]]
em seu lugar.

Funções inline
A palavra-chave inline introduzida no C99, serve como uma requisição ao compilador que
expanda a função declarada com essa palavra-chave na linha em que ela é chamada.

Como é uma requisição, significa que a mesma talvez não seja atendida, sendo o
comportamento esperado que a chamada da função seja otimizada.
Sintaxe: inline type func-name([args]);

Teoricamente uma função inline não tem um bloco de código associado na memória, sendo
assim seu endereço não pode ser extraído, porém caso seu endereço tente ser capturado, o
compilador irá gerar uma função non-inline.

Geralmente funções inline não aparecem na depuração do código.

Por padrão elas tem um escopo de arquivo com ligação interna, sendo necessário o uso da
palavra-chave extern caso seja desejada uma ligação externa da função, porém seu uso com
ligação externa e desencorajado.

Argumentos variáveis
Usa-se a elipse depois de no mínimo um argumento nomeado, para informar ao compilador
que a função tem uma lista de argumentos variáveis.
Sintaxe: type func-name(type arg, ...);

Usa-se três macros, quatros a partir do C99, juntamente com um tipo typedef, todos declarados
em stdarg.h, para manipulação da lista argumentos variádicos.

Identificador Tipo
va_type typedef
va_start Function-macro
va_arg Function-macro
va_end Function-macro
va_copy Function-macro
Padronização K&R C89 C90 C95 C99 C11 C17 C23

va_type: O tipo de dado que irá receber a lista.

void va_start(va_list arg, param): arg será inicializada como sendo uma lista dos argumentos
opcionais, e param deve ser o último argumento fixo da função.

type va_arg(va_list arg, type): Faz um operação de pop da lista de argumentos opcionais, e
executa um casting de acordo o tipo informado, retornando assim o tipo especificado no
casting.

void va_end(va_list arg): Libera os recursos de arg.

void va_copy(va_list dest, va_list src): Copia uma lista da origem para o destino. A lista é copiada
a partir do argumento referenciado por src, e todos as operações de pop da lista de origem
constam na lista de destino. Esse macro foi introduzido no C99.
 Anotação 7: Outros Tipos
Juntamente com os tipos escalares primitivos, há também outros tipos escalares que possuem
uma semântica mais complexas, são eles: ponteiros e enumerações.

Fora os tipos escalares da linguagem C há também os tipos agregados, eles são tipos que
funcionam como uma coleção sequencial ou indexados de dados, e aceitam mais de um único
valor.

A linguagem C define três tipos agregados: coleções, estruturas e uniões.

Arrays
Os arranjos são uma coleção de dados que são alocados sequencialmente na memória
principal. Possuem um tipo de dado base, o qual será o tipo de seus elementos, e possuem uma
expressão a qual será avaliada para o tamanho de sua alocação.
Sintaxe: tipo identificador [tamanho];

Seus elementos são acessados através do operador de subscrito, utilizado índices.

Sintaxe: array-name [index];

O primeiro elemento do array é acessado com um índice de valor zero, logo o intervalo dos
índices é: de 0 a tamanho-1.

Eles são inicializados através de uma lista de inicializadores, sendo que cada inicializador é
separado por uma vírgula.
Sintaxe: tipo identificador [tamanho] = {lista};

Arrays multidimensionais
Para declara arrays multidimensionais declara-se uma nova dimensão com o tamanho
escolhido.
Sintaxe: tipo identificador [tamanho] [tamanho] [[tamanho]...];

Para acessar os valores desse array multidimensional, a operação de subscrito é feita n vezes,
de acordo com quantas dimensões tem o array.
Sintaxe: array-name [index][index];

Sua inicialização, pode ser organizada em uma lista contendo outras lista, também de acordo
com as dimensões do array.
Sintaxe: tipo identificador [tamanho][tamanho] = {{lista}{lista} ... };

Arrays incompletos
É possível especificar um array sem tamanho definido, a linguagem C define seu tamanho
através de seu inicializador.
Sintaxe: tipo identificador [] = {initializers};

Para arrays multidimensionais, a dimensão mais à esquerda é que deve ficar sem um tamanho
definido, pois assim a linguagem C o indexa de maneira correta.
Sintaxe: tipo identificador [] [tamanho] = {initializers};
Variable-length array
Antes do C99 o tamanho do array deveria ser uma constante inteira, a partir do C99, pode-se
usar variáveis/expressões para definir o tamanho de um array.
Sintaxe: tipo identificador [var];

Isso traz algumas restrições quanto ao VLA, sendo que o mesmo deve por obrigação ter um
alocamento automático, e não deve ser inicializado quando definido.

Apesar da implementação do VLA ser obrigatória no C99, a partir do C11 se tornou um

mecanismo opcional da linguagem.

Arrays como parâmetros formais

Quando um array é definido como parâmetro formal de uma função, o mesmo é internamente
manipulado como um ponteiro do tipo base do array, e não como um tipo array, todas as
operações para esse parâmetro são feitas em um ponteiro.

A parti do C99 quando um array for um parâmetro formal de uma função é possível qualificar o
ponteiro desse array através dos usos dos qualificadores de tipos: const, volatile e restrict; e da
classe de armazenamento static; essas palavras-chave devem ser usadas dentro dos colchetes.
Sintaxe: void func(int array[restrict 10]);

O uso do static, serve para qualificar um ponteiro que aponta para no mínimo n elementos.

O tamanho do array quando qualificado é opcional, porém obrigatório com o uso de static.

É possível utilizar um asterisco em vez do tamanho de um array, quando o mesmo for um

parâmetro do tipo variable-length array numa função. Isso é possível somente para protótipos
de função, e somente a partir do C99;
Sintaxe: void func(int array[*]);

Structs
Estruturas são uma coleção de dados de diferentes tipos. Na linguagem C primeiro é declarado
o tipo dessa estrutura com a palavra-chave struct para depois aloca-la.
Sintaxe: struct tag {dados}[alocação];

Essa declaração server para criar um novo tipo de dados na linguagem C.

Para criar uma variável desse novo tipo usa-se a sintaxe abaixo.
Sintaxe: struct tag var;

Para inicializar o novo tipo a inicialização por lista é usada, porém cada inicializador será usado
na ordem em que os dados aparecem durante a declaração dos tipos.
Sintaxe: struct tag var = {initializers};

Structs incompletas
Pode-se declara uma estrutura incompleta sem a definição de seus dados, porém para a
estrutura ser alocada com sucesso, os mesmos devem ser definidos depois.
Exemplo:
struct b;
struct a {struct b * ptr; /* ... */};
struct b {struct a * ptr; /* ... */};

Operador ponto e operador seta

Para acessar uma estrutura a partir de uma alocação estática usa o operador ponto (.).
Sintaxe: [Link];

Para acessar uma estrutura a partir de um ponteiro usa o operador seta (->).
Sintaxe: var->elem;

O operador seta faz implicitamente um derreferência no ponteiro pra a estrutura, sendo

equivalente a:
Sintaxe: *(var).elem;

Flexible array na struct

A partir do C99 é possível declara um array incompleto dentro de uma estrutura para uso em
uma alocação dinâmica, o array incompleto deve aparecer como último membro da estrutura
depois de no mínimo um membro completo.

Caso a estrutura seja alocada estaticamente ou automaticamente, o array não é alocado, pois
seu tamanho é desconhecido.

Na alocação dinâmica deve-se incluir um tamanho extra para o array.

Exemplo com declaração e alocação:

struct s{int a; int b; int arr[];};
malloc(sizeof(struct s) + sizeof(int)*5);

Union
Uniões são estruturas cujo os dados são compartilhados dentro do mesmo espaço de alocação.
Sintaxe: union tag {dados}[alocação];

As mesmas operações e aspectos válidos para estruturas, são válidos também para uniões,
exceto o membro de array flexível.

Bit-fields
São estruturas ou uniões com membros do tipo int ou unsigned int — isso inclui todos os
modificadores de tipos para int — com a possibilidade do programador especificar quantos bits
cada membro terá de tamanho.

Sendo que o tamanho não pode exceder o tamanho do tipo base.

Sintaxe: struct tag {tipo : tamanho ... }[alocação];

As operações em bit-fields são as mesmas operações para estruturas e uniões.

Observe que estruturas e uniões com membros do tipo _BitInt, tipo existente a partir do C23, não
são consideradas campos de bits.

Inicialização
Inicializador lista
Para inicializar um tipo agregado — arrys, estruturas e uniões —, usa-se uma lista de dados
separada por virgulas, é possível aninha listas para arrays multidimensionais ou estrutura ou
uniões alinhadas.
Sintaxe: { [dados...] };

Caso a lista esteja vazia, o tipo agregado é inicializado a zero. Essa inicialização não é a mesma
que a inicialização vazia existente a partir do C23, e em padronizações pré C23 são permitidas
somente a tipos agregados.

Inicializador especifico
A partir do C99 é possível inicializar membros específicos de um tipo agregado, sem a
necessidade de inicializa-los sequencialmente.
Sintaxe array: { [index] = inicializador ...};
Sintaxe struct, union e bit-fields: { .membro = inicializador...};

Structs e unions anônimas

A partir do C11 é possível definir uma estrutura ou união anônima como membro de outra
estrutura ou união.

Para defini-las como anônimas basta omitir a tag de identificação.

Os membros anônimos serão acessados como um membro comum dentro escopo do tipo
agregado associado. Essa definição serve primeiramente para métodos de organização.
Sintaxe: struct tag{ struct {dados}; ...}

Enumerações
A partir do C ANSI foi introduzido o tipo escalar enum, como o próprio nome aponta ele serve
para prover uma interface de enumerações de inteiros, declarado um novo tipo.
Sintaxe: enum tag { constantes }[alocação];

A constantes são identificadores definidos pelo usuário e são trazidas automaticamente para o
escopo em que elas aparecem, e são usadas como valores para os tipos dessa enumeração.

Por padrão as constantes são inteiros e iniciam com o valor de zero, sendo incrementadas com
o valor de mais um a cada constante.

Esse comportamento pode ser alterado com a seguinte sintaxe:

enum tag { constante = valor [, constante = valor] }[alocação];

O valor deve ser uma constante inteira, e as próximas constantes, se alguma, continuam a serem
incrementadas com mais um.
Enumerações são definidas em tempo de compilação, e podem ser usadas em um construto
switch por exemplo, sendo intercambiáveis com o tipo int.

Enumerações no C23
A partir do C23 enumerações podem explicitamente declarar o tipo base de seu tipo, através
da seguinte sintaxe:
Sintaxe: enum tag : type { constantes }[alocação];

Declaração typedef
Uma declaração typedef inicia com a palavra-chave typedef, seguido por uma sintaxe normal
de declaração de um objeto ou função, exceto pelo uso não permitido de classes de
armazenamento ou o especificador _Alignas e inicializadores.

Cada declaração typedef define um identificador como um sinônimo para um tipo especifico.

Sem a palavra-chave typedef, a mesma sintaxe iria declarar um objeto ou função do tipo dado.

Compound Literals
Literais compostos foi um novo aspecto introduzido no C99.

Essa característica permite definir objetos de qualquer tipo agregados, em tempo de execução
ou em tempo de compilação.
Sintaxe: (tipo-agregado) {lista de valores};

Se usados dentro de um escopo global tem uma alocação estática e só podem ter valores
imediato para alocação, caso sejam alocados dentro de um escopo de bloco, irá possuir uma
alocação automática. Literais compostos são objetos não nomeados, logo não possuem
identificadores para um acesso.

Ponteiros
Ponteiros são um tipo de dado escalar da linguagem C, eles representam um objeto capaz de
armazenar um endereço arbitrário da memória principal.

São declarados através da seguinte sintaxe:

Sintaxe: type * name;

O tipo base de um ponteiro define como o dado a ele associado será representado.

Inicialização
A inicialização de um ponteiro é somente feita através a associação de um endereço da
memória com o ponteiro a ser inicializado. Para recuperar esse endereço usa-se outro ponteiro
ou uma operação de referência de um objeto através do operador de endereço: &.
Sintaxe: type * name = ptr;
Sintaxe: type * name = &obj;
O inicializador usado deve ser compatível com o tipo base do ponteiro, caso contrário uma
coerção explicita deve ser necessária, exceto para ponteiros do tipo void.

Qualificação do ponteiro
Um ponteiro, como representa um tipo qualquer, o mesmo pode ser qualificado, para isso
ocorre, o qualificador deve aparecer entre o asterisco e o nome do ponteiro, caso contrario a
qualificação se aplica para o objeto que o ponteiro aponta, e não para o ponteiro em si.
Exemplo: char * const p;

O exemplo acima apresenta um ponteiro const para um objeto do tipo char.

Existe um qualificador exclusivo para ponteiros: restric.

 Anotação 8: Pré-processador
Na linguagem C, você pode informa várias instruções para o pré-processador, essas instruções
são executadas antes do arquivo fonte ser passado para o compilador.

Diretivas
As instruções do pré-processador são chamadas de diretivas e devem começar com o
caractere cerquilha (#) e terminam com um caractere de nova linha, porém podem ser
estendidas com o uso do caractere de continuação de linha (\).

Cada diretiva deve estar em sua própria linha.

Podem ser antecedidas somente pelos caracteres de espaço e tabulação.

Segue abaixo uma tabela com as diretivas.

#define #endif #ifdef #line

#elif #error #ifndef #pragma
#else #if #include #undef
#elifdef #elifndef #embed #warning
Padronização K&R C89 C90 C95 C99 C11 C17 C23

#define
Faz a definição de um macro, podendo o mesmo ser testado posteriormente.
Sintaxe: #define macro-name

Define um identificador como um macro name, cujo o mesmo será substituído por um macro
replacement.
Sintaxe: #define macro-name char-sequence

Funções macros
A diretiva #define também pode aceitar argumentos cujo serão substituídos de acordo como
o marco replacement.
Sintaxe: #define macro-name(arg) char-sequence-with-arg

Exemplo:

#include <stdio.h>
#define ABS(a) (a) < 0 ? -(a) : (a)
int main(void){
printf("abs de -1 e 1: %d %d", ABS(-1), ABS(1));
return 0;
}

Funções macros variádicas

Uma função macro pode receber uma lista de argumentos variáveis a partir da implementação
C99. Para informa que a função macro recebe uma lista de tamanho variável, usa-se a elipse.
Os argumentos passados serão identificados através do identificador de pré-processamento
chamado: __VA_ARGS__.
Sintaxe: #define macro-name(...) sequence-__VA_ARGS__

Exemplo

#include <stdio.h>
#define print(..) printf(__VA_ARGS__)
int main(void){
print("Index inicial: %d", 0);
return 0;
}

A partir do C23, dentro do contexto de funções macros variádicas, o identificador __VA_OPT__

foi adicionado ao ambiente de pré-processamento.

Esse identificador expando para nada, caso nenhum argumento tenha sido passado para a
função macro, porém caso haja algum argumento para a função macro, ele expande para o
argumento passado para o mesmo.
Sintaxe: #define macro-name(...) __VA_OPT__(arg)

Exemplo

#include <stdio.h>
#define print(s, ..) printf(s __VA_OPT__(,) __VA_ARGS__)
int main(void){
print("Index inicial: %d", 0);
return 0;
}

Nesse exemplo __VA_OPT__ irá expandir para o caractere (,), devido a existência de passagem de
argumentos para o macro print.

#error
Força o compilador a parar a compilação quando a diretiva é encontrada, mostrando a
mensagem diagnóstico.
Sintaxe: #error error-message

A mensagem não necessita estar entre aspas duplas, pois faz parte do contexto do pré-
processador, e um objeto não é alocado para conter a string.

#warning
Surgiu na implementação C23, funciona da mesma forma que #error, mostrando a mensagem
diagnóstico quando executada a diretiva, porém, diferente de #error, a compilação não é
suspensa.
Sintaxe: #warning error-message

A mensagem não necessita estar entre aspas duplas, pois faz parte do contexto do pré-
processador, e um objeto não é alocado para conter a string.
#include
Faz a leitura e inclusão do conteúdo de um arquivo. Geralmente esse conteúdo é originado de
arquivos de cabeçalhos.
Sintaxe: #include <source_file>
Sintaxe: #include “source_file”

Existe duas sintaxes, a primeira busca o arquivo no path da biblioteca padrão do compilador, a
segunda busca no diretório atual do arquivo de compilação ou no diretório path informado ao
compilador.

#embed
... TODO

#if, #else, #elif e #endif

Essas diretivas incluem uma porção de código baseando em uma condição verdadeira ou
falsa.

Sintaxe:
#if constant-expression
statement sequence
[#elif constant-expression]
<statement sequence>
[#elif constant-expression]
<statement sequence>
[#else constant-expression]
<statement sequence>
#endif

#ifdef e #ifndef
Inclui a porção de código somente se o macro foi definido anteriormente.

Sintaxe:
#ifdef macro-name
statement sequence
#endif

Inclui a porção de código somente se o macro não foi definido anteriormente.

Sintaxe:
#ifdef macro-name
statement sequence
#endif
#elifdef e #elifndef
Macro definidos somente a partir do C23.

Inclui a porção de código somente se o macro foi definido anteriormente, atua como um #elif
defined(macro).

Sintaxe:
#ifdef macro-name
statement sequence
#elifdef macro-name
statement sequence
#endif

Inclui a porção de código somente se o macro não foi definido anteriormente, atua como um
#elif !defined(macro).

Sintaxe:
#ifdef macro-name
statement sequence
#elifndef macro-name
statement sequence
#endif

#undef
Remove um macro definido anteriormente.
Sintaxe: #undef macro-name

#line
Muda o conteúdo dos macros pré-definidos __LINE__ e __FILE__ respectivamente.
Sintaxe: #line number "filename"

Sendo “filename” opcional.

O conteúdo padrão de __LINE__ é um inteiro representando a linha da atual da instrução.

O conteúdo padrão de __FILE__ é uma string contendo o nome da atual unidade de tradução.

#pragma
É uma diretiva implementation-defined que serve para passar instruções para a
implementação, uma diretiva pragma que não é reconhecida pela implementação é
ignorada.
Toda diretiva pragma possui um escopo associado a um bloco, no escopo global ela faz parte
do escopo da unidade de tradução, ela toma efeito até uma outra diretiva pragma
equivalente ser alcançada ou o escopo ser finalizado.
Sintaxe: #pragma directiva

A padronização C99 define 3 pragmas padrões, e o C23 define mais 2.

#pragma STDC FP_CONTRACT args

#pragma STDC FENV_ACCESS args
#pragma STDC CX_LIMITED_RANGE args
#pragma STDC FENV_DEC_ROUND dec-direction
#pragma STDC FENV_ROUND direction
Padronização K&R C89 C90 C95 C99 C11 C17 C23

• #pragma STDC FP_CONTRACT args

o Habilita ou desabilita expressões contratos. Essas expressões são expressões de

ponto flutuante avaliadas como sendo uma única expressão, logo são avaliadas
em uma única operação.

• #pragma STDC FENV_ACCESS args

o Habilita a manipulação e alteração do ambiente de ponto flutuante na biblioteca

<fenv.h>.

• #pragma STDC CX_LIMITED_RANGE args

o Quando habilitado, informa a implementação que a multiplicação, divisão, e o

valor absoluto de números complexos podem usar fórmulas matemáticas mais
simples.

• #pragma STDC FENV_DEC_ROUND dec-direction

o Altera a forma de como os pontos flutuantes decimais são arredondados.

o Essa pragma só deve ser usada se a implementação suporta pontos flutuantes

decimais.

• #pragma STDC FENV_ROUND direction

o Altera a forma de como os pontos flutuantes binários são arredondados.

Onde args:

ON OFF DEFAULT
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Onde dec-direction é um dos macros abaixo, definidos na biblioteca <fenv.h>:

FE_DEC_DOWNWARD FE_DEC_TONEAREST FE_DEC_TONEARESTFROMZERO

FE_DEC_TOWARDZERO FE_DEC_UPWARD FE_DEC_DYNAMIC
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Onde direction é um dos macros abaixo, definidos na biblioteca <fenv.h>:

FE_DOWNWARD FE_TONEAREST FE_TONEARESTFROMZERO

 FE_TOWARDZERO FE_UPWARD FE_DYNAMIC
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Fora da padronização do C, existe algumas pragmas não padronizadas, porém que são
suportadas pela maioria dos compiladores.

• #pragma once

• Família #pragma pack

o #pragma pack(arg)

o #pragma pack()

o #pragma pack(push)

o #pragma pack(push, arg)

o #pragma pack(pop)

Operadores
Os operadores de pré-processamento só podem aparecer no contexto do pré-processador.

defined
Um operador que testa se o macro foi ou não definido.
Sintaxe: defined macro-name

É usado em conjunção com #if e #elif.

## e #
São operadores utilizado com a diretiva #define, no contexto de funções macros.

# transforma o argumento que o sucede em uma string.

Exemplo:

#include <stdio.h>
#define mkstr(s) # s
int main(void){
printf(mkstr(I like C));
return 0;
}

## concatena dois tokens de uma função macro.

Exemplo:

#include <stdio.h>
#define concat(a, b) a ## b
int main(void){
int xz = 5;
printf("%d\n", concat(x,z));
return 0;
}

Alguns compiladores tem suporte ao operador #@, ele faz a mesma coisa que o operador #,
porém ao invés de transformar o argumento que o sucede em uma string com aspas duplas, o
transforma em um caractere, com o uso de aspas simples. Esse operador não é padronizado.

_Pragma
A partir do C99 foi adicionado o operador _Pragma, esse operador possui a seguinte sintaxe:
Sintaxe: _Pragma(“directive”)

O operador _Pragma funciona da mesma forma que a diretiva #pragma, ele foi adicionado
para poder ser usado em expansão de macros, sendo que o mesmo pode funcionar fora do
contexto do pré-processador.

__has_c_attribute
Sintaxe: __has_c_attribute(token)

Operador que surgiu no C23, ele verifica se o atributo nomeado pelo token está presente na
implementação. Deve ser usado nas diretivas #if e #elif, onde o resultado do operador irá
expandir para um constante inteira longa no formato de ano e mês. Esse operador pode ser
usado como teste de macro por #ifdef, #ifndef, #elifdef, #elifndef e defined, nesse caso o
resultado será tratado como uma checagem de definições de macros.
Exemplo: #if __has_c_attribute(deprecated)

__has_include
Sintaxe: __has_include(header)

Operador que surgiu no C23, ele verifica se o cabeçalho nomeado pelo header pode ser
incluído pela implementação. Deve ser usado nas diretivas #if e #elif, onde o resultado do
operador irá expandir para um constante inteira longa no formato de ano e mês. Esse operador
pode ser usado como teste de macro por #ifdef, #ifndef, #elifdef, #elifndef e defined, nesse
caso o resultado será tratado como uma checagem de definições de macros.
Exemplo: #if __has_include(<threads.h>)

A nomeação do header deve seguir as mesmas regras da diretiva #include, onde <sequence> indica
cabeçalhos padrões, e “sequence” indica cabeçalhos do usuário.

__has_embed
TODO

Os operadores __has_c_attribute, __has_include e __has_embed, podem ser usados como um

macro para checagem de existência dos mesmos, permitindo assim que padronizações pré C23
não faça uso deles.
Exemplo: #ifdef __has_c_attribute
Exemplo: #ifdef __has_include
Exemplo: #ifdef __has_embed

Macros predefinidos obrigatórios

__LINE__ __FILE__
__DATE__ __TIME__
__STDC__ __STDC_VERSION__
__STDC_HOSTED__ __STDC_UTF_16__
__STDC_UTF_32__
Padronização K&R C89 C90 C95 C99 C11 C17 C23

__LINE__ contém a atual linha de compilação.

__FILE__ o atual nome da unidade compilada.

__DATE__ a data em que a unidade foi compilada. Uma string com o formato: mm/dd/yy.

__TIME__ a hora em que a unidade foi compilada. Uma string com o formato: hh:mm:ss.

__STDC__ se definido como 1, o compilador está de acordo com os padrões da linguagem C.

__STDC_UTF_16__ se definido como 1, indica que o tipo char16_t são codificados como UTF-16.
Esse macro já existia como um macro opcional da padronização C11, porém a partir do C23
passou a ser obrigatório.

__STDC_UTF_32__ se definido como 1, indica que o tipo char32_t são codificados como UTF-32.
Esse macro já existia como um macro opcional da padronização C11, porém a partir do C23
passou a ser obrigatório.

__STDC_HOSTED__ se definido como 1 indica que a implementação é hospedada, e que dá

suporte a toda a biblioteca padrão necessária. Caso contrário, é definido como 0.

__STDC_VERSION__ define qual padrão o compilador segue, no formato de um inteiro longo:

yyyymmL onde yyyy é o ano e mm é o mês.

Esse macro pode ter os seguintes valores.

Valor Referente a:
199409L C95
199901L C99
201112L C11
201710L C17
202311L C23

Macros predefinidos não obrigatórios

Os macros listados abaixo não são obrigatórios, e se presente indicam que a implementação
tem suporte no que diz a descrição. São chamados de macros condicionais, pois suas presenças
indicam que tal característica associada está implementada.

__STDC_IEC_559_COMPLEX__ (Depreciado no
__STDC_IEC_559__ (Depreciado no C23)
C23)
__STDC_ISO_10646__ __STDC_MB_MIGHT_NEQ_WC__
__STDC_UTF_16__ (Obrigatória a partir do
__STDC_UTF_32__ (Obrigatória a partir do C23)
C23)
__STDC_ANALYZABLE__ __STDC_LIB_EXT1__
__STDC_NO_ATOMICS__ __STDC_NO_COMPLEX__
__STDC_NO_THREADS__ __STDC_NO_VLA__
__STDC_IEC_60559_BFP__ __STDC_IEC_60559_DFP__
__STDC_IEC_60559_COMPLEX__ __STDC_IEC_60559_TYPES__
Padronização K&R C89 C90 C95 C99 C11 C17 C23

__STDC_IEC_559__ definido como 1, indica que a implementação da aritmética de ponto

flutuante está conforme o padrão IEC 60559 e implementa o anexo F da padronização C —
Depreciado no C23.

__STDC_IEC_559_COMPLEX__ definido como 1, indica que a implementação tem suporte a tipos

imaginários: __Imaginary, e a aritmética de ponto flutuante complexos está conforme o padrão
IEC 60559, e que o compilador implementa o anexo G da padronização C99 — Depreciado no
C23.

__STDC_ISO_10646__ define que o tipo wchar_t segue o padrão ISSO/IEC 10646, no formato de
um inteiro longo. Esse macro é definido com o valor de: yyyymmL onde yyyy é o ano e mm é o
mês. Indica o ano da revisão Unicode.

__STDC_MB_MIGHT_NEQ_WC__ definido como 1, indica que na codificação para wchar_t, um

membro do conjunto de caracteres básico não precisa ter um valor de código igual ao valor
quando usado como caractere único em uma constante de caractere inteiro.

__STDC_UTF_16__ definido como 1, indica que o tipo char16_t são codificados como UTF-16. A
partir do C23 esse macro passa a ser obrigatório.

__STDC_UTF_32__ definido como 1, indica que o tipo char32_t são codificados como UTF-32. A
partir do C23 esse macro passa a ser obrigatório.

__STDC_ANALYZABLE__ definido como 1, indica que o a implementação suporta a análise de

erros em tempo de execução, especificado pelo anexo L do C11.

__STDC_LIB_EXT1__ definido com uma interface yyyymmL indica que a implementação suporta
a funções com bounds-checking, especificado no anexo K do C11.

__STDC_NO_ATOMICS__ definido como 1, indica que a implementação não suporta tipos e

funções de atômico, incluindo o qualificador _Atomic, e o cabeçalho stdatomic.h está ausente.

__STDC_NO_COMPLEX__ definido como 1, indica que a implementação não suporta a

aritmética de tipos complexos, incluído os tipos _Complex e _Imaginary, e o cabeçalho
complex.h está ausente.

__STDC_NO_THREADS__ definido como 1, indica que a implementação não suporta

multithreading. Estando o cabeçalho threads.h ausente.

__STDC_NO_VLA__ definido como 1, indica que a implementação não suporta arrays com
tamanho variável.
__STDC_IEC_60559_BFP__ definido com uma interface yyyymmL indica que a aritmética IEC
60559 é suportada para ponto flutuante binário, especificado no anexo F da padronização C23.
Esse macro substitui o macro __STDC_IEC_559__.

__STDC_IEC_60559_DFP__ definido com uma interface yyyymmL indica que a implementação

tem suporte para pontos flutuantes decimais, e a aritmética IEC 60559 é suportada para os
pontos flutuantes decimais, especificado no anexo F da padronização C23.

__STDC_IEC_60559_COMPLEX__ definido com uma interface yyyymmL indica que a

implementação tem suporte a tipos imaginários: __Imaginary, e a aritmética IEC 60559 é
suportada para números complexos e que o compilador implementa o anexo G da
padronização C23. Esse macro substitui o macro __STDC_IEC_559_COMPLEX__.

__STDC_IEC_60559_TYPES__ definido com uma interface yyyymmL indica que a implementação

está em conformação com o conteúdo do anexo H da padronização C23.

Observação
Uma implementação que define __STDC_NO_COMPLEX__ não deve definir
__STDC_IEC_559_COMPLEX__ ou __STDC_IEC_60559_COMPLEX__.
 Anotação 9: Entrada e Saída
A linguagem C não define nenhuma instrução nativa para entrada e saída de dados, em vez
disso, todas as operações de E/S geralmente são feitas através de funções definidas na
biblioteca padrão que se encontram no cabeçalho <stdio.h>. Essas mesmas funções utilizam as
chamadas de sistema do kernel do sistema operacional para implementar a entrada e saída
de dados.

Padrão vs E/S Unix

C foi originalmente implementado em um sistema Unix, assim as primeiras versões do C suportam
um conjunto de funções de E/S compatíveis com o Unix. Esse conjunto de funções de E/S às
vezes é chamado de sistema de E/S do tipo Unix ou sistema de E/S sem buffer. No entanto,
quando C foi padronizado, as funções do tipo Unix não foram incorporadas ao padrão,
principalmente por serem funções especificas as sistemas *nix.

Porém muitos compiladores ainda possuem um suporte para as funções de E/S do tipo Unix.

Ressaltando que a padronização POSIX, padroniza as funções de E/S do tipo Unix.

Macro de Teste
A partir do C23 a biblioteca <stdio.h> define um macro de teste, que expande para a atual
versão da biblioteca.

Macro Valor
__STDC_VERSION_STDIO_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Declarações em <stdio.h>
Segue abaixo uma tabela de referência de funções do cabeçalho <stdio.h>.

Nome Observação Protótipo

Acesso de arquivo
fopen FILE *fopen (const char *filename, const char *mode);
FILE *freopen(const char*filename, const char *mode,
freopen
FILE*stream );
fclose int fclose(FILE *stream );
fflush int fflush(FILE *stream );
setbuf void setbuf(FILE *stream, char *buffer );
setvbuf int setvbuf(FILE *stream, char *buffer, int mode, size_t size );
E/S
fread size_t fread(void *buffer, size_t size, size_t count, FILE *stream);
size_t fwrite(const void *buffer, size_t size, size count, FILE
fwrite
*stream );
E/S não formatado
Protótipo idêntico
getc int getc(FILE *stream);
a fgetc, pode ser
 implementada
como macro
Protótipo idêntico
fgetc int fgetc(FILE *stream);
a getc
Função
gets depreciada no C99 char *gets(char *str );
e removida no C11
fgets char *fgets(char *str, int length, FILE *stream);
Protótipo idêntico
a fputc, pode ser
putc int putc(int ch, FILE *stream);
implementada
como macro
Protótipo idêntico
fputc int fputc(int ch, FILE *stream);
a putc
puts int puts(const char *str );
fputs int fputs(const char *str, FILE *stream );
getchar int getchar(void);
putchar int putchar(int ch );
ungetc int ungetc(int ch, FILE *stream);
E/S de string formatada – família printf
printf int printf(const char *format, ... );
Um fluxo é
fprintf int fprintf(FILE *stream, const char *format, ... );
especificado.
Um buffer é
sprintf int sprintf(char *output, const char *format, ... );
especificado.
Um buffer e seu
int snprintf(char *restrict output, size_t bufsz, const char
snprintf tamanho são
*restrict format, ...);
especificados.
Uma lista variádica
vprintf int vprintf(const char *format, va_list vlist);
é especificada.
Um fluxo e uma
vfprintf lista variádica são int vfprintf(FILE *stream, const char *format, va_list vlist);
especificados.
Um buffer e uma
vsprintf lista variádica são int vsprintf(char * output, const char *format, va_list vlist);
especificados.
Um buffer, seu
tamanho e uma int vsnprintf(char *restrict output, size_t bufsz, const char
vsnprintf
lista variádica são *restrict format, va_list vlist);
especificados
E/S de string formatada – família scanf
scanf int scanf(const char *format, ... );
Um fluxo é
fscanf int fscanf(FILE *stream, const char *format, ... );
especificado.
Um buffer é
sscanf int sscanf(const char *input, const char *format, ... );
especificado.
Uma lista variádica
vscanf int vscanf(const char *restrict format, va_list vlist );
é especificada.
Um fluxo e uma
int vfscanf(FILE *restrict stream, const char *restrict format,
vfscanf lista variádica são
va_list vlist );
especificados.
Um buffer e uma
int vsscanf(const char *restrict input, const char *restrict
vsscanf lista variádica são
format, va_list vlist );
especificados.
Posição de arquivo
 ftell long ftell(FILE *stream);
fsetpos int fsetpos(FILE *stream, const fpos_t *pos);
fgetpos int fgetpos(FILE *stream, fpos_t *pos );
fseek int fseek(FILE *stream, long offset, int origin);
rewind void rewind(FILE *stream);
Manipulação de erro
clearerr void clearerr(FILE *stream );
feof int feof(FILE *stream );
ferror int ferror(FILE *stream );
perror void perror(const char *s);
Manipulação de arquivos
remove int remove(const char *fname);
rename int rename(const char *old, const char *new);
tmpfile FILE *tmpfile(void);
tmpnam char *tmpnam(char *s);
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Segue abaixo uma tabela de referência de macros.

Macro Descrição
EOF Fim de arquivo
FOPEN_MAX Máximo de arquivos abertos simultaneamente
FILENAME_MAX Tamanho máximo do array do tipo char para um nome de um
arquivo
BUFSIZ Tamanho do buffer usado por setbuf
_IOFBF Argumento para setvbuf, fully buffered I/O
_IOLBF Argumento para setvbuf, line buffered I/O
_IONBF Argumento para setvbuf, unbuffered I/O
SEEK_SET Argumento para fseek, posição inicial
SEEK_CUR Argumento para fseek, posição corrente
SEEK_END Argumento para fseek, posição final
TMP_MAX Máximo de nomes de arquivos únicos gerado por tmpnam
L_tmpnam Tamanho do array de char para a string gerada por tmpnam
NULL Representa um valor nulo
_PRINTF_NAN_LEN_MAX Expande para o máximo de caracteres que pode ter numa saída [-
]NAN(n)
stdin Entrada padrão
stdout Saída padrão
stderr Saída de erro padrão
stdaux* Geralmente porta serial (Implementado por compiladores DOS)
stdprn* Geralmente porta paralela (Implementado por compiladores DOS)
Padronização K&R C89 C90 C95 C99 C11 C17 C23
*Esses macros não fazem parte da padronização C, e estão listados para questões de conhecimento.
O macro NULL é declarado nas bibliotecas <stddef> — implementação fonte —, <locale.h>, <stdlib.h>,
<string.h>, <time.h>, <uchar.h>, e <wchar.h>.

Segue abaixo uma tabela de referência de tipos.

Tipo Descrição Nota

Implementation
FILE Representa um arquivo
defined
Representa a posição do curso de um
fpos_t Um tipo non-array
arquivo
 Implementation
size_t Representa um tamanho de um objeto
defined
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O tipo size_t é declarado nas bibliotecas <stddef> — implementação fonte —, <stdlib.h>, <string.h>,
<time.h>, <uchar.h>, e <wchar.h>.

Streams
Streams são um canal por onde o fluxo de dados transita até o arquivo desejado, são uma
abstração implementada com a estrutura FILE, cujo os objetos instanciados possuem
informações sobre um determinado arquivo, e é a interface que o padrão C utiliza para ler e
escrever nos arquivos de um sistema, além de fazer outras operações.

A linguagem C possui streams padrões, abertos no início da execução do programa, associados

a dispositivos do computador.

• stdin: dispositivo de entrada padrão (geralmente o teclado).

• stdout: dispositivo de saída padrão (geralmente o vídeo).

• stderr: dispositivo de saída de erro padrão (geralmente o vídeo).

• stdaux: dispositivo de saída auxiliar (em muitos sistemas, associado à porta serial) — Não
padronizado.

• stdprn: dispositivo de impressão padrão (em muitos sistemas, associado à porta paralela)
— Não padronizado.

Stream de Texto
Streams de texto são fluxos associados a uma representação textual durante as operações feitas
nesse fluxo.

Durante a leitura de um fluxo de dados do tipo texto, o programa lê um caractere NL (nova

linha) no final de cada linha. Ao gravar em um fluxo de texto, o programa grava um NL para
sinalizar o final de uma linha. Para corresponder a convenções diferentes entre ambientes para
a representação de textos em arquivos, as funções da biblioteca podem alterar o número de
representações de caracteres transmitidos entre o programa e um fluxo de texto.

Stream Binária
Um fluxo binário consiste em um ou mais bytes de informações arbitrárias. As funções da
biblioteca padrão não alteram os bytes transmitidos entre o programa e um fluxo binário. No
entanto, elas podem acrescentar um número arbitrário de bytes nulos para o arquivo que você
escreve com um fluxo binário. O programa precisa lidar com esses bytes nulos adicionais no final
de qualquer fluxo binário.

Orientação

Todo fluxo possui uma orientação associado ao mesmo quando a primeira operação é feita no
fluxo.
Logo após o fluxo ser associado a um arquivo, ele não possui nenhuma orientação, no momento
que uma operação de E/S de caracteres estreitos — narrow characters —, ou bytes for
executada, esse fluxo irá possuir um byte-oriented stream; porém se a primeira operação for
uma E/S de caracteres largos — wide characters —, esse fluxo passará a possuir uma orientação
wide-oriented stream.

Fluxos com uma determinada orientação não pode ser operado por funções que fazem parte
de outra determinada orientação. Somente uma chamada a freopen ou fwide podem altera
uma orientação já estabelecida.

Arquivo FILE
Na biblioteca padrão do C, um objeto do tipo FILE representa um arquivo arbitrário qualquer
“aberto” pelo kernel do sistema operacional.

Esse tipo é definido como uma estrutura capaz de registra informações do arquivo, e seu stream
associado, como: buffer, ponteiro de E/S, indicador e final de arquivo e indicador de erro.

Objetos dessa estrutura são criados pelas chamadas de funções da biblioteca, e geralmente
são retornados como sendo ponteiros para esse objeto.

Abrir um Arquivo
Protótipo: FILE *fopen(const char *filename, const char *mode);

Abre um arquivo filename no modo especificado por mode.

Em caso de falha um ponteiro nulo é retornado, em sucesso um stream FILE é retornado.

Tabela de referência para mode.

Modo Descrição
r Abre o arquivo em modo leitura. O arquivo deve existir.
Abre o arquivo em modo leitura e atualização, permitindo tanto leitura quanto
r+
escrita. O arquivo deve existir.
Abre o arquivo em modo escrita. Caso o arquivo já exista, ele é sobrescrito,
w funcionando como se fosse um novo arquivo vazio, se o arquivo não existe, o mesmo
é criado.
Abre o arquivo em modo escrita e atualização, permitindo tanto leitura quanto
w+ escrita. Caso o arquivo já exista, ele é sobrescrito, funcionando como se fosse um
novo arquivo vazio.
Abre o arquivo em modo anexo. Sempre que uma função de escrita for chamada
(fwrite, fputs, ...), os dados são escritos no fim do arquivo, não importando a posição
a atual do ponteiro. Funções de leitura podem ler em qualquer posição, desde que o
arquivo seja reposicionado utilizando fseek, fsetpos ou rewind. Caso o arquivo não
exista, o mesmo é criado.
Abre o arquivo em modo anexo e atualização, permitindo tanto leitura quanto
a+
escrita. Caso o arquivo não exista, o mesmo é criado.

Modificador Descrição Exemplos

Abre o arquivo em modo binário ao invés de modo texto.
rb; r+b;
b Normalmente, este modificador apenas surte efeito na plataforma
rb+
Windows, sendo ignorado em sistemas *nix.
 Este modificador especifica que, quando o arquivo já existe, a
wx;
x função fopen deve falhar ao invés de sobrescrever o arquivo
wb+x;
existente.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Reabrir um Arquivo
Protótipo: FILE *freopen(const char *filename, const char *mode, FILE *stream);

O arquivo especificado em filename é aberto e associado ao fluxo apontado no parâmetro

stream. O fluxo original do arquivo, se existir, é fechado. Os modos válidos são os mesmos que
os da função fopen.

Em caso de falha um ponteiro nulo é retornado, em sucesso um stream FILE é retornado.

Caso o parâmetro filename seja NULL, a função tenta reassociar o fluxo corrente a um novo
modo. Existem restrições para quais modos são válidos, dependendo do modo original:

• Fluxos abertos com o modo ‘r+’, ‘w+’ ou ‘a+’ podem ser reabertos com qualquer modo.

• Fluxos abertos com o modo ‘a’ podem ser reabertos com o modo ‘a’ ou ‘w’.

• Fluxos abertos com o modo ‘w’ podem ser abertos com o modo ‘a’ ou ‘w’.

• Fluxos abertos com o modo ‘r’ só podem ser reabertos com o modo ‘r’.

Uma chamada de freopen remove a orientação atual de um fluxo, fazendo o mesmo não ter
uma orientação, até ser feita alguma operação nesse fluxo.

Fechar um Arquivo
Protótipo: int fclose (FILE *fp);

Fecha um arquivo e faz com que qualquer dado que tenha permanecido não escrito no fluxo
de saída seja gravado; qualquer buffer associado ao arquivo é desassociado e desalocado se
possível. O ponteiro fp aponta para o arquivo a ser fechado.

Observações: A função retorna zero no caso de sucesso e um EOF em caso de falha.

Buffer
Um buffer é uma região na memória principal em que os dados são armazenados antes de
serem lidos ou escritos em um dispositivo ou arquivo.

As funções fopen e freopen abre o arquivo com uma bufferização completa, ou seja, o arquivo
associado irá possuir um buffer de armazenamento.

Arquivos que não possuem buffer tem seus dados lidos e escritos de forma direta, sem
bufferização.

Há ainda a bufferização por linha, onde arquivos são lidos ou escritos até um caractere de nova
linha.

As funções setbuf e setvbuf são responsáveis por manipularem o buffer, recebem um argumento
mode para especificar qual o tipo do buffer. Abaixo é descrito os tipos de buffer.

Valores para o parâmetro mode:

 Modo Descrição
_IONBF Sem bufferização: Os dados são transmitidos de forma imediata.
Bufferização completa: Os dados são guardados até sua quantidade exceder o
_IOFBF
tamanho máximo do buffer.
Bufferização por linha: Os dados são guardados em um buffer até uma nova linha
_IOLBF
(\n) ser escrita ou até preencher o buffer.

setbuf
Protótipo: void setbuf (FILE * stream, char * buffer);

A função setbuf permite especificar um buffer de forma explicita para o fluxo stream, com ela
também é possível trocar entre o modo sem bufferização e o modo bufferização completa.

Para colocar o fluxo no modo sem bufferização, é preciso especificar o buffer como NULL:
setbuf(fluxo, NULL);. Essa chamada é equivalente a: setvbuf(fluxo, NULL, _IONBF, 0);.

Para colocar o fluxo no modo bufferização completa, basta passar um buffer. setbuf(fluxo,
buffer);. Essa chamada é equivalente a: setvbuf(fluxo, buffer, _IOFBF, BUFSIZ);.

Quando um buffer é passado para a função, ela associa esse buffer com uma bufferização
completa, e espera que o buffer tenha um tamanho mínimo equivalente a BUFSIZ.

Essa função não possui retorno.

setvbuf
Protótipo: int setvbuf (FILE* stream, char* buf, int mode, size_t size);

A função setvbuf permite especificar um buffer buf, seu tamanho size e um modo de
bufferização mode para um fluxo. Ela deve ser chamada antes de qualquer operação no
arquivo.

Se o parâmetro buffer for passado como NULL e o tamanho especificado por size passado for
diferente de zero, um buffer com o tamanho especificado será alocado automaticamente, e
desalocado quando o fluxo for fechado.

Se o parâmetro buffer passado não for NULL, é responsabilidade do usuário desalocar o buffer
— caso ele tenha sido alocado dinamicamente com malloc —, quando o fluxo for fechado.

A função retorna zero no caso de sucesso e um não zero em caso de falha.

E/S de caracteres
As funções getc e fgetc são equivalentes, e são mantidas por legado.

Geralmente getc é implementada como um macro.

As funções putc e fputc são equivalentes, e são mantidas por legado.

Geralmente putc é implementada como um macro.

Leitura
Protótipo: int getc(FILE *fp);
Como funciona: Ler um caractere do fluxo apontado pelo ponteiro fp e retorna o caractere
lido.

Em caso de erro, é retornado o macro EOF.

Observações: Apesar de retorna um inteiro, o caractere está contido no byte de baixa ordem
do inteiro.

Escrita
Protótipo: int putc(int ch, FILE *fp);

Como funciona: Recebe um caractere para ser escrito e o fluxo fp para onde escrever,
caractere é escrito e retornado.

Em caso de falha é retornado o macro EOF.

Observações: Apesar de retorna e receber um inteiro, o caractere está contido no byte de

baixa ordem do inteiro.

E/S de Strings não Formatada

Leitura
Protótipo: char *fgets(char *str, int length, FILE *fp);

Como funciona: Ler uma string do fluxo fp até length-1 bytes, então a string é armazenada no
local apontado por str. A leitura para caso um caractere de nova linha ou EOF for encontrado

A função retorna a str.

Em caso de erro um ponteiro nulo é retornado.

Observações: O caractere final enter, se lido, é colocado na string, diferente da função gets.

Escrita
Protótipo: int fputs(const char *str, FILE *fp);

Como funciona: Recebe uma string indicada pelo ponteiro str para escrita no fluxo apontado
por fp.

Se executada corretamente um valor não negativo é retornado, em caso de falha é retornado

o macro EOF.

Observações: O caractere de nova linha não é escrito automaticamente após a string.

E/S de Bytes
Leitura
Protótipo: size_t fread(void *buffer, size_t num_bytes, size_t count, FILE *fp);

Como funciona: O buffer é a região de memória na qual serão armazenados os dados lidos. O
num_bytes é o tamanho da unidade a ser lida, count indica quantas vezes as unidades devem
ser lidas. O arquivo é representado por fp.
Observações: A função retorna o número de unidades efetivamente lidas. Este número pode
ser menor que count quando o fim do arquivo for encontrado ou ocorrer algum erro.

Escrita
Protótipo: size_t fwrite(const void *buffer, size_t num_bytes, size_t count, FILE *fp);

Como funciona: O buffer é a região de memória que contém os dados a serem escritos. O
num_bytes é o tamanho da unidade a ser gravada, count indica quantas vezes unidades
devem ser gravadas. O arquivo é representado por fp.

Observações: A função retorna o número de itens escritos. Este valor será igual a count a menos
que ocorra algum erro.

E/S nos dispositivos padrões

Leitura
Leitura de caracteres.

Leitura de strings.

Sobre a família scanf.

Escrita
Escrita de caracteres.

Escrita de strings.

Sobre a família printf.

Acesso Randômico
fseek
Para fazer procuras e acessos randômicos em arquivos arbitrários usa-se a função fseek. Esta
função move a posição corrente do ponteiro de leitura/escrita no arquivo, a partir de um ponto
de deslocamento específico.
Protótipo: int fseek (FILE *fp, long numbytes, int origem);

O parâmetro origem determina a partir de onde os numbytes de movimentação serão

contados. Os valores possíveis para origem são definidos pelos macros:

Nome Valor Significado

SEEK_SET 0 Início do arquivo
SEEK_CUR 1 Ponto corrente no arquivo
SEEK_END 2 Fim do arquivo

Tendo definido a partir de onde irá contar, numbytes determina quantos bytes serão deslocados
da posição corrente.
fsetpos
Seta o cursor em uma posição específica em um arquivo.
Protótipo: int fsetpos (FILE * stream, const fpos_t * pos);

Observações: fpots_t geralmente é um typedef para long long.

Retorno: Em sucesso 0 em falha um número não zero.

fgetpos
Armazena em pos a posição atual do curso de um arquivo.
Protótipo: int fgetpos (FILE * stream, fpos_t * pos);

Observações: fpots_t geralmente é um typedef para long long.

Retorno: Em sucesso 0 em falha um número não zero.

ftell
Retorna a posição atual do curso de um arquivo.
Protótipo: long int ftell (FILE * stream);

Retorno: Em sucesso o indicador de posição em falha -1.

rewind
Reseta a posição corrente do curso do arquivo para o início.
Protótipo: void rewind (FILE *fp);

A função não possui retorno.

Funções miscelâneas
remove
Protótipo: int remove (char *nome_do_arquivo);

Apaga um arquivo específico. A tentativa de apagar um arquivo atualmente aberto resulta em

um comportamento implementation-defined.

Retorno: Em sucesso retorna zero, em falha um número não zero.

rename
Protótipo: int rename ( const char * oldname, const char * newname );

Renomeia um arquivo específico. A tentativa de renomear um arquivo para um nome de um

arquivo já existe no diretório corrente resulta num comportamento implementation-defined.

Retorno: Em sucesso retorna zero, em falha um número não zero.

ferror
Protótipo: int ferror (FILE *fp);

Verifica se ocorreu algum erro no stream associado.

Retorno: Em sucesso retorna zero, em falha um número não zero.

feof
Protótipo: int feof (FILE *fp);

A função feof verifica o indicador de fim de arquivo (EOF) do fluxo, e retorna um valor diferente
de zero se este indicador estiver setado.

Retorno: Em sucesso não zero, em falha retorna zero.

clearerr
Protótipo: void clearerr (FILE * stream);

A função clearerr limpa o indicador de EOF e o indicador de erro do fluxo.

A função não possui retorno.

fflush
Protótipo: int fflush (FILE * stream);

A função fflush atua em streams de saída, descarregando o buffer associado a um arquivo

stream, fazendo qualquer dado não escrito no arquivo ser escrito. Caso um argumento NULL for
passado, todos arquivos de saídas abertos são descarregados.

O uso dessa função com streams de entrada causa um comportamento undefined behavior,
porém alguns compiladores implementam seu uso como uma limpa do buffer de entrada —
esse uso não é padronizado.

Retorno: Em sucesso retorna zero, em falha o macro EOF.

Funções utilitárias
ungetc
Protótipo: int ungetc (int 92haracter, FILE * stream);

Insere o caractere apontado por 92haracter de volta ao fluxo de entrada apontado por stream.

Retorno: Em sucesso retorna o caractere, em falha o macro EOF.

tmpfile
Protótipo: FILE* tmpfile (void);

Cria um arquivo binário temporário. O nome deste arquivo é garantidamente diferente de

qualquer outro arquivo existente no filesystem. O arquivo é aberto no modo: “wb+”.

O arquivo é removido:
 • Quando fechado com a função fclose.

• Quando o programa terminar normalmente.

• Em caso de término abrupto do programa, a exclusão do arquivo depende da

implementação, do sistema operacional e da biblioteca.

Retorno: Em sucesso retorna o FILE, em falha um ponteiro nulo.

tmpnam
Protótipo: char * tmpnam (char * string);

Gera o nome de um arquivo temporário, válido e único. O nome deste arquivo é

garantidamente diferente de qualquer outro arquivo existente no diretório corrente, até um
certo número de chamadas, indicadas pelo macro TMP_MAX.

O nome gerado é armazenado no ponteiro string.

O ponteiro pode ser nulo, pois a string é retornada pela função.

Retorno: Em sucesso retorna a string, em falha um ponteiro nulo.

perror
Protótipo: void perror (const char * string);

A função perror mapeia o erro numérico, contido na variável global errno, para uma mensagem
de erro. Em seguida, a função imprime essa mensagem de erro na saída de erro padrão —
stderr.

A função escreve a cadeia de caracteres indicada pelo parâmetro string, então escreve dois
pontos (:) e um espaço, seguido da mensagem de erro associada ao último erro numérico,
seguido de uma nova linha.

O parâmetro string pode ser nulo.

A função não possui retorno.

MACROS e tipos
FILE
O tipo FILE armazena todas as informações referentes a um arquivo. Uma variável do tipo FILE é
utilizada para interagir com as funções da biblioteca padrão que trabalham com arquivos.

Este tipo normalmente é implementado como uma struct, mas é dependente da

implementação da biblioteca padrão e, portanto, sua estrutura interna não deve ser acessada
diretamente. O acesso aos dados de uma variável do tipo FILE deve ser feito com as funções
da biblioteca padrão.

fpos_t
O tipo fpos_t armazena uma posição dentro de um arquivo. Uma variável deste tipo é capaz
de identificar uma posição dentro de um arquivo sem ambiguidade.
EOF
O macro EOF — end-of-file —, especifica o fim de arquivo. Expande para um inteiro negativo
que é, normalmente: -1.

BUFSIZ
O macro BUFSIZ expande para um inteiro que representa o tamanho de um buffer utilizado pela
função setbuf.

FOPEN_MAX
O macro FOPEN_MAX expande para uma constante inteira que indica o número máximo de
fluxos simultâneos que podem estar abertos. O padrão C indica que este número deve ser, ao
menos, 8.

TMP_MAX
O macro TMP_MAX expande para um inteiro que indica o número de vezes que a função
tmpnam pode ser chamada e ainda gerar um nome de arquivo único. O padrão também
especifica que a função tmpfile pode utilizar esse macro para especificar a quantidade mínima
de arquivos temporários abertos simultaneamente.

O padrão C especifica que o valor de TMP_MAX deve ser, ao menos, 25.

L_tmpnam
O macro L_tmpnam expande para um inteiro, o qual deve ser o tamanho mínimo de uma
cadeia de caracteres grande o suficiente para armazenar o nome de arquivo gerado pela
função tmpnam.

FILENAME_MAX
O macro FILENAME_MAX expande para um inteiro que define o tamanho da cadeia de
caracteres necessário para guardar o maior nome suportado de um arquivo.

_PRINTF_NAN_LEN_MAX
Macro implementado no C23. Expande para um inteiro que representa o número máximos de
caracteres de uma saída [-]NAN(n-char-sequence). O padrão define que seu valor deve ser
menor que 64, e caso a implementação não suporte NaN, seu valor deve ser zero.
 Anotação 10: Entrada e Saída: Dispositivos padrão
As informações aqui apresentadas complementam as informações apresentadas na anotação
anterior.

Abaixo são discutidos os métodos para a leitura e escrita na entrada e saídas padrão do sistema.

Caracteres
Leitura
Protótipo: int getchar(void);

Como funciona: Espera um caractere ser pressionado, ler a entrada padrão e retorna o
caractere lido, sendo o caractere retornado ecoado na tela, na atual posição do cursor.

Em caso de falha é retornado o macro EOF.

Observações: Apesar de retorna um inteiro o caractere está contido no byte de baixa ordem.

Escrita
Protótipo: int putchar(int c);

Como funciona: Recebe um caractere para escrita na saída padrão e retorna o mesmo.

Em caso de falha é retornado o macro EOF.

Observações: Apesar de retorna e receber um inteiro o caractere está contido no byte de baixa
ordem.

String
Leitura
Protótipo: char *gets(char *str);

Como funciona: Captura uma string da entrada padrão até encontrar um caractere de nova
linha, depois essa string é armazenada no endereço apontado por str.

A função retorna a str.

a função também retorna o endereço da string.

Observações: O caractere final enter não é colocado na string, ele é substituído pelo terminador
nulo. Essa função foi depreciada na padronização C11 e removida no C23.

Escrita
Protótipo: int puts(const char *str);

Como funciona: Recebe uma string indicada pelo ponteiro str para escrita na saída padrão.

Se executada corretamente um valor não negativo é retornado, em caso de falha é retornado

o macro EOF.

Observações: O caractere de nova linha é escrito automaticamente após a string.

String formatada
Leitura – scanf
Protótipo: int scanf(const char *control_string, . . . );

Como funciona: Lê toda a string da entrada padrão até encontrar um caractere em branco
fazendo atribuições de valores as variáveis de acordo com a string formatada.

Essa função retorna o número de variáveis atribuídas com sucesso, e em caso de falha o macro
EOF é retornado.

Observações: Os argumentos depois da string de controle devem ser compatíveis com os

especificadores de formato caso haja algum, e são passados ponteiros como argumentos.

A família scanf possui várias outras funções que atuam de maneira similar a execução dessa,
para uma lista completa: família scanf.

Escrita – printf
Protótipo: int printf(const char *control_string, . . . );

Como funciona: Escreve uma string formatada apontada do por control_string no stream de
saída padrão, em sucesso retorna o número de caracteres escrito, no caso de falha seta a flag
de erro no stream.

Observações: Os argumentos depois da string de controle devem ser compatíveis com os

especificadores de formato caso haja algum.

A família printf possui várias outras funções que atuam de maneira similar a execução dessa,
para uma lista completa: família printf.

String de controle – família printf

A string de controle das funções printf consiste em dois tipos de itens: Os caracteres que serão
printados de forma verbatim, e um contêiner iniciado pelo caractere: %, chamado de
especificador de conversão, ele possui especificadores de formatos juntamente com
modificadores, que serão precisamente substituídos por outros valores, e então incorporados a
string a ser printada.

O padrão C especifica que esse especificador de conversão deve apresentar seus elementos
seguinte ordem:

• Flags — Um ou mais sinalizadores, em qualquer ordem, que modificam o significado do

especificador.

• Field width — Uma largura mínima opcional que irá preencher o objeto substituído até o
tamanho da largura especificada.

• Precision — Uma precisão opcional que ditará a quantidade de números mínimos, em

alguns casos os números depois da virgula.
 • Length modifier — O tamanho opcional do argumento.

• Specifier — Um especificador que defini para qual tipo o argumento será convertido para
ser incorporado.

Os especificadores de conversão possuem a seguinte sintaxe.

Sintaxe: %[sinalizadores][largura][.precisão][tamanho]especificador

Especificadores de formato
Especificador Usado para Como funciona
Hexadecimal que tem o
a Ponto flutuante — double formato
[-][Link]±dd
Hexadecimal que tem o
A Ponto flutuante — double formato
[-][Link]±dd
c Caractere — char Caractere de byte único
s Cadeia de Caracteres — char * Saída para string
d Inteiro — int Inteiro decimal com sinal
i Inteiro — int Inteiro decimal com sinal
e Ponto flutuante — double Notação cientifica
E Ponto flutuante — double Notação cientifica
Ponto flutuante que tem a
f Ponto flutuante — double forma
[-]dddd . dddd
Funciona igualmente o %f,
F Ponto flutuante — double porém NaN e Infinity é
mostrado em uppercase
g Ponto flutuante — double Usa %f ou %e
G Ponto flutuante — double Usa %F ou %E
b Inteiro sem sinal — unsigned int Saída em binário
o Inteiro sem sinal — unsigned int Saída em octal
u Inteiro sem sinal — unsigned int Inteiro sem sinal
x Inteiro sem sinal — unsigned int Saída em hexadecimal [-]0xh
X Inteiro sem sinal — unsigned int Saída em hexadecimal [-]0Xh
p Tipo de ponteiro Mostra o endereço do ponteiro
Guarda o atual valor da
n Contador de Caracteres — int * quantidade de caracteres no
endereço especificado
% Printa o caractere por cento
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Especificadores de tamanho
Prefixo Para especificar Com especificador de tipo
signed char
hh b, d, i, o, u, x ou X
unsigned char
short int
h b, d, i, o, u, x ou X
short unsigned int
L long double a, A, e, E, f, F, g ou G
 long int
l c, s, n, b, d, i, o, u, x ou X
long unsigned int
long long int
ll n, b, d, i, o, u, x ou X
unsigned long long int

intmax_t
j n, b, d, i, o, u, x ou X
uintmax_t
z size_t n, b, d, i, o, u, x ou X
t ptrdiff_t n, b, d, i, o, u, x ou X
wN intN_t n, b, d, i, o, u, x ou X
wfN int_fastN_T n, b, d, i, o, u, x ou X
H _Decimal32 a, A, e, E, f, F, g ou G
D _Decimal64 a, A, e, E, f, F, g ou G
DD _Decimal126 a, A, e, E, f, F, g ou G
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Onde N deve ser um inteiro positivo, para especificar tidos definidos no cabeçalho <stdint.h>.
O especificador b, foi introduzido no C23.

O prefixo %l pode ser aplicado no especificador %c e %s, para identificar um argumento wint_t
e wchar_t respectivamente.

Os prefixos usados com o especificador %n quando apresentar há ambiguidade, representará

o tipo positivo com sinal, exemplo: %jn, especifica um ponteiro do tipo intmax_t.

O prefixo %t quando aplicado com o especificador %n especifica um ponteiro para um ptrdiff_t.

A partir do C99, o modificador %l pode ser aplicado com os especificadores do tipo de ponto
flutuante: a, A, e, E, f, F, g ou G, porém não tem efeito.

Especificador de precisão
Especificador Significado Padrão
A precisão padrão é 13. Se a precisão
Número de dígitos após a for 0, nenhum ponto decimal será
a, A
vírgula impresso, a menos que o sinalizador #
seja usado
A precisão não tem nenhum
c O caractere foi impresso
efeito
A precisão especifica o número
b, d, i, o, u, x, X A precisão padrão é 1
mínimo de dígitos a ser impresso
Número de dígitos a serem
impressos após a vírgula
e, E A precisão padrão é 6
decimal. O último dígito
impresso será arredondado
Número de dígitos após a
vírgula decimal. O valor é
f, F A precisão padrão é 6
arredondado para o número
apropriado de dígitos
Número máximo de dígitos Seis dígitos significativos são impressos
g, G
significativos impressos e os zeros à direita são truncados
Número máximo de caracteres Os caracteres são impressos até que
s
a serem impressos seja encontrado um caractere nulo
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O especificador b, foi introduzido no C23.
Especificador de largura
O argumento de largura é um inteiro decimal não negativo que controla o número mínimo de
caracteres de saída. Se o número de caracteres no valor de saída for menor que a largura
especificada, espaços em branco serão adicionados à esquerda ou à direita dos valores —
dependendo se o sinalizador de alinhamento à esquerda ( - ) for especificado — até que a
largura mínima seja atingida. Se a largura tiver 0 como prefixo, zeros à esquerda serão
adicionados ao inteiro ou a conversão de ponto flutuante até que a largura mínima seja
atingida.

Sinalizador
Sinalizador Significado Padrão
Alinha à esquerda o resultado dentro da
- Alinhar à direita.
largura de campo determinada.
O sinal será exibido
Use um sinal (+ ou -) como prefixo no valor
+ somente para valores
de saída se for de um tipo com sinal.
assinados negativos (-).
Se a largura não for atingida, zeros à
esquerda serão adicionados até que a
0 largura mínima seja atingida. Se 0 Nenhum preenchimento.
aparecer com o sinalizador: (-), o 0 será
ignorado.
Quando ele for usado com o formato o,
b, x ou X, o sinalizador # usará 0, 0b, 0x ou Não há exibição de um
0X, respectivamente, para o prefixo de prefixo
qualquer valor de saída diferente de zero.
Quando ele for usado com o formato e, E, O ponto decimal será
f, F, a ou A, o sinalizador # obrigará o valor exibido somente se os
# de saída a conter um ponto decimal. dígitos o seguirem.
Quando ele for usado com o formato g O ponto decimal será
ou G, o sinalizador # obrigará o valor de exibido somente se os
saída a conter um ponto decimal e dígitos o seguirem. Zeros
evitará o truncamento de zeros à direita. à direita são truncados.
Ignorado quando usado com c, d, i, u ou
s.
Um espaço é prefixado antes do valor de
saída somente para uma conversão de
Não há a adição do
Caractere espaço números sem sinal ou valores que não são
espaço adicional
caracteres. Esse sinalizador é ignorado se
usado com: (+).
O especificador b, foi introduzido no C23.

Asterisco
O asterisco pode ser usado no lugar do especificador de largura e de precisão, isso indica que
o próximo argumento da função printf será o valor do asterisco associado.
Sintaxe: printf(“%*.*d”, var1, var2, 10);
String de controle – scanf
A string de controle da função scanf consiste em três tipos de itens: Os especificadores de
formato, caracteres de espaço em branco e caracteres que não são espaço em branco.

• Caracteres de espaço em branco: espaço branco (‘ ‘); tabulação (‘\t’) ou nova linha
(‘\n’).

o Um caractere de espaço em branco faz com que scanf leia, mas não armazene
todos os caracteres de espaço em branco consecutivos na entrada, até o
próximo caractere que não seja de espaço em branco.

• Caracteres que não são de espaço em branco, exceto pelo sinal de porcentagem (%).

o Um caractere que não é de espaço em branco faz com que scanf leia, mas não
armazene um caractere que não seja de espaço em branco correspondente. Se
o próximo caractere no fluxo de entrada não for correspondente, scanf será
encerrado.

• Especificações de formato, introduzidas pelo sinal de porcentagem (%).

o Um especificador de formato faz com que scanf leia e converta caracteres na

entrada em valores de um tipo especificado. O valor é atribuído a um argumento
na lista de argumentos.

Os especificadores de formato possuem a seguinte sintaxe.

Sintaxe: %[*][largura][tamanho]especificador

Especificadores de formato
Especificador Usado para ler
a Ponto flutuante — float
A Ponto flutuante — float
c Caractere — char *, signed char *, unsigned char ou void *
Cadeia de Caracteres — char *, signed char *, unsigned char
s
ou void *
d Inteiro em base 10 — int
i Inteiro em base 10 — int
e Ponto flutuante — float
E Ponto flutuante — float
f Ponto flutuante — float
F Ponto flutuante — float
g Ponto flutuante — float
G Ponto flutuante — float
b Inteiro em binário — unsigned int
o Inteiro em octal — unsigned int
u Inteiro em base 10— unsigned int
x Inteiro em hexadecimal — unsigned int
X Inteiro em hexadecimal — unsigned int
p Tipo de ponteiro
n Contador de Caracteres
% Ler o caractere por cento
[] Scanset
 Padronização K&R C89 C90 C95 C99 C11 C17 C23

Especificadores de tamanho
Prefixo Para especificar Com especificador de tipo
signed char
hh b, d, i, o, u, x ou X
unsigned char
short int
h b, d, i, o, u, x ou X
short unsigned int
L long double a, A, e, E, f, F, g ou G
long int
l c, s, n, b, d, i, o, u, x ou X
long unsigned int
l double a, A, e, E, f, F, g ou G
long long int
ll n, b, d, i, o, u, x ou X
unsigned long long int

intmax_t
j n, b, d, i, o, u, x ou X
uintmax_t
z size_t n, b, d, i, o, u, x ou X
t ptrdiff_t n, b, d, i, o, u, x ou X
wN intN_t n, b, d, i, o, u, x ou X
wfN int_fastN_T n, b, d, i, o, u, x ou X
H _Decimal32 a, A, e, E, f, F, g ou G
D _Decimal64 a, A, e, E, f, F, g ou G
DD _Decimal126 a, A, e, E, f, F, g ou G
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Onde N deve ser um inteiro positivo, para especificar tidos definidos no cabeçalho <stdint.h>.
O especificador b, foi introduzido no C23.

O prefixo %l pode ser aplicado no especificador %c e %s, para identificar um argumento wint_t
e wchar_t respectivamente.

Os prefixos usados com o especificador %n quando apresentar há ambiguidade, representará

o tipo positivo com sinal, exemplo: %jn, especifica um ponteiro do tipo intmax_t.

O prefixo %t quando aplicado com o especificador %n especifica um ponteiro para um ptrdiff_t.

A partir do C99, o modificador %l pode ser aplicado com os especificadores do tipo de ponto
flutuante: a, A, e, E, f, F, g ou G, porém não tem efeito.

Largura
Esse modificador opcional dita o tamanho de caracteres que será processado para o resultado
da conversão.
Exemplo: scanf(“%2d”, &var);

Somente os dois primeiros caracteres da entrada serão processados para a conversão e

armazenado em var.

Asterisco
O asterisco faz com que o scanf leia um campo como dita o especificador de formato e
descarte o mesmo.
Sintaxe: scanf(“%*d”);

Scanset
Um scanset define um conjunto de caracteres para serem lidos e processados.

Quando scanf processa esse scanset, ele irá ler os caracteres desde que esses caracteres façam
parte do conjunto definido pelo scanset. Os caracteres lidos serão atribuídos ao array de
caracteres apontado pelo argumento que corresponde ao scanset.

O scanset espera um array de caracteres char, para caracteres wchar_t, deve usar o
modificador de tamanho l.

O array terá um terminador nulo depois do scanf processa-lo.

Especificador Significado
[Caracteres] Leitura normal
[^Caracteres] Leitura invertida
[Caractere - Caractere] Alcance
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Sintaxe char: scanf(“%[scanset]”, array);

Sintaxe wchar_t: scanf(“%l[scanset]”, array);
PARTE II
 Biblioteca 1: assert.h
Asserções são um teste lógico, onde o resultado esperado é um resultado avaliado em
verdadeiro, caso o resultado seja avaliado em falso, uma determinada ação é executada.

A linguagem C, não possuía o suporte a asserções nativas até a introdução do C11, antes disso
era usado a biblioteca <assert.h> para o tratamento de asserções, que, como a biblioteca
estipula, são testadas em tempo de execução.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_ASSERT_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referência
Identificador Tipo Descrição
assert Função macro Implementa a asserção
static_assert (Removido no
Macro Macro de conveniência
C23)
Padronização K&R C89 C90 C95 C99 C11 C17 C23

assert
Protótipo: assert(int);

A função assert é um macro que implementa a asserção em tempo de execução, essa função
aceita um argumento que será reduzido a um inteiro para um teste booleano.

Caso esse argumento seja reduzido a um não-zero — indicando um valor verdadeiro —, a

função não faz nada, caso contrário, é escrito uma mensagem de erro gerada pelo próprio
compilado no stream padrão de erro: stderr, e então a função abort é chamada encerrando o
programa.

A mensagem de saída deve incluir:

• O nome arquivo do arquivo fonte — macro __FILE__.

• O número da linha do arquivo fonte — macro __LINE__.

• A função fonte — identificador pré-definido __func__ (C99).

• O texto da expressão avaliada em 0.

Exemplo de uma mensagem padrão de uma asserção avaliada em falso:

program: program.[Link] main: Assertion ‘ 1 != 1’ failed.

Static_assert
 Protótipo: static_assert(int line, char * string);

Esse macro é expandido para a palavra-chave _Static_assert, e é usado como um macro de

conveniência. Esse macro só está disponível a partir do C11, porém foi removido a partir do C23,
devido ao fato de static_assert referenciar uma palavra-chave.

Observações
• Caso macro NDEBUG seja definido o antes da inclusão de <assert.h>, todas as asserções
dessa biblioteca serão ignoradas.

Segundo a padronização, as asserções com o macro NDEBUG definidos são

implementadas como:
#define assert(...) ((void)0)

• A mensagem de erro exibida por assert tem um comportamento definida pela

implementação.
 Biblioteca 2: complex.h
Essa biblioteca tem a finalidade de suportar a aritmética de números complexo. Ela foi
implementada a partir do C99, com parte da mesma sendo opcional, neste caso no que diz
respeito a números imaginários. A começar pelo C11 todo conteúdo dessa biblioteca, além do
suporte nativo de números complexo, se tornou opcional.

Informações sobre os macros de testes que definem funcionalidades opcionais: macros não
obrigatórios.

Essa biblioteca é afetada pelo uso da diretiva #pragma STDC CX_LIMITED_RANGE.

Informações sobre as diretivas de #pragma.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_COMPLEX_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Macros
Identificador Tipo Descrição
complex Macro Macro de conveniência. Expande para _Complex.
Imaginary Macro Macro de conveniência. Expande para _Imaginary.
Constante que representa a unidade matemática
_Complex_I Macro
imaginária i.
Constante que representa a unidade matemática
_Imaginary_I Macro
imaginária i.
Constante que representa a unidade matemática
I Macro
imaginária i.
CMPLX
Função Constrói um número complexo a partir das partes reais e
CMPLXF
macro imaginárias
CMPLXL
Padronização K&R C89 C90 C95 C99 C11 C17 C23

O macro _Complex_I expande para uma constante do tipo float _Complex, com um valor
representando uma unidade imaginária.

O macro _Imaginary_I expande para uma constante do tipo float _Imaginary, com um valor que
representa uma unidade imaginária.

O macro I expande para _Imaginary_I se os tipos imaginários estiverem definidos, ou _Complex_I

caso não definidos.

Os macros CMPLX, CMPLXF e CMPLXL são implementados a partir do C11, e são definidos
somente se a implementação tiver suporte nativo para números imaginários, são funções
macros com os seguintes protótipos.

Protótipo:
double _Complex CMPLX(double real, double imag);
 float _Complex CMPLXF(float real, float imag);
long double _Complex CMPLXL(long double real, long double imag);

Elas retornam um número complexo formado a partir dos seus argumentos, que representam a
parte real e imaginaria do número.

Segundo a padronização esses macros são definidos das seguintes formas:

#define CMPLX(x, y) ((double complex)((double)(x) + \

_Imaginary_I * (double)(y)))
#define CMPLXF(x, y) ((float complex)((float)(x) + \
_Imaginary_I * (float)(y)))
#define CMPLXL(x, y) ((long double complex)((long double)(x) + \
_Imaginary_I * (long double)(y)))

Funções
As funções dessa biblioteca, assim como as da biblioteca <math.h>, seguem uma organização
padrão, todas recebem um ou mais argumentos do tipo double _Complex, e retornam um valor
do tipo double _Complex.

Exemplo: uma função hipoteticamente nomeada de cteste.

Seu protótipo seria:

double _Complex cteste(double _Complex);

Porém todas as funções apresentam versões que utilizam float _Complex ou long double
_Complex como argumento(s) e retorno, para identificar essas funções, seus nomes terminam
com o caractere f, caso a rotina trabalhe com um float _Complex, ou o caractere l, para
especificar um long double _Complex.

Exemplo: duas funções hipoteticamente nomeadas de ctestef e ctestl.

Seus protótipos seriam:

float _Complex ctestef(float _Complex);
long double _Complex ctestel(long double _Complex);

Funções com mais de um argumento possuem o mesmo tipo para todos argumentos, no caso,
o tipo de dado da função.

Exceto as famílias de funções: creal, cimag, cabs e carg; não seguem esse padrão de
organização, pois retornam ou recebem pontos flutuantes binários: float, double e long double.

Segue abaixo uma lista de referência, usando somente o nome das funções, seus protótipos são
formados de acordo com seus nomes — seguindo o padrão da biblioteca.

Lembrando que as funções dessa biblioteca interpretam os valores como sendo radianos, e não
graus.

Funções de manipulação
Identificadores: Protótipos:
creal double creal(double complex z);
crealf float crealf(float complex z);
creall long double creall(long double complex z);
 Descrição e retorno: Computa e retorna a parte real de um numero complexo z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
cimag double cimag(double complex z);
cimagf float cimagf(float complex z);
cimagl long double cimagl(long double complex z);
Descrição e retorno: Computa e retorna a parte imaginária de um número complexo z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
cabs double cabs(double complex z);
cabsf float cabsf(float complex z);
cabsl long double cabsl(long double complex z);
Descrição e retorno: Computa e retorna o valor absoluto de um número complexo z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
carg double carg(double complex z);
cargf float cargf(float complex z);
cargl long double cargl(long double complex z);
Descrição e retorno: Computa e retorna o ângulo de fase de um número complexo z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
conj double complex conj(double complex z);
conjf float complex conjf(float complex z);
conjl long double complex conjl(long double complex z);
Descrição e retorno: Computa e retorna o conjugado de um número complexo z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
cproj double complex cproj(double complex z);
cprojf float complex cprojf(float complex z);
cprojl long double complex cprojl(long double complex z);
Computa e retorna a projeção de um número complexo z na esfera
Descrição e retorno:
de Riemann.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções exponenciais
Identificadores: Protótipos:
cexp double complex cexp(double complex z);
cexpf float complex cexpf(float complex z);
cexpl long double complex cexpl(long double complex z);
Computa e retorna a potência complexa da constante Euler
Descrição e retorno: elevada a z.
ez
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
 clog double complex clog(double complex z);
clogf float complex clogf(float complex z);
clogl long double complex clogl(long double complex z);
Computa e retorna o logaritmo natural complexo de z.
Descrição e retorno:
loge z
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções de potência
Identificadores: Protótipos:
double complex cpow(double complex x, double complex y);
cpow
float complex cpowf(float complex x, float complex y);
cpowf
long double complex cpowl(long double complex x, long double
cpowl
complex y);
Computa e retorna a potência complexa de x elevado a y.
Descrição e retorno:
xy
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
csqrt double complex csqrt(double complex z);
csqrtf float complex csqrtf(float complex z);
csqrtl long double complex csqrtl(long double complex z);
Computa e retorna a raiz quadrada complexa de um número z.
Descrição e retorno:
√𝑧
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções trigonométricas
Identificadores: Protótipos:
csin double complex csin(double complex z);
csinf float complex csinf(float complex z);
csinl long double complex csinl(long double complex z);
Descrição e retorno: Computa e retorna o seno complexo de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
ccos double complex ccos(double complex z);
ccosf float complex ccosf(float complex z);
ccosl long double complex ccosl(long double complex z);
Descrição e retorno: Computa e retorna o cosseno complexo de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
ctan double complex ctan(double complex z);
ctanf float complex ctanf(float complex z);
ctanl long double complex ctanl(long double complex z);
Descrição e retorno: Computa e retorna a tangente complexa de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
casin double complex casin(double complex z);
casinf float complex casinf(float complex z);
 casinl long double complex casinl(long double complex z);
Descrição e retorno: Computa e retorna o arco seno complexo de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
cacos double complex cacos(double complex z);
cacosf float complex cacosf(float complex z);
cacosl long double complex cacosl(long double complex z);
Descrição e retorno: Computa e retorna o arco cosseno complexo de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
catan double complex catan(double complex z);
catanf float complex catanf(float complex z);
catanl long double complex catanl(long double complex z);
Descrição e retorno: Computa e retorna o arco tangente complexo de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Funções hiperbólicas
Identificadores: Protótipos:
csinh double complex csinh(double complex z);
csinhf float complex csinhf(float complex z);
csinhl long double complex csinhl(long double complex z);
Descrição e retorno: Computa e retorna o seno hiperbólico complexo de um número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
ccosh double complex ccosh(double complex z);
ccoshf float complex ccoshf(float complex z);
ccoshl long double complex ccoshl(long double complex z);
Computa e retorna o cosseno hiperbólico complexo de um número
Descrição e retorno:
z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
ctanh double complex ctanh(double complex z);
ctanhf float complex ctanhf(float complex z);
ctanhl long double complex ctanhl(long double complex z);
Computa e retorna a tangente hiperbólico complexa de um número
Descrição e retorno:
z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
casinh double complex casinh(double complex z);
casinhf float complex casinhf(float complex z);
casinhl long double complex casinhl(long double complex z);
Computa e retorna o arco seno hiperbólico complexo de um número
Descrição e retorno:
z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
 cacosh double complex cacosh(double complex z);
cacoshf float complex cacoshf(float complex z);
cacoshl long double complex cacoshl(long double complex z);
Computa e retorna o arco cosseno hiperbólico complexo de um
Descrição e retorno:
número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificadores: Protótipos:
catanh double complex catanh(double complex z);
catanhf float complex catanhf(float complex z);
catanhl long double complex catanhl(long double complex z);
Computa e retorna o arco tangente hiperbólico complexo de um
Descrição e retorno:
número z.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
 Biblioteca 3: ctype.h
Essa biblioteca é usada para a manipulação de caracteres curtos — narrow characters. Ela
define várias funções para esse propósito, apesar dessas funções receberem um inteiro como
argumento e retorno, somente o byte de baixa ordem do inteiro é usado para representar o
caractere.

Referência
Identificador Tipo Descrição
isalnum Função Testa se é um caractere alfanumérico.
Isalpha Função Testa se é um caractere alfabético.
Islower Função Testa se é um caractere em caixa baixa.
Isupper Função Testa se é um caractere em caixa alta.
Isdigit Função Testa se é um caractere de digito.
Isxdigit Função Testa se é um caractere hexadecimal.
Iscntrl Função Testa se é um caractere de controle.
Isgraph Função Testa se é um caractere gráfico.
Isspace Função Testa se é um caractere de espaço.
Isblank Função Testa se é um caractere vazio.
Isprint Função Testa se é um caractere printável.
Ispunct Função Testa se é um caractere de pontuação.
Tolower Função Converte um caractere para caixa baixa.
Toupper Função Converte um caractere para caixa alta.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções
Todas as funções dessa biblioteca seguem um padrão, onde todas apresentam como base o
seguinte protótipo:
Sintaxe: int func-name(int c);

Elas recebem um único inteiro, representado o caractere a operaram, e retornam também um

inteiro, ambos são do tipo int.

Essas funções tem um comportamento indefinido se o inteiro passado não pode ser
representado como caractere do tipo unsigned char, ou igual ao valor do macro EOF — macro
definido na biblioteca <stdio.h>.

Essas funções retornam um inteiro representando não-zero em caso de sucesso, e um zero em

caso de falha, exceto as funções tolower e toupper, onde retornam um inteiro que representa
um caractere convertido, sendo o byte de baixa ordem desse inteiro a representação desse
caractere.

Observações
O equivalente dessa biblioteca para caracteres largos — wide characters — é a: BIBLIOTECA
<wctype.h>

Segue abaixo uma tabela com os possíveis retornos de cada função — exceto toupper e
tolower — inclusive as funções para caracteres largos da biblioteca <wctype.h>.
 Valores ASCII
Caracteres c p s b g p n a u l d x
Base10 Base16 Base8
0–8 x0–x8 0–10 Controle * 0 0 0 0 0 0 0 0 0 0 0
9 x9 11 Tab (\t) * 0 * * 0 0 0 0 0 0 0 0
10–13 xA–xD 12–15 Brancos (\n\v\f\r) * 0 * 0 0 0 0 0 0 0 0 0
14-31 xE–x1F 16–37 Controle * 0 0 0 0 0 0 0 0 0 0 0
32 x20 40 Espaço 0 * * * 0 0 0 0 0 0 0 0
33–47 x21-x2F 41–57 !”#$%&’()*+,-./ 0 * 0 0 * * 0 0 0 0 0 0
48–57 x30–x39 60–71 0123456789 0 * 0 0 * 0 * 0 0 0 * *
58–64 x3A–x40 72–100 :;?@ 0 * 0 0 * * 0 0 0 0 0 0
65–70 x41–x46 101–106 ABCDEF 0 * 0 0 * 0 * * * 0 0 *
GHIJKLMNOP
71–90 x47–x5A 107–132 0 * 0 0 * 0 * * * 0 0 0
QRSTUVWXYZ
91–96 x5B–x60 133–140 [\]^_` 0 * 0 0 * * 0 0 0 0 0 0
97–102 x61–x66 141–146 abcdef 0 * 0 0 * 0 * * 0 * 0 *
ghijklmnop
103–122 x67–x7A 147–172 0 * 0 0 * 0 * * 0 * 0 0
qrstuvwxyz
123–126 x7B–x7E 172–176 {|}~ 0 * 0 0 * * 0 0 0 0 0 0
127 x7F 177 Deletar (DEL) * 0 0 0 0 0 0 0 0 0 0 0

Onde:

• * — Verdadeiro.

• 0 — Falso.

• C — iscntrl ou iswcntrl.

• P — isprint ou iswprint.

• S — isspace ou iswspace.

• B — isblank ou iswblank.

• G — isgraph ou iswgraph.

• P — ispunct ou iswpunct.

• N — isalnum ou iswalnum.

• A — isalpha ou iswalpha.

• U — isupper ou iswupper.

• L — islower ou iswlower.

• D — isdigit ou iswdigit.

• X — isxdigit ou iswxdigit.
 Biblioteca 4: errno.h
Essa biblioteca tem a finalidade de fazer o reconhecimento de erros que ocorrem durante a
execução do programa.

Como funciona: muitas das funções da biblioteca padrão do C, alteram o valor de uma variável
global: errno, e de acordo com seu valor pode-se obter informações se houve um erro e de qual
tipo de erro se trata. Para atestar qual foi o erro ocorrido deve-se testa a igualdade do valor de
errno com macros pré-definidos, caso seja verdadeiro, tal erro ocorreu.

Qual macro utilizar vai depender do contexto, sendo que o padrão C só especifica
obrigatoriamente três macros — anterior ao C95, somente dois macros eram especificados —
porém a implementação pode/deve definir vários outros macros, inclusive em outras
bibliotecas, sendo esses macros implementation -defined.

Referência
Identificador Tipo Descrição
Expande para uma modifiable lvalue do
errno Variável
tipo int, que representa um erro.
Constante inteira do tipo int que
EDOM Macro representa:
Erro de domínio.
Constante inteira do tipo int que
ERANGE Macro representa:
Erro de intervalo.
Constante inteira do tipo int que
EILSEQ Macro representa:
Erro de sequência.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

errno
Quando definida como macro, ele é expandido para o atual valor da variável errno através de
uma chamada de função, em caso de ser definida como variável ela é uma referência externa
a um inteiro.

Dependendo da implementação errno pode ser declarada como uma referência para um
inteiro ou pode ser incluída como um macro, porém a parti do C11 a padronização define como
sendo um macro.

Macros
Esses macros são definidos pela padronização com valores constantes e únicos do tipo int, eles
servem para identificar erros.

EDOM
Macro que representa um erro quando um número está fora de seu domínio.
Exemplo: sqrt(-1);
ERANGE
Macro que representa um erro quando um número está fora de seu intervalo numérico.
Exemplo: strtol(“0xffffffffff”, NULL, 0);

EILSEQ
Macro que representa um erro quando uma sequência de bytes é ilegal.
Exemplo: mbstowcs(buf,”\xff”, 1);

Observações
• Quando o programa inicia errno é iniciada com o valor de zero.

• Muitas bibliotecas modificam errno implicitamente.

• Cada thread possui a sua própria referência a errno, logo o mesmo é thread-safe.
 Biblioteca 5: fenv.h
Biblioteca usada para acessar o ambiente de ponto flutuante, sendo implementada a partir da
padronização C99. O ambiente de ponto flutuante modifica como certas bibliotecas irão
trabalho com números decimais.

Toda modificação do ambiente de ponto flutuante deve ser feita depois de uma diretiva
pragma ser executada, especificamente a diretiva: #pragma STDC FENV_ACCESS ON, caso
essa diretiva não seja executada, a implementação é livre para ignorar qualquer modificação
no ambiente.

A começar do C23 duas novas pragmas foram adicionadas: #pragma STDC FENV_ROUND e
#pragma STDC FENV_DEC_ROUND, elas servem para setar o modo de arredondamento dos
pontos flutuantes binários e decimais respectivamente.

Sobre as diretivas de #pragma.

Observe que: a biblioteca <fenv.h> tem seus macros e comportamento de acordo com a implementação, sendo
recomendado não modificar o ambiente de ponto flutuante diretamente, em vez disso deve-se usar as funções
definidas na biblioteca, juntamente com seus macros.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_FENV_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referência
Identificador Tipo Descrição
Tipos auxiliares
Tipo de
fenv_t Representa todo o ambiente de p.f.
dados
Tipo de
fexcept_t Representa uma exceção.
dados
Tipo de Representa todo o modo de p.f, incluindo
Femode_t
dados os modos de arredondamento.
Funções de exceções
feclearexcept Função Limpar uma exceção de p.f.
feraiseexcept Função Levanta uma exceção de p.f.
Captura exceções de p.f de acordo com a
fegetexceptflag Função
flag.
Seta exceções de p.f de acordo com a
Fesetexceptflag Função
flag.
Fesetexcept Função Seta exceções de p.f.
fetestexcept Função Testa uma exceção de p.f.
Testa uma exceção de p.f de acordo com
fetestexceptflag Função
a flag.
Funções de arredondamento
 Captura o modo de arredondamento — p.f
fegetround Função
binário.
Coloca o modo de arredondamento — p.f
fesetround Função
binário.
Captura o modo de arredondamento — p.f
fe_dec_getround Função
decimal.
Coloca o modo de arredondamento — p.f
fe_dec_setround Função
decimal.
Funções de ambiente de ponto flutuante
fegetenv Função Captura o ambiente de p.f.
fesetenv Função Coloca o ambiente de p.f.
feholdexcept Função Salva o ambiente de p.f.
feupdateenv Função Atualiza o ambiente de p.f.
Macros de exceção
FE_DIVBYZERO Macro Pole error.
FE_INEXACT Macro Resultado inexato.
FE_INVALID Macro Resultado inválido.
FE_OVERFLOW Macro Estouro acima do permitido.
FE_UNDERFLOW Macro Estouro abaixo do permitido.
FE_ALL_EXCEPT Macro Junção de todas exceções.
Macros de arredondamento
FE_DOWNWARD Macro Arredondamento para baixo — p.f binário.
Arredondamento para o mais próximo — p.f
FE_TONEAREST Macro
binário.
Arredondamento para o mais próximo
FE_TONEARESTFROMZERO Macro
longe de zero — p.f binário.
FE_TOWARDZERO Macro Arredondamento para zero — p.f binário.
FE_UPWARD Macro Arredondamento para cima — p.f binário.
FE_DEC_DOWNWARD Macro Arredondamento para baixo — p.f decimal.
FE_DEC_TONEAREST Macro Arredondamento para o mais próximo — p.f
decimal.
Arredondamento para o mais próximo
FE_DEC_TONEARESTFROMZERO Macro
longe de zero — p.f decimal.
FE_DEC_TOWARDZERO Macro Arredondamento para zero — p.f decimal.
FE_DEC_UPWARD Macro Arredondamento para cima — p.f decimal.
Macros de ambiente
FE_DFL_ENV Macro Ambiente de p.f padrão.
FE_DFL_MODE Macro Ambiente padrão do p.f dinâmico.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
As funções: fe_dec_getround e fe_dec_setround, e os macros: FE_DEC_DOWNWARD, FE_DEC_TONEAREST,
FE_DEC_TONEARESTFROMZERO, FE_DEC_TOWARDZERO e FE_DEC_UPWARD, só estão disponíveis se a
implementação tiver suporte para pontos flutuantes decimais.

Macros
Exceto pelos macros FE_DFL_ENV e FE_DFL_MODE, o restante dos macros é expandido para um
inteiro, e tem seu valor dependente da implementação, e são descritos na tabela de referência.

FE_DFL_ENV
Esse macro é expandido para um ponteiro do tipo fenv_t, sendo que esse ponteiro representa
o ambiente de ponto flutuante no seu estado padrão, ou seja, o modo de como o ambiente se
encontrava no início da execução do programa, em seu estado default.

FE_DFL_MODE
Esse macro é definido a partir do C23, ele é expandido para um ponteiro do tipo femode_t,
sendo que esse ponteiro representa a coleção de modos do ambiente de ponto flutuante no
seu estado padrão, ou seja, o modo como o a coleção de modos do ambiente se encontrava
no início da execução do programa, em seu estado default.

Arredondamento
Os modos de arredondamento modificam como a linguagem irá arredondar as operações com
pontos flutuantes. Esses modos devem ser manipulados pelas funções fesetround e fegetround
para pontos flutuantes binários e fe_dec_setround e fe_dec_getround para pontos flutuantes
decimais, juntamente com os devidos macros definidos para esse propósito, os quais são:

Para: fe_setround e fe_getround Para: fe_dec_setround e fe_dec_getround

FE_DOWNWARD FE_DEC_DOWNWARD
FE_TONEAREST FE_DEC_TONEAREST
FE_TONEARESTFROMZERO FE_DEC_TONEARESTFROMZERO
FE_TOWARDZERO FE_DEC_TOWARDZERO
FE_UPWARD FE_DEC_UPWARD
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Esses macros são descritos na tabela de referência.

O modo de arredondamento padrão do início do programa são os macros: FE_TONEAREST e

FE_DEC_TONEAREST.

Fegetround
Protótipo: int fegetround();

Retorna um inteiro que representa a atual direção de arredondamento. Esse inteiro é um dos
macros de arredondamento.

Fesetround
Protótipo: int fesetround(int round);

Tenta estabelecer um modo de arredondamento, retornando zero em sucesso. O inteiro

representado o arredondamento: round, deve ser um dos macros de arredondamento definidos
pela biblioteca.

Fe_dec_getround
Protótipo: int fe_dec_getround();

Retorna um inteiro que representa a atual direção de arredondamento dos pontos flutuantes
decimais. Esse inteiro é um dos macros de arredondamento.
Fe_dec_setround
Protótipo: int fe_dec_setround(int round);

Tenta estabelecer um modo de arredondamento, retornando zero em sucesso. O inteiro

representado o arredondamento: round, deve ser um dos macros de arredondamento definidos
pela biblioteca.

A tabela abaixo lista as funções afetadas pelo modo de arredondamento para pontos
flutuantes binários.

Cabeçalho Família de funções

<math.h> acos, acospi, asin, asinpi, atan, atan2, atan2pi, atanpi
<math.h> cos, cospi, sin, sinpi, tan, tanpi
<math.h> acosh, asinh, atanh
<math.h> cosh, sinh, tanh
<math.h> exp, exp10, exp10m1, exp2, exp2m1, expm1
<math.h> log, log10, log10p1, log1p, log2, log2p1, logp1
<math.h> scalbn, scalbln, ldexp
<math.h> cbrt, compoundn, hypot, pow, pown, powr, rootn, rsqrt, sqrt
<math.h> erf, erfc
<math.h> lgamma, tgamma
<math.h> rint, nearbyint, lrint, llrint
<math.h> fdim
<math.h> fma
fadd, dadd, fsub, dsub, fmul, dmul, fdiv, ddiv, ffma, dfma, fsqrt,
<math.h>
dsqrt
<stdlib.h> atof, strfrom, strto
<wchar.h> wcsto
<stdio.h> printf, scanf
<wchar.h> wprintf, wscanf

A tabela abaixo lista as funções afetadas pelo modo de arredondamento para pontos
flutuantes decimais.

Cabeçalho Família de funções

<math.h> acos, acospi, asin, asinpi, atan, atan2, atan2pi, atanpi
<math.h> cos, cospi, sin, sinpi, tan, tanpi
<math.h> acosh, asinh, atanh
<math.h> cosh, sinh, tanh
<math.h> exp, exp10, exp10m1, exp2, exp2m1, expm1
<math.h> log, log10, log10p1, log1p, log2, log2p1, logp1
<math.h> scalbn, scalbln, ldexp
<math.h> cbrt, compoundn, hypot, pow, pown, powr, rootn, rsqrt, sqrt
<math.h> erf, erfc
<math.h> lgamma, tgamma
<math.h> rint, nearbyint, lrint, llrint
<math.h> quantize
<math.h> fdim
<math.h> fma
d32add, d64add, d32sub, d64sub, d32mul, d64mul, d32div,
<math.h>
d64div,
 d32fma, d64fma, d32sqrt, d64sqrt
<stdlib.h> strfrom, strto
<wchar.h> wcsto
<stdio.h> printf, scanf
<wchar.h> wprintf, wscanf

Para mais sobre as funções da família de funções matemáticas: BIBLIOTECA <math.h>

Exceções
Toda operação de ponto flutuante pode levantar uma exceção, para representar um
comportamento específico dessa operação. Essas exceções são representadas pelos macros
definidos pela biblioteca, podendo os mesmos serem agrupados através de um bitwise OR para
representaram mais de uma exceção. Uma exceção quando levantada fica armazenada no
ambiente de ponto flutuante.

Os macros de exceções são os seguintes:

FE_DIVBYZERO FE_OVERFLOW
FE_INEXACT FE_UNDERFLOW
FE_INVALID FE_ALL_EXCEPT
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Esses macros são descritos na tabela de referência.

Feclearexcept
Protótipo: int feclearexcept(int excepts);

Tenta limpar as exceções especificadas pelo argumento excepts, em caso de sucesso, ou se o

argumento excepts possuir o valor de zero, é retornado zero, caso contrário um não-zero.

feraiseexcept
Protótipo: int feraiseexcept(int excepts);

Teta levantar as exceções especificadas pelo argumento excepts, em caso de sucesso, ou se o

argumento excepts possuir o valor de zero, é retornado zero, caso contrário um não-zero.

Caso tente levantar FE_OVERFLOW ou FE_UNDERFLOW, essa função pode adicionalmente

levantar FE_INEXACT, porém esse comportamento é implementation-defined.

Fegetexceptflag
Protótipo: int fegetexceptflag(fexcept_t* flagp, int excepts);

Captura as exceções do ambiente de ponto flutuante de acordo com o argumento excepts, e

grava no ponteiro flagp os estados das exceções capturadas.

Em caso de sucesso é retornado zero, caso contrário um não-zero.

fesetexceptflag
 Protótipo: int fesetexceptflag(const fexcept_t* flagp, int excepts);

Coloca as exceções que estão no ponteiro flagp, de acordo com o argumento excepts,
modificando o ambiente de ponto flutuante. Essa função não levanta nenhuma exceção,
somente modifica o estado do ambiente de ponto flutuante.

Em caso de sucesso, ou se o argumento excepts possuir o valor de zero, é retornado zero, caso
contrário um não-zero.

fesetexcept
Protótipo: int fesetexcept(int excepts);

Coloca as exceções especificadas pelo argumento excepts em um estado de levantadas,

modificando o ambiente de ponto flutuante. Essa função não levanta nenhuma exceção,
somente modifica o estado do ambiente de ponto flutuante.

Em caso de sucesso, ou se o argumento excepts possuir o valor de zero, é retornado zero, caso
contrário um não-zero.

fetestexcept
Protótipo: int fetestexcept(int excepts);

Testa se as exceções representadas pelo argumento excepts estão levantadas, retornando um

bitwise OR das exceções levantadas de acordo com o argumento except; um retorno de valor
zero representa que nenhuma exceção testada foi levantada.

Fetestexceptflag
Protótipo: int fetestexceptflag(const fexcept_t * flagp, int excepts);

Testa se as exceções representadas contidas no ponteiro flagp mascaradas com as exceções

representadas em excepts estão levantadas, retornando um bitwise OR das exceções
levantadas de acordo com o argumento flagp mascarado com except; um retorno de valor
zero representa que nenhuma exceção testada foi levantada.

Ambiente
fegetenv
Protótipo: int fegetenv(fenv_t* envp);

Uma tentativa de guarda todo o ambiente no objeto apontado por envp é feita, em sucesso é
retornado zero, caso contrário um não-zero.

fesetenv
Protótipo: int fesetenv(const fenv_t* envp);

Uma tentativa de setar todo o ambiente de ponto flutuante é feita, baseando-se no objeto
apontado por envp, em sucesso é retornado zero, caso contrário um não-zero.
O valor de envp pode ser o macro FE_DFL_ENV, restaurando o ambiente de ponto flutuante ao
seu estado padrão.

Feupdateenv
Protótipo: int feupdateenv(const fenv_t* envp);

Atualiza o estado do ambiente de ponto flutuante, baseado no objeto apontado por envp,
fazendo uma junção com as exceções levantadas antes da chamada da função.

Em sucesso é retornado zero, caso contrário um não-zero.

O valor de envp pode ser o macro FE_DFL_ENV, restaurando o ambiente de ponto flutuante ao
seu estado padrão.

Feholdexcept
Protótipo: int feholdexcept(fenv_t* envp);

Salva o estado atual do ambiente de ponto flutuante no objeto apontado por envp, limpa todas
flags do ambiente e coloca o mesmo no modo non-stop — operação futuras de ponto flutuante
não interromperão a execução do programa, se suportado — até uma chamada de
feupdateenv ou fesetenv.

Em sucesso é retornado zero, caso contrário um não-zero.

fegetmode
Protótipo: int fegetmode(femode_t *modep);

Uma tentativa de guarda todo o modo de controle no objeto apontado por modep é feita, em
sucesso é retornado zero, caso contrário um não-zero.

fesetmode
Protótipo: int fesetmode(const femode_t *modep);

Uma tentativa de setar todo o modo de controle baseando-se no objeto apontado por modep
é feito, em sucesso é retornado zero, caso contrário um não-zero.

O valor de envp pode ser o macro FE_DFL_MODE, restaurando os modos do ambiente de ponto
flutuante ao seu estado padrão.
 Biblioteca 6: float.h
Essa biblioteca é composta por macros que definem os limites e característica dos tipos de
pontos flutuantes, sendo que, os valores dos macros vão depender do sistema e da
implementação em o compilador C foi é executado.

Macros
Os macros que começam com FLT, DBL e LDBL representam valores para float, double e long
double respectivamente.

Macro Valor Significa Descrição

FLT_RADIX 2 ou maior RADIX Base para todos pontos flutuantes
FLT_MANT_DIG 6 ou maior
MANTissa
DBL_MANT_DIG 10 ou maior Precisão da mantissa
DIGits
LDBL_MANT_DIG 10 ou maior
FLT_DIG
Números de dígitos decimais que
6 ou maior
podem ser arredondados para um
DBL_DIG 10 ou maior DIGits
tipo p.f, e vice-versa sem a perda
10 ou maior
de precisão.
LDBL_DIG
Números de dígitos decimais que
FLT_DECIMAL_DIG 6 ou maior
DECIMAL podem ser convertidos para um
DBL_DECIMAL_DIG 10 ou maior
DIGits tipo p.f, e vice-versa sem a perda
LDBL_DECIMAL_DIG 10 ou maior
de precisão
FLT_MIN_EXP
MINimum
DBL_MIN_EXP Valor mínimo para um expoente
EXPonent
LDBL_MIN_EXP
FLT_MIN_10_EXP MINimum
Valor mínimo para um expoente
DBL_MIN_10_EXP -37 ou menor base-10
de uma expressão em base 10
LDBL_MIN_10_EXP EXPonent
FLT_MAX_EXP
MAXimum
DBL_MAX_EXP Valor máximo para um expoente
EXPonent
LDBL_MAX_EXP
FLT_MAX_10_EXP MAXimum
Valor máximo para um expoente
DBL_MAX_10_EXP 37 ou maior base-10
de uma expressão em base 10
LDBL_MAX_10_EXP EXPonent
FLT_MAX
1E+37 ou
DBL_MAX MAXimum Valor máximo finito
maior
LDBL_MAX
FLT_EPSILON
1E-5 ou menor
Diferença entre 1.0 e o próximo
DBL_EPSILON 1E-9 ou menor EPSILON
valor representável
1E-9 ou menor
LDBL_EPSILON
1E-37 ou
menor
FLT_MIN
1E-37 ou Valor mínimo, normalizado e
DBL_MIN MINimum
menor positivo representável.
LDBL_MIN
1E-37 ou
menor
FLT_TRUE_MIN 1E-37 ou
TRUE Valor mínimo positivo
DBL_TRUE_MIN menor
MINimun representável
LDBL_TRUE_MIN 1E-37 ou
 menor
1E-37 ou
menor
FLT_NORM_MAX
1E+37 ou NORMalized
DBL_NORM_MAX Valor máximo normalizado
maior Maximum
LDBL_NORM_MAX
Arredondamento.
-1: não determinado
0: para zero
1: para o mais próximo par
2: para positivo infinito
FLT_ROUNDS ROUND
3: para negativo infinito
4: para o mais próximo longe de
zero
Outros valores: implementation-
defined.
Propriedades do formato de
avaliação. Possíveis valores:
-1: não conhecido
0: alcance e precisão são naturais
do tipo
EVALuation 1: float e double tem avaliação
FLT_EVAL_METHOD
METHOD como double, e long double como
long double.
2: todos p.f são avaliados como
sendo do tipo long double
Valores negativos são
implementation-defined.
Números de dígitos decimais que
DECIMAL podem ser arredondados para um
DECIMAL_DIG
DIGits long double, e vice-versa sem a
perda de precisão.
Se o tipo suporta números
FLT_HAS_SUBNORM subnormais
SUBNORmal
DBL_HAS_SUBNORM -1: indeterminado
number
LDBL_HAS_SUBNORM 0: absento
1: presente
Se o tipo corresponde ao formato
IEC 60559
FLT_IS_IEC_60559
0: tipo não corresponde
DBL_IS_IEC_60559
1: tipo corresponde ao formato
LDBL_IS_IEC_60559
2: tipo corresponde ao formato,
inclusive suas operações
FLT_SNAN Expande pra uma expressão
Signaling Not
DBL_SNAN constante que representa um
A Number
LDBL_SNAN signaling NaN.
Expande para uma constante float
representado um positivo ou
INFINITY negativo infinito.
Somente definido caso a
implementação tenha suporte.
Expande para uma constante float
Not A representado um quiet NaN.
NAN
Number Somente definido caso a
implementação tenha suporte.
 Padronização K&R C89 C90 C95 C99 C11 C17 C23
*Os dados faltando na coluna valor, tem seus valores dependente da implementação.

Os macros abaixo só estão disponíveis se a implementação tem suporte aos tipos de ponto
flutuante decimal, introduzidos na padronização C23.

Os macros que começam com DEC32, DEC64 e DEC128 representam valores para _Decimal32,
_Decimal64 e _Decimal128 respectivamente.

Macro Valor Significa Descrição

DEC32_MANT_DIG 7 ou maior
MANTissa
DEC64_MANT_DIG 16 ou maior Precisão da mantissa.
DIGits
DEC128_MANT_DIG 34 ou maior
DEC32_MIN_EXP
MINimum
DEC64_MIN_EXP Valor mínimo para um expoente.
EXPonent
DEC128_MIN_EXP
DEC32_MAX_EXP
MAXimum
DEC64_MAX_EXP Valor máximo para um expoente
EXPonent
DEC128_MAX_EXP
DEC32_MAX
DEC64_MAX MAXimum Valor máximo finito
DEC128_MAX
DEC32_EPSILON 1E-6 ou menor
Diferença entre 1.0 e o próximo
DEC64_EPSILON 1E-15 ou menor EPSILON
valor representável
DEC128_EPSILON 1E-33 ou menor
1E-95 ou menor
DEC32_MIN 1E-383 ou
Valor mínimo, normalizado e
DEC64_MIN menor MINimum
positivo representável.
DEC128_MIN 1E-6143 ou
menor
DEC32_TRUE_MIN
TRUE
DEC64_TRUE_MIN Valor mínimo positivo representável
MINimun
DEC128_TRUE_MIN
Propriedades do formato de
avaliação. Possíveis valores:
-1: não conhecido
0: alcance e precisão são naturais
do tipo
EVALuation 1: _Decimal32 e _Decimal64 tem
DEC_EVAL_METHOD
METHOD avaliação como _Decimal64, e
_Decimal128 como _Decimal128.
2: todos p.f decimais são avaliados
como sendo do tipo _Decimal128
Valores negativos são
implementation-defined.
DEC32_SNAN Signaling Expande pra uma expressão
DEC64_SNAN Not A constante que representa um
DEC128_SNAN Number signaling NaN.
Expande para uma constante
DEC_INFINITY _Decimal32 representado um
positivo infinito.
Expande para uma constante
Not A
DEC_NAN _Decimal32 representado um quiet
Number
NaN.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
*Os dados faltando na coluna valor, tem seus valores dependente da implementação.
 Biblioteca 7: inttypes.h
Essa biblioteca define macros para permitir que os tipos inteiros definidos em <stdint.h> tenham
portabilidade entres compiladores.

Essa biblioteca foi adicionada a partir da padronização C99, e inclui automaticamente a

biblioteca <stdint.h>.

Referência
Identificador Tipo Descrição
struct imaxdiv_t Tipo de dado Representa o quociente e o restante da expressão x/y.
Computa o valor absoluto de um número do tipo
imaxabs Função
intmax_t.
Computa as expressões x/y e x%y em uma única
imaxdiv Função
operação.
Strtoimax Função Converte uma string em intmax_t.
strtoumax Função Converte uma string em uintmax_t.
wcstoimax Função Converte uma wide string em intmax_t.
wcstoumax Função Converte uma wide string em uintmax_t.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

struct imaxdiv_t
Um tipo, implementado como uma estrutura, que representa o quociente e o restante de uma
operação de divisão. Um valor desse tipo deve ser obtido chamando a função imaxdiv.

Os membros desse tipo são, quot e rem, representado o quociente e o restante de uma divisão
respectivamente; esses membros são do tipo intmax_t.

imaxabs
Protótipo: intmax_t imaxabs(intmax_t j);

Essa função calcula e retorna o valor absoluto de um inteiro j. Se o resultado não pode ser
representado seu comportamento é indefinido.

Imaxabs
Protótipo: imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);

Essa função computa e retorna os valores das operações numer/denom e numer%denon, em

um resultado do tipo imaxdiv_t.

strtoimax e strtoumax
Protótipos:
intmax_t strtoimax(const char * restrict nptr, char ** restrict endptr, int base);
uintmax_t strtoumax(const char * restrict nptr, char ** restrict endptr, int base);

Essas funções são equivalentes a strtol, strtoll, strtoul, strtoul, exceto que a string é convertida
para intmax_t e uimax_t respectivamente.
Essas funções retornam o valor convertido, ou zero se não houver conversão. Caso o valor está
fora do alcance dos valores representáveis, INTMAX_MAX, INTMAX_MIN, ou UINTMAX_MAX é
retornado, de acordo com o valor a ser representado, e o valor de ERANGE é armazenado em
errno.

Wcstoimax e wcstoumax
Protótipos:
intmax_t wcstoimax(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);

Essas funções são equivalentes a wcstol, wcstoll, wcstoul, wcstoul, exceto que a string larga é
convertida para intmax_t e uimax_t respectivamente.

Essas funções retornam o valor convertido, ou zero se não houver conversão. Caso o valor está
fora do alcance dos valores representáveis, INTMAX_MAX, INTMAX_MIN, ou UINTMAX_MAX é
retornado, de acordo com o valor a ser representado, e o valor de ERANGE é armazenado em
errno.

Macros
Os macros a seguir são expandidos para um literal do tipo string, cujo seu conteúdo é o
especificador solicitado para funções de entrada e saída que usam strings formatadas.
Geralmente são usados para as strings de controle da família de funções printf e scanf. Observe
que o caractere ‘%’ não é incluído na string.

Segue a tabela de referência:

Macro Descrição Exemplo

Família printf
PRIiMAX é o equivalente de i (em “%i”) para
PRIxMAX Especificador para intmax_t
valores intmax_t.
PRId16 é o equivalente de d (em “%d”) para
PRIxN Especificador para intN_t
valores int16_t.
Especificador para PRIuLEAST32 é o equivalente de u (em “%u”)
PRIxLEASTN
int_leastN_t for uint32_t.
Especificador para PRIxFAST8 é o equivalente de x (em “%x”) for
PRIxFASTN
int_fastN_t uint8_t.
PRIuPTR é o equivalente de u (em “%u”) para
PRIxPTR Especificador para intptr_t
valores uintptr_t.
Família scanf
SCNiMAX é o equivalente de i (em “%i”) para
SCNxMAX Especificador para intmax_t
valores intmax_t.
SCNd16 é o equivalente de d (em “%d”) para
SCNxN Especificador para intN_t
valores int16_t.
Especificador para SCNuLEAST32 é o equivalente de u (em “%u”)
SCNxLEASTN
int_leastN_t para valores uint32_t.
Especificador para SCNxFAST8 é o equivalente de x (em “%x”)
SCNxFASTN
int_fastN_t para valores uint8_t.
SCNuPTR é o equivalente de u (em “%u”) para
SCNxPTR Especificador para intptr_t
valores uintptr_t.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Onde:
• x deve ser um dos especificadores de formato: d, i, o, u ou x (para família printf pode usar
o especificador: x em caixa alta).

• N deve ser: 8, 16, 32, 64 ou outra largura suportada por <stdint.h>.

• Os especificadores assumem que d e i são inteiros com sinal; o, u, x e X é assumido como

um inteiro sem sinal.
 Biblioteca 8: isso646.h
Essa biblioteca define macros que servem como uma alternativa para as grafias dos operados
lógicos.

A biblioteca foi implementada a partir do C95.

Macros
Os macros abaixo expandem paras os seguintes operadores associados.

Macro Operador
and &&
and_eq &=
bitand &
bitor |
compl ~
not !
not_eq !=
or ||
or_eq |=
xor ^
xor_eq ^=
Padronização K&R C89 C90 C95 C99 C11 C17 C23
 Biblioteca 9: limits.h
Essa biblioteca define os limites básicos dos tipos inteiros, os valores dos limites são dependentes
da implementação e da plataforma.

São usados macros para representar todos os limites.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_FENV_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Macros
Macro Descrição Valor teórico
CHAR_BIT Números de bits em um objeto do tipo char 8 ou maior
SCHAR_MIN Valor mínimo de um objeto do tipo signed char -127 (-27+1) ou menor
SCHAR_MAX Valor máximo de um objeto do tipo signed char 127 (27-1) ou maior
Valor máximo de um objeto do tipo unsigned
UCHAR_MAX 255 (28-1) ou maior
char
CHAR_MIN Valor mínimo de um objeto do tipo char SCHAR_MIN ou 0
SCHAR_MAX ou
CHAR_MAX Valor máximo de um objeto do tipo char
UCHAR_MAX
Número máximo de bytes em um caractere
MB_LEN_MAX 1 ou maior
multibyte em qualquer locale
-32767 (-215+1) ou
SHRT_MIN Valor mínimo de um objeto do tipo short int
menor
SHRT_MAX Valor máximo de um objeto do tipo short int 32767 (215-1) ou maior
Valor máximo de um objeto do tipo unsigned
USHRT_MAX 65535 (216-1) ou maior
short int
-32767 (-215+1) ou
INT_MIN Valor mínimo de um objeto do tipo int
menor
INT_MAX Valor máximo de um objeto do tipo int 32767 (215-1) ou maior
UINT_MAX Valor mínimo de um objeto do tipo unsigned int 65535 (216-1) ou maior
-2147483647 (-231+1)
LONG_MIN Valor mínimo de um objeto do tipo long int
ou menor
2147483647 (231-1) ou
LONG_MAX Valor máximo de um objeto do tipo long int
maior
Valor máximo de um objeto do tipo unsigned long 4294967295 (232-1) ou
ULONG_MAX
int maior
-9223372036854775807
LLONG_MIN Valor mínimo de um objeto do tipo long long int
(-263+1) ou menor
9223372036854775807
LLONG_MAX Valor máximo de um objeto do tipo long long int
(263-1) ou maior
Valor máximo de um objeto do tipo unsigned long 18446744073709551615
ULLONG_MAX
long int (264-1) ou maior
BOOL_WIDTH Largura de bit do tipo _Bool 1 ou maior
CHAR_WDITH Largura de bit de um byte 8 ou maior
SCHAR_WIDTH Largura de bits do tipo signed char 8 ou maior
 UCHAR_WIDTH Largura de bits do tipo unsigned char 8 ou maior
SHRT_WIDTH Largura de bits do tipo short 16 ou maior
USHRT_WIDTH Largura de bits do tipo unsigned short 16 ou maior
INT_WIDTH Largura de bits do tipo int 16 ou maior
UINT_WIDTH Largura de bits do tipo unsigned int 16 ou maior
LONG_WIDTH Largura de bits do tipo long 32 ou maior
ULONG_WIDTH Largura de bits do tipo unsigned long 32 ou maior
LLONG_WIDTH Largura de bits do tipo long long 64 ou maior
ULLONG_WIDTH Largura de bits do tipo unsigned long long 64 ou maior
Largura máxima de bits dos tipos _BitInt e
BITINT_MAXWIDTH 64 ou maior
unsigned _BitInt
K&R C89 C90 C95 C99 C11 C17 C23
Padronização
 Biblioteca 10: locale.h
Essa biblioteca é responsável por gerenciar a localidade do programa, uma localidade
representa características e formatos de informações idiomáticas usada pelo programa,
geralmente o formato de números e valores monetários.

Referências
Identificador Tipo Descrição
Tipo de Estrutura representando as informações sobre a
struct lconv
dado localidade.
Setlocale Função Define ou recupera a localidade.
Retorna informações sobre a atual configuração da
Localeconv Função
localidade.
LC_ALL Macro Representa toda a localização.
LC_COLLATE Macro Afeta o comportamento das funções strcoll e strxfrm.
Afeta o comportamento de todas funções de
LC_CTYPE Macro
manipulação de caracteres curtos, largos e multibytes.
Afeta a informação monetária retornada por
LC_MONETARY Macro
localeconv.
Afeta operações de e/s e funções de formatação de
LC_NUMERIC Macro
strings, além da informação retornada por localeconv.
LC_TIME Macro Afeta o comportamento da função strftime e wcsftime.
NULL Macro Representa um valor nulo.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O macro NULL é declarado nas bibliotecas <stddef> — implementação fonte —, <stdio.h>, <stdlib.h>,
<string.h>, <time.h>, <uchar.h>, e <wchar.h>.

struct lconv
Essa estrutura contém informações sobre a localização, cada membro representa uma
configuração especifica.

Valor
Membro Tipo Descrição
padrão
Formatação numérica
Ponto decimal usado para quantidade não
decimal_point char* “.”
monetárias.
Caractere usado para separar grupos de
Thousands_sep char* “”
números para quantidades não monetárias.
String que dita o tamanho dos grupos
Grouping char* “”
separados por thousands_sep.
Formatação monetária
Ponto decimal usado para quantidades
mon_decimal_point char* “”
monetárias.
Caractere usado para separar grupos de
Mon_thousands_sep char* “”
números para quantidades monetárias
String que dita o tamanho dos grupos
mon_grouping char* “”
separados por mon_thousands_sep.
Sinal usado para quantidades monetárias
Positive_sign char* “”
não-negativas.
 Sinal usado para quantidades monetárias
Negative_sign char* “”
negativas.
Formatação monetária local
currency_symbol char* “” Símbolo da moeda local.
Números de dígitos após o ponto decimal
Frac_digits char CHAR_MAX
para quantidades monetárias locais.
Definido como 1 se o símbolo de moeda
preceder o valor para a quantidade
P_cs_precedes char CHAR_MAX
monetária local não negativa. Definido
como 0 se o símbolo seguir o valor.
Definido como 1 se o símbolo de moeda
preceder o valor para a quantidade
N_cs_precedes char CHAR_MAX
monetária local negativa. Definido como 0
se o símbolo suceder o valor.
Definido como 1 se o símbolo de moeda for
separado por espaço do valor para a
P_sep_by_space char CHAR_MAX quantidade monetária local não negativa.
Definido como 0 se não houver nenhuma
separação por espaço.
Definido como 1 se o símbolo de moeda for
separado por espaço do valor para a
N_sep_by_space char CHAR_MAX quantidade monetária local negativa.
Definido como 0 se não houver nenhuma
separação por espaço.
Posição do sinal positivo em quantidades
monetárias locais não negativas.
0: Símbolo de moeda e sinal cercado por
parênteses.
1: Sinal antes da quantidade e do símbolo
P_sign_posn char CHAR_MAX de moeda.
2: Sinal depois da quantidade e do símbolo
de moeda.
3: Sinal antes do símbolo de moeda.
4: Sinal depois do símbolo de moeda.
CHAR_MAX: Não especificado.
Posição do sinal negativo em quantidades
monetárias locais negativas.
0: Símbolo de moeda e sinal cercado por
parênteses.
1: Sinal antes da quantidade e do símbolo
N_sign_posn char CHAR_MAX de moeda.
2: Sinal depois da quantidade e do símbolo
de moeda.
3: Sinal antes do símbolo de moeda.
4: Sinal depois do símbolo de moeda.
CHAR_MAX: Não especificado.
Formatação monetária internacional
String de 3 letras que segue a padronização
int_curr_symbol char* “” ISSO-4217 seguido do símbolo de moeda
internacional.
Mesmo que frac_digits, mas para formato
Int_frac_digits char CHAR_MAX
internacional.
Mesmo que p_cs_precedes, mas para formato
Int_p_cs_precedes char CHAR_MAX
internacional.
 Mesmo que n_cs_precedes, mas para formato
Int_n_cs_precedes char CHAR_MAX
internacional.
Mesmo que p_sep_by_space, mas para
Int_p_sep_by_space char CHAR_MAX
formato internacional.
Mesmo que n_sep_by_space mas para formato
Int_n_sep_by_space char CHAR_MAX
internacional.
Mesmo que p_sign_posn, mas para formato
Int_p_sign_posn char CHAR_MAX
internacional.
Mesmo que n_sign_posn mas, para formato
Int_n_sign_posn char CHAR_MAX
internacional.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

setlocale
Protótipo: char* setlocale (int category, const char* locale);

Função que altera toda a localização do atual programa ou partes do mesmo, usando os
macros definidos em <locale.h>, quando alterado com sucesso a localização, a função retorna
uma string que representa a localização usada como argumento, em falha um ponteiro nulo é
retornado.

A localização a ser aplicada é especificada pela string locale.

Para alterar somente partes os macros: LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC ou

LC_TIME, devem ser usados como categorias específicas, para representar todas as partes, o
macro LC_ALL é usado.

Para recuperar a atual localização, o argumento locale deve ser nulo, sendo assim, a string da
localização atual será retornada.

Para designar uma localização de acordo com o ambiente, o argumento locale deve ser uma
string vazia – “”.

As strings das localizações suportados são definidos pela implementação, porém a

padronização especifica ao menos duas strings de localização:

Nome Descrição
“C” Localização padrão
“” Localização do ambiente padrão

A localização “C” é a localização padrão da implementação, e é implicitamente definida

quando todo programa inicia. Já a localização “” usa as variáveis ambientes para definir uma
localização do sistema em que o programa está executando.

Localeconv
Protótipo: struct lconv *localeconv(void);

Essa função retorna um ponteiro para uma estrutura do tipo lconv, ondes a mesma possui as
informações numéricas e monetárias sobre a atual localização.

Essa estrutura não deve ser modificada.

Observações
A localização no C é bastante criticada, visto que a configuração de localidade é armazenada
em espaços globais. Isso significa que todas operações de localidade em um programa só pode
ocorrer com uma localidade específica por vez.
 Biblioteca 11: math.h
Essa biblioteca é usada para operações matemáticas. Ela define tipos, macros e várias rotinas
usada para computações matemáticas.

Originalmente essas funções foram implementadas em cima do tipo double, porém a partir do
C99, versões alternativas dessas funções utilizando o tipo float e long double foram
implementadas. Seguindo tal organização, a começar pelo C23 outras versões utilizando os
tipos decimais: _Decimal32, _Decimal64 e _Decimal128, foram implementadas.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_MATH_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Tipos
Os tipos definidos nessa biblioteca podem ser avaliados de forma diferente há depender da
implementação.

Tipo Descrição
float_t Pelo menos tão largo quanto um float
double_t Pelo menos tão largo quanto um double
_Decimal32_t Pelo menos tão largo quanto um _Decimal32
_Decimal64_t Pelo menos tão largo quanto um _Decimal64
Padronização K&R C89 C90 C95 C99 C11 C17 C23

A forma como cada tipo acima é avaliada é dependente do valor dos macros
FLT_EVAL_METHOD e DEC_EVAL_METHOD, definidos na biblioteca <float.h>, sendo mostrado
abaixo as possibilidades.

FLT_EVAL_METHOD float_t é avaliado como double_t é avaliado como

0 float double
1 double double
2 long double long double
Outro valor implementation-defined implementation-defined
Padronização K&R C89 C90 C95 C99 C11 C17 C23

DEC_EVAL_METHOD _Decimal32_t é avaliado como _Decimal64_t é avaliado como

0 _Decimal32 _Decimal64
1 _Decimal64 _Decimal64
2 _Decimal128 _Decimal128
Outro valor implementation-defined implementation-defined
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Macros
 Tipo
Macro Descrição
expandido
INFINITY float Representa o infinito positivo
DEC_INFINITY _Decimal32 Representa o infinito positivo
NAN float Representa um não número
DEC_NAN _Decimal32 Representa um não número
HUGE_VAL double Maior valor finito de double
HUGE_VALF float Maior valor finito de float
HUGE_VALL long double Maior valor finito de long double
HUGE_VAL_D32 _Decimal32 Maior valor finito de _Decimal32
HUGE_VAL_D32 _Decimal64 Maior valor finito de _Decimal64
HUGE_VAL_D32 _Decimal128 Maior valor finito de _Decimal128
math_errhandling int Atual método de erro
MATH_ERRNO Possíveis valores de math_errhandling, sendo
int
MATH_ERREXCEPT os inteiros 1 e 2 respectivamente
FP_FAST_FMA
Define a eficiência das funções fma, fmaf e
FP_FAST_FMAF int
fmal
FP_FAST_FMAL
FP_FAST_FMAD32
Define a eficiência das funções fmad32,
FP_FAST_FMAD64 int
fmad64 e fmad128
FP_FAST_FMAD128
FP_FAST_FADD
FP_FAST_FADDL
FP_FAST_DADDL Define a eficiência das funções fadd, faddl,
int
FP_FAST_D32ADDD64 daddl, d32add64, d32add128 e d64add128
FP_FAST_D32ADDD128
FP_FAST_D64ADDD128
FP_FAST_FSUB
FP_FAST_FSUBL
FP_FAST_DSUBL Define a eficiência das funções fsub, fsubl,
int
FP_FAST_D32SUBD64 dsubl, d32subd64, d32subd128 e d64subd128
FP_FAST_D32SUBD128
FP_FAST_D64SUBD128
FP_FAST_FMUL
FP_FAST_FMULL
FP_FAST_DMULL Define a eficiência das funções fmul, fmull,
int
FP_FAST_D32MULD64 dmull, d32muld64, d32muld128 e d64muld128
FP_FAST_D32MULD128
FP_FAST_D64MULD128
FP_FAST_FDIV
FP_FAST_FDIVL
FP_FAST_DDIVL Define a eficiência das funções fdiv, fdivl,
int
FP_FAST_D32DIVD64 ddivl, d32div64, d32divd128 e d64divd128
FP_FAST_D32DIVD128
FP_FAST_D64DIVD128
FP_FAST_FSQRT
FP_FAST_FSQRTL
FP_FAST_DSQRTL Define a eficiência das funções fsqrt, fsqrtl,
int
FP_FAST_D32SQRTD64 dsqrtl, d32sqrtd64, d32sqrtd64 e d64sqrt128
FP_FAST_D32SQRTD128
FP_FAST_D64SQRTD128
FP_FAST_FFMA
FP_FAST_FFMAL
FP_FAST_DFMAL Define a eficiência das funções ffma, ffmal,
int
FP_FAST_D32FMAD64 d32mad64, d32fmad128 e d64fmad128
FP_FAST_D32FMAD128
FP_FAST_D64FMAD128
 FP_INFINITE
FP_NAN
FP_NORMAL int Possíveis valores retornados por fpclassify
FP_SUBNORMAL
FP_ZERO
FP_INT_UPWARD Valores usados como segundo argumento das
FP_INT_DOWNWARD famílias de funções:
FP_INT_TOWARDZERO int fromfp, fromfpx, ufromfp e ufromfpx
FP_INT_TONEARESTFROMZERO Representam um método de
FP_INT_TONEAREST arredondamento
FP_ILOGB0
int Valores especiais retornados por ilogb
FP_ILOGBNAN
FP_LLOGB0
int Valores especiais retornados por llogb
FP_LLOGBNAN
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Os macros INFINITY, DEC_INFINITY, NAN, e DEC_NAN, são declarados obsoletos no C23, devendo ser
utilizados através dos macros em <float.h>.

Macros FP_FAST
Esses macros se presentes indicam que sua função associada opera com mais rapidez e
precisão do que uma expressão correspondente a função.

FP_FAST_FMA
FP_FAST_FADD

FP_FAST_FSUB

FP_FAST_FMUL

FP_FAST_FDIV

FP_FAST_FSQRT

FP_FAST_FFMA

Macros FP_FAST
Esses macros podem ser retornados pelas famílias de funções: ilogb e llogb.

FP_ILOGB0

FP_ILOGBNAN

FP_LLOGB0

FP_LLOGBNAN

math_errhandling
Esse macro pode possuir um dos seguintes valores: MATH_ERRNO, MATH_ERREXCEPT, ou
MATH_ERRNO|MATH_ERREXCEPT, e define qual método de erro a biblioteca utiliza.
Sendo:
 MATH_ERRNO, para a utilização da variável errno.
MATH_ERREXCEPT, para a utilização do ambiente de exceções em <fenv.h>.
MATH_ERRNO|MATH_ERREXCEPT para os dois métodos acimas descritos.

Funções macros
Exceto por fpclassify, todas funções a seguir servem para um teste booleano, retornando um
não-zero para representar o valor booleano true e um zero para representa o valor false.

Função Descrição Argumentos

Classificação
fpclassify Classifica um ponto flutuante 1
isfinite Testa se x é valor finito 1
isinf Testa se x é valor infinito 1
isnan Testa se x é um NaN 1
isnormal Testa se x é normal 1
signbit Testa o bit de sinal de x 1
iszero Testa se x é zero 1
issubnormal Testa se x é subnormal 1
iscanonical Testa se x é canônico 1
issignaling Testa se x é um signaling NaN 1
Comparação
iseqsig x é igual a y 2
isgreater x é maior que y 2
isgreaterequal x é maior ou igual a y 2
isless x é menor que y 2
islessequal x é menor ou igual a y 2
islessgreater x é menor ou maior que y 2
isunordered x ou y é desordenado 2
Padronização K&R C89 C90 C95 C99 C11 C17 C23

fpclassify
Essa função macro retorna um inteiro que especifica a categoria do ponto flutuante passado
como argumento.

O inteiro retornado é associado aos macros a seguir:

Macro Descrição
FP_INFINITE Positivo ou negativo overflow
FP_NAN Not-A-Number
FP_ZERO Valor de zero
FP_SUBNORMAL Sub-normal underflow
FP_NORMAL Valor normal (nenhum dos acima)
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O resultado dessa função pode ser um valor de uma categoria implementation-defined.

Macros de arredondamentos
Esses macros de arredondamento, devem ser utilizados com as famílias de funções: fromfp,
ufromfp, fromfpx e ufromfpx.
 Macros Descrição Equivalente a — fenv.h
FP_INT_UPWARD Arredondamento para cima FE_UPWARD
FP_INT_DOWNWARD Arredondamento para baixo FE_DOWNWARD
FP_INT_TOWARDZERO Próximo de zero FE_TOWARDZERO
Inteiro mais próximo longe de
FP_INT_TONEARESTFROMZERO FE_TONEARESTFROMZERO
zero
FP_INT_TONEAREST Inteiro mais próximo FE_TONEAREST
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções
As funções dessa biblioteca, assim como as da biblioteca complex.h, seguem uma organização
padrão, todas recebem um ou mais argumentos do tipo double, e retornam um valor do tipo
double.

Exemplo: uma função hipoteticamente nomeada de fteste.

Seu protótipo seria:

double fteste(double);

Porém a começar com o C99 as funções podem apresentar versões que utilizam float ou long
double como argumento e retorno, para identificar essas funções, seus nomes terminam com o
caractere f, caso a rotina trabalhe com um float, ou o caractere l, para especificar um long
double.

Exemplo: duas funções hipoteticamente nomeadas de ftestef e ftestl.

Seus protótipos seria:

float ftestef(float);
long double ftestel(long double);

Para os tipos decimas, implementados a partir do C23, os caracteres finais são: d32, d64 e d128
para: _Decimal32, _Decimal64 e _Decimal128 respectivamente.

Exemplo: três funções hipoteticamente nomeadas de ftested32, ftestd64 e ftested128.

Seus protótipos seria:

_Decimal32 ftested32(_Decimal32);
_Decimal64 ftested64(_Decimal64);
_Decimal128 ftested128(_Decimal128);

Funções com mais de um argumento possuem o mesmo tipo para todos argumentos, no caso
o tipo de dado da função.

Poucas funções da biblioteca math.h não seguem esse padrão de organização.

Segue abaixo uma lista de referência, usando somente o nome das funções, seus protótipos são
formados de acordo com seus nomes — seguindo o padrão da biblioteca.

As funções especificas cujo há uma quebra da padronização de nomenclatura são sinalizadas

com um asterisco, e descritas posteriormente.

Argumento
Função Descrição
s
Operações gerais
fabs Computa o valor absoluto de um ponto flutuante 1
 fabsf Se o valor de entrada é x, o retorno da função será
fabsl |x|
fabsd32
fabsd64
fabsd128
fmod
fmodf
Computa o restante da divisão de um ponto
fmodl
flutuante 2
fmod32
O retorno será o restante da operação x/y
fmod64
fmod128
remainder
remainderf
Computa o restante da divisão de um ponto
remainderl
flutuante de acordo com o IEC 60559 2
remainderd32
A operação será: X REM Y
remainderd64
remainderd128
remquo
remquof Computa o quociente e o restante de uma divisão 3*
remquol
fma
fmaf
fmal Computa uma operação de multiply–accumulate
3*
fmad32 Operação equivalente à: (x * y) + z
fmad64
fmad128
fadd
faddl
Computa a soma de x e y, arredondado o
daddl
resultado para o tipo da função de acordo com o 2*
d32addd64
modo de arredondamento
d32addd128
d64addd128
fsub
fsubl
Computa a diferença de x e y, arredondado o
dsubl
resultado para o tipo da função de acordo com o 2*
d32subd64
modo de arredondamento
d32asubd128
d64subd128
fmul
fmull
Computa o produto de x e y, arredondado o
dmull
resultado para o tipo da função de acordo com o 2*
d32muld64
modo de arredondamento
d32muld128
d64muld128
fdiv
fdivl
Computa o quociente de x e y, arredondado o
ddivl
resultado para o tipo da função de acordo com o 2*
d32divd64
modo de arredondamento
d32divd128
d64divd128
ffma
ffmal Computa a multiply–accumulate de x, y e z: (x * y) +
dfmal z, arredondado o resultado para o tipo da função 3*
d32fmad64 de acordo com o modo de arredondamento
d32fmad128
 d64fmad128
fsqrt
fsqrtl
Computa a raiz quadrada de x, arredondado o
dsqrtl
resultado para o tipo da função de acordo com o 1*
d32sqrtd64
modo de arredondamento
d32sqrtd128
d64sqrtd128
fmax
fmaxf
fmaxl
Retorna o maior valor dos argumentos 2
fmaxd32
fmaxd64
fmaxd128
fmin
fminf
fminl
Retorna o menor valor dos argumentos 2
fmind32
fmind64
fmind128
fmaximum
fmaximumf
fmaximuml
Retorna o maior valor dos argumentos 2
fmaximumd32
fmaximumd64
fmaximumd128
fminimum
fminimumf
fminimuml
Retorna o menor valor dos argumentos 2
fminimumd32
fminimumd64
fminimumd128
fmaximum_mag
fmaximum_magf
fmaximum_magl
Retorna o argumento com maior magnitude 2
fmaximum_magd32
fmaximum_magd64
fmaximum_magd128
fminimum_mag
fminimum_magf
fminimum_magl
Retorna o argumento com menor magnitude 2
fminimum_magd32
fminimum_magd64
fminimum_magd128
fmaximum_num
fmaximum_numf
Retorna o maior valor dos argumentos
fmaximum_numl
Difere da família fmaximum somente no tratamento 2
fmaximum_numd32
de números NaN
fmaximumd_num64
fmaximumd_num128
fminimum_num
fminimum_numf
Retorna o menor valor dos argumentos
fminimum_numl
Difere da família fminimum somente no tratamento 2
fminimum_numd32
de números NaN
fminimum_numd64
fminimum_numd128
 fmaximum_mag_num
fmaximum_mag_numf
fmaximum_mag_numl
fmaximum_mag_numd3 Retorna o argumento com maior magnitude
2 Difere da família fmaximum_mag somente no 2
fmaximum_mag_numd6 tratamento de números NaN
4
fmaximum_mag_numd1
28
fminimum_mag_num
fminimum_mag_numf
fminimum_mag_numl Retorna o argumento com menor magnitude
fminimum_mag_numd32 Difere da família fminimum_mag somente no 2
fminimum_mag_numd64 tratamento de números NaN
fminimum_mag_numd12
8
fdim
fdimf Retorna a diferença positiva dos argumentos
fdiml Onde:
2
fdimd32 x – y se x > y
fdimd64 +0 se x < y
fdimd128
nan
nanf
nanl
Retorna um quiet NaN 1*
nand32
nand64
nand128
Exponenciais
exp
expf
Computa a potência da constante Euler elevada a
expl
x 1
expd32
ex
expd64
expd128
exp10
exp10f
exp10l Computa a potência de base 10 elevada a x
1
exp10d32 10x
exp10d64
exp10d128
exp2
exp2f
exp2l Computa a potência de base 2 elevada a x
1
exp2d32 2x
exp2d64
exp2d128
expm1
expm1f
Computa a potência da constante Euler eleva a x,
expm1l
somando a -1 1
expm1d32
ex-1
expm1d64
expm1d128
 exp10m1
exp10m1f
Computa a potência de base 10 elevada a x
exp10m1l
menos 1 1
exp10m1d32
10x - 1
exp10m1d64
exp10m1d128
exp2m1
exp2m1f
Computa a potência de base 2 elevada a x menos
exp2m1l
1 1
exp2m1d32
2x - 1
exp2m1d64
exp2m1d128
log
logf
logl Retorna o logaritmo natural de x
1
logd32 loge x
logd64
logd128
log10
log10f
log10l Computa o logaritmo de x na base 10
1
log10d32 log10 x
log10d64
log10d128
log10p1
log10p1f
log10p1l Computa o logaritmo de 1 + x na base 10
1
log10p1d32 log10 (1+x)
log10p1d64
log10p1d128
log2
log2f
log2l Computa o logaritmo de x na base 2
1
log2d32 log2 x
log2d64
log2d128
log1p
log1pf
log1pl
log1pd32
log1pd64
log1pd128 Computa o logaritmo natural de 1 somado com x
1
logp1 loge (1+x)
logp1f
logp1l
logp1d32
logp1d64
logp1d128
log2p1
log2p1f
Computa o logaritmo de base 2 de 1 somado com
log2p1l
x 1
log2p1d32
log2(1 +x)
log2p1d64
log2p1d128
Potenciação
 pow
powf
powl Computa a potência de x elevado a y
2
powd32 xy
powd64
powd128
pown
pownf
Computa a potência de x elevado a nº
pownl 2*
xn
pownd32
pownd64
powr
powrf
Computa a potência de x elevado a n, sendo
powrl
equivalente a 𝑒 𝑛 𝑙𝑜𝑔𝑒 𝑥 2
powrd32
xn = 𝑒 𝑛 𝑙𝑜𝑔𝑒 𝑥
powrd64
powrd128
rootn
rootnf
Computa a raiz enésima yº de x
rootnl 𝑦
√𝑥 2*
rootnd32
rootnd64
rootnd128
sqrt
sqrtf
sqrtl Computa da raiz quadrada de um número x
1
sqrtd32 √𝑥
sqrtd64
sqrtd128
rsqrt
rsqrtf
Computa da raiz quadrada inversa de um número x
rsqrtl 1 1
rsqrtd32
rsqrtd64 √𝑥
rsqrtd128
cbrt
cbrtf
cbrtl Computa a raiz cubica de um número x
1
cbrtd32 3
√𝑥
cbrtd64
cbrtd128
hypot
hypotf
Computa a raiz quadrada da soma do quadrado
hypotl
de dois números x e y 2
hypotd32
√𝑥 2 + 𝑦 2
hypotd64
hypotd128
compoundn
compoundnf
compoundnl Computa a potência de 1 + x elevado a y
2*
compoundnd32 (1+x)y
compoundnd64
compoundnd128
Trigonométrica
sin 1
 sinf
sinl
Computa o seno de um número x medido em
sind32
radianos
sind64
sind128
cos
cosf
cosl Computa o cosseno de um número x medido em
1
cosd32 radianos
cosd64
cosd128
tan
tanf
tanl Computa a tangente de um número x medido em
1
tand32 radianos
tand64
tand128
asin
asinf
asinl Computa o arco seno de um número x no intervalo
π π 1
asind32 [− 2 , + 2 ]
asind64
asind128
acos
acosf
acosl Computa o arco cosseno de um número x no
1
acosd32 intervalo [0, π]
acosd64
acosd128
atan
atanf
atanl Computa o arco tangente de um número x no
π π 1
atand32 intervalo [− 2 , + 2 ]
atand64
atand128
atan2
atan2f
atan2l Computa o arco tangente de um número y/x no
2
atan2d32 intervalo [-π, +π]
atan2d64
atan2d128
asinpi
asinpif
asinpil Computa o principal valor de um arco seno x
1 1 1
asinpid32 dividido por π no intervalo [− , + ]
2 2
asinpid64
asinpid128
acospi
acospif
acospil Computa o principal valor de um arco cosseno x
1
acospid32 dividido por π no intervalo [0, 1]
acospid64
acospid128
 tanpi
tanpif
tanpil Computa o principal valor de um arco tangente x
1 1 1
tanpid32 dividido por π no intervalo [− 2 , + 2]
tanpid64
tanpid128
atan2pi
atan2pif
atan2pil Computa o arco tangente de um número x dividido
2
atan2pid32 por π, em um intervalo [-1, +1]
atan2pid64
atan2pid128
sinpi
sinpif
sinpil
Computa o seno de (π * x) 1
sinpid32
sinpid64
sinpid128
cospi
cospif
cospil
Computa o cosseno de (π * x) 1
cospid32
cospid64
cospid128
tanpi
tanpif
tanpil
Computa a tangente de (π * x) 1
tanpid32
tanpid64
tanpid128
Hiperbólicas
sinh
sinhf
sinhl
Computa o seno hiperbólico de um número x 1
sinhd32
sinhd64
sinhd128
cosh
coshf
coshl
Computa o cosseno hiperbólico de um número x 1
coshd32
coshd64
coshd128
tanh
tanhf
tanhl
Computa a tangente hiperbólica de um número x 1
tanhd32
tanhd64
tanhd128
asinh
asinhf Computa o arco seno hiperbólico de um número x 1
asinhl
 asinhd32
asinhd64
asinhd128
acosh
acoshf
acoshl Computa o arco cosseno hiperbólico de um
1
acoshd32 número x no intervalo [0, +∞]
acoshd64
acoshd128
atanh
atanhf
atanhl Computa o arco tangente hiperbólica de um
1
atanhd32 número x
atanhd64
atanhd128
Erro e gama
erf
erff
erfl
Computa uma função erro de x 1
erfd32
erfd64
erfd128
erfc
erfcf
erfcl
Computa uma função erro complementar de x 1
erfcd32
erfcd64
erfcd128
tgamma
tgammaf
tgammal
Computa uma função gama de x 1
tgammad32
tgammad64
tgammad128
lgamma
lgammaf
lgammal
Computa o logaritmo natural da função gama de x 1
lgammad32
lgammad64
lgammad128
Arredondamento
ceil
ceilf
ceill
Arredondamento para cima 1
ceild32
ceild64
ceild128
floor
floorf
floorl
Arredondamento para baixo 1
floord32
floord64
floord128
 trunc
truncf
truncl
Trunca um número para seu valor inteiro 1
truncd32
truncd64
truncd128
round
roundf
Arredonda um número para o inteiro mais próximo
roundl
longe de zero, sem considerar o atual modo de 1
roundd32
arredondamento
roundd64
roundd128
lround
lroundf Arredonda um número para o inteiro mais próximo
lroundl longe de zero, sem considerar o atual modo de
1*
lroundd32 arredondamento
lroundd64 Retornam um inteiro longo
lroundd128
llround
llroundf Arredonda um número para o inteiro mais próximo
llroundl longe de zero, sem considerar o atual modo de
1*
llroundd32 arredondamento
llroundd64 Retornam um inteiro duplamente longo
llroundd128
roundeven
roundevenf
Arredonda um número para o inteiro mais próximo,
roundevenl
em algumas vezes ímpar, sem considerar o atual 1
roundevend32
modo de arredondamento
roundevend64
roundevend128
nearbyint
nearbyintf
Arredonda um número para um inteiro baseando-
nearbyintl
se no modo de arredondamento, essa função não 1
nearbyintd32
levanta a exceção FE_INEXACT
nearbyintd64
nearbyintd128
rint
rintf
Arredonda um número para um inteiro baseando-
rintl
se no modo de arredondamento, podendo 1
rintd32
levantar a exceção FE_INEXACT
rintd64
rintd128
lrint
lrintf Arredonda um número para um inteiro baseando-
lrintl se no modo de arredondamento, podendo
1*
lrintd32 levantar a exceção FE_INEXACT
lrintd64 Retornam um inteiro longo
lrintd128
llrint
llrintf Arredonda um número para um inteiro baseando-
llrintl se no modo de arredondamento, podendo
1*
llrintd32 levantar a exceção FE_INEXACT
llrintd64 Retornam um inteiro duplamente longo
llrintd128
 fromfp
fromfpf Arredonda um número x para um inteiro, no
fromfpl intervalo y de acordo com o modo indicado por r
3*
fromfpd32 Sendo o intervalo: — [−2(y−1), 2(y−1) − 1]
fromfpd64 Essa função não levanta a exceção FE_INEXACT
fromfpd128
ufromfp
Arredonda um número x para um inteiro sem sinal,
ufromfpf
no intervalo y de acordo com o modo indicado por
ufromfpl
r 3*
ufromfpd32
Sendo o intervalo: — [0, 2y − 1]
ufromfpd64
Essa função não levanta a exceção FE_INEXACT
ufromfpd128
fromfpx
fromfpxf Arredonda um número x para um inteiro, no
fromfpxl intervalo y de acordo com o modo indicado por r
3*
fromfpxd32 Sendo o intervalo: — [−2(y−1), 2(y−1) − 1]
fromfpxd64 Essa função pode levantar a exceção FE_INEXACT
fromfpxd128
ufromfpx
Arredonda um número x para um inteiro sem sinal,
ufromfpxf
no intervalo y de acordo com o modo indicado por
ufromfpxl
r 3*
ufromfpxd32
Sendo o intervalo: — [0, 2y − 1]
ufromfpxd64
Essa função pode levanta a exceção FE_INEXACT
ufromfpxd128
Manipulação de ponto flutuante
frexp
frexpf
frexpl Quebra um número em uma fração normalizada e
2*
frexpd32 um expoente
frexpd64
frexpd128
ldexp Multiplica um número x pela potência de base 2
ldexpf elevado a y quando é usado um ponto flutuante
ldexpl padrão
ou 2*
ldexpd32
Multiplica um número x pela potência de base 10
ldexpd64
elevado a y quando é usado um ponto flutuante
ldexpd128
decimal
modf
modff
modfl
Quebra um número em parte inteira e fracionária 2*
modfd32
modfd64
modfd128
scalbn Multiplica um número x pela potência de FLT_RADIX
scalbnf elevado a y quando usado um ponto flutuante
scalbnl padrão
𝑥 ∗ 𝐹𝐿𝑇_𝑅𝐴𝐷𝐼𝑋 𝑦
ou 2*
scalbnd32
Multiplica um número x pela potência de 10
scalbnd64
elevado a y quando usado um ponto flutuante
scalbnd128
decimal
𝑥 ∗ 10𝑦
 scalbln Multiplica um número x pela potência de FLT_RADIX
scalblnf elevado a y quando usado um ponto flutuante
scalblnl padrão
𝑥 ∗ 𝐹𝐿𝑇_𝑅𝐴𝐷𝐼𝑋 𝑦
ou 2*
scalblnd32
Multiplica um número x pela potência de 10
scalblnd64
elevado a y quando usado um ponto flutuante
scalblnd128
decimal
𝑥 ∗ 10𝑦
logb
logbf
logbl
Retorna o expoente unbiased de um número x 1
logbd32
logbd64
logbd128
ilogb
ilogbf
ilogbl Retorna o expoente unbiased de um número x
1*
ilogbd32 como um inteiro
ilogbd64
ilogbd128
llogb
llogbf
llogbl Retorna o expoente unbiased de um número x
1*
llogbd32 como um inteiro longo
llogbd64
llogbd128
nextafter
nextafterf
nextafterl Determina o próximo ponto flutuante representável
2
nextafterd32 depois de x em direção a y
nextafterd64
nextafterd128
nexttoward
nexttowardf
nexttowardl Determina o próximo ponto flutuante representável
2*
nexttowardd32 depois de x em direção a y
nexttowardd64
nexttowardd128
nextup
nextupf
nextupl Determina o próximo valor representável maior que
1
nextupd32 x
nextupd64
nextupd128
nextdown
nextdownf
nextdownl Determina o próximo valor representável menor que
1
nextdownd32 x
nextdownd64
nextdownd128
canonicalize
canonicalizef Produz uma versão canônica de ponto flutuante x,
2*
canonicalizel e armazena em y
canonicalized32
 canonicalized64
canonicalized128
copysign
copysignf
copysignl Produz um número com a magnitude de x e o sinal
2
copysignd32 de y
copysignd64
copysignd128
Quantização
quantized32
Retorna um valor que possui o valor numérico de x
quantized64 2
e o expoente quantizado de y
quantized128
samequantumd32
Retorna verdadeiro se x e y possui o mesmo
samequantumd64 2*
expoente quantizado, falso se contrário
samequantumd128
quantumd32
quantumd64 Retorna o valor quantizado de x 1
quantumd128
llquantexpd32
Retorna o valor quantizado de x como um inteiro
llquantexpd64 1*
longo
llquantexpd128
Recodificação
encodedecd32 Codifica um decimal y no esquema baseado na
encodedecd64 codificação decimal, armazenando o resultado no 2*
encodedecd128 ponteiro x
decodedecd32 Decodifica um decimal apontado por y no
decodedecd64 esquema baseado na codificação decimal, 2*
decodedecd128 armazenando o resultado no ponteiro x
encodebind32 Codifica um decimal y no esquema baseado na
encodebind64 codificação decimal, armazenando o resultado no 2*
encodebind128 ponteiro x
decodebind32 Decodifica um decimal apontado por y no
decodebind64 esquema baseado na codificação decimal, 2*
decodebind128 armazenando o resultado no ponteiro x
Padronização K&R C89 C90 C95 C99 C11 C17 C23

remquo
Protótipo:
double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y, int *quo);

Essas funções computam o quociente e o restante operação x/y, sendo o restante retornado
pela função e o quociente armazenado no objeto apontado pelo ponteiro quo.

fma
Protótipo:
double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y, long double z);
_Decimal32 fmad32(_Decimal32 x, _Decimal32 y, _Decimal32 z);
 _Decimal64 fmad64(_Decimal64 x, _Decimal64 y, _Decimal64 z);
_Decimal128 fmad128(_Decimal128 x, _Decimal128 y, _Decimal128 z);

Essas funções fazem a seguinte computação: a soma de z com o produto de x e y, retornando

assim o resultado: (x*y)+z.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FMA double fma()
FP_FAST_FMAF floatfmaf()
FP_FAST_FMAL long double fmal()
FP_FAST_FMAD32 _Decimal32 fmad32()
FP_FAST_FMAD64 _Decimal64 fmad64()
FP_FAST_FMAD128 _Decimal128 fmad128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão:
(x*y)+z.

fadd
Protótipo:
float fadd(double x, double y);
float faddl(long double x, long double y);
double daddl(long double x, long double y);
_Decimal32 d32addd64(_Decimal64 x, _Decimal64 y);
_Decimal32 d32addd128(_Decimal128 x, _Decimal128 y);
_Decimal64 d64addd128(_Decimal128 x, _Decimal128 y);

Essas funções retornam a soma de x e y, arredondado para o tipo de retorno especifico da

função, geralmente: float ou double para pontos flutuantes binários, ou, _Decimal32 ou
_Decimal64 para pontos flutuantes decimais, não há retorno de tipos: long double e
_Decimal128. O método de arredondamento é levado em consideração.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FADD float fadd()
FP_FAST_FADDL float faddl()
FP_FAST_DADDL double daddl()
FP_FAST_D32ADDD64 _Decimal32 d32addd64()
FP_FAST_D32ADDD128 _Decimal32 d32addd128()
FP_FAST_D64ADDD128 _Decimal64 d64addd128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão: x+y
seguida por uma conversão.

fsub
Protótipo:
float fsub(double x, double y);
 float fsubl(long double x, long double y);
double dsubl(long double x, long double y);
_Decimal32 d32subd64(_Decimal64 x, _Decimal64 y);
_Decimal32 d32subd128(_Decimal128 x, _Decimal128 y);
_Decimal64 d64subd128(_Decimal128 x, _Decimal128 y);

Essas funções retornam a diferença de x e y, arredondado para o tipo de retorno especifico da

função, geralmente: float ou double para pontos flutuantes binários, ou, _Decimal32 ou
_Decimal64 para pontos flutuantes decimais, não há retorno de tipos: long double e
_Decimal128. O método de arredondamento é levado em consideração.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FSUB float fsub()
FP_FAST_FSUBL float fsubl()
FP_FAST_DSUBL double dsubl()
FP_FAST_D32SUBD64 _Decimal32 d32subd64()
FP_FAST_D32SUBD128 _Decimal32 d32subd128()
FP_FAST_D64SUBD128 _Decimal64 d64subd128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão: x-y
seguida por uma conversão.

fmul
Protótipo:
float fmul(double x, double y);
float fmull(long double x, long double y);
double dmull(long double x, long double y);
_Decimal32 d32muld64(_Decimal64 x, _Decimal64 y);
_Decimal32 d32muld128(_Decimal128 x, _Decimal128 y);
_Decimal64 d64muld128(_Decimal128 x, _Decimal128 y);

Essas funções retornam o produto de x e y, arredondado para o tipo de retorno especifico da

função, geralmente: float ou double para pontos flutuantes binários, ou, _Decimal32 ou
_Decimal64 para pontos flutuantes decimais, não há retorno de tipos: long double e
_Decimal128. O método de arredondamento é levado em consideração.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FMUL float fmul()
FP_FAST_FMULL float fmull()
FP_FAST_DMULL double dmull()
FP_FAST_D32MULD64 _Decimal32 d32muld64()
FP_FAST_D32MULD128 _Decimal32 d32muld128()
FP_FAST_D64MULD128 _Decimal64 d64muld128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão: x*y
seguida por uma conversão.
fdiv
Protótipo:
float fdiv(double x, double y);
float fdivl(long double x, long double y);
double ddivl(long double x, long double y);
_Decimal32 d32divd64(_Decimal64 x, _Decimal64 y);
_Decimal32 d32divd128(_Decimal128 x, _Decimal128 y);
_Decimal64 d64divd128(_Decimal128 x, _Decimal128 y);

Essas funções retornam o quociente de x e y, arredondado para o tipo de retorno especifico da

função, geralmente: float ou double para pontos flutuantes binários, ou, _Decimal32 ou
_Decimal64 para pontos flutuantes decimais, não há retorno de tipos: long double e
_Decimal128. O método de arredondamento é levado em consideração.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FDIV float fdiv()
FP_FAST_FDIVL float fdivl()
FP_FAST_DDIVL double ddivl()
FP_FAST_D32DIVD64 _Decimal32 d32divd64()
FP_FAST_D32DIVD128 _Decimal32 d32divd128()
FP_FAST_D64DIVD128 _Decimal64 d64divd128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão: x/y
seguida por uma conversão.

ffma
Protótipo:
float ffma(double x, double y, double z);
float ffmal(long double x, long double y, long double z);
double dfmal(long double x, long double y, long double z);
_Decimal32 d32fmad64(_Decimal64 x, _Decimal64 y, _Decimal64 z);
_Decimal32 d32fmad128(_Decimal128 x, _Decimal128 y, _Decimal128 z);
_Decimal64 d64fmad128(_Decimal128 x, _Decimal128 y, _Decimal128 z);

Essas funções retornam a operação de (x*y)+z, arredondado para o tipo de retorno especifico
da função, geralmente: float ou double para pontos flutuantes binários, ou, _Decimal32 ou
_Decimal64 para pontos flutuantes decimais, não há retorno de tipos: long double e
_Decimal128. O método de arredondamento é levado em consideração.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FFMA float ffma()
FP_FAST_FFMAL float ffmal()
FP_FAST_DFMAL double dfmal()
FP_FAST_D32FMAD64 _Decimal32 d32fmad64()
FP_FAST_D32FMAD128 _Decimal32 d32fmad128()
 FP_FAST_D64FMAD128 _Decimal64 d64fmad128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão:
(x*y)+z seguido por uma conversão.

fsqrt
Protótipo:
float fsqrt(double x);
float fsqrtl(long double x);
double dsqrtl(long double x);
_Decimal32 d32sqrtd64(_Decimal64 x);
_Decimal32 d32sqrtd128(_Decimal128 x);
_Decimal64 d64sqrtd128(_Decimal128 x);

Essas funções retornam a raiz quadrada de x, arredondado para o tipo de retorno especifico
da função, geralmente: float ou double para pontos flutuantes binários, ou, _Decimal32 ou
_Decimal64 para pontos flutuantes decimais, não há retorno de tipos: long double e
_Decimal128. O método de arredondamento é levado em consideração.

Essa família de funções tem uma relação com os macros pré-definidos:

Macro Função correspondente

FP_FAST_FSQRT float fsqrt()
FP_FAST_FSQRTL float fsqrtl()
FP_FAST_DSQRTL double dsqrtl()
FP_FAST_D32SQRTD64 _Decimal32 d32sqrtd64()
FP_FAST_D32SQRTD128 _Decimal32 d32sqrtd128()
FP_FAST_D64SQRTD128 _Decimal64 d64sqrtd128()
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Se caso alguns destes macros estiver definido pela implementação, significa que a função
correspondente ao macro pode ser avaliada mais rápida e mais precisa que a expressão: srqt(x)
seguido por uma conversão.

nan
Protótipo:
float nanf( const char* arg );
double nan( const char* arg );
long double nanl( const char* arg );

Retornam um ponto flutuante que representa um quiet NaN da string numérica representa pelo
ponteiro arg.

pown
Protótipo:
double pown(double x, long long int n);
float pownf(float x, long long int n);
long double pownl(long double x, long long int n);
 _Decimal32 pownd32(_Decimal32 x, long long int n);
_Decimal64 pownd64(_Decimal64 x, long long int n);
_Decimal128 pownd128(_Decimal128 x, long long int n);

Essas funções calculam a potência de um número x, elevado ao valor inteiro de n: xn

Diferente das funções pow, as funções pown recebem um inteiro longo como segundo
argumento.

rootn
Protótipo:
double rootn(double x, long long int n);
float rootnf(float x, long long int n);
long double rootnl(long double x, long long int n);
_Decimal32 rootnd32(_Decimal32 x, long long int n);
_Decimal64 rootnd64(_Decimal64 x, long long int n);
_Decimal128 rootnd128(_Decimal128 x, long long int n);

Essas funções calculam a raiz enésima de um índice inteiro n de um número x: √𝑥

𝑛

Diferente do padrão da biblioteca, as funções rootn recebem um inteiro longo como segundo
argumento.

compoundn
Protótipo:
double compoundn(double x, long long int n);
float compoundnf(float x, long long int n);
long double compoundnl(long double x, long long int n);
_Decimal32 compoundnd32(_Decimal32 x, long long int n);
_Decimal64 compoundnd64(_Decimal64 x, long long int n);
_Decimal128 compoundnd128(_Decimal128 x, long long int n);

Essas funções calculam a potência da soma de 1+x, elevada ao expoente n: (1+x)n

Diferente do padrão da biblioteca, as funções compoundn recebem um inteiro longo como

segundo argumento.

lround
Protótipo:
long int lround(double x);
long int lroundf(float x);
long int lroundl(long double x);
long int lroundd32(_Decimal32 x);
long int lroundd64(_Decimal64 x);
long int lroundd128(_Decimal128 x)
Essas funções arredondam um número x, para o inteiro mais próximo longe de zero. Operam
igual a round e llround, porém retornam um inteiro longo. Não são afetadas pelo atual modo
de arredondamento.

llround
Protótipo:
long long int llround(double x);
long long int llroundf(float x);
long long int llroundl(long double x);
long long int llroundd32(_Decimal32 x);
long long int llroundd64(_Decimal64 x);
long long int llroundd128(_Decimal128 x);

Essas funções arredondam um número x, para o inteiro mais próximo longe de zero. Operam
igual a round e lround, porém retornam um inteiro duplamente longo. Não são afetadas pelo
atual modo de arredondamento.

lrint
Protótipo:
long int lrint(double x);
long int lrintf(float x);
long int lrintl(long double x);
long int lrintd32(_Decimal32 x);
long int lrintd64(_Decimal64 x);
long int lrintd128(_Decimal128 x);

Essas funções arredondam um número x, para o inteiro mais próximo. Operam igual a rint e llrint,
porém retornam um inteiro longo. Elas são afetadas pelo atual modo de arredondamento.

llrint
Protótipo:
long long int llrint(double x);
long long int llrintf(float x);
long long int llrintl(long double x);
long long int llrintd32(_Decimal32 x);
long long int llrintd64(_Decimal64 x);
long long int llrintd128(_Decimal128 x);

Essas funções arredondam um número x, para o inteiro mais próximo. Operam igual a rint e lrint,
porém retornam um inteiro duplamente longo. Elas são afetadas pelo atual modo de
arredondamento.

fromfp
Protótipo:
double fromfp(double x, int rnd, unsigned int width);
 float fromfpf(float x, int rnd, unsigned int width);
long double fromfpl(long double x, int rnd, unsigned int width);
_Decimal32 fromfpd32(_Decimal32 x, int rnd, unsigned int width);
_Decimal64 fromfpd64(_Decimal64 x, int rnd, unsigned int width);
_Decimal128 fromfpd128(_Decimal128 x, int rnd, unsigned int width);

Arredondam um número x para um inteiro, no intervalo width de acordo com o modo indicado
por rnd.

Sendo o intervalo: — [−2(width−1), 2(width−1) − 1].

O modo de arredondamento indicado por rnd deve ser um dos macros de arredondamento
da biblioteca math.h.

Diferente do padrão da biblioteca, as funções fromfp recebem um inteiro sem sinal como
terceiro argumento.

Os macros usados como segundo argumento são especificados na tabela de macros.

ufromfp
Protótipo:
double ufromfp(double x, int rnd, unsigned int width);
float ufromfpf(float x, int rnd, unsigned int width);
long double ufromfpl(long double x, int rnd, unsigned int width);
_Decimal32 ufromfpd32(_Decimal32 x, int rnd, unsigned int width);
_Decimal64 ufromfpd64(_Decimal64 x, int rnd, unsigned int width);
_Decimal128 ufromfpd128(_Decimal128 x, int rnd, unsigned int width);

Arredondam um número x para um inteiro sem sinal, no intervalo width de acordo com o
modo indicado por rnd.

Sendo o intervalo: — [0, 2width − 1].

O modo de arredondamento indicado por rnd deve ser um dos macros de arredondamento
da biblioteca math.h.

Diferente do padrão da biblioteca, as funções ufromfp recebem um inteiro sem sinal como
terceiro argumento.

Os macros usados como segundo argumentos são especificados na tabela de macros.

fromfpx
Protótipo:
double fromfpx(double x, int rnd, unsigned int width);
float fromfpxf(float x, int rnd, unsigned int width);
long double fromfpxl(long double x, int rnd, unsigned int width);
_Decimal32 fromfpxd32(_Decimal32 x, int rnd, unsigned int width);
_Decimal64 fromfpxd64(_Decimal64 x, int rnd, unsigned int width);
_Decimal128 fromfpxd128(_Decimal128 x, int rnd, unsigned int width);

Arredondam um número x para um inteiro, no intervalo width de acordo com o modo indicado
por rnd.
Sendo o intervalo: — [−2(width−1), 2(width−1) − 1].

O modo de arredondamento indicado por rnd deve ser um dos macros de arredondamento
da biblioteca math.h.

Diferente do padrão da biblioteca, as funções fromfpx recebem um inteiro sem sinal como
terceiro argumento.

Essas funções atuam exatamente iguais as suas contrapartes fromfp, com a diferença que
essas funções podem levantar a exceção FE_INEXACT.

Os macros usados como segundo argumentos são especificados na tabela de macros.

ufromfpx
Protótipo:
double ufromfpx(double x, int rnd, unsigned int width);
float ufromfpxf(float x, int rnd, unsigned int width);
long double ufromfpxl(long double x, int rnd, unsigned int width);
_Decimal32 ufromfpxd32(_Decimal32 x, int rnd, unsigned int width);
_Decimal64 ufromfpxd64(_Decimal64 x, int rnd, unsigned int width);
_Decimal128 ufromfpxd128(_Decimal128 x, int rnd, unsigned int width);

Arredondam um número x para um inteiro sem sinal, no intervalo width de acordo com o
modo indicado por rnd.

Sendo o intervalo: — [0, 2width − 1].

O modo de arredondamento indicado por rnd deve ser um dos macros de arredondamento
da biblioteca math.h.

Diferente do padrão da biblioteca, as funções ufromfpx recebem um inteiro sem sinal como
terceiro argumento.

Essas funções atuam exatamente iguais as suas contrapartes ufromfpx, com a diferença que
essas funções podem levantar a exceção FE_INEXACT.

Os macros usados como segundo argumentos são especificados na tabela de macros.

frexp
Protótipo:
double frexp(double value, int *p);
float frexpf(float value, int *p);
long double frexpl(long double value, int *p);
_Decimal32 frexpd32(_Decimal32 value, int *p);
_Decimal64 frexpd64(_Decimal64 value, int *p);
_Decimal128 frexpd128(_Decimal128 value, int *p);

Essas funções quebram um número em ponto flutuante value, em uma fração normalizada e
um expoente inteiro. Retornando a fração e armazenando o expoente no objeto apontado por
p.
ldexp
Protótipo:
double ldexp(double x, int p);
float ldexpf(float x, int p);
long double ldexpl(long double x, int p);
_Decimal32 ldexpd32(_Decimal32 x, int p);
_Decimal64 ldexpd64(_Decimal64 x, int p);
_Decimal128 ldexpd128(_Decimal128 x, int p);

Essas funções multiplicam o ponto flutuante x pela potência integral de expoente p.

Quando as funções ldexp, ldexpf e ldexpl são chamadas, a potência usada é de base 2: x * 2p.

Já quando as funções ldexpd32, ldexpd64 e ldexpd128 são chamadas, a potência usada é de

base 10: x * 10p.

modf
Protótipo:
double modf(double x, double *iptr);
float modff(float x, float *iptr);
long double modfl(long double x, long double *iptr);
_Decimal32 modfd32(_Decimal32 x, _Decimal32 *iptr);
_Decimal64 modfd64(_Decimal64 x, _Decimal64 *iptr);
_Decimal128 modfd128(_Decimal128 x, _Decimal128 *iptr);

Retornam a parte fracionária de um número x e armazena sua parte inteira no objeto apontado
por iptr.

scalbn
Protótipo:
double scalbn(double x, int n);
float scalbnf(float x, int n);
long double scalbnl(long double x, int n);
_Decimal32 scalbnd32(_Decimal32 x, int n);
_Decimal64 scalbnd64(_Decimal64 x, int n);
_Decimal128 scalbnd128(_Decimal128 x, int n);

Essas funções computam o produto de um número x pela potência de base integral elevada
pelo expoente n.

Quando as funções scalbn, scalbnf e scalbnl são chamadas, a potência usada é de base
FLT_RADIX: x * FLT_RADIXn.

Já quando as funções scalbnd32, scalbnd64 e scalbnd128 são chamadas, a potência usada é

de base 10: x * 10n.

Diferente do padrão da biblioteca, as funções scalbn recebem retornam um inteiro como

resultado.
scalbln
Protótipo:
double scalbln(double x, long int n);
float scalblnf(float x, long int n);
long double scalblnl(long double x, long int n);
_Decimal32 scalblnd32(_Decimal32 x, long int n);
_Decimal64 scalblnd64(_Decimal64 x, long int n);
_Decimal128 scalblnd128(_Decimal128 x, long int n);

Essas funções computam o produto de um número x pela potência de base integral elevada
pelo expoente n.

Quando as funções scalbln, scalblnf e scalblnl são chamadas, a potência usada é de base
FLT_RADIX: x * FLT_RADIXn.

Já quando as funções scalblnd32, scalblnd64 e scalblnd128 são chamadas, a potência usada

é de base 10: x * 10n.

Diferente do padrão da biblioteca, as funções scalbln recebem retornam um inteiro longo como
resultado, sendo essa característica a única diferença dessas funções para as funções scalbn.

ilogb
Protótipo:
int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);
int ilogbd32(_Decimal32 x);
int ilogbd64(_Decimal64 x);
int ilogbd128(_Decimal128 x);

Essas funções extraem o expoente unbiased do número x.

Essas funções funcionam exatamente igual as funções logb, com a diferença na quebra de
padrão, pois elas retornam um inteiro.

O valor de retorno pode ser representado por um dos seguintes macros abaixo, de acordo com
valor de x.

Caso Resultado de retorno — Macro

x seja zero FP_ILOGB
x seja NaN FP_ILOGBNAN
x seja infinito INT_MAX
Padronização K&R C89 C90 C95 C99 C11 C17 C23

llogb
Protótipo:
long int llogb(double x);
long int llogbf(float x);
long int llogbl(long double x);
long int llogbd32(_Decimal32 x);
 long int llogbd64(_Decimal64 x);
long int llogbd128(_Decimal128 x);

Essas funções extraem o expoente unbiased do número x.

Essas funções funcionam exatamente igual as funções logb, com a diferença na quebra de
padrão, pois elas retornam um inteiro longo.

O valor de retorno pode ser representado por um dos seguintes macros abaixo, de acordo com
valor de x.

Caso Resultado de retorno — Macro

x seja zero FP_LLOGB
x seja NaN FP_LLOGBNAN
x seja infinito LONG_MAX
Padronização K&R C89 C90 C95 C99 C11 C17 C23

nexttoward
Protótipo:
double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);
_Decimal32 nexttowardd32(_Decimal32 x, _Decimal128 y);
_Decimal64 nexttowardd64(_Decimal64 x, _Decimal128 y);
_Decimal128 nexttowardd128(_Decimal128 x, _Decimal128 y);

Essas funções retorna o próximo ponto flutuante representável x, na direção de y.

Elas operam exatamente como as funções nextafter, porém com a diferença de que o segundo
argumento será um long double para as funções: nexttoward, nexttowardf e nexttowardl, ou
um _Decimal128 para as funções: nexttowardd32, nexttowardd64 e nexttowardd128.

canonicalize
Protótipo:
int canonicalize(double * cx, const double * x);
int canonicalizef(float * cx, const float * x);
int canonicalizel(long double * cx, const long double * x);
int canonicalized32(_Decimal32 cx, const _Decimal32 * x);
int canonicalized64(_Decimal64 cx, const _Decimal64 * x);
int canonicalized128(_Decimal128 cx, const _Decimal128 * x);

Essas funções tentam produzir uma versão de um ponto flutuante canônico de x, e armazenam
o resultado no objeto apontado por cx.

Elas retornam zero se o resultado canônico foi armazenado com sucesso em cx, e um não zero
caso contrário.

samequantumd32
Protótipo:
bool samequantumd32(_Decimal32 x, _Decimal32 y);
 bool samequantumd64(_Decimal64 x, _Decimal64 y);
bool samequantumd128(_Decimal128 x, _Decimal128 y);

Essas funções testam se os números x e y possuem o mesmo expoente quantizados.

Diferente do padrão da biblioteca, as funções samequantumd32 retornam um booleano.

llquantexpd32
Protótipo:
long long int llquantexpd32(_Decimal32 x);
long long int llquantexpd64(_Decimal64 x);
long long int llquantexpd128(_Decimal128 x);

Essas funções computa o expoente quantizado de um número x.

Diferente do padrão da biblioteca, as funções llquantexpd32 retornam um inteiro longo. Caso

o argumento de x for infinito ou um NaN, o retorno é igual ao macro LLONG_MIN.

encodedecd32
Protótipo:
void encodedecd32(unsigned char encptr[restrict static 4],
const _Decimal32*restrict xptr);
void encodedecd64(unsigned char encptr[restrict static 8],
const _Decimal64*restrict xptr);
void encodedecd128(unsigned char encptr[restrict static 16],
const _Decimal128*restrict xptr);

Essas funções codificam um ponto flutuante decimal apontado por xptr e armazenam o
resultado no array apontado por encptr.

Elas não retornam nada.

A codificação usada é uma codificação de ponto flutuante decimal.

decodedecd32
Protótipo:
void decodedecd32(_Decimal32 * restrict xptr,
const unsigned char encptr[restrict static 4]);
void decodedecd64(_Decimal64 * restrict xptr,
const unsigned char encptr[restrict static 8]);
void decodedecd128(_Decimal128 * restrict xptr,
const unsigned char encptr[restrict static 16])

Essas funções decodificam o array apontado por encptr, e armazenam o resultado como um
ponto flutuante decimal apontado por xptr.

Elas não retornam nada.

A codificação usada é uma codificação de ponto flutuante decimal.

encodebind32
Protótipo:
void encodebind32(unsigned char encptr[restrict static 4],
const _Decimal32 * restrict xptr);
void encodebind64(unsigned char encptr[restrict static 8],
const _Decimal64 * restrict xptr);
void encodebind128(unsigned char encptr[restrict static 16],
const _Decimal128 * restrict xptr);

Essas funções codificam um ponto flutuante decimal apontado por xptr e armazenam o
resultado no array apontado por encptr.

Elas não retornam nada.

A codificação usada é uma codificação de ponto flutuante binário.

decodebind32
Protótipo:
void decodebind32(_Decimal32 * restrict xptr,
const unsigned char encptr[restrict static 4]);
void decodebind64(_Decimal64 * restrict xptr,
const unsigned char encptr[restrict static 8]);
void decodebind128(_Decimal128 * restrict xptr,
const unsigned char encptr[restrict static 16]);

Essas funções decodificam o array apontado por encptr, e armazenam o resultado como um
ponto flutuante decimal apontado por xptr.

Elas não retornam nada.

A codificação usada é uma codificação de ponto flutuante binário.

 Biblioteca 12: setjmp.h
Essa biblioteca é usada para passar as restrições imposta por um pulo local — como por
exemplo: uma rotina de chamada de função —, preservando o ambiente em meio aos pulos.

Referências
Identificador Tipo Descrição
longjmp Função Realiza um jump
setjump Função macro Salva o ambiente para um jump
Retém informação para restaurar o
jmp_buf Tipo de dado
ambiente
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções
setjump
Sintaxe: int setjmp (jmp_buf env);

Essa função serve para especificar um ponto de execução no código usando o argumento env
como ambiente de execução, funcionando semelhante a um label. Numa chamada direta ela
retorna zero, a partir disso seu retorno é determinado pela chamada de longjmp.

O padrão não especifica se ela é implementada como sendo um macro ou um identificador

com ligação externa.

longjmp
Sintaxe: void longjmp (jmp_buf env, int val);

Realiza um jump para o ponto de execução especificado pelo argumento env, passando o
argumento val como retorno para a função setjmp.

O valor de val — que será o retorno de setjmp — não deve ser 0, caso seja setjmp retornará o
valor de 1.

Tipos
jmp_buf
Representa o atual ambiente de execução.

Esse tipo armazena as informações necessárias para restaurar o ambiente previamente salvo.

Essas informações não incluem estados de flags de ponto flutuante, arquivos abertos, ou
qualquer outro componente de máquina abstrato.
 Biblioteca 13: signal.h
A biblioteca <signal.h> serve para a manipulação de sinais do ambiente em que o programa C
roda.

Um sinal é uma mensagem enviada para o processo que representa o programa, ela pode ser
enviada tanto pelo kernel, quanto pelo próprio programa. Essa mensagem, denominada sinal,
pode ter um tratamento especifico ou um tratamento de rotina padrão.

Referência
Identificador Tipo Descrição
signal Função Manipula um sinal recebido
raise Função Levanta um sinal
Tipo inteiro para sinais
sig_atomic_t Tipo de dados
assíncronos
SIG_DFL Função macro Handler default
SIG_IGN Função macro Ignora um sinal
SIG_ERR Função macro Erro de sinal
SIGABRT Macro Representa um sinal
SIGFPE Macro Representa um sinal
SIGILL Macro Representa um sinal
SIGINT Macro Representa um sinal
SIGSEGV Macro Representa um sinal
SIGTERM Macro Representa um sinal
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções
signal
Protótipo: void (*signal(int sig, void (*func)(int)))(int);

Essa função serve para registrar um handler para um sinal determinado por sig, sendo o handler
especificado pelo parâmetro func — um ponteiro para função do tipo void que recebe um int.
Esse handler é a função de callback que será invocada quando o sinal acontecer, sendo que
signal chama a função passada juntamente com o valor de sig.

O tipo de retorno dessa função é o mesmo tipo do parâmetro func. Se a função obtiver sucesso,
o handler anterior é retornado caso haja algum, em caso de falha em registrar o procedimento
para um determinado sinal, então SIG_ERR é retornado e errno pode ser colocado como um
valor inteiro positivo.

raise
Protótipo: int raise (int sig);

Levanta um sinal representado por sig para o atual programa em execução.

Retorna zero em sucesso ou um não-zero caso contrário.

Macros
Os macros abaixo são usados para representar os sinais no ambiente em que o programa
executa. A implementação está livre para poder definir sinais adicionais.

Macro Sinal
SIGABRT (Signal Abort) Termino anormal
(Signal Floating-Point Exception) Operação aritmética errônea, como por exemplo
SIGFPE
divisão por zero, ou overflow (não necessariamente uma operação de p.f)
(Signal Illegal Instruction) Imagem ilegal, tal como uma instrução invalida. É
SIGILL
gerado por uma corrupção no código ou a tentativa de executar dados.
SIGINT (Signal Interrupt) Sinal de atenção interativa. Geralmente gerada pela aplicação.
(Signal Segmentation Violation) Acesso de armazenamento inválido: Quando um
SIGSEGV
programa tenta ler ou escrever fora de sua memória alocada.
SIGTERM (Signal Terminate) Requisição de termino para o programa.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Os macros abaixo são expandidos para uma função que recebem um int e retorna void, são
usados para a manipulação dos sinais. Podem ser usados como segundo argumento da função
signal.

SIG_DFL Default handling: O sinal é manipulado pela ação padrão

SIG_IGN Ignore Signal: O sinal é ignorado
SIG_ERR Erro. Quando retornado por signal representa um erro
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Tipos
sig_atomic_t
Um tipo inteiro que pode ser acessado como uma entidade atômica mesmo na presença de
sinais assíncronos.
 Biblioteca 14: stdalign.h
Definições de macros usados como alternativas para as palavras-chave _Alignas e _Alignof,
além de macros que expande para inteiros que determinam se as palavras-chave estão ou não
definidas.

Macro Expande para

alignas Expande para a palavra-chave _Alignas
alignof Expande para a palavra-chave _Alignof
__alignas_is_defined Expande para a constante inteira: 1
__alignof_is_defined Expande para a constante inteira: 1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Observação:

A partir do C23 esse cabeçalho não prover nenhum conteúdo.

 Biblioteca 15: stdarg.h
Essa biblioteca faz possível o uso de funções com argumentos variáveis.

Ela define os seguintes identificadores.

Identificador Tipo
va_type typedef
va_start Function-macro
va_arg Function-macro
va_end Function-macro
va_copy Function-macro
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Como a biblioteca funciona é explicada no subtópico Argumentos variáveis do capítulo de

funções.
 Biblioteca 16: stdatomic.h
Essa biblioteca é implementada a partir da padronização C11, ela tem seu conteúdo e sua
implementação opcional. Sua utilidade é a de gerenciar e manipular tipos e operações
atômicas.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_STDATOMIC_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Macros
Essa biblioteca define os seguintes macros.

ATOMIC_BOOL_LOCK_FREE ATOMIC_SHORT_LOCK_FREE
ATOMIC_CHAR_LOCK_FREE ATOMIC_INT_LOCK_FREE
ATOMIC_CHAR8_T_LOCK_FREE ATOMIC_LONG_LOCK_FREE
ATOMIC_CHAR16_T_LOCK_FREE ATOMIC_LLONG_LOCK_FREE
ATOMIC_CHAR32_T_LOCK_FREE ATOMIC_POINTER_LOCK_FRE
ATOMIC_WCHAR_T_LOCK_FREE ATOMIC_FLAG_INIT
ATOMIC_VAR_INIT – Depreciado no C17, removido no kill_dependency
C23
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Esses macros — exceto por ATOMIC_FLAG_INIT, ATOMIC_VAR_INIT e kill_dependency —,

expandem para um valor que pode ser usado em diretivas de pré-processamento de
condicionais de inclusão, que indica que o tipo indicado possui uma propriedade lock-free.
Esses macros expandem para:

Valor Significado
0 O tipo atômico nunca é lock-free.
1 O tipo atômico as vezes é lock-free.
2 O tipo atômico é sempre lock-free.

O macro ATOMIC_FLAG_INIT expando para um inicializador adequado para um objeto do tipo

atomic_flag, o estado inicializado é clear.

O macro ATOMIC_VAR_INIT é um macro-função:

#define ATOMIC_VAR_INIT(value) /* unspecified */

Ela expande para um inicializador adequado para uma variável atômica do tipo igual ao tipo
passado para valor.

O macro kill_dependency é um macro-função:

Pseudo protótipo: type kill_dependency(type y);

Essa função-macro informa ao compilador que a expressão y deve ter seu valor removida da
arvore de dependência. Ela retorna o valor de y.
Tipos
Identificador Tipo
memory_order Enumeração
struct atomic_flag Estrutura
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Além dos tipos mencionados acimas, essa biblioteca tem declarações de apelidos de tipos,
usados para a criação de objetos de determinados tipos atômicos.

Segue os tipos declaradas abaixo:

Declaração typedef Tipo equivalente

atomic_bool _Atomic _Bool
atomic_char _Atomic char
atomic_schar _Atomic signed char
atomic_uchar _Atomic unsigned char
atomic_short _Atomic short
atomic_ushort _Atomic unsigned short
atomic_int _Atomic int
atomic_uint _Atomic unsigned int
atomic_long _Atomic long
atomic_ulong _Atomic unsigned long
atomic_llong _Atomic long long
atomic_ullong _Atomic unsigned long long
atomic_char8_t _Atomic char8_t
atomic_char16_t _Atomic char16_t
atomic_char32_t _Atomic char32_t
atomic_wchar_t _Atomic wchar_t
atomic_int_least8_t _Atomic int_least8_t
atomic_uint_least8_t _Atomic uint_least8_t
atomic_int_least16_t _Atomic int_least16_t
atomic_uint_least16_t _Atomic uint_least16_t
atomic_int_least32_t _Atomic int_least32_t
atomic_uint_least32_t _Atomic uint_least32_t
atomic_int_least64_t _Atomic int_least64_t
atomic_uint_least64_t _Atomic uint_least64_t
atomic_int_fast8_t _Atomic int_fast8_t
atomic_uint_fast8_t _Atomic uint_fast8_t
atomic_int_fast16_t _Atomic int_fast16_t
atomic_uint_fast16_t _Atomic uint_fast16_t
atomic_int_fast32_t _Atomic int_fast32_t
atomic_uint_fast32_t _Atomic uint_fast32_t
atomic_int_fast64_t _Atomic int_fast64_t
atomic_uint_fast64_t _Atomic uint_fast64_t
atomic_intptr_t _Atomic intptr_t
atomic_uintptr_t _Atomic uintptr_t
atomic_size_t _Atomic size_t
atomic_ptrdiff_t _Atomic ptrdiff_t
atomic_intmax_t _Atomic intmax_t
atomic_uintmax_t _Atomic uintmax_t
Padronização K&R C89 C90 C95 C99 C11 C17 C23
memory_order
Esse tipo é uma enumeração que possui as seguintes constantes:

Constantes Descrição
memory_order_relaxed Nenhuma operação de ordenação é feita na memória
Uma operação de carregamento (load operation) executa
memory_order_consume
uma operação de consumo na memória afetada.
Uma operação de carregamento (load operation) executa
memory_order_acquire
uma operação de aquisição na memória afetada.
Uma operação de armazenamento (store operation)
memory_order_release
executa uma operação de liberação na memória afetada.
Uma operação de leitura-modificação-escrita (read-modify-
memory_order_acq_rel write operation) executa uma operação de aquisição e
liberação na memória afetada.
Uma operação de carregamento (load operation) executa
uma operação de aquisição, já uma operação de
armazenamento (store operation) executa uma operação
de liberação, e uma operação de leitura-modificação-
memory_order_seq_cst
escrita (read-modify-write operation) executa uma
operação de aquisição e liberação, todas na memória
afetada.
Essa é a constante padrão da biblioteca.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

atomic_flag
Esse tipo é uma estrutura que representa um tipo atômico “booleano” com dois estados: set e
clear. Diferente de outros tipos atômicos, esse tipo é garantido ser lock-free.

O macro ATOMIC_FLAG_INIT deve ser usado para inicializar um objeto do tipo atomic_flag, sua
inicialização ocorre no estado clear.

Esse tipo é usado com as funções: atomic_flag_test_and_set, atomic_flag_test_and_set_explicit,

atomic_flag_clear e atomic_flag_clear_explicit.

Funções
Identificador Tipo Descrição
Função
atomic_init Inicializa um objeto atômico
genérica
Estabelece uma ordem de memória na
atomic_thread_fence Função
thread.
Estabelece uma ordem de memória
atomic_signal_fence Função para a thread e o handler de sinal
executado pela thread.
Função Verifica se determinado objeto tem a
atomic_is_lock_free
genérica propriedade lock-free.
Função Faz uma operação de armazenamento
atomic_store
genérica na memória indicada.
Faz uma operação de armazenamento
Função
atomic_store_explicit na memória indicada, com determinada
genérica
ordem.
 Função Faz uma operação de carregamento na
atomic_load
genérica memória indicada.
Faz uma operação de carregamento na
Função
atomic_load_explicit memória indicada, com determinada
genérica
ordem.
Função Troca o valor da memória indicada. Essa
atomic_exchange
genérica operação é read-modify-write.
Troca o valor da memória indicada, com
Função
atomic_exchange_explicit determinada ordem. Essa operação é
genérica
read-modify-write.
Função Compara um valor da memória indicada
atomic_compare_exchange_strong
genérica com o valor desejado.
Compara um valor da memória indicada
atomic_compare_exchange_strong_ Função
com o valor desejado, especificando a
explicit genérica
ordem.
Compara um valor da memória indicada
Função
atomic_compare_exchange_weak com o valor desejado. Comparação de
genérica
forma espúria.
Compara um valor da memória indicada
atomic_compare_exchange_weak_e Função
com o valor desejado, especificando a
xplicit genérica
ordem. Comparação de forma espúria.
Função Executa uma operação de adição em
atomic_fetch_add
genérica um objeto atômico.
Função Executa uma operação de subtração
atomic_fetch_sub
genérica em um objeto atômico.
Função Executa uma operação OU em um
atomic_fetch_or
genérica objeto atômico.
Função Executa uma operação OU EXCLUSIVO
atomic_fetch_xor
genérica em um objeto atômico.
Função Executa uma operação E em um objeto
atomic_fetch_and
genérica atômico.
Executa uma operação de adição em
Função
atomic_fetch_add_explicit um objeto atômico, especificando a
genérica
ordem.
Executa uma operação de subtração
Função
atomic_fetch_sub_explicit em um objeto atômico, especificando a
genérica
ordem.
Função Executa uma operação OU em um
atomic_fetch_or_explicit
genérica objeto atômico, especificando a ordem.
Executa uma operação OU EXCLUSIVO
Função
atomic_fetch_xor_explicit em um objeto atômico, especificando a
genérica
ordem.
Função Executa uma operação E em um objeto
atomic_fetch_and_explicit
genérica atômico, especificando a ordem.
Função Coloca um objeto atomic_flag em um
atomic_flag_test_and_set
genérica estado set.
Função Coloca um objeto atomic_flag em um
atomic_flag_test_and_set_explicit
genérica estado set, especificando a ordem.
Coloca um objeto atomic_flag em um
atomic_flag_clear Função
estado clear.
Coloca um objeto atomic_flag em um
atomic_flag_clear_explicit Função
estado clear, especificando a ordem.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
atomic_init
void atomic_init(volatile A *obj, C value)

Essa função genérica inicializa um objeto apontado por obj com o valor desejado por value,
além de inicializar qualquer estado adicional que a implementação necessite para o objeto
atômico. Essa função não evita data-races.

atomic_thread_fence
void atomic_thread_fence(memory_order order);

Essa função estabelece uma ordem de sincronização para operação não atômicas e
operações atômicas relaxadas para a thread corrente e a thread sincronizada.

atomic_signal_fence
void atomic_signal_fence(memory_order order);

Essa função opera exatamente como atomic_thread_fence, execto que a ordem de

sincronização é válida somente para a thread corrente e um handler de sinal na mesma thread.

atomic_is_lock_free
_Bool atomic_is_lock_free(const volatile A *obj);

Retorna um booleano indicando se o objeto apontando por obj tem uma propriedade lock-
free.

atomic_store e atomic_store_explicit
void atomic_store(volatile A *object, C desired);
void atomic_store_explicit(volatile A *object, C desired, memory_order order);

Executa uma operação de armazenamento na memória indicada pelo ponteiro object. A

ordem da memória é indicada por order, caso contrário a constante padrão
memory_order_seq_cst é usada, nesse caso para a primeira versão da função. A ordem de
memória não deve ser memory_order_acquire, memory_order_consume, ou
memory_order_acq_rel.

atomic_load e atomic_load_explicit
C atomic_load(const volatile A *object);
C atomic_load_explicit(const volatile A *object, memory_order order);

Executa uma operação de carregamento na memória indicada pelo ponteiro object. A ordem
da memória é indicada por order, caso contrário a constante padrão memory_order_seq_cst é
usada, nesse caso para a primeira versão da função. A ordem de memória não deve ser
memory_order_release ou memory_order_acq_rel.

Retorna o valor do objeto apontado por object.

atomic_exchange e atomic_exchange_explicit
C atomic_exchange(volatile A *object, C desired);
C atomic_exchange_explicit(volatile A *object, C desired, memory_order order);

Troca o valor do objeto apontado por object com o valor determinado por desired, essa função
executa uma operação read-modify-write na memória indicada. A ordem da memória é
indicada por order, caso contrário a constante padrão memory_order_seq_cst é usada, nesse
caso para a primeira versão da função.

Retorna o valor de objeto apontado por object antes dos efeitos serem aplicados.

atomic_compare_exchange_strong e atomic_compare_exchange_strong_explicit
bool atomic_compare_exchange_strong(volatile A *object, C *expected, C desired);
bool atomic_compare_exchange_strong_explicit(volatile A *object, C *expected, C
desired, memory_order success, memory_order failure);

Faz uma comparação do valor do objeto apontado por object com o valor esperado pelo
objeto apontado por expected. Caso seja verdade, atualiza o valor de object com o valor de
desired, em falso, atualiza o valor de expected com o valor de object.

Dependendo do resultado da comparação: em sucesso essa função executa uma operação

read-modify-write na memória indicada, em falso, executa uma operação de carregamento.

A ordem de memória em sucesso é indicada por sucess, e em caso de falha é indicada por
failure. O argumento failure não pode ser memory_order_release ou memory_order_acq_rel.

Retorna verdadeiro caso a comparação seja verdade, falso em contrário.

atomic_compare_exchange__weak e atomic_compare_exchange_ weak_explicit

bool atomic_compare_exchange_weak(volatile A *object, C *expected, C desired);
bool atomic_compare_exchange_weak_explicit(volatile A *object, C *expected, C desired,
memory_order success, memory_order failure);

Essa função opera da mesma forma que sua versão strong, com a diferença que seu resultado
pode ser espúrio, mesmo com a comparação tendo valores equalitários, a função pode tratar
isso como uma comparação falsa.

Essa função tem uma performance melhor que sua outra versão.

atomic_fetch
C atomic_fetch_add(volatile A *object, M operand);
C atomic_fetch_add_explicit(volatile A *object, M operand, memory_order order);
C atomic_fetch_sub(volatile A *object, M operand);
C atomic_fetch_sub_explicit(volatile A *object, M operand, memory_order order);
C atomic_fetch_or(volatile A *object, M operand);
C atomic_fetch_or_explicit(volatile A *object, M operand, memory_order order);
C atomic_fetch_xor (volatile A *object, M operand);
C atomic_fetch_xor_explicit(volatile A *object, M operand, memory_order order);
C atomic_fetch_and(volatile A *object, M operand);
 C atomic_fetch_and_explicit(volatile A *object, M operand, memory_order order);

Executa uma operação read-modify-write, de acordo com a computação apropriada da

função. A ordem é indicada por order.

Retorna o valor do objeto apontado por object antes dos efeitos serem aplicados.

atomic_flag_test_and_set e atomic_flag_test_and_set_explicit
bool atomic_flag_test_and_set(volatile atomic_flag *object);
bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order
order);

Coloca o objeto atomic_flag apontado por object em um estado set. A ordem é indicada por
order na função de versão explicit.

Retorna o estado booleano do objeto apontado por object antes dos efeitos serem aplicados.

atomic_flag_clear e atomic_flag_clear_set_explicit
void atomic_flag_clear(volatile atomic_flag *object);
void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);

Limpa o estado do objeto atomic_flag apontado por object, ou seja, seu estado é clear. A
ordem é indicada por order na função de versão explicit.
Biblioteca 17: stdbit.h
 Biblioteca 18: stdbool.h
A partir do C99 com a palavra-chave _Bool foi implementada a biblioteca stdbool.h com
macros para a utilização de tipos booleanos.

Macro Expande para

bool _Bool
true Constante inteira 1
false Constante inteira 0
__bool_true_false_are_defined Constante inteira 1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Observação:

A partir do C23 esse cabeçalho não prover nenhum conteúdo, exceto o macro
__bool_true_false_are_defined, que é sinalizado como depreciado.
 Biblioteca 19: stdckdint.h
Biblioteca implementada a partir do C23, ela define vários macros com a finalidade de checar
uma aritmética de inteiros.

Referência
Identificador Tipo Descrição
ckd_add Função macro Realiza uma operação de adição
Função macro Realiza uma operação de
ckd_sub
subtração
Função macro Realiza uma operação de
ckd_mul
multiplicação
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções macros ckd_

Protótipo:
bool ckd_add(type1 *result, type2 a, type3 b);
bool ckd_sub(type1 *result, type2 a, type3 b);
bool ckd_mul(type1 *result, type2 a, type3 b);

Essas funções fazem adição, subtração e multiplicação respectivamente, dos valores de a e b,

e armazenam o resultado no objeto apontado por result. Os tipos de result, a e b devem ser
inteiros, outros que: char, bool, um inteiro de precisão de bits, ou uma enumeração. O padrão
recomenda a implementação produzir uma mensagem de diagnostico caso os tipos não sejam
adequados, ou o objeto apontado por result não seja um modifiable lvalue.

Um valor verdadeiro representa o resultado matemático envolto no tamanho do objeto

apontado por result. Caso esses macros retornem falso, o valor atribuído a *result é a correta
representação matemática do resultado da operação
 Biblioteca 20: stddef.h
Biblioteca utilizada para propósitos gerais.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_STDDEF_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Define os seguintes identificadores.

Identificador Tipo Descrição

Inteiro sem sinal que representa o tamanho de
size_t Tipo de dados
algo.
wchar_t Tipo de dados Representa um caractere longo.
Inteiro com sinal retornado pela subtração de
ptrdiff_t Tipo de dados
dois ponteiros.
NULL Macro Representação de algo nulo.
Representação de um ponteiro que aponta
nullptr_t Tipo de dados
para nulo.
Um tipo com alinhamento maior que qualquer
max_align_t Tipo de dados
outro tipo escalar.
Computa o offset em bytes de um membro
offsetof Função macro
em relação a sua estrutura.
Expande para uma expressão void que invoca
unreachable Função macro um comportamento não definido durante sua
execução.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O tipo size_t é redeclarado nas bibliotecas <stdio.h>, <stdlib.h>, <string.h>, <time.h>, <uchar.h>, e
<wchar.h>.
O macro NULL é redeclarado nas bibliotecas <locale.h>, <stdio.h>, <stdlib.h>, <string.h>, <time.h>,
<uchar.h>, e <wchar.h>.
O tipo wchar_t é redeclarado nas bibliotecas <stdlib.h> e <wchar.h>.

offsetof
Protótipo: size_t offsetof(type, member-designator)

É uma função macro que retorna um size_t, que representa o valor em bytes do deslocamento
do membro dentro da estrutura. O valor de type deve ser o especificador de tipo da struct e
member-designator o identificador do membro.

unreachable
Protótipo: void unreachable(void);

Representa um fluxo que nunca deve ser tomado, essa chamada de função não deve ser
alcançada, se executada executa um comportamento não definido.
 Biblioteca 21: stdint.h
Essa biblioteca define inteiros com tamanhos específicos além de seus limites implementados
através de macros. Foi incluída a partir da implementação C99.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_STDINT_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Tipos
Tipo Tipo sem sinal Descrição
Tipo inteiro com o maior tamanho
intmax_t uintmax_t
suportado
int8_t uint8_t Tipos inteiros com o tamanho exato de 8,
int16_t uint16_t 16, 32, ou 64 bits.
int32_t uint32_t Opcional: Tipos podem não existir se tal
int64_t uint64_t características não forem possíveis
int_least8_t uint_least8_t Tipo inteiro com o tamanho mínimo de 8,
int_least16_t uint_least16_t 16, 32, ou 64 bits.
int_least32_t uint_least32_t Nenhum outro inteiro existe com um
int_least64_t uint_least64_t tamanho menor
int_fast8_t uint_fast8_t Tipo inteiro com o tamanho mínimo de 8,
int_fast16_t uint_fast16_t 16, 32, ou 64 bits.
int_fast32_t uint_fast32_t Nenhum outro inteiro mais rápido existem
int_fast64_t uint_fast64_t com o mínimo tamanho
Inteiro capaz de representar um ponteiro
intptr_t uintptr_t Opcional: Esses tipos podem não existir em
algumas implementações
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Macros
Macros de valores
Os macros abaixo representam os valores máximos e mínimos dos inteiros definidos por stdint.h.

Macro Descrição Definido como

INTMAX_MIN Valor mínimo de intmax_t -(263-1), ou menor
INTMAX_MAX Valor máximo de intmax_t 263-1, ou maior
UINTMAX_MAX Valor máximo de uintmax_t 264-1, ou maior
INTN_MIN Valor mínimo de um inteiro exato Exatamente -2(N-1)
INTN_MAX Valor máximo de um inteiro exato Exatamente 2(N-1)-1
Valor mínimo de um inteiro sem sinal
UINTN_MAX Exatamente 2N-1
exato
Valor mínimo de um inteiro de
INT_LEASTN_MIN -(2(N-1)-1), ou menor
tamanho mínimo
 Valor máximo de um inteiro de
INT_LEASTN_MAX 2(N-1)-1, ou maior
tamanho mínimo
Valor máximo de um inteiro sem sinal
UINT_LEASTN_MAX 2N-1, ou maior
de tamanho mínimo
INT_FASTN_MIN Valor mínimo de um inteiro rápido -(2(N-1)-1), ou menor
INT_FASTN_MAX Valor máximo de um inteiro rápido 2(N-1)-1, ou maior
Valor máximo de um inteiro rápido
UINT_FASTN_MAX 2N-1, ou maior
sem sinal
INTPTR_MIN Valor mínimo de intptr_t -(215-1), ou menor
INTPTR_MAX Valor máximo de intptr_t 215-1, ou maior
UINTPTR_MAX Valor máximo de uintptr_t 216-1, ou maior
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Onde:

• N deve ser: 8, 16, 32, 64 ou outra largura suportada por stdint.h

• Os macros INTN_MAX, INTN_MIN, UINTN_MAX, INTPTR_MAX, INTPTR_MIN e UINTPTR_MAX

são opcionais, assim como suas contrapartes.

Macros de tamanhos
Os macros abaixo representam os tamanhos em bits dos inteiros definidos por stdint.h.

Macro Descrição
INTMAX_WIDTH Tamanho de bits de intmax_t
UINTMAX_ WIDTH Tamanho de bits de uintmax_t
INTN_ WIDTH Tamanho de bits de um inteiro exato
UINTN_ WIDTH Tamanho de bits de um inteiro sem sinal exato
INT_LEASTN_ WIDTH Tamanho de bits de um inteiro de tamanho mínimo
Tamanho de bits de um inteiro sem sinal de tamanho
UINT_LEASTN_ WIDTH
mínimo
INT_FASTN_ WIDTH Tamanho de bits de um inteiro rápido
UINT_FASTN_ WIDTH Tamanho de bits de um inteiro rápido sem sinal
INTPTR_ WIDTH Tamanho de bits de intptr_t
UINTPTR_ WIDTH Tamanho de bits de uintptr_t
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Onde:

• N deve ser: 8, 16, 32, 64 ou outra largura suportada por stdint.h

• Os macros INTN_WIDTH, UINTN_WIDTH, INTPTR_WIDTH e UINTPTR_WIDTH são opcionais, assim

como suas contrapartes.

Macros de valores de outras bibliotecas

Os macros abaixo representam os valores de inteiros definidos em outras bibliotecas.

Macro Descrição Definido como

Valor máximo de
SIZE_MAX 264-1, ou maior
size_t
Valor mínimo de
PTRDIFF_MIN -(216-1), ou menor
ptrdiff_t
Valor máximo de
PTRDIFF_MAX 216-1, ou maior
ptrdiff_t
 Valor mínimo de Se sig_atomic_t é signed: -127, ou menor
SIG_ATOMIC_MIN
sig_atomic_t Se sig_atomic_t é unsigned: 0
Valor máximo de Se sig_atomic_t é signed: 127, ou maior
SIG_ATOMIC_MAX
sig_atomic_t Se sig_atomic_t é unsigned: 255, ou maior
Valor mínimo de Se wchar_t é signed: -127, ou menor
WCHAR_MIN
wchar_t Se wchar_t é unsigned: 0
Valor máximo de Se wchar_t é signed: 127, ou maior
WCHAR_MAX
wchar_t Se wchar_t é unsigned: 255, ou maior
Valor mínimo de Se wint_t é signed: -32767, ou menor
WINT_MIN
wint_t Se wint_t é unsigned: 0
Valor máximo de Se wint_t é signed: 32767, ou maior
WINT_MAX
wint_t Se wint_t é unsigned: 65535, ou maior
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Os macros WCHAR_MIN e WCHAR_MAX são redeclarados na biblioteca <wchar.h> — implementação
fonte.

Macros de valores de outras bibliotecas

Os macros abaixo representam os tamanhos em bits dos inteiros definidos em outras bibliotecas.

Macro Descrição
SIZE_ WIDTH Tamanho de bits de size_t
PTRDIFF_ WIDTH Tamanho de bits de ptrdiff_t
SIG_ATOMIC_ WIDTH Tamanho de bits de sig_atomic_t
WCHAR_ WIDTH Tamanho de bits de wchar_t
WINT_ WIDTH Tamanho de bits de wint_t
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Funções macros
Essas funções expandem para constantes inteira adequadas para iniciar seus tipos.

Elas aceitam somente um argumento.

Macro Descrição
INTMAX_C Expande para um valor do tipo intmax_t
UINTMAX_C Expande para um valor do tipo uintmax_t
INTN_C Expande para um valor do tipo int_leastN_t
UINTN_C Expande para um valor do tipo uint_leastN_t
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Onde:

• N deve ser: 8, 16, 32, 64 ou outra largura suportada por stdint.h

Tendo o protótipo:
type func_macro(value)

Elas promovem o valor para o tipo adequado de acordo com a função chamada.
 Biblioteca 22: stdio.h
O conteúdo dessa biblioteca é expandido e explicado em: Anotação 9 e Anotação 10.
 Biblioteca 23: stdlib.h
Essa biblioteca tem a finalidade de ser uma biblioteca de propósito geral.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_STDLIB_H__ 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referências
Identificador Tipo Descrição
Tipo de
size_t Um tipo para representar o tamanho de algo
dados
Tipo de
wchar_t Representa um caractere largo
dados
Tipo de
once_flag Representa um objeto para armazenar flags de threads
dados
Tipo de Estrutura para representar o quociente e o restante de
div_t
dados uma razão inteira x/y
Tipo de Estrutura para representar o quociente e o restante de
ldiv_t
dados uma razão inteira x/y
Tipo de Estrutura para representar o quociente e o restante de
lldiv_t
dados uma razão inteira x/y
NULL Macro Representa um valor nulo
ONCE_FLAG_INIT Macro Valor usado para inicializar objetos do tipo once_flag
EXIT_SUCCESS Macro Constante inteira representando um retorno de sucesso
EXIT_FAILURE Macro Constante inteira representando um retorno de falha
RAND_MAX Macro Valor máximo retornado pela função rand
Macro Número máximo de bytes em um caractere multibyte
MB_CUR_MAX
no locale corrente
call_once Função Faz a chamada de uma função somente uma vez
atof Função Converte uma string ASCII para um ponto flutuante
atoi Função Converte uma string ASCII para um inteiro
atol Função Converte uma string ASCII para um inteiro longo
Função Converte uma string ASCII para um inteiro duplamente
atoll
longo
Função Armazena uma string formata com uso de p.f no buffer
strfromf
apontado
strfromd Função Armazena uma string formata com uso de p.f no buffer
apontado
strfroml Função Armazena uma string formata com uso de p.f no buffer
apontado
strfromd32 Função Armazena uma string formata com uso de p.f no buffer
apontado
strfromd64 Função Armazena uma string formata com uso de p.f no buffer
apontado
strfromd128 Função Armazena uma string formata com uso de p.f no buffer
apontado
 strtof Função Converte uma porção de uma string para float
strtod Função Converte uma porção de uma string para double
strtold Função Converte uma porção de uma string para long double
strtod32 Função Converte uma porção de uma string para _Decimal32
strtod64 Função Converte uma porção de uma string para _Decimal64
strtod128 Função Converte uma porção de uma string para _Decimal128
strtol Função Converte uma porção de uma string para long int
strtoll Função Converte uma porção de uma string para long long int
Função Converte uma porção de uma string para unsigned
strtoul
long int
Função Converte uma porção de uma string para unsigned
strtoull
long long int
rand Função Retorna um número inteiro aleatório
Função Retorna um número inteiro aleatório de acordo com o
srand
argumento
Função Aloca um espaço no heap com um alinhamento
aligned_alloc
especifico
malloc Função Aloca um espaço no heap
Função Aloca um espaço no heap como sendo um múltiplo de
calloc
x
realloc Função Realoca um espaço no heap previamente alocado
free Função Desaloca um espaço no heap
Função Desaloca um espaço no heap com um argumento de
free_sized
tamanho
Função Desaloca um espaço no heap com um argumento de
free_aligned_sized
tamanho e alinhamento
abort Função Finaliza o programa de forma anormal
Função Registra uma função callback para saída normal do
atexit
programa
exit Função Finaliza o programa de forma normal
Função Finaliza o programa de forma normal, sem a chamada
_Exit
de funções callback
Função Registra uma função callback para saída através de
at_quick_exit
quick_exit
Função Finaliza o programa de forma normal, de maneira
quick_exit
rápida
getenv Função Retorna uma lista de variáveis ambiente
system Função Executa um comando no ambiente de execução
bsearch Função Faz uma busca binária em um array de espaços
qsort Função Faz uma ordenação quick sort em um array de espaços
abs Função Retorna o valor absoluto como um inteiro
labs Função Retorna o valor absoluto como um inteiro longo
Função Retorna o valor absoluto como um inteiro duplamente
llabs
longo
Função Retorna o quociente e o restante de uma razão inteira
div
x/y
Função Retorna o quociente e o restante de uma razão inteira
ldiv
x/y
Função Retorna o quociente e o restante de uma razão inteira
lldiv
x/y
Função Determina os números de bytes de um caractere
mblen
multibyte
mbtowc Função Converte um caractere multibyte para wide
wctomb Função Converte um caractere wide para multibyte
 mbstowcs Função Converte uma string multibyte para wide
wcstombs Função Converte uma string wide para multibyte
Função Retorna o número máximo de alinhamento do
memalignment
endereço
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O tipo size_t é declarado nas bibliotecas <stddef> — implementação fonte —, <stdio.h>, <string.h>,
<time.h>, <uchar.h>, e <wchar.h>.
O macro NULL é declarado nas bibliotecas <stddef> — implementação fonte —, <locale.h>, <stdio.h>,
<string.h>, <time.h>, <uchar.h>, e <wchar.h>.
O tipo wchar_t é declarado nas bibliotecas <stddef.h> — implementação fonte — e <wchar.h>.
O tipo once_flag e macro ONCE_FLAG_INIT são declarados na biblioteca <threads.h> — implementação
fonte.

atf, atoi, atol e atoll

Protótipo:
double atof(const char *nptr);
int atoi(const char *nptr);
long int atol(const char *nptr);
long long int atoll(const char *nptr);

Faz uma tentativa de conversão da string para suas respectivas versões numéricas.

strfromf, strfromd e strfroml

Protótipo:
int strfromf(char *restrict s, size_t n, const char *restrict format, float fp);
int strfromd(char *restrict s, size_t n, const char *restrict format, double fp);
int strfroml(char *restrict s, size_t n, const char *restrict format, long double fp);

Essas funções são equivalentes a chamada de: snprintf(s, n, format, fp), exceto que a string de
formato deve conter somente um caractere de especificador de ponto-flutuante.

strfromd32, strfromd64 e strfromd128

Protótipo:
int strfromd32(char*restrict s, size_t n, const char *restrict format, _Decimal32 fp);
int strfromd64(char*restrict s, size_t n, const char *restrict format, _Decimal64 fp);
int strfromd128(char*restrict s, size_t n, const char *restrict format, _Decimal128
fp);

Essas funções são equivalentes a chamada de: snprintf(s, n, format, fp), exceto que a string de
formato deve conter somente um caractere de especificador de ponto-flutuante.

strtof, strtod e strtold

Protótipo:
float strtof(const char *restrict nptr, char **restrict endptr);
double strtod(const char *restrict nptr, char **restrict endptr);
 long double strtold(const char *restrict nptr, char **restrict endptr);

Faz uma tentativa de converter uma string apontada por nptr, para seus respectivos valores de
ponto flutuante, caso a conversão falhe o valor de nptr é armazenado no ponteiro endptr.

strtod32, strtod64 e strtod128

Protótipo:
_Decimal32 strtod32(const char * restrict nptr, char ** restrict endptr);
_Decimal64 strtod64(const char * restrict nptr,char ** restrict endptr);
_Decimal128 strtod128(const char * restrict nptr,char ** restrict endptr);

Faz uma tentativa de converter uma string apontada por nptr, para seus respectivos valores de
ponto flutuante, caso a conversão falhe o valor de nptr é armazenado no ponteiro endptr.

strtol, strtoul, strtoll e strtoul

Protótipo:
long int strtol(const char *restrict nptr, char **restrict endptr, int base);
unsigned long int strtoul(const char *restrict nptr, char **restrict endptr, int base);
long long int strtoll(const char *restrict nptr, char **restrict endptr, int base);
unsigned long long int strtoull(const char *restrict nptr, char **restrict endptr, int
base)

Faz uma tentativa de converter uma string apontada por nptr, para seus respectivos valores de
inteiro longo ou duplamente longo, o ponteiro endptr irá aponta onde a conversão da string
termina.

Caso a conversão falhe o valor de nptr é armazenado no ponteiro endptr.

O inteiro base representa a base numérica encontrada na string: sendo valores validos entre 0
e 36.

rand
Protótipo:
int rand(void);

Retorna um valor inteiro aleatório, entre 0 e RAND_MAX.

O valor de RAND_MAX segundo a padronização deve ser no mínimo: 32767.

srand
Protótipo:
void srand(unsigned int seed);

Altera o comportamento de rand, para que chamadas subsequentes usem seed como valor
para geração de números randômicos.
aligned_alloc
Protótipo:
void *aligned_alloc(size_t alignment, size_t size);

Aloca um espaço de tamanho size e alinhamento alignment, caso alignment não seja um valor
válido, a função retorna um ponteiro nulo.

malloc
Protótipo:
void *malloc(size_t size);

Aloca um espaço de memória no heap. Retorna um ponteiro nulo em falha.

calloc
Protótipo:
void *calloc(size_t nmemb, size_t size);

Aloca um espaço de tamanho size com o valor de nmemb membros. O espaço é inicializado
em zero.

realloc
Protótipo:
void *realloc(void *ptr, size_t size);

Desaloca o espaço apontado por ptr, e retorna um novo espaço de tamanho determinado por
size. O antigo espaço alocado é usado para a nova alocação, sem alteração no conteúdo.

free
Protótipo:
void free(void *ptr);

Desaloca um espaço previamente alocado. Se ptr for nulo nenhuma ação é tomada, porém
se ptr aponta para um espaço já desalocado ou que não foi previamente alocado, um
comportamento não definido ocorre.

free_sized
Protótipo:
void free_sized(void *ptr, size_t size);

Desaloca um espaço previamente alocado desde que size seja o tamanho equivalente do
espaço alocado. Se ptr for nulo nenhuma ação é tomada, porém se ptr aponta para um
espaço já desalocado, ou que não foi previamente alocado, ou size não equivale ao tamanho
correspondente do espaço alocado, um comportamento não definido ocorre.
free_aligned_sized
Protótipo:
void free_aligned_sized(void *ptr, size_t alignment, size_t size);

Desaloca um espaço previamente alocado desde que size e alignment seja o tamanho e
alinhamento respectivamente equivalente do espaço alocado. Se ptr for nulo nenhuma ação
é tomada, porém se ptr aponta para um espaço já desalocado, ou que não foi previamente
alocado, ou size não equivale ao tamanho correspondente do espaço alocado, ou alignment
não seja o valor certo do espaço alocado, um comportamento não definido ocorre.

abort
Protótipo:
[[noreturn]] void abort(void);

A chamada dessa função causa uma finalização anormal do programa.

atexit
Protótipo:
int atexit(void (*func)(void));

Registra uma função a ser chamada quando o programa finaliza normalmente. Retorna zero
em sucesso, não-zero em falha.

exit
Protótipo:
[[noreturn]] void exit(int status);

Termina o programa de forma normal, retornando um valor de status para o ambiente de

execução.

_Exit
Protótipo:
[[noreturn]] void _Exit(int status);

Termina o programa de forma normal, retornando um valor de status para o ambiente de

execução. Porém funções de callback não são chamadas, sinais não são disparados e buffers
abertos não são limpos.

at_quick_exit
Protótipo:
int at_quick_exit(void (*func)(void));
Registra uma função a ser chamada quando o programa finaliza através da chamada de
quick_exit. Retorna zero em sucesso, não-zero em falha.

quick_exit
Protótipo:
[[noreturn]] void quick_exit(int status);

Faz uma terminação normal e rápida do programa, chamando as funções registradas por
at_quick_exit, porém qualquer buffer ou descritor aberto não é limpo, pois a função faz sua
terminação através de _Exit.

getenv
Protótipo:
char *getenv(const char *name);

Busca na lista de variáveis ambiente a variável determinada por nome, retornando uma string
em sucesso, ou um ponteiro nulo em falha.

system
Protótipo:
int system(const char *string);

Teta executar um comando no ambiente hospedeiro, retornando um valor implementation-

defined. Quando um ponteiro nulo é passado como argumento, um não zero é retornado se o
processador de comandos está disponível.

bsearch
Protótipo:
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int
(*compar)(const void *, const void *));

Faz uma busca binária do valor key, no array base de tamanho size, com o número de nmemb
elementos, usando a função compar como método de comparação. Retorna um ponteiro
para o elemento correspondente.

qsort
Protótipo:
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const
void *));

Faz uma ordenação do tipo quick sort no array base de tamanho size, com o número de nmemb
elementos, usando a função compar como método de comparação.
abs, labs e llabs
Protótipo:
int abs(int j);
long int labs(long int j);
long long int llabs(long long int j);

Retorna o valor absoluto do inteiro j. Em falha um comportamento não definido ocorre.

div, ldiv e lldiv

Protótipo:
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
lldiv_t lldiv(long long int numer, long long int denom);

Retorna o valor da razão numer/denom, juntamente com o restante em uma única operação.

O valor e o restante são retornados como uma estrutura div_t, ldiv_t ou lldiv_t respectivamente,
essas estruturas possuem dois membros: quot e rem que possuem o tipo dos argumentos de suas
respectivas funções. Esses membros representam o quociente — quot — e o restante — rem.
Caso os valores da razão e do restante não poderem ser representados, o comportamento
dessa função resulta em undefined behavior.

mblen
Protótipo:
int mblen(const char *s, size_t n);

Retorna o número de bytes do caractere multibyte apontado por s, um -1 representa uma string
inválida. Um ponteiro nulo retorna um zero ou não zero. n representa o número de bytes da string
s a ser analisados.

mbtowc
Protótipo:
int mbtowc(wchar_t * restrict pwc, const char * restrict s, size_t n);

Converte um caractere multibyte s, inspecionando n bytes, armazenando o caractere no

ponteiro pwc.

wctomb
Protótipo:
int wctomb(char *s, wchar_t wc);

Converte um caractere wc em um caractere multibyte, armazenando o caractere convertido

no ponteiro s.
mbstowcs
Protótipo:
size_t mbstowcs(wchar_t * restrict pwcs, const char * restrict s, size_t n);

Converte uma string multibyte s, armazenando a string no ponteiro pwc, não mais que n
caracteres serão modificados no ponteiro pwc.

wcstombs
Protótipo:
size_t wcstombs(char * restrict s, const wchar_t * restrict pwcs, size_t n);

Converte uma string larga pwcs em uma string multibyte, armazenando a string convertida no
ponteiro s, parando se exceder o limite de n.

memalignment
Protótipo:
size_t memalignment(const void * p);

Essa função recebe um endereço arbitrário de um objeto p, e retorna um inteiro com o valor do
alinhamento máximo satisfeito para o endereço. Se o endereço for nulo, zero é retornado.
 Biblioteca 24: stdnoreturn.h
Essa biblioteca foi implementada a partir do C11. Ela define somente um macro de
conveniência.

Identificador Tipo Descrição

noreturn Macro Expande para a palavra-chave _Noreturn
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Observação:

A partir do C23 tanto esse cabeçalho quanto o macro noreturn é sinalizado como depreciado.
 Biblioteca 25: string.h
O propósito dessa biblioteca é a manipulação de sequências de bytes, as chamadas strings,
algumas dessas sequências podem ter como um byte terminador o caractere nulo: ‘\0’, para
indicar uma sequência textual no dialeto da linguagem C.
A versão dessa biblioteca com manipulação com caracteres largos é encontrada em: <wchar.h>.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_STRING_H__ 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referências
Identificador Tipo Descrição
size_t Tipo de dados Um tipo para representar o tamanho de algo.
NULL Macro Representa um valor nulo.
memcpy Função Copia um array de dados para outro.
Copia um array de dados para outro, com um
memccpy Função
delimitador
memmove Função Move um array de dados para outro.
strcpy Função Copia uma string para outra.
strncpy Função Copia n caracteres de string para outra.
strdup Função Faz a alocação de uma cópia de uma string.
Faz a alocação de n caracteres de uma cópia de uma
strndup Função
string.
strcat Função Concatena duas strings.
strncat Função Concatena n caracteres de duas strings.
memcmp Função Compara dois arrays de dados.
strcmp Função Compara duas strings.
Compara duas strings de acordo com a atual
strcoll Função
localização.
strncmp Função Compara n caracteres de duas strings.
Transforma uma string de acordo com a atual
strxfrm Função
localização.
Retorna o tamanho do segmento inicial de caracteres
strcspn Função
não encontrados em uma string.
Retorna o tamanho do segmento inicial de caracteres
strspn Função
encontrados em uma string.
strtok Função Quebra uma string em tokens delimitados.
memset Função Preenche um array de dados.
Preenche um array de dados. Seguro para sensitive
memset_explicit Função
information.
strerror Função Retorna uma versão textual de um erro.
strlen Função Retorna o tamanho de uma string.
Função (Função
Busca em um array de dados a primeira ocorrência de
memchr genérica no
um caractere.
C23)
 Função (Função
Busca a primeira ocorrência de um caractere em uma
strchr genérica no
string.
C23)
Função (Função
Busca os caracteres declarados em uma string em
strpbrk genérica no
outra.
C23)
Função (Função
Busca a última ocorrência de um caractere em uma
strrchr genérica no
string.
C23)
Função (Função
Busca a primeira ocorrência de uma substring em uma
strstr genérica no
string.
C23)
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O tipo size_t é redeclarado nas bibliotecas <stddef> — implementação fonte —, <stdio.h>, <stdlib.h>,
<time.h>, <uchar.h>, e <wchar.h>.
O macro NULL é redeclarado nas bibliotecas <stddef> — implementação fonte —, <locale.h>, <stdio.h>,
<stdlib.h>, <time.h>, <uchar.h>, e <wchar.h>.

Funções
As funções dessa biblioteca são definidas para operarem em strings com o terminador nulo, e
arrays de tamanhos conhecidos, e todos os dados passados a essas funções no que dizem a
respeito de caracteres, são interpretados como unsigned char.

A partir do C23 as funções memchr, strchr, strrchr, strpbrk, e strstr são implementadas como
sendo funções genéricas com uso de macros.

Essas funções genéricas recebem um arrays para trabalharem, e retornam um ponteiro para um
elemento com a mesma qualificação do array passado como argumento, no caso de o
argumento for um array qualificado como const, o retorno será um ponteiro para um elemento
qualificado como const, da mesma forma que um array não qualificado como const retornará
um ponteiro para um elemento não qualificado como const.

Essas funções genéricas retornam e recebem os tipos genéricos QVoid e Qchar, que
respectivamente representam os tipos *void e *char, sendo qualificados ou não.

Identificador: memset
Protótipo: void *memset(void *s, int c, size_t n);
Descrição: Copia o valor de c para os primeiros n caracteres de s.
Retorno: Retorna s.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: memset_explicit
Protótipo: void *memset_explicit(void *s, int c, size_t n);
Copia o valor de c para os primeiros n caracteres de s. Essa função
Descrição: opera da mesma forma que memset, exceto que é segura para
informações sensíveis.
Retorno: Retorna s.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: memcpy
Protótipo: void *memcpy(void * restrict s1, const void * restrict s2, size_t n);
Descrição: Copia n caracteres de s2 para s1.
 Retorno: Retorna s1.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: memccpy
Protótipo: void *memccpy(void * restrict s1, const void * restrict s2, int c, size_t n);
Copia os caracteres de s2 para s1, até o caractere c ser encontrado
Descrição:
ou n caracteres serem copiados, o que vir primeiro
Retorna um ponteiro para o caractere depois de c em s1, ou um
Retorno: ponteiro nulo se não haver ocorrência de c nos primeiros n
caracteres de s2
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: memmove
Protótipo: void *memmove(void *s1, const void *s2, size_t n);
Copia n caracteres de s2 para s1. A cópia acontece de s2 para um
Descrição:
objeto temporariamente criado, para depois ser copiado em s1
Retorno: Retorna o valor de s1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: memcmp
Protótipo: int memcmp(const void *s1, const void *s2, size_t n);
Compara os primeiros n caracteres de s1 nos primeiros n caracteres
Descrição:
de s2.
Retorna um inteiro maior que, menor que, ou igual a zero, se s1 for,
Retorno:
maior, menor, ou igual a s2 respectivamente.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strlen
Protótipo: size_t strlen(const char *s);
Descrição: Computa o tamanho da string s.
Retorna o números de caracteres que precedem o terminador nulo
Retorno:
de s.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strcmp
Protótipo: int strcmp(const char *s1, const char *s2);
Descrição: Compara a string s1 com a string s2.
Retorna um inteiro maior que, menor que, ou igual a zero, se s1 for,
Retorno:
maior, menor, ou igual a s2 respectivamente.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strncmp
Protótipo: int strncmp(const char *s1, const char *s2, size_t n);
Compara a string s1 com a string s2, não mais que n caracteres.
Descrição:
Caracteres depois do terminador nulo não são comparados.
Retorna um inteiro maior que, menor que, ou igual a zero, se s1 for,
Retorno:
maior, menor, ou igual a s2 respectivamente.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strcoll
 Protótipo: int strcoll(const char *s1, const char *s2);
Compara a string s1 com a string s2. A comparação ocorre de
Descrição:
acordo com o LC_COLLATE da localização corrente.
Retorna um inteiro maior que, menor que, ou igual a zero, se s1 for,
Retorno:
maior, menor, ou igual a s2 respectivamente.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strxfrm
Protótipo: size_t strxfrm(char * restrict s1, const char * restrict s2, size_t n);
Transforma a string s2 de acordo com o LC_COLLATE da localização
Descrição: corrente. A string transformada é colocada em s1, mas não mais que
n caracteres. Caso n seja zero, s1 pode conter o valor nulo.
Retorno: Retorna o tamanho da string transformada, sem seu caractere nulo.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strcpy
Protótipo: char *strcpy(char * restrict s1, const char * restrict s2);
Descrição: Copia a string s2, incluído o terminador nulo, para s1
Retorno: Retorna o valor de s1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strncpy
Protótipo: char *strncpy(char * restrict s1, const char * restrict s2, size_t n);
Copia a string s2, para s1, não mais que n caracteres, caracteres
Descrição:
depois do terminado nulo não são copiados
Retorno: Retorna o valor de s1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strcat
Protótipo: char *strcat(char * restrict s1, const char * restrict s2);
Concatena uma cópia de s2 na string s1. O caractere nulo de s1 é
Descrição:
sobrescrito com a cópia de s2.
Retorno: Retorna o valor de s1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strncat
Protótipo: char *strncat(char * restrict s1, const char * restrict s2, size_t n);
Concatena uma cópia de s2 na string s1, não mais que n caracteres.
Descrição:
O caractere nulo de s1 é sobrescrito com a cópia de s2.
Retorno: Retorna o valor de s1
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strdup
Protótipo: char *strdup(const char *s);
Descrição: Cria uma cópia da string s, como fosse uma chamada a malloc
Retorna a string copiada, ou um ponteiro nulo em falha. A string
Retorno:
retornada pode ser passada para uma chamada de free
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strndup
 Protótipo: char *strndup(const char *s, size_t size);
Cria uma string, com os primeiros size caracteres, ou até um
Descrição: caractere nulo ser encontrado, o que vier primeiro. Um caractere
nulo é anexo no final da string se necessário.
Retorna a string criada, ou um ponteiro nulo em falha. A string
Retorno:
retornada pode ser passada para uma chamada de free
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: memchr
Protótipo: void *memchr(const void *ptr, int c, size_t n );
Protótipo C23: QVoid *memchr(QVoid *s, int c, size_t n);
Descrição: Localiza a primeira ocorrência de c nos primeiros n caracteres de s.
Retorna a posição de c em ptr, ou um ponteiro nulo caso não houver
Retorno:
c em ptr.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strchr
Protótipo: char *strchr(const char *s, int );
Protótipo C23: QChar *strchr(QChar *s, int c);
Descrição: Localiza a primeira ocorrência de c na string s.
Retorna a posição de c em s, ou um ponteiro nulo caso não houver c
Retorno:
em s.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strrchr
Protótipo: char *strrchr(const char *s, int c);
Protótipo C23: QChar *strrchr(QChar *s, int c);
Descrição: Localiza a última ocorrência de c na string s.
Retorna a posição de c em s, ou um ponteiro nulo caso não houver c
Retorno:
em s.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strpbrk
Protótipo: char *strpbrk(const char *s1, const char *s2 );
Protótipo C23: QChar *strpbrk(QChar *s1, const char *s2);
Localiza a primeira ocorrência dos caracteres declarados em s2 na
Descrição:
string s1.
Retorna a ocorrência de algum dos caracteres de s2 em s1, ou um
Retorno:
ponteiro nulo caso não houver nenhum caractere em s1.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strstr
Protótipo: char *strstr( const char *s1, const char *s2 );
Protótipo C23: QChar *strstr(QChar *s1, const char *s2);
Descrição: Localiza a primeira ocorrência da string s2 na string s1.
Retorna a posição de s2 em s1, ou um ponteiro nulo caso não houver
Retorno:
s2 em s1.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strspn
Protótipo: size_t strspn(const char *s1, const char *s2);
 Computa o tamanho máximo do segmento inicial que contém um
Descrição:
dos caracteres declarados na string s2.
Retorno: Retorna o tamanho do segmento.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strcspn
Protótipo: size_t strcspn(const char *s1, const char *s2);
Computa o tamanho máximo do segmento inicial que não contém
Descrição:
um dos caracteres declarados na string s2.
Retorno: Retorna o tamanho do segmento.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strtok
Protótipo: char *strtok(char * restrict s1, const char * restrict s2);
Cada chamada a strtok quebra a string s1 em sequencias de tokens
Descrição: delimitados pela string s2. Chamadas subsequentes com s1 sendo
NULL retornam o próximo token. Essa função altera o conteúdo de s1.
Retorna um token a cada chamada, ou um ponteiro nulo se não
Retorno:
houver tokens.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: strerror
Protótipo: char *strerror(int errnum);
Mapeia o erro indicado pelo inteiro errnum em uma mensagem
Descrição:
textual.
Retorno: Retorna uma string com a mensagem de erro.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
 Biblioteca 26: tgmath.h
Essa biblioteca define macros genéricos para a chamadas de funções matemáticas definidas
na biblioteca <math.h> e <complex>, exceto as funções:

O uso dos macros invoca uma função correspondente ao tipo do argumento utilizado no
macro, essa associação é chamada de parâmetro genérico. Os parâmetros genéricos são
correspondentes aos os parâmetros do tipo double nas funções matemáticas sem sufixos.
Exemplo:

A função pow de <math.h>, possui dois parâmetros do tipo double, logo, o macro genérico
pow, terá dois parâmetros do tipo genérico. Já scalbn possui dois parâmetros, um do tipo double
e o outro sendo int, no macro genérico scalbn, somente o primeiro parâmetro será do tipo
genérico.

Para as funções exclusiva para os tipos de ponto flutuante decimais, cujo não possuem
contraparte sem sufixos, todas possuem macros genéricos, exceto as funções e suas variações:
decodedecd64, encodedecd64, decodebind64 e encodebind64.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_TGMATH_H__ 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Macros

Para cada função de <math.h> sem sufixos, que possui uma contraparte com o sufixo c
em<complex>, existe um macro genérico correspondente com o mesmo nome da função
não sufixada em <math>. Na função ambígua fabs e cabs, o nome fabs é utilizado como
macro.

acos acosh cos cosh exp sqrt

asin asinh sin sinh log fabs
atan atanh tan tanh pow
Se no mínimo um dos argumentos dos parâmetros genéricos for um tipo complexo, o macro
invoca uma função complexa, caso contrário, o macro invoca uma função real.

Para cada função de <math.h> sem sufixos, que possui não uma contraparte com o prefixo c
em<complex>, existe um macro genérico correspondente com o mesmo nome da função
não sufixada em <math>. Exceto as funções: fadd, fsub, fmul, fdiv, ffma, fsqrt, canonicalize —
todas adicionadas na padronização C23 —, e a função mdf, não possuem macros genéricos.

acospi floor ldexp nextup

asinpi fmax lgamma pown
atan2pi fmaximum llogb powr
atan2 fmaximum_mag llrint remainder
atanpi fmaximum_num llround remquo
cbrt fmaximum_mag_num log10p1 rint
 ceil fma log10 rootn
compoundn fmin log1p roundeven
copysign fminimum log2p1 round
cospi fminimum_mag log2 rsqrt
erfc fminimum_num logb scalbln
erf fminimum_mag_num logp1 scalbn
exp10m1 fmod lrint sinpi
exp10 frexp lround tanpi
exp2m1 fromfpx nearbyint tgamma
exp2 fromfp nextafter trunc
expm1 hypot nextdown ufromfpx
fdim ilogb nexttoward ufromfp
Se todos os argumentos dos parâmetros genéricos for um tipo real, então o macro invoca uma
função real, caso contrário seu comportamento e indefinido.

Para cada função sem sufixo em <complex.h> que não possui uma contraparte sem o prefixo c
em <math.h>, existe um macro genérico correspondente com o mesmo nome da função não
sufixada em <complex>.

carg cimag conj cproj creal

O uso desses macros com argumentos de ponto flutuante padrões, ou um tipo complexo,
invoca uma função complexo, o uso com argumentos de ponto flutuante decimais tem um
comportamento indefinido.

Para as funções de arredondamento estreito, implementadas a partir do C23, existe macros

nomeados com os mesmos nomes das funções com a emissão do sufixo final. São eles:

fadd fsub fmul fdiv ffma fsqrt

dadd dsub dmul ddiv dfma dsqrt
Todos os argumentos devem ser reais, porém argumentos de ponto flutuantes decimais possuem
um comportamento não definido.

d32add d32sub d32mul d32div d32fma d32sqrt

d64dadd d64sub d64mul d64div d64fma d64sqrt
Todos os argumentos devem ser reais, porém argumentos de ponto flutuantes padrões possuem
um comportamento não definido.

Para cada função em <math.h> que possui um sufixo d64 — exceto as funções: decodedecd64,
encodedecd64, decodebind64 e encodebind64 —; e que não possui uma versão sem sufixo,
há macro genérico correspondente que tem o mesmo nome da função, porém sem o sufixo.

quantize samequantum quantum llquantexp

O uso desses macros com argumentos de ponto flutuantes padrões, tipos complexos ou tipos
inteiros, tem um comportamento não definido.
 Biblioteca 27: threads.h
Introdução

O cabeçalho <thread.h> inclui o cabeçalho <time.h>.

A implementação que não tem suporte a essa biblioteca deve definir o macro
__STDC_NO_THREADS__, logo essa biblioteca é opcional.

Macros

Macros Descrição
thread_local (removido no C23) Expande para o especificador de classe _Thread_local.
ONCE_FLAG_INIT Inicializa um objeto do tipo once_flag.
Uma constante inteira representando o número máximo
TSS_DTOR_ITERATIONS de vezes que um destruidor será chamado quando a
thread terminar.

Tipos Descrição
thrd_t Identificador de uma thread
Um ponteiro int (*) (void *) que representa a função usada como
thrd_start_t
thread.
cnd_t Identificador de uma variável condicional.
mtx_t Representa um mutex.
once_flag Tipo usado como flag para a função call_once.
Representa um ponteiro para um bloco de memória especifico por
tss_t
thread.
Representa um ponteiro void (*) (void *), usado como destruidor do
tss_dtor
bloco de memória do ponteiro tss_t.

Essa biblioteca ainda possui duas enumerações não nomeadas, um usada no contexto de
status de erros, e outra no contexto de mutexs.

Segue abaixo as constantes usadas como status de uma operação.

Constante Descrição
thrd_success Indica sucesso em uma operação.
thrd_error Indica erro em uma operação.
thrd_nomem Indica falha devido falta de memória.
thrd_timedout Indica falha devido ao tempo ter expirado.
Indica falha devido ao recurso não estar
thrd_busy
disponível.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Segue abaixo as constantes usadas durante a criação de um mutex com mtx_int.

Constante Descrição
mtx_plain Representa um mutex simples.
Representa um mutex com suporte a
mtx_recursive
recursividade.
Representa um mutex com suporte a
mtx_timed
timeout.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Funções

Identificador Descrição
call_once Chama a função somente um vez.
thrd_create Cria uma nova thread.
thrd_equal Checa se dois identificadores de threads são iguais.
thrd_current Retorna o identificador da thread corrente.
thrd_sleep Suspende a thread corrente por determinado período.
thrd_yield Pede ao sistema para finalizar o time slice.
thrd_exit Finaliza a thread corrente.
Bloqueia a thread corrente até a finalização da thread
thrd_join
especificada.
thrd_detach Desanexa a thread especificada.
mtx_init Cria um novo mutex.
mtx_lock Tenta adquirir a trava de um mutex.
mtx_unlock Destrava a mutex.
mtx_timedlock Tenta adquiri a trava de um mutex até o tempo expirar.
Tenta adquiri a trava de um mutex, não bloqueando a
mtx_trylock
thread.
mtx_destroy Destrói um mutex.
cnd_init Cria uma variável condicional.
Desbloqueia uma thread bloqueada na variável
cnd_signal
condicional.
Desbloqueia todas as threads bloqueadas na variável
cnd_broadcast
condicional.
cnd_wait Bloqueia a thread na variável condicional.
Bloqueia a thread na variável condicional até o tempo
cnd_timedwait
expirar.
cnd_destroy Destrói a variável condicional.
tss_create Cria um ponteiro tss com um devido destrutor.
tss_set Escreve um endereço no ponteiro tss.
tss_get Recupera o endereço apontado pelo ponteiro tss.
tss_delete Destrói o ponteiro tss.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

call_once

void call_once(once_flag *flag, void (*func)(void));

Chama a função indicada pelo ponteiro func somente uma vez, essa garantia é determinada
pelo objeto apontado por flag.

thrd_create

int thrd_create(thrd_t *thr, thrd_start_t func, void *arg);

Cria uma nova thread, armazenando seu identificador no objeto apontado por thr.

A função a ser chamada é especificada por func, e sua lista de argumento é dado por arg,
logo a nova thread criada tem como chamada func(arg). Sua execução começa
imediatamente após a conclusão dessa função.
Em sucesso retorna a constante thread_sucesso, em falha thread_error, ou thread_nomem caso
não tenha memória suficiente para a criação da thread.

thrd_equal

int thrd_equal( thrd_t thr0, thrd_t thr1 );

Verifica se os identificadores de thread thr0 e thr1 são iguais.

Retorna zero, e somente zero, se dois identificadores referem a threads diferentes, retornando
um não zero se os identificadores referem a threads iguais.

thrd_current

thrd_t thrd_current(void);

Retorna o identificado thr_t da thread corrente.

thrd_sleep

int thrd_sleep(const struct timespec *duration, struct timespec *remaining);

Suspende a execução da thread corrente de acordo com o tempo especificado no objeto

apontado por duration. O tempo de suspensão pode ser um pouco mais longo que o
especificado, devido ao arredondamento de tempo.

Caso a thread sofra um despertar espúrio através de um sinal, o tempo restante é armazenado
em remainig, caso o mesmo não seja nulo.

Retorna zero se o tempo especificado foi decorrido, -1 se a função foi interrompida por um sinal,
ou um valor negativo, incluindo -1, se houver falha na chamada da função.

thrd_yield

void thrd_yield(void);

Permite que outras threads executem o atual time slice, mesmo se a thread corrente seja
permitida a continuar.

thrd_exit

[[noreturn]] void thrd_exit(int res); C23

_Noreturn void thrd_exit(int res); C11

Finaliza a thread corrente, retornando o valor inteiro res.

Caso a thread corrente possua algum ponteiro tss, o ponteiro é posto num estado nulo, e seu
destrutor se houver, é chamado. Essa função chama os destrutores do ponteiro tss até a
quantidade de vezes especificadas pelo macro TSS_DTOR_ITERATIONS.

thrd_join
int thrd_join(thrd_t thr, int *result);

Uma thread que chama thread_join fica bloqueada até a thread especificada por thr seja
finalizada. Essa função libera os recursos da thread em sua finalização. A thread thr não deve
ter sido previamente chamada por outra função thrd_join, ou chamada por thr_detach na
thread corrente.

O retorno da thread especificada é escrita em result, se for um ponteiro não-nulo.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

thrd_detach

int thrd_detach(thrd_t thr);

Solicita ao sistema operacional que os recursos associados a thread thr sejam liberados quando
a thread finalizar. Assim como thrd_join, a thread thr não deve ter sido previamente chamada
por outra função thrd_join, ou chamada por thr_detach na thread corrente.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

mtx_init

int mtx_init(mtx_t *mtx, int type);

Cria um novo mutex no objeto apontado por mtx. O tipo do mutex é especificado por type, e
deve ser uma das seguintes constantes: mtx_plain, mtx_timed, mtx_plain | mtx_recursive ou
mtx_timed | mtx_recursive.

Onde:

mtx_plain: representa um mutex simples.

mtx_timed: representa um mutex com timeout, que pode ser usado com mtx_timedlock.

mtx_plain | mtx_recursive: representa um mutex simples e recursivo.

mtx_timed | mtx_recursive: representa um mutex com timeout e recursivo.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

mtx_lock

int mtx_lock(mtx_t *mtx);

Essa função bloqueia a thread até conseguir adquirir a trava para o mutex apontado por mtx.
Ela não deve ser chamada mais de uma vez pela thread corrente se o mutex mtx não for
recursivo.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

mtx_unlock

int mtx_unlock(mtx_t *mtx);

Essa função destrava o mutex mtx adquirido pela thread corrente.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

mtx_timedlock

int mtx_timedlock(mtx_t *restrict mtx, const struct timespec *restrict ts);

Essa função tenta adquirir a trava do mutex mtx, até conseguir a trava ou o tempo especificado
por ts expirar.

O mutex mtx deve ter suporte a timeout.

Em sucesso retorna a constante thread_sucesso, em falha thread_error, caso o tempo seja

expirado é retornado thrd_timedout.

mtx_trylock

int mtx_trylock(mtx_t *mtx);

Essa função tenta adquiri a trava do mutex mtx, se o mutex já tiver sido travado por outra thread
a função retorna sem bloquear a thread corrente.

Em sucesso retorna a constante thread_sucesso, em falha thread_error, caso o mutex não esteja
disponível é retornado thrd_busy.

OBS: Essa função pode falha mesmo com o mutex disponível, retornando thrd_busy.

mtx_destroy

void mtx_destroy(mtx_t *mtx);

Destrói e libera os recursos do mutex mtx.

cnd_init

int cnd_init(cnd_t *cond);

Cria uma nova variável condicional no objeto apontado por cond.

Em sucesso retorna a constante thread_sucesso, em falha thread_error, caso não há memória

para a criação da variável condicional é retornado thrd_nomem.

cnd_signal

int cnd_signal(cnd_t *cond);

Debloqueia uma thread que está bloqueada devido a variável condicional cond. Caso
nenhuma thread esteja bloqueada, a função faz nada e retorna um sucesso.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

cnd_broadcast

int cnd_broadcast(cnd_t *cond);

Debloqueia todas as thread que está bloqueada devido a variável condicional cond. Caso
nenhuma thread esteja bloqueada, a função faz nada e retorna um sucesso.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

cnd_wait

int cnd_wait(cnd_t *cond, mtx_t *mtx);

Essa função bloqueia a thread corrente na variável condicional cond e destrava

temporariamente o mutex mtx. Quando desbloqueada por cnd_signal, cnd_broadcast ou
devido alguma razão não especificada, o mutex mtx volta a ser travado pela thread corrente.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

cnd_timedwait

int cnd_timedwait(cnd_t *restrict cond, mtx_t *restrict mtx, const struct timespec *restrict ts);

A thread corrente é bloqueada na variável condiciona cond, destravando o mutex mtx, até a
mesma ser desbloqueado pelas funções cnd_signal ou cnd_broadcast, ou até o tempo
especificado por ts expirar, ou por alguma outra razão não especificada. Quando
desbloqueada o mutex mtx volta a ser travado.

Em sucesso retorna a constante thread_sucesso, em falha thread_error, caso o tempo expire e

retornado thrd_timedout.

cnd_destroy

void cnd_destroy(cnd_t *cond);

Essa função destrói e libera todos recursos necessário para a variável condicional cond.

tss_create

int tss_create(tss_t *key, tss_dtor_t dtor);

Cria um objeto do tipo ponteiro tss apontado por key com um destrutor associado por dtor, que
pode ser nulo. Esse ponteiro tss é mantido por thread, com o tempo de vida limitado a thread.
O valor do endereço associado inicial de key é nulo, podendo ser alterado e recuperado com
tss_set e tss_get respectivamento.

Quando a thread corrente é finalizada o destrutor associado é chamado, se não nulo, passando
o endereço apontado pelo ponteiro tss como argumento.

Em sucesso, key tem um valor único e a constante thread_sucesso é retornada, em falha, key
possui um valor indeterminado e a constante thread_error é retornada.

tss_set

int tss_set(tss_t key, void *val);

Coloca o valor do ponteiro tss key para o valor de endereço val.

Em sucesso retorna a constante thread_sucesso, em falha thread_error.

tss_get

void *tss_get(tss_t key);

Retorna o valor do endereço associado ao ponteiro tss key.

Em sucesso o endereço é retornado, um valor nulo é retornado em falha.

tss_delete

void tss_delete(tss_t key);

Essa função destrói e libera todos recursos associado ao ponteiro tss key.

O destrutor associado ao ponteiro tss não é chamado.

 Biblioteca 28: time.h
Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_TIME_H__ 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referências
Identificador Tipo Descrição
NULL Macro Representa um valor nulo.
Expande para uma expressão clock_t, igual ao
CLOCKS_PER_SEC Macro número de clock ticks por segundos, retornado pela
função clock.
Expande para um constante inteira maior que zero
TIME_UTC Macro
que determina a base do tempo UTC.
Se definido, expande para uma constante inteira
TIME_MONOTONIC Macro maior que zero que determina a base do tempo
monotônico.
Se definido, expande para um valor inteiro que
TIME_ACTIVE Macro
determina o tempo geral de execução.
Se definido, expande para um valor inteiro que
TIME_THREAD_ACTIVE Macro determina o tempo geral de execução da thread
ativa.
Tipo de
clock_t Representa um tempo de processador.
dados
Tipo de Representa um tempo de calendário. A codificação
time_t
dados desse tipo não é especificada.
Tipo de
struct timespec Representa um tempo em segundos e nanosegundos.
dados
Tipo de Representa um tempo de calendário no formato
struct tm
dados broken-down time.
Tipo de
size_t Um tipo para representar o tamanho de algo.
dados
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O macro NULL é redeclarado nas bibliotecas <stddef> — implementação fonte —, <locale.h>, <stdio.h>,
<stdlib.h>, <string.h>, <uchar.h>, e <wchar.h>.
O tipo size_t é redeclarado nas bibliotecas <stddef> — implementação fonte —, <stdio.h>, <stdlib.h>,
<string.h>, <uchar.h>, e <wchar.h>.
O tipo struct tm é redeclarada na biblioteca <wchar.h>.

O macro CLOCKS_PER_SEC é usado como divisor do retorno da função clock, para obter o
tempo em segundos.

Os macros TIME_UTC e TIME_MONOTONIC são usados nas funções: timespec_get e

timespec_getres. Sendo que o macro TIME_MONOTONIC é opcional.

Outros macros que comecem com TIME_ podem ser definidos pela implementação para serem
usados nas funções timespec_get e timespec_getres.
O tipo timespec possui os seguintes componentes:

Membro Tipo Descrição

tv_sec time_t tempo em segundos.
tv_nsec long tempo em nanosegundos.

O tipo tm possui os seguintes componentes:

Membro Tipo Descrição

tm_sec int Segundos [0, 60].
tm_min int Minutos [0, 59].
tm_hour int Horas [0, 23].
tm_mday int Dia do mês [1, 31].
tm_mon int Mês desde janeiro [0, 11].
tm_year int Anos desde 1900.
tm_wday int Dias desde Domingo [0, 6].
tm_yday int Dias desde 1º Janeiro [0 ,365].
Marcador flag para o
tm_isdst * int
Daylight Saving Time.
* O valor de tm_isdst é um número positivo se Daylight Saving Time está em efeito, ou zero caso contrário.

Funções
Nome Descrição
time
Essa função retorna o tempo do processador usado pelo
clock
programa.
difftime
timespec_get
timespec_getres
asctime (Depreciado no
C23)
ctime (Depreciado no C23)
strftime
gmtime
gmtime_r
localtime
localtime_r
mktime
timegm
Padronização K&R C89 C90 C95 C99 C11 C17 C23

time

time_t time(time_t *timer);

Essa função computa o tempo de calendário corrente. Esse valor é atribuído ao objeto
apontado por timer caso o ponteiro não seja nulo e também retornado pela função.

Em sucesso o tempo aproximado é retornado, em falha é retornado: (time_t) (-1).

clock

clock_t clock(void);

Essa função retorna um objeto clock_t, que é uma representação aproximada da

implementação do tempo ativo do processador associado a execução do programa desde do
inicio de uma era definida pela implementação. Para determinar em segundos, o valor
retornado por clock dever ser dividido pelo macro CLOCKS_PER_SEC.

Caso o valor do tempo do processador não possa ser representado é retornado: (clock_t) (-1).

difftime

double difftime(time_t time1, time_t time0);

Essa função computa a diferença entre dois tempos: time1 – time0.

O resultado é retornado em segundos como um objeto do tipo double.

timespec_get

int timespec_get(struct timespec *ts, int base);

Essa função atribui o objeto apontado por ts para o intervalo em segundos e nanosegundos do
tempo de calendário corrente. O argumento base especifica o formato do valor a ser atribuído.

Onde base:

TIME_UTC, o membro tv_sec do objeto ts será os números de segundos desde de uma era
definida pela implementação, e tv_nsec é os números de nanosegundos, arredondados para
a resolução do relógio do sistema.

TIME_MONOTONIC, tem o mesmo comportamento que TIME_UTC, porém o ponto de referencia

é definido pela implementação, e pode variar a cada invocação do programa.

TIME_ACTIVE, faz com que o tempo medido de segundo no membro tv_sec, e de nanosegundo
no membro tv_nsec, seja do tempo ativo de processamento de todo o programa.

TIME_THREAD_ACTIVE, tem o mesmo comportamento que TIME_ACTIVE, porém o tempo medido

de segundos e nanosegundo é da thread corrente.

Macros adicionais que podem ser usados como valores de base, podem ser definidos pela
implementação, e devem começar com o prefixo TIME_.

Em sucesso essa thread retorna um não zero, sendo o mesmo valor que base, em falha é
retornado zero.

timespec_getres

int timespec_get(struct timespec *ts, int base);

Essa função funciona da mesma forma que timespec_get, porém para cada valor de base
suportado, múltiplas chamadas dessa função durante a execução do programa devem atribuir
os mesmos valores no objeto apontado por ts.
mktime

time_t mktime(struct tm *timeptr);

Essa função converte um tempo local apontado pelo ponteiro timeptr no formato broken-down
time para um tempo de calendário do tipo time_t, essa é a mesma codificação retornada pela
função time.

Em sucesso o tempo no formato broken-down time é convertido para um objeto time_t, e os

membros do objeto tmeptr são atribuídos aos valores apropriados, se o tempo não pode ser
representado, a função retorna: (time_t) (-1).

Os valores originais dos membros tm_wday e tm_yday da estrutura tm são ignorados.

asctime

[[deprecated]] char *asctime(const struct tm *timeptr); C23

char *asctime(const struct tm *timeptr); Pré-C23

Converte um tempo broken-down time apontado pelo ponteiro timeptr para uma
representação textual.

A representação segue o seguinte formato de string segundo o exemplo:

Sun Sep 16 [Link] 1973\n\0

Segundo a padronização C, a implementação dessa função é equivalente seguinte código:

char *asctime(const struct tm *timeptr)

{
static const char wday_name[7][3] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static const char mon_name[12][3] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static char result[26];
snprintf(result, 26, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
wday_name[timeptr->tm_wday],
mon_name[timeptr->tm_mon],
timeptr->tm_mday, timeptr->tm_hour,
timeptr->tm_min, timeptr->tm_sec,
1900 + timeptr->tm_year);
return result;
}

Caso o objeto apontado por timeptr possua valores foram dos aceitáveis, ou o ano a ser
representado tenha mais que quatro digito ou for menor que o ano 1000, o comportamento
dessa função é indefinido.

Em sucesso a string contendo o formato textual do tempo de calendário é retornado, em falha

uma string não prevista é retornada.
ctime

[[deprecated]] char *ctime(const time_t *timer); C23

char *ctime(const time_t *timer); Pré-C23

Essa função opera exatamente como asctime, exceto que a string retorna tem seu formato
correspondente a o tempo local.

Segundo a padronização essa função é equivalente a seguinte expressão:

asctime(localtime(timer))

strftime
size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict
timeptr);

gmtime

struct tm *gmtime(const time_t *timer);

Converte um tempo de calendário apontado por timer, para um tempo broken-down time,
retornado um objeto do tipo struct tm como valor convertido.

A base usada para conversão é o formato UTC.

Em sucesso um ponteiro para um objeto tm é retornado, em falha um ponteiro nulo.

gmtime_r

struct tm *gmtime_r(const time_t *timer, struct tm *buf);

Executa exatamente como gmtime, porém um endereço para a atribuição do resultado pode
ser especificado através do parâmetro buf.

localtime

struct tm *localtime(const time_t *timer);

Converte um tempo de calendário apontado por timer, para um tempo broken-down time,
retornado um objeto do tipo struct tm como valor convertido.

A base usada para conversão é o formato de tempo local.

Em sucesso um ponteiro para um objeto tm é retornado, em falha um ponteiro nulo.

localtime_r

struct tm *localtime_r(const time_t *timer, struct tm *buf);

Executa exatamente como localtime, porém um endereço para a atribuição do resultado pode
ser especificado através do parâmetro buf.
timegm

time_t timegm(struct tm *timeptr);

Essa função converte um tempo UTC apontado pelo ponteiro timeptr no formato broken-down
time para um tempo de calendário do tipo time_t, essa é a mesma codificação retornada pela
função time.

Em sucesso o tempo no formato broken-down time é convertido para um objeto time_t, e os

membros do objeto tmeptr são atribuídos aos valores apropriados, se o tempo não pode ser
representado, a função retorna: (time_t) (-1).

Os valores originais dos membros tm_wday e tm_yday da estrutura tm são ignorados.

Observações

As funções: asctime, ctime, gmtime, e localtime, retornam endereços de objetos alocados

estaticamente. Os valores desses objetos podem ser sobrescritos a cada invocação dessas
funções.
 Biblioteca 29: uchar.h
Essa biblioteca foi implementada a partir do C11, e define funcionalidades para a manipulação
de caracteres Unicode, como UTF-8, UTF-16 e UTF-32.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_UCHAR_H__ 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referências
Identificador Tipo Descrição
Tipo de
size_t Inteiro sem sinal que representa o tamanho de algo.
dados
Representa um objeto que contém informações do
Tipo de
mbstate_t estado de conversão entre sequência de caracteres
dados
multibytes e wide.
Tipo de
char8_t Representa um caractere de 8 bits.
dados
Tipo de Representa um caractere de 16 bits.
char16_t
dados
Tipo de Representa um caractere de 32 bits.
char32_t
dados
mbrtoc8 Função Converte um caractere multibyte para UTF-8.
c8rtomb Função Converte um caractere UTF-8 para multibyte.
mbrtoc16 Função Converte um caractere multibyte para UTF-16.
c16rtomb Função Converte um caractere UTF-16 para multibyte.
mbrtoc32 Função Converte um caractere multibyte para UTF-32.
c32rtomb Função Converte um caractere UTF-32 para multibyte.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O tipo size_t é declarado nas bibliotecas <stddef> — implementação fonte —, <stdio.h>, <stdlib.h>,
<string.h>, <time.h> e <wchar.h>.
O tipo mbstate_t é declarado na biblioteca <wchar.h> — implementação fonte.

Funções

Todas as funções dessa biblioteca recém um ponteiro para um objeto do tipo mbstate_t, esse
objeto irá possuir informações sobre o estado de conversão dos caracteres usados na função.
Caso esse ponteiro seja nulo, cada função usa seu próprio objeto mbstate_t interno.

mbrtoc8
size_t mbrtoc8(char8_t * restrict pc8, const char * restrict s, size_t n, mbstate_t *
restrict ps);
c8rtomb
size_t c8rtomb(char * restrict s, char8_t c8, mbstate_t * restrict ps);

mbrtoc16
size_t mbrtoc16(char16_t * restrict pc16, const char * restrict s, size_t n, mbstate_t
* restrict ps);

c16rtomb
size_t c16rtomb(char * restrict s, char16_t c16, mbstate_t * restrict ps);

mbrtoc32
size_t mbrtoc32(char32_t * restrict pc32, const char * restrict s, size_t n, mbstate_t
* restrict ps);

c32rtomb
size_t c32rtomb(char * restrict s, char32_t c32, mbstate_t * restrict ps);
 Biblioteca 30: wchar.h
Essa biblioteca foi incluída na padronização C95, ele serve para a manipulação e
gerenciamento do contexto de caracteres largos — wide characters.

Nessa biblioteca são definidas funções correspondentes as funções encontradas em: <stdio.h>,
<stdlib.h> e <string.h>, porém voltadas para a manipulação de tipos largos, como wchar_t e
wint_t, em contraparte as funções que manipulam tipos char e int.

Macro de teste
A partir do C23 essa biblioteca define um macro de teste, que expande para a atual versão da
biblioteca.

Macro Valor
__STDC_VERSION_STDIO_H 202311L
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Referências
Identificador Tipo Descrição
Tipo de
size_t Inteiro sem sinal que representa o tamanho de algo.
dados
Tipo de
wchar_t Representa um caractere longo.
dados
Representa um objeto que contém informações do estado
Tipo de
mbstate_t de conversão entre sequência de caracteres multibytes e
dados
wide.
Tipo de Representa um inteiro capaz de armazenar um caractere do
wint_t
dados conjunto estendido.
Tipo de Representa um tempo de calendário no formato broken-
struct tm down time.
dados
NULL Macro Representação de algo nulo.
Representa o valor mínimo de wchar_t.
WCHAR_MIN Macro Se wchar_t é signed: -127, ou menor
Se wchar_t é unsigned: 0
Representa o valor máximo de wchar_t.
WCHAR_MAX Macro Se wchar_t é signed: 127, ou maior
Se wchar_t é unsigned: 255, ou maior
Uma constante do tipo wint_t que não corresponde a
WEOF Macro qualquer valor do conjunto de caracteres estendido, usado
para indicar erros.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
O tipo size_t é redeclarado nas bibliotecas <stddef.h> — implementação fonte —, <stdio.h>, <stdlib.h>,
<string.h>, <time.h>, e <uchar.h>.
O tipo wchar_t é redeclarado nas bibliotecas <stddef.h> — implementação fonte —, e <stdlib.h>.
O tipo mbstate_t é redeclarado na biblioteca <uchar.h>.
Os tipos wint_t e o macro WEOF são também redeclarados na biblioteca <wctype.h>.
O tipo struct tm é redeclarada na biblioteca <time.h> — implementação fonte.
O macro NULL é declarado nas bibliotecas <locale.h>, <stdio.h>, <stdlib.h>, <string.h>, <time.h>,
<uchar.h>, e <wchar.h>.
Os macros WCHAR_MIN e WCHAR_MAX são redeclarados na biblioteca <stdint.h>.

Para informações sobre o tipo struct tm.

Funções
As funções listadas abaixo são funções que manipulam caracteres largos, em contraparte as
funções de caracteres curtos declaradas em outras bibliotecas.

A partir do C23 as funções wmemchr, wcschr, wcsrchr, wcspbrk, e wcsstr são implementadas
como sendo funções genéricas com uso de macros.

Essas funções genéricas recebem um arrays para trabalharem, e retornam um ponteiro para um
elemento com a mesma qualificação do array passado como argumento, no caso de o
argumento for um array qualificado como const, o retorno será um ponteiro para um elemento
qualificado como const, da mesma forma que um array não qualificado como const retornará
um ponteiro para um elemento não qualificado como const.

Essas funções genéricas retornam e recebem o tipo genéricos QWchar_t, que representa o tipo
*wchar_t, sendo qualificado ou não.

E/S não Formatada

Identificador: fgetwc
Protótipo: wint_t fgetwc(FILE *stream);
Essa função ler o próximo caractere largo do fluxo stream, e o
Descrição:
converte para wint_t, avançando o curso do arquivo.
Retorno: Retorna o próximo caractere largo do fluxo, ou WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: getwc
Protótipo: wint_t getwc(FILE *stream)
Essa função é equivalente a fgetwc, exceto que geralmente é
Descrição:
implementada como sendo um macro.
Retorno: Retorna o próximo caractere largo do fluxo, ou WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: fgetws
Protótipo: wchar_t *fgetws(wchar_t * restrict s, int n, FILE * restrict stream);
Essa função é ler n-1 caracteres largos, do fluxo stream, e armazena
Descrição: no buffer s. A leitura para caso um caractere de nova linha ou um
WEOF for encontrado.
Retorno: Retorna s, ou um ponteiro nulo em falha.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: getwchar
Protótipo: wint_t getwchar(void)
Descrição: Essa função é equivalente a fgetwc com o argumento stdin.
Retorno: Retorna o próximo caractere largo do fluxo stdin, ou WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23
 Identificador: fputwc
Protótipo: wint_t fputwc(wchar_t c, FILE *stream);
Descrição: Essa função escreve um caractere largo no fluxo stream.
Retorno: Retorna o caractere escrito, ou WEOF em erro.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: putwc
Protótipo: wint_t putwc(wchar_t c, FILE *stream);
Essa função é equivalente a fputwc, exceto que geralmente é
Descrição:
implementada como sendo um macro.
Retorno: Retorna o caractere escrito, ou WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: fputws
Protótipo: int fputws(const wchar_t * restrict s, FILE * restrict stream);
Descrição: Essa função escreve a string de caracteres largp s no fluxo stream.
Retorno: Em sucesso retorna um valor não negativo, em erro WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: putwchar
Protótipo: wint_t putwchar(wchar_t c);
Descrição: Essa função é equivalente a fputwc com o argumento stdin.
Retorno: Retorna o próximo caractere largo do fluxo stdin, ou WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: ungetwc
Protótipo: wint_t ungetwc(wint_t c, FILE *stream);
Descrição: Essa função coloca de volta o caractere largo no fluxo stream.
Retorno: Em sucesso retorna o caractere largo c, em falha WEOF.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

E/S de String Formatada – Família wprintf

As funções listadas abaixo, funcionam da mesma forma que suas contrapartes da família printf,
com a exceção que a string de formato deve ser uma string de caracteres largos, e as funções
que possuem um buffer específico como argumento, possuem também um argumento extra
para o tamanho do buffer, eliminado a necessidade de funções nprinft.

wprintf int wprintf(const wchar_t *restrict format, ... );

fwprintf int fwprintf(FILE * restrict stream, const wchar_t * restrict format, ...);
swprintf int swprintf(wchar_t * restrict s, size_t n, const wchar_t * restrict format, ...);
vwprintf int vwprintf(const wchar_t * restrict format, va_list arg);
vfwprintf int vfwprintf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);
int vswprintf(wchar_t * restrict s, size_t n, const wchar_t * restrict format, va_list
vswprintf
arg);
Padronização K&R C89 C90 C95 C99 C11 C17 C23

E/S de String Formatada – Família wprintf

As funções listadas abaixo, funcionam da mesma forma que suas contrapartes da família scanf,
com a exceção que a string de formato deve ser uma string de caracteres largos.
 wscanf int wscanf(const wchar_t * restrict format, ...);
fwscanf int fwscanf(FILE * restrict stream, const wchar_t * restrict format, ...);
swscanf int swscanf(const wchar_t * restrict s, const wchar_t * restrict format, ...);
vwscanf int vwscanf(const wchar_t * restrict format, va_list arg);
vfwscanf int vfwscanf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);
vswscanf int vswscanf(const wchar_t * restrict s, const wchar_t * restrict format, va_list arg);
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Utilidades de Strings Largas

As funções abaixo funcionam da mesma forma que suas contraparte char* definidas na
biblioteca <string.h>, com a diferença que a string a ser analisa será uma string de caracteres
largos.

wcstof float wcstof(const wchar_t * restrict nptr, wchar_t ** restrict endptr);

wcstod double wcstod(const wchar_t * restrict nptr, wchar_t ** restrict endptr);
wcstold long double wcstold(const wchar_t * restrict nptr, wchar_t ** restrict endptr);
wcstod32 _Decimal32 wcstod32(const wchar_t * restrict nptr, char ** restrict endptr);
wcstod64 _Decimal64 wcstod64(const wchar_t * restrict nptr,char ** restrict endptr);
wcstod128 _Decimal128 wcstod128(const wchar_t * restrict nptr,char ** restrict endptr);
wcstol long int wcstol(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
long long int wcstoll(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int
wcstoll
base);
unsigned long int wcstoul(const wchar_t * restrict nptr, wchar_t ** restrict endptr,
wcstoul
int base);
unsigned long long int wcstoull(const wchar_t* restrict nptr, wchar_t** restrict
wcstoull
endptr, int base);
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Manipulação de Arrays Wide

As funções abaixo funcionam da mesma forma que suas contrapartes void* definidas na
biblioteca <string.h>.

wmemcpy wchar_t *wmemcpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
wmemove wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2, size_t n);
wmemcmp int wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n);
wmemset wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n );
wmemchr
QWchar_t *wmemchr(QWchar_t *s, wchar_t c, size_t n);
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Cópia de Strings Largas

As funções abaixo funcionam da mesma forma que suas contrapartes char* definidas na
biblioteca <string.h>.

wcscpy wchar_t *wcscpy(wchar_t * restrict s1, const wchar_t * restrict s2);

wcsncpy wchar_t *wcsncpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
wcscat wchar_t *wcscat(wchar_t * restrict s1, const wchar_t * restrict s2);
wcsncat wchar_t *wcsncat(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
wcsxfrm size_t wcsxfrm(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Manipulação de Strings Largas
As funções abaixo funcionam da mesma forma que suas contrapartes char* definidas na
biblioteca <string.h>.

wcslen size_t wcslen(const wchar_t *s);

wcscmp int wcscmp(const wchar_t *s1, const wchar_t *s2);
wcsncmp int wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n);
wcscoll int wcscoll(const wchar_t *s1, const wchar_t *s2);
wchar_t *wcschr(const wchar_t *s, wchar_t c);
wcschr
QWchar_t *wcschr(QWchar_t *s, wchar_t c);
wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
wcsrchr
QWchar_t *wcsrchr(QWchar_t *s, wchar_t c);
wcsspn size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
wcscspn size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
wcspbrk
QWchar_t *wcspbrk(QWchar_t *s1, const wchar_t *s2);
wchar_t *wcsstr(const wchar_t *dest, const wchar_t *src);
wcsstr
QWchar_t *wcsstr(QWchar_t *s1, const wchar_t *s2);
wchar_t *wcstok(wchar_t * restrict s1, const wchar_t * restrict s2, wchar_t ** restrict
wcstok
ptr);
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Manipulação de Multibytes
Identificador: mbsinit
Protótipo: int mbsinit(const mbstate_t *ps);
Se ps não é nulo, essa função determina se o objeto apontado por ps
Descrição:
descreve um valor inicial de conversão.
Retorna um não zero, se ps não nulo descreve um valor inicial de
Retorno:
conversão, zero caso contrário.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: btowc
Protótipo: wint_t btowc(int c);
Caso c seja um caractere estreito valido, essa função retorna um
Descrição:
caractere largo equivalente.
Retorna um WEOF se c não for valido ou for um EOF, caso contrário é
Retorno:
retornada a representação de c em caracteres largos.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: wctob
Protótipo: int wctob(wint_t c);
Caso c seja um caractere largo valido, essa função retorna um
Descrição:
caractere estreito equivalente.
Retorna um EOF se c não for valido, ou não tiver o tamanho de 1
Retorno: byte, caso contrário é retornada à representação de c em
caracteres estreitos.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: mbrlen
Protótipo: size_t mbrlen(const char * restrict s, size_t n, mbstate_t * restrict ps)
Determina o tamanho em bytes da representação do próximo
Descrição:
caractere multibyte em s.
 Onde n é o tamanho em bytes a ser analisado, e ps é o estado de
conversão.
Retorna um inteiro, onde:
0 – Se os próximos n caracteres representa um caractere nulo, ou se s
é um ponteiro nulo.
Retorno:
[1...n] – O tamanho em byte do caractere analisado.
-2 – Se os próximos n bytes são parte de um caractere multibyte.
-1 – Se um erro de codificação ocorrer.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: mbrtowc
size_t mbrtowc(wchar_t * restrict pwc, const char *restrict s, size_t n,
Protótipo:
mbstate_t * restrict ps);
Converte um caractere multibyte s em sua representação larga,
armazenado em pwc.
Descrição:
Onde n é o tamanho em bytes a ser convertido de s, e ps é o estado
de conversão.
Retorna um inteiro, onde:
0 – Se o caractere convertido é um caractere nulo.
Retorno: [1...n] – O tamanho em byte do caractere convertido.
-2 – Se os próximos n bytes são parte de um caractere multibyte.
-1 – Se um erro de codificação ocorrer.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: wcrtomb
Protótipo: size_t wcrtomb(char * restrict s, wchar_t wc, mbstate_t * restrict ps);
Converte um caractere largo wc em sua representação multibyte,
Descrição: armazenado em s.
Onde ps é o estado de conversão.
Retorno: Retorna o número de bytes escritos em s, ou -1 em falha.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: mbsrtowcs
size_t mbsrtowcs(wchar_t * restrict dst, const char ** restrict src, size_t
Protótipo:
len, mbstate_t * restrict ps);
Converte uma string multibyte, cujo primeiro elemento é apontado
por *src, em sua representação larga, armazenado em dst.
Descrição: Onde len é o tamanho em bytes de dst, e ps é o estado de
conversão.
Essa função modifica o valor de *src.
Retorna o número de caracteres escritos em dst, excluindo o
Retorno:
caractere nulo, em erro -1 é retornado.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Identificador: wcsrtombs
size_t wcsrtombs(char * restrict dst, const wchar_t ** restrict src, size_t
Protótipo:
len, mbstate_t * restrict ps);
Converte uma string larga, cujo primeiro elemento é apontado por
*src, em sua representação multibyte, armazenado em dst.
Descrição: Onde len é o tamanho em bytes de dst, e ps é o estado de
conversão.
Essa função modifica o valor de *src.
 Retorna o número de caracteres escritos em dst, excluindo o
Retorno:
caractere nulo, em erro -1 é retornado.
Padronização K&R C89 C90 C95 C99 C11 C17 C23

Miscelânea
A função wcsftime é equivalente a função strftime declarada em <time.h>, exceto que ela
manipula uma string de caracteres largos.

size_t wcsftime(wchar_t * restrict s, size_t maxsize,

wcsftime
const wchar_t * restrict format, const struct tm * restrict timeptr);
Padronização K&R C89 C90 C95 C99 C11 C17 C23
 Biblioteca 31: wctype.h
Essa biblioteca foi implementada a partir da padronização C95, e é o equivalente da biblioteca
ctype.h para a manipulação de caracteres longos — wide characters. Essa biblioteca define
funções que que seguem um padrão, recebem um único argumento do tipo wint_t <wchar.h>
e retornam um inteiro, salvo algumas exceções.

Referência
Identificador Tipo Descrição
Tipo de Representa um objeto capaz de armazena qualquer valor
wint_t
dados membro do conjunto de caracteres estendido
Tipo de Tipo escalar que armazena valores que representam
wctrans_t
dados mapeamentos locale-specific de caracteres
Tipo de Tipo escalar que armazena valores que representam
wctype_t
dados classificações locale-specific de caracteres
Macro Uma constante do tipo wint_t que não corresponde a
WEOF qualquer valor do conjunto de caracteres estendido,
usado para indicar erros
iswalnum Função Testa se é um caractere alfanumérico
iswalpha Função Testa se é um caractere alfabético
iswlower Função Testa se é um caractere em caixa baixa
iswupper Função Testa se é um caractere em caixa alta
iswdigit Função Testa se é um caractere de digito
iswxdigit Função Testa se é um caractere hexadecimal
iswcntrl Função Testa se é um caractere de controle
iswgraph Função Testa se é um caractere gráfico
iswspace Função Testa se é um caractere de espaço
iswblank Função Testa se é um caractere vazio
iswprint Função Testa se é um caractere printável
iswpunct Função Testa se é um caractere de pontuação
Função Classifica um caractere de acordo com a categoria
iswctype
LC_CTYPE a partir da localização atual
wctype Função Retorna uma categoria de acordo com seu argumento
towctrans Função Retorna o mapping LC_CTYPE a partir da localização atual
wctrans Função Retorna um mapping de acordo com seu argumento
towlower Função Converte um caractere para caixa baixa
towupper Função Converte um caractere para caixa alta
Padronização K&R C89 C90 C95 C99 C11 C17 C23
Os tipos wint_t e o macro WEOF são também redeclarados na biblioteca <wchar.h> — implementação
fonte.

Funções
Todas as funções dessa biblioteca seguem um padrão, onde todas apresentado o seguinte
protótipo:
Sintaxe: int func-name(wint_t c);

Retornam um inteiro e recebem um único inteiro como argumento.

Essas funções retornam um não-zero em caso sucesso e zero em caso de falha, exceto pelas
funções towlower, towupper, iswctype, wctype, wctrans e towctrans que possuem sua própria
forma de operação
towwupper
Protótipo: wint_t towupper(wint_t wc);

Retorna o caractere wc convertido em caixa alta.

towlower
Protótipo: wint_t towlower(wint_t wc);

Retorna o caractere wc convertido em caixa baixa.

wctype
Protótipo: wctype_t wctype(const char *property);

Retorna um wctype_t que representa a categoria LC_CTYPE da localização atual, e deve ser
usada na função iswctype, seu retorno depende da string apontado por property. Um wctype_t
com o valor de retorno zero representa uma tentativa falha de recuperar a categoria.

Sendo os possíveis valores para property:

String Equivalente a categoria usada por

"alnum" iswalnum
"alpha" iswalpha
"blank" iswblank
"cntrl" iswcntrl
"digit" iswdigit
"graph" iswgraph
"lower" iswlower
"print" iswprint
"space" iswspace
"upper" iswupper
"xdigit" iswxdigit
Padronização K&R C89 C90 C95 C99 C11 C17 C23

iswctype
Protótipo: int iswctype(wint_t wc, wctype_t desc);

Determina se o caractere representado por wc faz parte da categoria LC_CTYPE indicada por
desc, retornando um não zero em sucesso e um zero em caso de um valor falso.

wctrans
Protótipo: wctrans_t wctrans(const char *property);

Retorna um wctrans_t que representa o mapping LC_CTYPE da localização atual, e deve ser
usado na função towctrans, seu retorno depende da string apontado por property. Um
wctrans_t com o valor de retorno zero representa uma tentativa falha de recuperar o mapping.

Sendo os possíveis valores para property:

String Equivalente a função

 "tolower" towlower
"toupper" towupper
Padronização K&R C89 C90 C95 C99 C11 C17 C23

towctrans
Protótipo: wint_t towctrans(wint_t wc, wctrans_t desc);

Determina se o caractere representado por wc pode ser mapeado para o mapping LC_CTYPE
indicado por desc, retornando o caractere mapeado em sucesso, ou um zero em caso de falha.

Observações
O equivalente dessa biblioteca para caracteres curtos — narrow characters — é a: BIBLIOTECA
<ctype.h>

Segue abaixo uma tabela com os possíveis retornos de cada função — exceto towlower,
towupper, iswctype, wctype, wctrans e towctrans — inclusive as funções para caracteres curtos
da biblioteca <ctype.h>.

Valores ASCII
Caracteres c p s b g p n a u l d x
Base10 Base16 Base8
0–8 x0–x8 0–10 Controle * 0 0 0 0 0 0 0 0 0 0 0
9 x9 11 Tab (\t) * 0 * * 0 0 0 0 0 0 0 0
10–13 xA–xD 12–15 Brancos (\n\v\f\r) * 0 * 0 0 0 0 0 0 0 0 0
14-31 xE–x1F 16–37 Controle * 0 0 0 0 0 0 0 0 0 0 0
32 x20 40 Espaço 0 * * * 0 0 0 0 0 0 0 0
33–47 x21-x2F 41–57 !"#$%&'()*+,-./ 0 * 0 0 * * 0 0 0 0 0 0
48–57 x30–x39 60–71 0123456789 0 * 0 0 * 0 * 0 0 0 * *
58–64 x3A–x40 72–100 :;<=>?@ 0 * 0 0 * * 0 0 0 0 0 0
65–70 x41–x46 101–106 ABCDEF 0 * 0 0 * 0 * * * 0 0 *
GHIJKLMNOP
71–90 x47–x5A 107–132 0 * 0 0 * 0 * * * 0 0 0
QRSTUVWXYZ
91–96 x5B–x60 133–140 [\]^_` 0 * 0 0 * ≠ 0 0 0 0 0 0
97–102 x61–x66 141–146 abcdef 0 * 0 0 * 0 * * 0 * 0 *
ghijklmnop
103–122 x67–x7A 147–172 0 * 0 0 * 0 * * 0 * 0 0
qrstuvwxyz
123–126 x7B–x7E 172–176 {|}~ 0 * 0 0 * * 0 0 0 0 0 0
127 x7F 177 Deletar (DEL) * 0 0 0 0 0 0 0 0 0 0 0

Onde:

• * — Verdadeiro

• 0 — Falso

• C — iscntrl ou iswcntrl

• P — isprint ou iswprint

• S — isspace ou iswspace

• B — isblank ou iswblank

• G — isgraph ou iswgraph

• P — ispunct ou iswpunct
• N — isalnum ou iswalnum

• A — isalpha ou iswalpha

• U — isupper ou iswupper

• L — islower ou iswlower

• D — isdigit ou iswdigit

• X — isxdigit ou iswxdigit
PARTE III
 Especialização 1: Programas em C
Terminação de um processo
Há oito maneiras de um programa C terminar.

5 formas normais.

• Retorno de main.

• Chamando exit.

• Chamando _exit() — POSIX —, _Exit() — C99 —, ou quick_exit() — C11.

• Chamando thrd_exit() — C11—, ou pthread_exit() — POSIX —, na última thread.

3 formas anormais

• Chamando abort().

• Recebendo um sinal.

• Resposta de cancelamento da última thread.

Alocação de uma string

O que determina como um literal do tipo string é alocado é o contexto no qual o literal aparece.
As strings quando aparecem em um contexto global são alocadas no espaço de memória
estática. Já no contexto local, sua alocação irá depender se há ou não uma atribuição de
variável.

As strings definidas no contexto local sem uma atribuição de variáveis são alocadas
dinamicamente, porém caso haja uma atribuição a uma variável do tipo array — observe que
não se aplica ao tipo ponteiro — a string é alocada na pilha, caso a variável seja um ponteiro,
a string ainda é alocada no segmento estático.

Segue abaixo um exemplo de alocações de strings.

char str_e[] = "string"; // Alocação estática

int main(){
"string"; // Alocação estática
char str_l[] = "string"; // Alocação na pilha
char *str_le = "string"; // Alocação estática
return 0;
}

Layout de memória
Historicamente um programa em C consiste nas seguintes peças:

• O segmento de texto – consiste em instruções de máquina para a CPU. Geralmente

esse segmento é compartilhado, para assim haver somente uma cópia do segmento
para os processos em execução. Ressalta-se que esse segmento geralmente é read-
only.
 • Segmento de dados inicializados – também chamado de segmento de dados simples
ou .data, contém variáveis globais ou estáticas que podem ter seus valores alterados.

• Segmento de dados não inicializados – também chamado de .bss, consiste em dados

estáticos ou globais que não possuem um inicializador ou que são inicializados com
zero pelo kernel.

• Pilha – uma estrutura de dados onde as variáveis automáticas são alocadas,

juntamente com informações de uma chamada de função.

• Heap – espaço para a alocação de memória dinâmica.

• Maior endereço – espaço para argumentos de CLI e Variáveis de ambiente

Representação de um layout de um programa C

Bibliotecas
Em programação, bibliotecas é um conjunto de código pré compilado, geralmente esse código
é constituído de rotinas e definições de tipos. Uma biblioteca geralmente é linkada em um
programa durante o estágio de ligação.

Geralmente há três tipos de bibliotecas: static, shared e dynamically loaded.

Static
São o modelo mais antigo e simples de bibliotecas, elas geralmente são arquivos compactados,
que contém uma coleção de arquivos objetos. Na fase de ligação todo o conteúdo do arquivo
objeto da biblioteca é ligado ao programa, sendo assim, a ligação estática ocorre em tempo
de compilação, e devido a isso, as bibliotecas estáticas não possui dependência externa
quando ligadas a um programa.

Geralmente possuem a extensão .a, .sa ou .lib.

Shared
Introduzida pela Sun Microsystem no início dos anos 90s, as bibliotecas compartilhadas são
carregadas em tempo de execução pelo loader do sistema, juntamente com a aplicação que
a necessita, portanto, as referências da biblioteca são solucionadas pelo loader do sistema, e
não pelo linker.

Os programas que fazem referência a uma biblioteca shared aponta para uma única cópia
dessa biblioteca no sistema ambiente, dessa maneira o sistema mantém um gerenciamento de
uma única cópia compartilhada entre os usuários dessa biblioteca.

Bibliotecas compartilhadas possuem dependência externa, devido a isso, a portabilidade dos

programas que usam essa biblioteca é reduzida.

Geralmente possuem a extensão .so, .dylib ou .dll.

Dynamically loaded
Bibliotecas dinâmicas diferentes das compartilhadas, são carregadas enquanto o programa
está rodando, e geralmente são carregadas pela própria aplicação, ou pela sandbox que roda
a aplicação. Em algumas plataformas são carregadas por demanda.

Devido a isso, seu gerenciamento e manipulação são dependentes da aplicação, porém,

qualquer tipo de biblioteca, seja ela estática ou compartilhada pode ser usada como sendo
uma biblioteca dinâmica.
 Especialização 2: Aplicações
Compilador
Um compilador é a aplicação responsável por transformar o código fonte entre em uma
linguagem de alto-nível como o C, para uma linguagem de baixo-nível, como o Assembly. O
programa resultante gerado em Assembly, por sua vez é passo para outro compilador, o
assembler; esse que, será o responsável para compilar o programa originalmente escrito em C
para linguagem de máquina.

Existes vários compiladores para a linguagem C, assim como front-ends que fazem todo o
processo de compilação e ligamento de um código C.

GCC

O front-end para compiladores do projeto GNU, ele possui suporte há varias linguagem,
incluindo o C.

Página na internet: [Link]

Biblioteca padrão
A biblioteca padrão C é chamada de libc, ela define operações de E/S, visto que a linguagem
não oferece instruções nativas para isso.

Existe várias implementações da libc.

GNU C Library

Também chamada de glibc, é a biblioteca padrão C do projeto GNU, é uma das

implementações da libc.

Página na internet: [Link]

Depurador
O depurador ou debbuger é um utilitário que executa um programa passo a passo, com um
total controle sobre o mesmo, permitindo assim ao o usuário recuperar informações em sobre o
estado do programa em momentos diferentes.

O depurador roda o programa cujo está sendo depurado em um processo inferior ao o processo
do depurador, e apesar de aparentar que o mesmo analisa as instruções tendo como base o
código fonte, as atuais instruções analisadas são as instruções de máquina.

Tabela de símbolos
A tabela de símbolos é uma estrutura de dados mantido pelo compilador que armazena
informações sobre as várias entidades do programa, como variáveis locais, nome de funções,
objetos estáticos, etc.
Para uma depuração efetiva seu programa deve ser compilador com essas informações da
tabela de símbolos, é possível especificar esse tipo de compilação com flags do compilador.