Introdução à Linguagem C
Olá leitor, seja muito bem-vindo à nossa jornada de Linguagem C aqui no Portal da Micilini! 🥳
Antes de continuarmos, deixa eu te fazer uma pequena pergunta...
Você já abriu um programa e pensou em tudo o que acontece quando clicamos em um botão e vemos alguma coisa aparecer na tela?
A grande verdade é que uma imagem que aparece na sua tela, por mais simples que ela seja, ela precisa ser processada de alguma maneira.
Um arquivo precisa ser lido por um motor tão rápido que você nem imagina que existe.
E por fim, alguém precisa organizar os dados na memória e explicar ao computador o que fazer com eles.
E é nesse universo que a linguagem C, que iremos aprender nessa jornada, vai nos acompanhar: uma linguagem de programação que nos permite construir desde pequenos utilitários até componentes de sistemas operacionais, bibliotecas e ferramentas de multimídia.
E eu tenho um motivo bem pessoal para abrir essa jornada é que eu sou apaixonado por programação, e muito antes de a inteligência artificial entrar no nosso cotidiano, eu já ensinava programação e criava jornadas e tutoriais por aí na internet.
Tanto é que você pode encontrar um dos meus vídeos mais antigos no Youtube, aonde eu mostrava como criar um bloco de notas com Delphi 7. 😄
E sim, na época em que eu gravei aquele vídeo, eu não soube gravar direito e não saiu som nenhum rs
Hoje, eu tenho no meu github alguns projetos como HobbyOS, N.148i, NessMuxer e NessStudio que levam o uso da linguagem C ao extremo, e que ao mesmo tempo tornam ainda mais interessante compartilhar os fundamentos que aparecem por trás dessas construções.
Dito isso, a ideia desta jornada é começar do começo, com exemplos, imagens e espaço para entender cada peça que será ensinada aqui.
Por fim, eu gostaria de te dizer que ao terminar este artigo, você vai saber o que é C, por que ele existe e como um arquivo de texto se transforma em um programa 😉

Antes de continuarmos, o que você precisa saber?
Se você chegou até aqui, eu imagino que você consegue usar um computador, certo?
Certifique-se também de que você consegue criar uma pasta e salvar um arquivo, e que tem alguma noção de lógica de programação, mas fique tranquilo que aqui nós iremos explicar os conceitos essenciais ao longo do caminho.
Gostaria de te dizer que não existe uma exigência de conhecer HTML, CSS, JavaScript ou outra linguagem para começar por aqui. E também não precisa chegar sabendo eletrônica ou decorando instruções de processador, ok? 🙂
Se você já programa em alguma linguagem de programação, ótimo! Aqui você vai aprender a olhar com mais atenção para o gerenciamento de memória, compilação e organização dos dados.
Mas se você está começando agora... pode ficar tranquilo, só peço acompanhe os exemplos sem pressa rs
Neste primeiro encontro, nós vamos montar a visão geral do universo da linguagem C, coisas relacionadas com a instalação e a configuração detalhada do ambiente vão ficar para uma próxima etapa, ok?
O que é a linguagem C?
C é uma linguagem de programação de propósito geral (sim, você consegue fazer tudo com ela, só dá mais trabalho do que as outras linguagens rs).
E isso significa que ela pode expressar soluções para problemas bem diferentes, como calcular um resultado, transformar uma imagem, organizar arquivos ou implementar parte de um sistema operacional.
Ela é normalmente utilizada com compiladores que transformam o código escrito por nós em uma forma executável pela máquina.
Se você for agora no tio Google e pesquisar sobre C, é bem provavel que aparecem algumas palavras que parecem complicadas, tais como algumas referencias que dizem que a linguagem C ela é: imperativa, estruturada e procedural. Mas calma, vamos conhecer seus significados:
- Imperativa: você descreve ações que o programa deve realizar, como calcular um total, mudar um valor ou gravar um resultado. Essas ações podem alterar o estado dos dados.
- Estruturada: você organiza o caminho do programa usando sequências, decisões e repetições. Por exemplo: conferir uma condição antes de executar uma tarefa.
- Procedural: você reúne tarefas em funções, que podem receber informações e devolver resultados. Isso ajuda a dividir uma solução grande em partes compreensíveis (para nós humanos, é claro).
Imagine uma papelaria. Uma parte do programa calcula o valor da compra, outra confere o estoque, e a outra registra o pedido. Cada tarefa tem um papel, e as funções ajudam a expressar essa divisão.
Também existem linguagens e estilos que enfatizam outras formas de pensar, como transformar valores por funções ou descrever relações lógicas.
Nesta jornada, nós iremos começar com instruções, dados e funções, sem precisar decorar um catálogo de paradigmas. Ufa 🫣
Linguagens de programação de baixo nível vs de alto nível
Se essa é sua primeira vez tendo contato com programação, é necessário que você entenda duas grandes diferenças que existem nesse ramo: as linguagens de baixo nível e as linguagens de alto nível.
É importante ressaltar que esse nomes (alto nível e baixo nível) indicam o nível de abstração que a linguagem oferece.
Abstrair significa permitir que você trabalhe com uma ideia sem precisar cuidar de todos os detalhes que existem por trás dela.
Existe uma grande diferença entre fazer um bolo de chocolate comprando todos os ingredientes pré-prontos no mercado, do que plantar cacau e seguir todo o fluxo do zero rs
Ainda não entendeu? Então vamos a um outro exemplo mais prático: sabe aquelas cafeteiras modernas em capsulas? Então, quando você insere a capsula ali dentro e aperta um botão, você não precisa controlar manualmente cada componente envolvido no preparo do café.
Ou seja, você simplesmente utiliza uma operação mais simples, enquanto outros mecanismos cuidam de parte do trabalho.
E no universo da programação, acontece algo parecido... 🤗
Começando pelas de alto nível, elas permitem escrever programas usando conceitos como variáveis, funções, listas e objetos, sem precisar escolher diretamente cada instrução que o processador vai executar.
Linguagens como: Python, Javascript, Java, C# e PHP são grandes exemplos desse grupinho rs
E elas aparecem bastante no cotidiano dos desenvolvedores! Na pesquisa do Stack Overflow de 2026, entre os 14.099 participantes que responderam à pergunta sobre linguagens, 62% relataram ter desenvolvido com JavaScript no último ano, enquanto 58% disseram ter usado Python.
Para que você possa entender melhor o funcionamento dessas linguagens de alto nível, imagine que você queira mostrar o resultado de uma soma (3+5) usando Python. No caso dele, você poderia escrever o seguinte comando para a máquina:
print(3 + 5)No exemplo acima, acabamos de escrever uma operação simples, responsável por realizar o calculo dos números 3 e 5. Tudo isso representado em uma única linha, fácil de entender e replicar, não é verdade?
Tá... como veremos mais adiante, existe inúmeras operações por de baixo dessa função chamada "print", que cuida de diversas lógicas e operações. Mas isso foi abstraído de forma tão simples, que não precisamos entender o resto.
É como receber uma oficina equipada: você ainda precisa saber construir o que deseja, mas já encontra várias ferramentas preparadas para facilitar o trabalho. 🧰
E atenção: alto nível não significa que qualquer pessoa vai criar um sistema complexo sem estudar. A linguagem pode esconder detalhes do hardware, mas a lógica, a organização e as regras do programa continuam sendo responsabilidades de quem desenvolve.
Do outro lado da moeda, nós temos as linguagens de programação de baixo nível, onde o código fica mais próximo das operações que uma arquitetura de processador oferece.
Como exemplo de linguagens de baixo nível, temos C++ e o Assembly, que são as mais famosas.
Quando se fala de baixo nível, muito se fala também do código de máquina, que representa instruções na forma binária que a CPU executa.
Por exemplo, uma operação que aparece como uma expressão simples em uma linguagem de alto nível (como é o caso do print(3+5) em python) pode exigir que você descreva separadamente como movimentar os valores, realizar o cálculo e guardar o resultado, ou seja, fazer na unha o que a função print do Python faz para você rs
Na mesma pesquisa do Stack Overflow de 2026, 7,2% dos participantes que responderam sobre linguagens relataram uso de Assembly no seu cotidiano.
C é de alto nível ou de baixo nível?
A resposta depende da comparação. Em relação ao código de máquina e ao Assembly, C oferece um nível maior de abstração: você escreve uma função ou uma repetição sem escolher manualmente cada instrução da CPU.
Ao mesmo tempo, C oferece recursos para trabalhar perto da representação dos dados, como ponteiros e operações sobre bits, e é por isso ele aparece tanto em conversas sobre programação de baixo nível.
É um pouco como dirigir tendo acesso a mais controles de um carro. Você pode fazer ajustes importantes, mas precisa compreender o que esses controles fazem e como se comunicam entre si.
E respondendo a pergunta desse tópico, SIM, a linguagem C é mais usada para programação de baixo nível, devido a sua rapidez e eficácia.
A história do C: uma linguagem que foi construída para resolver problemas
O C surgiu nos Bell Labs, no início dos anos 1970, durante o desenvolvimento do Unix. Dennis Ritchie foi seu principal criador, e o ano de 1972 se tornou um marco importante dessa evolução.
A história tem uma família: a linguagem BCPL, de Martin Richards, que influenciou a linguagem B, criada por Ken Thompson. Ritchie desenvolveu C a partir de B, acrescentando, entre outras coisas, um sistema de tipos muito mais rico e detalhado.
Em 1973, o núcleo do Unix para o PDP-11 acabou sendo reescrito na linguagem C. Tornando-se uma demonstração concreta de que uma linguagem mais abstrata que Assembly poderia servir para construir um sistema operacional.
Depois, em 1978, Brian Kernighan e Dennis Ritchie publicaram um livro chamado The C Programming Language, o famoso livro K&R, que ajudou a documentar e difundir a linguagem mundo a fora.
O próprio Ritchie conta como foi o processo de desenvolvimento, e o mesmo pode ser encontrado aqui: The Development of the C Language.
E sim, ele mesmo disse que foi uma construção gradual, ligada a necessidades reais de programação e dificuldades que eles estavam enfrentando naquela época.

Por que existem C89, C99, C11 e tantos outros nomes?
Se você deu uma pesquisada antes de entrar nesse artigo, talvez tenha visto referencias como C89, C99, C11...
A grande verdade é que conforme uma linguagem chega a mais computadores e ferramentas, surge uma necessidade: combinar quais regras todos devem seguir. Caso contrário, cada implementação pode falar um “dialeto” incompatível, e teríamos diversos programas feitos em C que só funcionam na maquina de algumas pessoas.
É como se cada Brasileiro resolvesse seguir suas próprias regras linguisticas, resultado? Ninguém ia entender nada, e é por isso que foram criadas as normas linguísticas 😂
Um padrão documenta as regras da linguagem e de sua biblioteca padrão. Ele permite comparar implementações e escrever código com expectativas bem definidas.
Estes são alguns marcos que você vai encontrar, conforme a relação oficial de versões do WG14, o grupo responsável pela padronização da linguagem C:
- C89 e C90: primeira padronização pela ANSI, em 1989, e sua adoção internacional pela ISO, em 1990.
- C95: emenda publicada em 1995 para a edição de 1990.
- C99: revisão publicada em 1999.
- C11: revisão publicada em 2011.
- C17, também chamado C18: revisão publicada em 2018.
- C23: revisão publicada como ISO/IEC 9899:2024. Sim, o apelido e o ano de publicação podem ser diferentes. 😅
Mas calma lá, você não precisa memorizar essa lista, tudo bem?
O ponto é que você precisa entender que a linguagem C continua evoluindo e que o compilador precisa oferecer suporte aos recursos que você pretende usar.
E não, diferente do que você pode estar pensando, linguagens de baixo nível recebem atualizações sim... nem tanto quanto as de alto nível, mas sim, elas recebem, mesmo que por um grande espaço de tempo rs
Nos comandos que vermeos ao longo dessa jornada, nós vamos selecionar a C17 explicitamente e trabalhar com fundamentos que também fazem parte de versões anteriores.
E quando uma diferença de versão importar para um exemplo que estamos construindo, ela vai ser explicada, tudo bem?
Isso evita depender silenciosamente da configuração padrão de uma ferramenta. Extensões particulares de um compilador também merecem atenção, principalmente quando queremos levar o código para outros ambientes.
C e C++ são a mesma coisa?
Você provavelmente já viu as duas aparecendo juntas como “C/C++”.
E sim, só pra você saber, elas têm uma relação histórica e compartilham bastante da sua sintaxe, mas são linguagens distintas, com padrões e práticas próprias.
C++ oferece, entre outros recursos, classes, templates e mecanismos de gerenciamento de recursos que não fazem parte do C. E não é correto afirmar que qualquer programa C válido será automaticamente um programa C++ válido, ou seja, o que eu quero dizer com isso... "Nem todo programa feito em C vai conseguir rodar dentro do C++".
Essa diferença é explicada pelo próprio criador de C++, Bjarne Stroustrup, em sua resposta sobre a compatibilidade entre as linguagens.
Aprender C ajuda a reconhecer conceitos em C++, Objective-C e outras linguagens relacionadas ou influenciadas por ele. Ainda assim, cada linguagem merece ser estudada pelos seus próprios recursos.
Dito isso, afirmo e reafirmo: Nesta jornada, nosso foco é C ☺️
O que dá para construir com C?
Tem muita coisa interessante além de imprimir uma frase no terminal.
Um simples HELLO WORLD é só a primeira ferramenta de observação, agora... O universo que se abre depois de aprender e dominar C é bem maior. 😎
- Sistemas operacionais e drivers: componentes que coordenam recursos e se comunicam com dispositivos.
- Sistemas embarcados e firmware: software de placas, sensores, câmeras e equipamentos automotivos, muitas vezes com recursos limitados.
- Compiladores, interpretadores e ferramentas: programas que ajudam a construir ou executar outros programas.
- Bancos de dados e bibliotecas: componentes reutilizáveis que podem atender aplicações escritas em outras linguagens.
- Imagem, áudio e vídeo: filtros, codecs, processamento de sinais, conversão e organização de arquivos multimídia.
- Aplicativos e utilitários: editores de texto, programas de cálculo, planilhas, ferramentas de terminal, jogos e interfaces gráficas com as bibliotecas adequadas.
- Computação científica e engenharia: cálculos, simulações e processamento de grandes quantidades de dados.
Dois exemplos concretos: a documentação do kernel Linux descreve o uso de C em seu desenvolvimento, e os responsáveis pelo SQLite explicam por que implementam o banco de dados em C.
Isso não transforma C na escolha obrigatória para todo projeto, tá?
Até porque construir uma interface, um site ou uma integração pode ser mais prático de ser feito com outras linguagens, principalmente as da categoria de alto nível.
A escolha depende do problema, das bibliotecas disponíveis e do esforço de desenvolvimento.
Outra distinção: embarcado descreve software integrado a um dispositivo, tempo real envolve cumprir requisitos de tempo. Um equipamento pode reunir as duas características, mas elas não significam a mesma coisa.
Programadores (ou também chamados de desenvolvedores) que trabalham com C (e com outras linguagens de baixo nível), são aqueles artesões que geralmente estão criando as ferramentas que os próprios artistas usarão para criar suas artes.
Como é o caso de criar uma chave de fenda do zero, um pincel do zero e afins. Ou seja, o C é muito utilizado para a construção de bibliotecas e frameworks, de forma a facilitar ainda mais a vida dos desenvolvedores de alto nível.
E aqui na Micilini, onde essa história aparece?
Eu gosto de olhar para projetos concretos porque eles dão um destino para assuntos que, à primeira vista, parecem abstratos. Memória, funções e arquivos passam a ter outro sabor quando você percebe o que pode construir com eles.
- HobbyOS: meu projeto de exploração de sistemas, com uma base pública em C que trabalha com UEFI com Kernel próprio, comandos, arquivos e recursos da máquina. É uma forma de estudar o que existe abaixo de um aplicativo comum.
- N.148i: meu codec de imagens, desenvolvido em C. Ele aproxima pixels, representação de dados e algoritmos de compressão. Aqui no portal, a jornada de codecs acompanha essa construção.
- NessMuxer: uma biblioteca nativa com interface em C que recebe quadros de vídeo, utiliza caminhos de codificação e organiza o resultado em um contêiner MKV. É um exemplo de componente que outro programa pode chamar.
- NessStudio: meu gravador de tela, webcam e áudio. A interface usa C# e WPF, enquanto bibliotecas nativas participam do processamento. Na evolução para a V3, a libnessstudio escrita em C amplia esse trabalho no núcleo da aplicação.
Repara que, no NessStudio, diferentes linguagens colaboram no mesmo produto. Uma interface em C# pode se comunicar com uma biblioteca em C por uma integração apropriada.
E sim, foi isso mesmo que você entendeu... o projeto inteiro não precisa ter uma única linguagem.
E uma pequena separação que evita confusão: codec trata de codificar e decodificar uma representação, e o muxer organiza os fluxos dentro de um contêiner.
O NessMuxer reúne caminhos de codificação com a montagem do arquivo. O N.148i é nosso projeto de imagens.
Esses projetos servem como possibilidades para explorar na linguagem C 🤭

Mas, afinal, o que é um programa?
Vamos imaginar que você trabalha em uma papelaria. Um cliente compra três cadernos, cada um custando R$ 12. E você quer que o computador informe o valor total.
Antes de pensar na lógica e na linguagem de programação, o ideal é imaginar como descrever o fluxo dessa nova tarefa:
- Obter a quantidade de cadernos. Que no caso são 3.
- Obter o preço de cada caderno: Que no caso custa R$ 12.
- Multiplicar a quantidade pelo preço.
- E por fim, mostrar o resultado final que é R$ 36.
Essa sequência de passos é um algoritmo: que nada mais é do que uma forma organizada de resolver um problema.
O programa é a implementação dessa solução, com as instruções e os dados necessários para realizá-la. Um programa maior pode conter vários algoritmos e também cuidar da entrada de informações, dos arquivos e da interação com o usuário.
Já a linguagem de programação nos dá a forma de expressar essas instruções, ou seja, chegar para a maquina e dizer: print(3+5) por exemplo...
É parecido com planejar um móvel e depois escrever as instruções para montá-lo.
É importante ressaltar que o plano da solução e a forma de comunicá-lo estão relacionados, mas não são a mesma coisa.
Entrada, processamento e saída
Antes de continuarmos, você precisa entender o fluxo básico de um programa:
- Entrada: são os dados recebidos, como quantidade e preço. Podem vir do teclado, de um arquivo, de um sensor ou de outra parte do programa.
- Processamento: é o trabalho realizado com esses dados, como multiplicar os valores ou verificar uma regra.
- Saída: é o resultado final, como o total mostrado na tela, um arquivo gravado ou uma resposta enviada a outro componente.
Agora imagine que você escreva uma instrução para somar a quantidade e preço. O computador pode calcular 3 + 12 perfeitamente e devolver 15. Só que esse resultado não resolve o nosso problema.
A máquina executa as operações definidas pelo programa, porém, ela não conclui sozinha que você queria realizar uma multiplicação. É por isso que precisamos compreender os requisitos e conferir os resultados (sempre!)
Esse cuidado continua valendo quando o programa é um gravador de tela, onde produzir um arquivo não basta, o conteúdo precisa corresponder ao que deveria ter sido gravado, e precisamos de um jeito de validar isso.

CPU, RAM e armazenamento: quem faz o quê?
Para o programa funcionar, várias partes do seu computador (incluindo até seu celular, e sua smart TV) precisam colaborar entre si.
Vamos pensar em uma oficina: existe alguém realizando tarefas, uma bancada com o material do momento e um armário para guardar o que será usado depois.
CPU: onde as instruções são executadas
A CPU, ou unidade central de processamento, executa instruções, realiza operações e participa do controle da execução. Na nossa oficina, ela ocupa o papel de quem trabalha com o material, sim, aquele ser humaninho que geralmente é CLT rs
Cada arquitetura de processador possui um conjunto de instruções: operações que ela sabe executar, como movimentar dados, fazer cálculos e mudar o fluxo de execução.
A comparação com uma pessoa termina aí: a CPU não tem vontade nem decide o objetivo do programa. Ela executa instruções conforme as regras da arquitetura, e leva tudo ao pé da letra.
RAM: a bancada de trabalho
A RAM é uma memória usada para manter instruções e dados disponíveis durante o trabalho. Na analogia, é a bancada onde você coloca tudo aquilo que você precisa para realizar a tarefa.
Ela oferece acesso rápido em comparação com o armazenamento comum e é normalmente volátil: seu conteúdo depende de energia para ser mantido.
É por isso que escrever um texto e salvar esse texto, são operações completamente diferentes. Se a informação existe apenas na memória do processo, ela ainda não está necessariamente registrada em um arquivo.
E como ela é volátil e precisa de energia, experimente tirar a energia e veja essa informação sumir para sempre 🫠
SSD e HD: onde os arquivos ficam guardados
O SSD e o HD são dispositivos de armazenamento. Eles guardam arquivos de forma persistente, conservando os dados mesmo quando o computador é desligado normalmente.
Na nossa oficina, eles são os armários. O programa salvo no SSD e o programa em execução estão em situações diferentes: para executar um aplicativo, o sistema prepara seus recursos e disponibiliza código e dados no ambiente de memória.
Existem outros detalhes nessa história, como caches e memória virtual, mas por enquanto eu peço que você guarde a divisão principal: CPU executa, RAM serve de memória de trabalho e armazenamento conserva os arquivos.

E o sistema operacional entra onde?
O sistema operacional coordena recursos da máquina e oferece serviços aos programas. Ele participa da gestão de memória, da execução de aplicativos e do acesso a arquivos e dispositivos.
Windows, sistemas baseados em Linux, macOS, Android e iOS são exemplos de ambientes (sistemas operacionais) com os quais você pode ter contato.
Dentro dessa organização, o kernel, ou núcleo, cuida de responsabilidades centrais, como coordenar execução, memória e acesso ao hardware, conforme a arquitetura do sistema.
Quando um aplicativo pede para gravar um arquivo ou receber dados do teclado, ele normalmente usa serviços e bibliotecas que se apoiam nesse ambiente.
Atenção: Escrever C não elimina as permissões e os limites impostos pelo sistema.
Já em firmware e projetos como o HobbyOS, o contexto de execução é diferente. Isso exige outros conhecimentos, além dos que usaremos nos nossos primeiros programas de console aqui nesta jornada.
No caso do HobbyOS, ele roda de forma independente e atua da mesma forma como um Windows, Linux e Mac, ou seja... ele é o próprio sistema operacional.
O pequeno ciclo que acontece dentro da CPU
Para que um modelo inicial execute suas operações dentro da CPU, ele tem que entender três pontos distinto:
- Buscar: obter a próxima instrução a executar.
- Decodificar: identificar qual operação aquela instrução representa.
- Executar: realizar a operação e atualizar o que for necessário para continuar.
Os registradores são pequenas áreas de armazenamento dentro da CPU. A unidade lógica e aritmética, ou ALU, realiza operações como cálculos e comparações, e a lógica de controle coordena o trabalho.
Esse ciclo é um modelo didático. Processadores modernos usam caches, sobreposição de etapas e outros mecanismos de forma lógica, não sendo necessário buscar cada instrução diretamente na RAM nem concluir tudo de uma em uma.
Também cuidado com o número na embalagem do processador que você comra: 1 GHz significa um bilhão de ciclos por segundo, e não obrigatoriamente um bilhão de instruções. A quantidade de trabalho por ciclo varia, como explica a Intel ao apresentar a frequência de clock.
Você não precisa dominar arquitetura de processadores agora. Essa visão apenas mostra que, por trás de um comando que parece simples, existe trabalho concreto (e muita das vezes muito complexo) sendo realizado por de baixo dos panos.

O que torna o C interessante?
Controle sobre os dados e grande potencial de eficiência
Em C, você consegue escolher com bastante precisão como organizar os dados e como trabalhar com a memória. Isso pode ajudar a reduzir desperdícios e construir programas eficientes.
Pense em um filtro que percorre milhões de pixels. A forma de guardar os pixels, a quantidade de cópias e o algoritmo escolhido podem fazer diferença no tempo gasto.
Mas o nome da linguagem não resolve um algoritmo ruim, e sim, isso significa que um programa em C pode ser lento, consumir muita memória ou repetir trabalho desnecessário.
Guarda essa frase: o desempenho precisa ser medido no cenário que interessa.
O C também permite construir componentes com poucas dependências de execução. Ainda assim, um programa concreto pode precisar de bibliotecas, serviços do sistema e outros recursos (mas você também pode criar esses outros recursos, só terá mais trabalho).
Portabilidade: levar o código para outros ambientes
Imagine que nosso programa da papelaria use apenas recursos padronizados. Com ferramentas adequadas, podemos compilar esse mesmo código para diferentes sistemas e processadores.
Isso é uma forma de portabilidade do código-fonte. O arquivo que você escreveu pode ser reaproveitado, desde que suas escolhas e dependências sejam compatíveis com o novo ambiente.
O executável é outra história... Um arquivo produzido para Windows e uma determinada arquitetura não passa a funcionar automaticamente no Linux ou no macOS porque a linguagem original era C.
Se o código usa uma função específica do Windows, talvez seja necessário substituir ou isolar essa parte. Tamanhos de tipos, formatos de dados e bibliotecas externas também podem exigir o mesmo cuidado.
E aqui vai uma dica... uma boa organização ajuda, isso significa dizer que é inteligente deixarmos o cálculo do pedido separado da forma como a janela é desenhada. Assim, você tem uma chance maior de reaproveitar a lógica quando a interface mudar.
Portabilidade, portanto, é algo que podemos favorecer com boas escolhas, não sendo uma autorização para ignorar as diferenças entre as plataformas.

Bits, bytes e ponteiros, sem susto
No mundo da tecnologia muito se fala sobre Bits, Bytes e até ponteiros, mas você realmente sabe diferenciá-los?
Um bit (menor forma de representar um dado) representa um de dois valores, que costumamos escrever como 0 e 1. Quando combinados, representamos números, caracteres, pixels e outras informações.
Nos computadores comuns que usaremos como referência, um byte tem oito bits (1 byte = 8 bits). E a linguagem C permite trabalhar com esses dados e oferece operadores para examinar ou alterar bits específicos.
Por exemplo, pequenos indicadores de “ligado” e “desligado” podem ser agrupados em um valor. Esse tipo de representação aparece em formatos de arquivo e na comunicação com dispositivos.
Já um ponteiro é um recurso para representar uma referência a um objeto ou a uma função. No caso dos dados, costumamos começar pensando no endereço pelo qual podemos alcançá-los na memória.
Imagine a diferença entre carregar uma caixa inteira e informar onde a caixa está. A analogia ajuda a visualizar a ideia, mas um ponteiro só pode ser utilizado respeitando as regras da linguagem e a validade do que ele referencia.
Ter um endereço não significa ter permissão para acessar qualquer lugar da máquina. E um endereço pode deixar de ser válido para aquele uso.
Mas acalma o seu coração aí, que nós vamos estudar essas situações com exemplos pequenos, sem começar por uma floresta de asteriscos. 😄
Liberdade também exige responsabilidade!
Sabe aquela frase que diz: "Com grandes poderes, vem grandes responsabilidades?", então...
Quando um programa pede memória dinamicamente, geralmente usando funções como o comando malloc, precisa organizar quem usará essa memória e quando ela será liberada com o comando free.
Isso não significa que toda variável de C exige um free. Objetos com duração automática ou estática seguem outras regras.
Esquecer uma liberação pode acumular desperdício. Acessar uma região depois de liberá-la ou escrever além de um espaço reservado pode causar falhas e vulnerabilidades no nosso programa.
Alguns desses erros levam a comportamentos indefinidos, que é quando o padrão deixa de garantir um resultado para aquela execução, ocasionando uma falha imediata, produção de um valor estranho ou parecer funcionar por algum tempo.
Essa responsabilidade faz parte do aprendizado. Não é motivo para fugir da linguagem; é um motivo para aprender com cuidado desde o primeiro exemplo. 🧰
Tá... eu dei alguns spoilers sobre alguns comandos que podemos utilizar em C, e imagino que você não deve ter entendido nada com isso, mas é bom que você já se prepara para o que vem a diante rs
Bibliotecas: ferramentas que você não precisa reconstruir
Até o momento, talvez voce esteja assustado e pensando: "Caramba, programar em C eu vou ter que fazer tudo do zero? Uma simples mensagem de Hello World é necessário entender o funcionamento de um driver de um monitor?".
Calma, tudo bem? Se você quer mostrar uma simples mensagem, você não precisa começar implementando um driver de monitor, Hoje em dia, existem funções e bibliotecas que oferecem serviços para os seus programas escritos em C rs
Ou seja, alguém pensou em facilitar também o desenvolvimento de aplicações em C por outros desenvolvedores que também trabalham em C, é como o alto nível coexistindo dentro do baixo nível 😂
A biblioteca padrão de C reúne recursos como entrada e saída, manipulação de strings, funções matemáticas e utilidades. Ela faz parte do ambiente padronizado de C, embora certos ambientes restritos ofereçam apenas uma parte desse suporte.
Alguns exemplos de cabeçalhos que vão aparecer ao longo da jornada são esses:
<stdio.h>: declara recursos de entrada e saída, incluindoprintfe operações com arquivos.<stdlib.h>: reúne utilidades, como alocação dinâmica de memória e conversões.<string.h>: oferece operações sobre strings e blocos de memória.<math.h>: declara funções matemáticas, como cosseno e tangente.
Também existem bibliotecas externas e APIs do sistema operacional. Criar uma janela, abrir uma conexão de rede ou capturar a tela normalmente envolve recursos que vão além da biblioteca padrão de C.
Uma biblioteca funciona como uma caixa de ferramentas reutilizáveis, e para usá-la corretamente, você precisa conhecer o contrato, que incluí: o que fornecer, o que ela devolve e quais responsabilidades continuam com o seu código.
Resumindo... até no C contamos com bibliotecas que nós ajudam a abstrair ainda mais o desenvolvimento, o que facilita muito a nossa vida. Mas caso desejar, você pode escolher criar um stdio.h, stdlib.h e outras bibliotecas só suas, o C te da esse nível de liberdade 😉
Você sabia que um programa bem feito começa antes do teclado?
Vamos voltar ao nosso exemplo da papelaria.
Vimos anteriormente que nós sabemos calcular três cadernos, mas ainda faltam algumas decisões: a quantidade pode ser zero? O preço pode ser negativo? O que acontece se o usuário digitar uma letra ao invés de um número?
Essas perguntas fazem parte dos requisitos. Elas descrevem o que a solução deve aceitar e como deve se comportar.
Uma forma útil de conduzir o trabalho é fazendo isto da seguinte forma:
- Definir o objetivo: entender o problema, as entradas, as regras e os resultados esperados.
- Planejar a solução: descrever os passos, separar responsabilidades e pensar na interface, isto é, quando ela existir.
- Implementar: traduzir o plano para o código, começando por uma parte pequena.
- Construir: usar as ferramentas para compilar e ligar as partes necessárias.
- Executar: observar o programa funcionando no ambiente previsto.
- Testar e depurar: comparar o comportamento com os requisitos e investigar as causas das falhas.
- Manter e evoluir: corrigir problemas, melhorar a organização e acrescentar funcionalidades conforme a necessidade.
Essa sequência acima não representa uma fila em que cada etapa só pode acontecer uma vez. Um teste pode mostrar que o requisito ficou ambíguo. Uma dificuldade de implementação pode pedir um ajuste no planejamento.
A maior dica que eu posso te dar agora é: Trabalhe em pequenos incrementos. Faça uma parte, confira, avance. Se você altera muita coisa de uma vez, fica mais difícil descobrir qual mudança causou um problema.
E a manutenção desse sistema continua depois da publicação, tudo bem? Não vai pensar que é só criar o sistema e partir para outro... sistemas operacionais mudam e recebem atualizações constantemente.
Quem abre o código meses mais tarde precisa entender o que foi feito, e essa pessoa pode muito bem ser você, logo, você deveria pensar também em escrever códigos limpos e arquiteturas robustas. 😅
Do problema inteiro para funções pequenas
Durante o desenvolvimento de aplicações com C, é bom você saber que existe uma abordagem chamada top-down, que visa começar pelo objetivo maior e o divide em tarefas. Como por exemplo, o simples fato de “Registrar uma venda” pode se tornar “ler os dados”, “validar”, “calcular” e “salvar”.
Depois, essas tarefas podem virar funções e ser organizadas em arquivos como entrada.c, calculos.c e registro.c., em vez de um único arquivo chamado programa.c que contem toda essa lógica.
A ideia é que cada parte tenha uma responsabilidade compreensível. Também queremos evitar que tudo dependa dos detalhes internos de todo o resto. Essa preocupação costuma aparecer com o seguinte nome: baixo acoplamento.
Uma alteração na mensagem exibida ao usuário não deveria obrigar você a reescrever a fórmula do total. Essa separação facilita testes, manutenção e a inclusão de novas funcionalidades.
Nomes claros, comentários que expliquem decisões e código legível ajudam mais do que espremer muitas operações em uma única linha.
No caso da linguagem C, ela permite escrever código conciso, e cabe a nós manter a leitura compreensível.

Como dica de leitura, deixo com você dois grandes livros que abordam sobre esse assunto:
Vale a pena dar uma conferida.
Editor, IDE, compilador e depurador: não misture as ferramentas
Antes de transformar o código em programa, precisamos reconhecer quem participa da construção. Dito isso, é necessário que você entenda as ferramentas que farão parte do seu dia a dia.
- Editor: é a ferramenta que permite escrever e modificar o código-fonte. Aplicações como Notepad++, Visual Studio Code e entre outros, atuam como o Microsoft Word que nos ajudam a escrever o código.
- Compilador: é um programinha que analisa e traduz o código escrito por nós pelo editor, emitindo diagnósticos quando encontra determinados problemas. GCC e Clang são exemplos de ferramentas desse universo da linguagem C.
- Montador: é outro programinha que transforma uma representação em Assembly em código objeto no fluxo tradicional de construção.
- Ligador, ou linker: mais um programinha que conecta arquivos objeto e bibliotecas, resolvendo referências necessárias para que o nosso programa rode sem muitos problemas.
- Depurador, ou debugger: outro programinha que ajuda a acompanhar a execução, examinar valores e investigar onde o comportamento divergiu do esperado.
- IDE: é um ambiente integrado de desenvolvimento. Reúne o editor e integra recursos de construção, navegação e depuração em uma interface. Como exemplo podemos citar o Visual Studio Comunnity, ele engloba desde o Editor contando com o compilador, montador, linker e debbuger em uma só aplicação.
Ambientes como Code::Blocks ou Visual Studio podem integrar várias dessas atividades, porém existem outros fluxos que combinam um editor com ferramentas no terminal.
O importante é conferir se a cadeia de ferramentas está instalada e configurada. Ter apenas o editor não garante que exista um compilador disponível, e isso vale tanto para Windows, quanto também para Linux e macOS.
Você também vai encontrar o termo build, ou construção durante essa jornada aqui no portal.
Uma BUILD nada mais é do que um conjunto de ações que prepara o programa para ser distribuído e executado na nossa máquina, ou seja, é quando pegamos o código que construímos e dizemos ao computador: "Tá aqui, converta em código de maquina e faça isso rodar na minha tela".
Em uma IDE, clicar em “Build” pode acionar compilador, montador e linker por de baixo dos panos, e é o certo... até porque é o que uma Build faz!
Do arquivo .c ao programa em execução
No seu cotidiano como desenvolvedor em C, você vai repetir quatro atividades quase que religiosamente: editar o código, compilar o código em um programa executável, ligar e executar.
Agora vamos abrir a parte da construção para entender o que normalmente acontece sobre cada um dos processos ditos acima.
Atenção: o exemplo abaixo descreve um fluxo tradicional de compilação nativa. Algumas ferramentas integram etapas e não deixam todos os arquivos intermediários visíveis, mas a separação ajuda a entender suas responsabilidades.
1. Edição: escrever a solução
Você escreve instruções em um arquivo-fonte, normalmente com extensão .c.
É importante ressaltar que a escolha de um nome importa muito, ou seja, m nome como ola.c ou calculos.c comunica melhor a função do arquivo que um nome aleatório tal qual: micilini.c, joao.c, eucrieiesseprograma.c rs
Cabeçalhos em C, normalmente com são salvos com a extensão .h, e eles podem compartilhar declarações entre partes do projeto. Um programa pequeno cabe em um único fonte. Já um um projeto maior costuma distribuir o trabalho por vários arquivos.
No caso desses arquivos, é importante entender que o computador não executa linha por linha do que escrevemos dentro da nossa CPU, até porque, como vimos, por de baixo dos panos, o sistema executa diversas conversões de modo que a CPU possa entender.
2. Pré-processamento: preparar o texto
Antes da compilação propriamente dita, entram diretivas como #include e #define.
Elas orientam operações de pré-processamento, como incluir o conteúdo de um cabeçalho e expandir certas macros.
Pense em preparar uma pasta de trabalho antes de entregá-la à próxima etapa, ou seja, precisamos acrescentar informações necessárias e aplicar substituições previstas pelas regras do nosso sistema.
Durante o desenvolvimento de programas em C, veremos muito essas diretivas como #include e $define espalhadas pelos nossos arquivos.
Ao encontrar #include <stdio.h>, a ferramenta incorpora informações desse cabeçalho. Isso não significa copiar automaticamente toda a implementação de entrada e saída para o executável, ok?!
3. Compilação: analisar e traduzir
Em um outro momento, o nosso compilador analisa o código preparado (nosso arquivos .c ou .h) e verifica regras da linguagem, como a estrutura das expressões, os nomes declarados e determinadas relações entre tipos.
A sintaxe, isto é, os termos que usamos para criar o nosso programa, trata da forma de escrever. Um ponto e vírgula ausente, quando exigido, pode quebrar essa forma. Há também regras sobre o significado e o uso das construções, que vão além de pontuação.
O compilador pode otimizar o código e gerar uma representação de baixo nível.
Em um fluxo tradicional, essa etapa pode produzir Assembly, que será transformado em código objeto pelo montador.
4. Montagem: produzir o arquivo objeto
O montador transforma a representação em Assembly em um arquivo objeto. Em um fluxo nativo convencional, esse arquivo contém código de máquina e informações que ajudam a conectar as partes do programa.
Extensões comuns são .o e .obj, conforme a ferramenta. Um GCC no Windows também pode gerar .o. porém a extensão não é uma regra universal do sistema operacional.
Um objeto ainda pode depender de funções definidas em outro lugar. Por isso, ele que ele ainda não é um programa pronto para abrir e executar.
Se por um acaso aparecer um arquivo .s no fluxo de montagem, saiba que ele costuma conter Assembly em texto.
5. Linkedição: conectar as partes
Agora que temos as peças traduzidas, é a hora de conectar todo mundo que nem peças LEGO.
O linker, também chamado ligador, conecta essas peças e resolve referências entre elas e as bibliotecas necessárias.
Suponha que principal.c chame uma função implementada em calculos.c. Depois de produzir os objetos, a construção precisa conectar a chamada à implementação correspondente.
E sim, durante o link, o nosso querido linker também pode reclamar, ou seja, uma implementação pode estar faltando, uma biblioteca pode não ter sido informada ou uma função pode ter sido definida mais de uma vez onde isso não é permitido.
Esse trabalho de combinar objetos e resolver referências é descrito no manual do GNU linker.
E a correção de uma falha apontada pelo Linker, pode estar tanto no código quanto também na configuração da construção.
Há ainda uma diferença útil: na ligação estática, código necessário de bibliotecas pode entrar no resultado.
Já na dinâmica, bibliotecas podem continuar como dependências separadas, e carregadas durante a execução.
Portanto, linkar não significa obrigatoriamente colocar todas as bibliotecas inteiras dentro de um único arquivo, uma vez que o executável final depende das diversas escolhas de construção.

6. Execução: colocar o resultado para trabalhar
Já quando iniciamos um aplicativo comum, o sistema operacional prepara o processo, a memória e as dependências necessárias. A execução passa pelo código de inicialização do ambiente até chegar ao nosso programa.
O programa pode pedir uma entrada pelo teclado, mostrar uma mensagem no console, ler um arquivo ou realizar trabalho sem exibir nada na tela.
Quando estivermos programando em C, o console ou também chamado de terminal é o ambiente de interação textual que usaremos para ver o nosso código rodando na tela.

Ele facilita observar entradas e resultados sem acrescentar a complexidade de janelas e botões, que é um tipo de coisa mais avançada rs
E se o resultado mostrado no console não corresponder ao esperado, investigamos, corrigimos e repetimos o ciclo.
É assim que a construção de nossas aplicações e a depuração das mesmas passam a fazer parte da rotina de todo desenvolvedor 😂
Compilar e interpretar são caminhos diferentes?
Na compilação nativa que estamos estudando, o fluxo é sempre preparar um código de máquina antes de executar o nosso aplicativo. Já um interpretador conduz a execução de uma representação do programa usando outro programa pré-existente.
Existem implementações que misturam técnicas: compilam para uma representação intermediária, interpretam parte dela ou geram código de máquina durante a execução, com compilação JIT.
Dito isso, é bom que você evite transformar “compilado” e “interpretado” em duas caixas rígidas que explicam tudo sobre uma linguagem.
Para começar em C, o caminho que interessa aqui é concreto: escrever o código fonte, construir uma versão executável para o ambiente escolhido e rodar ele na sua máquina (e torcer para não dar erro rs).
Nosso primeiro contato com a linguagem C
Depois de tanta conversa, eu acho que você merece ver a linguagem funcionando, não é verdade?
Nosso primeiro exemplo vai apenas mostrar uma mensagem de olá mundo na tela principal, para conseguirmos olhar cada parte do seu funcionamento. 🙂
Para ver isso funcionamento de forma rápida, recomendo que você abra uma outra aba do navegador e acesse este link: Online C Compiler.
Dentro da parte escura, apague todo o código ali existente e cole o código abaixo:
#include <stdio.h>
int main(void)
{
/* Nossa primeira mensagem nesta jornada. */
printf("Ola, Micilini!\n");
return 0;
}Por exemplo:

Se você clicar naquele botão verde chamado [RUN], verá que a saída do programa será esta:
Ola, Micilini!Agora vamos entender o que de fato escrevemos em cada linha da nossa sintaxe 😉
#include <stdio.h>disponibiliza as informações do cabeçalho de entrada e saída, incluindo a declaração deprintf.int main(void)define a função principal deste programa: ela devolve um inteiro e, nesta forma, não recebe parâmetros.- As chaves
{e}delimitam o corpo da função, reunindo as instruções que estão dentro dela. /* ... */delimita um comentário. Ele ajuda quem lê o código e não produz aquela mensagem durante a execução.printfescreve uma saída formatada. Neste exemplo, mostramos apenas um texto, e\nrepresenta a mudança de linha.return 0;termina a função principal indicando conclusão bem-sucedida ao ambiente que executou o programa.
Usamos a função chamada main porque este é um programa convencional em um ambiente hospedado, com suporte do sistema e da biblioteca.
Quando estamos trabalhando diretamente com firmware e kernels, saiba que eles podem adotar outra entrada e outras regras de inicialização.
Também escrevi “Ola” sem acento no exemplo para manter nossa primeira saída independente de ajustes de codificação do terminal.
E sim, você pode escrever qualquer texto ali dentro... a configuração correta dos caracteres será tratada quando necessário, e aprenderemos fazer isso futuramente.
Por enquanto, a ideia aqui é que você se familiarize cada vez mais com a estrutura e a sintaxe da linguagem C.
Tipos, funções, comentários e formatação de saída vão ganhar atenção própria ao longo da nossa jornada 😊
O que vamos estudar ao longo da jornada?
Agora que você já conhece o terreno, vamos olhar para as peças que aparecerão nos próximos encontros. Esta é uma visão do percurso, sem exigir que você domine todos os nomes hoje, beleza?
Primeiro ponto importante que você deve ter em mente: os assuntos se conectam!
Primeiro aprendemos a representar um dado; depois tomamos decisões com ele, agrupamos estes dados, dividimos tarefas e lidamos com memória e arquivos.
Por exemplo:
- Ambiente e o seu primeiro programa. Aqui vamos aprender a reparar ferramentas, compreender a estrutura de um código fonte, escrever comentários e usar
printf. - Variáveis, constantes e tipos. Trabalhar com nomes associados a dados e conhecer
int,char,floatedouble. C possui tipagem estática: os tipos participam da análise do programa antes da execução. Também veremosenumetypedef, que permite dar outro nome a um tipo. - Operadores e expressões. Fazer contas, atribuir valores, comparar resultados e combinar condições. Vamos distinguir operadores aritméticos, relacionais, lógicos e de bits, além de observar precedência e efeitos das operações.
- Decisões e repetições. Usar
ifeswitchpara escolher caminhos;for,whileedo whilepara repetir trabalho. Cada estrutura tem regras próprias, e a posição da verificação de uma condição pode mudar o resultado. - Arrays, matrizes e strings. Declarar e inicializar conjuntos de elementos, inclusive arrays com mais de uma dimensão. Estudar como textos são representados por sequências de caracteres e, nas strings convencionais de C, terminados pelo caractere nulo. Também veremos operações de texto e limites dos espaços utilizados.
- Funções e organização. Declarar, definir e chamar funções; trabalhar com parâmetros e retornos. Em C, argumentos são passados por valor, e passar o valor de um ponteiro pode permitir que uma função altere um objeto do chamador, e vamos entender essa diferença com calma.
- Ponteiros e memória. Declarar e usar ponteiros, compreender a desreferenciação e sua relação com funções e arrays. Estudar alocação dinâmica, tempo de vida, verificação de falhas e liberação de recursos. Arrays e ponteiros têm relações importantes, mas não são a mesma coisa.
- Estruturas de dados com struct. Reunir informações relacionadas, inicializar estruturas e trabalhar com estruturas dentro de outras. Um produto pode ter código, quantidade e preço sem que tudo fique espalhado em variáveis sem ligação clara.
- Pré-processador e construção do projeto. Aprofundar
#include,#define, cabeçalhos, arquivos separados e bibliotecas. Entender a função de um Makefile e como automatizar a construção sem perder de vista o que as ferramentas fazem. - Entrada, saída e persistência. Conhecer
getchar,scanf, especificadores de formato e verificação do resultado das leituras. Depois, abrir, ler, escrever e fechar arquivos. Usar funções da biblioteca padrão para texto, matemática e outras utilidades. - Depuração e qualidade. Interpretar erros e avisos, reconhecer falhas frequentes, acompanhar valores e usar a pilha de chamadas. Exercitar testes, legibilidade, modularidade e redução de dependências desnecessárias durante todo o percurso.
E não... você não precisa chegar ao final dessa nossa lista de artigos para construir algo útil. Cada etapa pode produzir um programa pequeno, e esses programas nos dão material para experimentar, errar, investigar e melhorar os nossos sistemas.

Como aproveitar melhor cada artigo?
A minha proposta é combinar conceito, exemplo e muuuuita tentativa própria.
Lembre-se de que: imagem ajuda a visualizar, o código permite observar o comportamento. Então nada de só passar os olhos pelos códigos aqui existentes, fingir que entendeu e ficar por isso mesmo, ok?!
Quando chegar um exemplo, tente prever o resultado antes de executar. Depois, altere uma coisa ou outra e compare o resultado final. Se o resultado mudar de um jeito inesperado, você ganhou uma pergunta concreta para investigar 🙃
Também vale explicar o assunto em voz alta, como se você estivesse ensinando alguém. Se uma parte da explicação fica confusa, ela mostra um bom ponto para voltar e estudar. Anote em seu caderno e em uma folha de papel, caso isso te ajuda a estudar, vale tudo para aprender C 🙃
Nossa jornada está só começando...
Agora você já consegue olhar para um arquivo .c e imaginar o trabalho que existe até ele virar um programa.
Também consegue enxergar por que assuntos como funções, memória e arquivos aparecem em projetos tão diferentes quanto um codec de imagens, um sistema experimental e um gravador de tela.
É esse entendimento que vamos desenvolver aqui no Portal da Micilini. Vamos criar programas que conseguimos explicar, observar e melhorar... um assunto de cada vez.
No próximo artigo aprenderemos a preparar o ambiente de desenvolvimento no seu computador e transformar essa visão geral em prática na sua máquina.
Te espero no próximo artigo! 👋
(E vê se não desiste de aprender C rs)

