Ambientes de Desenvolvimento: Configuração para Programação em C (e C++)

Pré-Requisitos

Os pré-requisitos para iniciar as atividades de programação em C são semelhantes aos descritos para linguagens anteriores, isto é, JavaScript, Python e Lua. Contudo, como C é uma linguagem compilada ao invés de interpretada, utiliza-se um compilador ao invés de um interpretador. Assim, a primeira opção é um editor de texto e um compilador. A segunda continua a ser um Ambiente Integrado de Desenvolvimento (em inglês, Integrated Development Environment ou IDE).

Para evitar repetir as discussões feitas anteriormente para JavaScript e Python:

• Se você já possui um editor de texto, você pode instalar e configurar um compilador para a linguagem C. Contudo, usar um compilador requer, no mínimo, um passo adicional se comparado a usar um interpretador. Portanto, se você está começando agora, pode se preferível optar por um IDE;
• Se você preferir usar um IDE, a opção mais simples é escolher algo que inclua, ao menos, editor de texto, compilador e depurador em um único programa'. Uma boa opção que reúne as três ferramentas chama-se Code::Blocks;
• Se você não sabe como instalar programas, o que é PATH ou como configurá-lo, consulte a entrada sobre instalação de programas. Ao contrário das linguagens anteriores, a configuração de PATH pode ser obrigatória para o uso de alguns IDEs para C (e C++).

Parte do conteúdo desta página será idêntico aos conteúdos anteriores. Portanto, caso alguns parágrafos sejam familiares, não será impressão, mas um certo déjà vu. Por sinal, isso também ocorrerá em novas entradas sobre ambientes de desenvolvimento em outras linguagens de programação. Afinal, os procedimentos para configuração são similares.

Por outro lado, a maior parte do conteúdo será inédito, porque C é uma linguagem de programação compilada. Programas compilados requerem um passo adicional antes do uso (a compilação), responsável por transformar código-fonte em um arquivo executável (o programa de computador).

Em particular, a seção sobre Compiladores e Programas será densa. Não é necessário entendê-la totalmente neste momento (especialmente caso se use um IDE), mas é importante lembrar-se dela quando for necessário trabalhar com bibliotecas externas.

De fato, exceto caso se tenha experiência com o uso de linha de comando, aconselho fortemente que iniciantes usem IDEs para ambas as linguagens C e C++.

C e C++

A preparação de um ambiente para C muitas vezes também é suficiente para C++. Ferramentas que são compatíveis com C++ também costumam ser compatíveis com C. Além disso, é possível usar código C em C++. Embora nem todo código C seja compatível com C++, implementações baseadas em padrões mais antigos (como C89) muitas vezes são compatíveis com C++ Por outro lado, a recíproca nem sempre é verdadeira; código C++ freqüentemente não é compatível com C sem os devidos cuidados.

Para este tópico, o mais importante é que os conceitos para compilação apresentados para C também valem para C++. Assim, ao invés de repeti-los, a página sobre preparação de ambientes para C++ referencia esta página.

C Como Primeira Linguagem de Programação

C está distante na minha lista, pois é uma linguagem de nível mais baixo (isto é, mais próxima do hardware) que Python, Lua e JavaScript (que são linguagens de nível mais alto). Para primeiros contatos com programação, C definitivamente não seria minha recomendação. Não é algo impossível (C foi minha primeira linguagem de programação), mas está longe de ser ideal.

Programação em C requer a realização de operações que são abstraídas, simplificadas ou inexistentes em linguagens mais modernas. O conhecimento de tais operações contribui para a formação de boas programadoras e bons programadores, mas constitui uma dificuldade inicial adicional que é desnecessária para primeiras atividades de programação.

Além disso, partes da biblioteca padrão de C requerem bastante cuidado e atenção para uso. Algumas funções são, inclusive, potencialmente tão perigosas que praticamente nunca devam ser usadas (por exemplo gets()).

Assim, caso se possa escolher, recomendo começar com Python, Lua ou JavaScript. Foque no aprendizado de conceitos, de lógica de programação e de pensamento computacional. Retorne para C quando tiver experiência. O aprendizado de C provavelmente será mais simples e produtivo caso já se entenda o básico.

Sobre C

C é uma linguagem de programação tradicional, compilada e, se usada corretamente, de alto desempenho e eficiente. Ela fornece uma leve abstração sobre o hardware, com pouco overhead (algo como sobrecarga no sentido de desperdícios). A linguagem é uma boa escolha para a escrita de sistemas operacionais e sistemas embarcados, assim como compiladores, interpretadores e bibliotecas que requeiram excelente desempenho e disponibilidade para múltiplas arquiteturas e plataformas. De fato, um dos projetos mais famosos escritos em C é o kernel do sistema operacional Linux, usado nos mais diversos dispositivos.

C é uma linguagem simples quanto a recursos, mas não exatamente simples quanto ao uso e ao aprendizado. De fato, a simplicidade de C provém da falta de recursos. Ela é, pois, elegante para pessoas experientes, capciosa para iniciantes (e também para pessoas experientes).

Programar bem em linguagem C requer entender como funciona o hardware, e arquiteturas de computadores e de software. Programar muito bem em C requer o entendimento de conceitos como layouts de memória e programação em linguagem de máquina. Isso ocorre porque a linguagem tende a ser classificada como de baixo a médio nível. Um dos níveis mais baixos seria programar em linguagem de máquina. C é próxima ao hardware. Tão próxima que, inclusive, é possível incluir código assembly em arquivos de código-fonte em linguagem C, mediante o uso de diretivas apropriadas.

C é uma linguagem antiga, sem modernidades e conveniências oferecidas por linguagens mais recentes. Não há estruturas de dados pré-definidas (apenas arrays são parte da linguagem, isto é, seqüências contíguas de posições de memória), não há sequer um tipo de dados para cadeias de caracteres. Um caractere é um número inteiro. Cadeias de caracteres são arrays de números. Embora isso seja verdade porque é como computadores funcionam, o resultado não é conveniente para programadoras e programadores.

Assim, C não é uma linguagem para iniciantes. Ao contrário de linguagens modernas, C assume que a programadora ou o programador saiba o que faça. A programadora ou o programador é realmente poderosa(o) em C. A liberdade tem custos, dos quais é possível destacar a complexidade para o aprendizado e o maior potencial para erros.

Por exemplo, a linguagem não impõe verificações em tempo de execução nem limita o acesso à memória da máquina. Desde que o código seja sintaticamente válido, a operação é permitida. Em outras palavras, pode-se fazer em C operações que não são permitidas (ou, ao menos, são mais difíceis de fazer) em outras linguagens de programação, como acessos a memória em posições arbitrárias por meio de endereços (inclusive que não sejam do próprio programa, algo que bons sistemas operacionais não permitem).

Assim, o aprendizado de C pode resultar em apreciação de todas as conveniências que linguagens de programação modernas costumam fornecer. O mesmo aprendizado pode também resultar em constatações de como linguagens de programação modernas atrapalham ("entram no caminho", obstruem) a programadora ou o programador.

Um dos diferenciais de C é a maior previsibilidade do código de máquina gerado pelo compilador a partir de um código-fonte. O código de máquina ou assembly gerado é, por vezes, praticamente uma tradução direta das instruções necessárias para a conversão do código-fonte escrito em C. Em outras palavras, a linguagem tende a fazer exatamente aquilo que a programadora ou o programador a instruiu a fazer.

Com os devidos cuidados, C permite a escrita de código-fonte portável entre diferentes arquiteturas de computadores (caso exista um compilador compatível com a arquitetura e plataforma escolhida). Bibliotecas escritas em C são, inclusive, usadas como base por algumas outras linguagens de programação. Algumas linguagens de programação possuem implementações de referência escritas em C. A escrita de uma interface C também é uma forma de permitir compartilhar código escrito em uma linguagem de programação para uso em outra linguagem diferente, assim como tecnologias como Common Gateway Interface (CGI) permitem usar C com sistemas Web.

Em suma, C é um dos pilares da programação e uma ótima linguagem para aquilo que se propõe a fazer. Prova disso é sua relevância desde sua criação (1972) até os dias de hoje.

Contudo, ensino e aprendizado de programação não é um dos pontos fortes para a linguagem C no século XXI. Para o ensino de programação, a herança mais aplicável de C pode ser o programa "Hello, world!" ("Olá, mundo!"), definido por Brian Kernighan e Dennis Ritchie no livro The C Programming Language.

Para documentação de C, pode-se usar os seguintes recursos:

• Páginas de manual em sistemas Linux.

  Usar o comando man. Por exemplo:

  man 3 printfPRINTF(3)                                   Linux Programmer's Manual                                   PRINTF(3)
  
  NAME
         printf,  fprintf, dprintf, sprintf, snprintf, vprintf, vfprintf, vdprintf, vsprintf, vsnprintf - formatted
         output conversion
  
  SYNOPSIS
         #include <stdio.h>
    (...)

• Documentação do GNU C Library (glibc);
• MSDN, para o compilador da Microsoft `MSVC`;
• cppreference.com;
• cplusplus.com.

Versões

C sempre foi uma linguagem relevante; contudo, os padrões para a linguagem tiveram ressurgimento nos últimos anos. Até cerca de uma década, padrões predominantes eram C89 ou C90, definidos entre os anos de 1989 e 1990, e C99, publicado em 1999 (e sem suporte por alguns compiladores populares).

Na última década, os padrões C11 e C17 modernizaram um pouco a linguagem C. Contudo, o suporte a novos padrões por compiladores varia. Para fazer uso de novos recursos, é, portanto, necessário verificar o suporte pelo compilador escolhido e para a plataforma desejada.

Para o aprendizado, é provável que muitos materiais considerem os padrões C89 ou C90 para recursos e exemplos. Caso se tenha interesse em usar os novos recursos, pode ser conveniente procurar por termos como "modern C".

No mais, a qualidade da biblioteca padrão da linguagem C (sobretudo para padrões antigos) varia. Como muitos programas (leia-se, décadas de criação de programas) dependem do comportamento errático de parte da biblioteca padrão, problemas que poderiam ter sido resolvidos há anos persistem, pois resolvê-los poderia afetar programas existentes de formas potencialmente imprevisíveis.

Assim, caso se tenha interesse em uso profissional de C, é conveniente adotar bibliotecas externas de qualidade, especialmente para operações como manipulação de cadeias de caracteres (strings). Para fins educacionais, pode ser interessante criar sua própria biblioteca padrão.

Compiladores e Programas

Diferentemente de JavaScript, Python e Lua, que são linguagens interpretadas, C é uma linguagem compilada.

Na prática, isso significa que existe um passo adicional para a programação: a geração de um programa na forma de um arquivo executável (por exemplo, com a extensão .exe no Windows).

Assim, por exemplo, para usar um programa "Olá, Mundo!" escrito em uma linguagem interpretada como Lua, pode-se criar algo como o seguinte arquivo (script.lua):

print("Olá, mundo!")

Para interpretar e executar o código:

# Criação do arquivo; pode-se usar qualquer editor de texto.
emacs script.lua
# Interpretação e execução do programa.
lua script.luaOlá, mundo!

Caso se queira usar o programa novamente, é necessário reinterpretá-lo.

# Interpretação e execução do programa.
lua script.luaOlá, mundo!

O interpretador converte o código-fonte escrito em Lua para código usado pelo computador em tempo de uso.

Em uma linguagem compilada como C, o processo requer o uso de um compilador (por exemplo gcc no Linux ou mingw no Windows) e da execução do programa gerado. Arquivos executáveis em Linux normalmente não possuem extensão, mas o exemplo adota .exe para facilitar a identificação do arquivo gerado para o programa.

Para compilar com gcc, deve-se passar o nome (ou caminho) para o arquivo. O comando mínimo necessário é algo como gcc meu_arquivo.c, que gerará um programa usando o nome padrão (normalmente algo como a.out ou a.exe). Para escolher o nome do arquivo para o programa de saída, pode-se usar a opção -o. Por exemplo, para que o arquivo do programa tenha nome meu_programa.exe, deve-se escrever -o meu_programa.exe. Combinando-se ambos os parâmetros, chega-se ao comando gcc meu_arquivo.c -o meu_programa.exe.

Para converter o exemplo Lua em um programa C equivalente, pode-se considerar o seguinte programa C, escrito no arquivo programa.c (printf() é a função da biblioteca padrão para escrita em console; documentação. stdio.h é a biblioteca que define a função printf()):

#include <stdio.h>

int main()
{
    printf("Olá, mundo!\n");
    return 0;
}

Em seguida, deve-se compilar o código-fonte em um programa para que se possa executá-lo. A compilação ocorre com sucesso apenas caso o código-fonte não tenha erros sintáticos.

# Criação do arquivo; pode-se usar qualquer editor de texto.
emacs programa.c
# Compilação.
gcc programa.c -o meu_programa.exe# Execução do programa.
./meu_programa.exeOlá, mundo!

Para a execução em Windows, deve-se usar meu_programa.exe ao invés de ./meu_programa.exe. Alternativamente, poder-se-ia clicar duas vezes sobre o ícone do programa meu_programa.exe para executá-lo em Windows.

Com o arquivo compilado, caso se queira usar o programa novamente, basta re-executar o arquivo.

# Execução do programa.
./meu_programa.exeOlá, mundo!

Para constatar que se trata de um arquivo executável, pode-se usar o comando file em sistemas Linux.

file meu_programa.exemeu_programa.exe: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=2753d51ad057364ad12b05c969a2dcd7285f8716, for GNU/Linux 4.4.0, not stripped

Assim, uma vantagem de gerar um arquivo binário executável para o programa é utilizá-lo em outra máquina sem a necessidade de instalação do ambiente de desenvolvimento (por exemplo, do compilador). Para ser mais exato, dependendo do tipo de ligação (link) usado para dependências (bibliotecas externas ao programa), pode ser necessário instalar bibliotecas dinâmicas para uso do programa. Por exemplo, para programas escritos em C++ usando Windows (por exemplo, videogames ou jogos digitais) usando o compilador MSVC, é comum precisar da instalação de pacotes redistribuíveis do Visual C++.

Uma desvantagem é que o uso do programa em outra máquina só será possível caso a arquitetura e a plataforma sejam compatíveis com a esperada pelo formato do arquivo executável.

Caso compilar e executar programas pareça requerer esforços incompatíveis para o início de aprendizado de programação, pode-se usar um IDE. Um bom IDE terá uma opção de compilar e executar o programa (em caso de compilação com sucesso), simplificando as operações e permitindo o foco no aprendizado. Caso a compilação falhe, o IDE apresentará uma lista com os erros descritos pelo compilador (normalmente com atalhos para navegar até linha na qual se identificou o erro no editor de texto integrado).

Cross-Compilation

Para gerar um arquivo executável em uma plataforma para uso em outra plataforma (diferente da primeira), é necessário realizar uma compilação chamada de cross-compilation. Por exemplo, um compilador compatível pode gerar um programa em uma máquina com sistema operacional Linux para uso por outra máquina com sistema operacional Windows. Uma possível opção de compilador C para Windows é o mingw (o gcc para Windows). Assim, um possível exemplo de cross-compilling usando Arch Linux para gerar um executável para Windows seria:

# Criação do arquivo; pode-se usar qualquer editor de texto.
emacs programa.c
# Compilação.
x86_64-w64-mingw32-gcc programa.c -o meu_programa.exe# O programa pode ser usado em Windows, não em Linux.

O uso do programa exige o uso de um ambiente Windows. Ele poderia ocorrer em outra máquina ou a mesma, usando dual boot, uma máquina virtual, ou gerando o executável no passo anterior com os novos subsistemas do Windows.

# Execução do programa em Windows.
meu_programa.exeOlá, mundo!

Bibliotecas e Ligação (Link)

Ligação (link), que utiliza uma ferramenta chamado ligador (linker), permite combinar código-fonte de diferentes arquivos para se utilizar em um único programa. Para o aprendizado de programação, a necessidade de usar o linker pode demorar (ou não); tudo depende de bibliotecas usadas, do ambiente e da escolha de usar (ou não) um IDE.

Para apresentar um exemplo, a biblioteca padrão de matemática (math.h) é uma das que podem requerer o uso de linker (dependendo do sistema).

O programa abaixo utiliza sqrt() (documentação) para cálculo da raiz quadrada de um número.

#include <stdio.h>
#include <math.h>

int main()
{
    printf("%f\n", sqrt(25));

    return 0;
}

Para compilar o programa, deve-se usar o parâmetro -l (l minúsculo) para usar o linker, seguido do nome da biblioteca. Por exemplo, caso a biblioteca chame-se Lib, deve usar -lLib. Caso se queira usar mais de uma biblioteca, deve-se repetir o procedimento todas. Por exemplo, para as bibliotecas Franco, E, e Garcia, o resultado para o linker seria -lFranco -lE -lGarcia.

No caso da biblioteca math.h, normalmente usa-se simplesmente m como nome da biblioteca (o nome do arquivo compilado da biblioteca pode ser diferente do usado pelo cabeçalho), resultando-se em -lm.

# Criação do arquivo; pode-se usar qualquer editor de texto.
emacs raiz_quadrada.c
# Compilação. O linker utiliza o parâmetro `-l` seguido no nome da biblioteca.
# Para `math.h`, usa-se `m`, resultando em `-lm`.
gcc raiz_quadrada.c -lm -o raiz_quadrada.exe# Execução do programa.
./raiz_quadrada.exe5.000000

Além disso, caso o link seja dinâmico, um arquivo com a biblioteca compilada deve estar presente no diretório do arquivo executável ou no PATH. Se o link for estático, o código da biblioteca será adicionado ao código da aplicação compilada.

IDEs podem reduzir a necessidade de uso de linker para o uso da biblioteca padrão. Portanto, essa é outra razão que fazem de um bom IDE uma opção relevante para se iniciar em programação C.

Além do linker, também pode ser necessário ajustar diretórios.

Bibliotecas e Diretórios de Cabeçalhos

Mesmo usando um IDE, o uso do linker é praticamente obrigatório para o uso de bibliotecas externas. Por exemplo, caso se queira usar bibliotecas gráficas em C ou C++, deve-se o linker -- mas não apenas.

Além de configurar o linker, também é necessário configurar diretórios de cabeçalhos e/ou código-fonte de bibliotecas externas. Para isso, é necessário passar mais um parâmetro para o compilador.

Por exemplo, para o gcc, o parâmetro é -L (L maiúsculo), seguido do caminho para o diretório da biblioteca. Caso o caminho para a biblioteca seja /home/franco/Desktop/lib, deve-se usar -L/home/franco/Desktop/lib como parâmetro.

Assim como o caso de -l (l minúsculo), deve-se passar, caso necessário, todos os caminhos para bibliotecas desejadas. Assim, para as bibliotecas Franco em /home/franco/Franco/, E em lib/E/, e Garcia em ../Garcia/, a inclusão de diretórios ficaria: -L/home/franco/Franco/ -Llib/E/ -L../Garcia/.

Como se pode perceber, é possível usar caminhos absolutos e relativos. Via de regra, o ideal é optar por caminhos relativos quando possível, e construir caminhos absolutos usando variáveis de ambientes quando não se pode usar um caminho relativo.

Convém ressaltar que é necessário combinar todos os parâmetros para realizar a compilação. Assim, o exemplo poderia ficar algo como:

gcc meu_programa.c \
   -o meu_programa.exe \
   -lFranco -lE -lGarcia \
   -L/home/franco/Franco/ -Llib/E/ -L../Garcia/

No caso, a \ (contrabarra) no final de uma linha em interpretadores como bash e zsh permite continuar um mesmo comando em várias linhas. Caso isso não seja feito, deve-se escrever o comando em uma única linha:

gcc meu_programa.c -o meu_programa.exe -lFranco -lE -lGarcia -L/home/franco/Franco/ -Llib/E/ -L../Garcia/

Sistemas de Construção

Se compilar programas em linguagem C (e C++) parece um pouco complicado, existem programados chamados build systems (algo como sistemas de construção) ou build automation software (software para automação de construção) que tentam simplificar o processo.

Algumas opções incluem:

• Makefile e GNU Make;
• GNU Autotools (Autoconf, Automake, Libtool);
• CMake;
• PreMake;
• SCons;
• Ninja.

Inclusive, alguns sistemas como CMake pode gerar projetos compatíveis com outros build systems.

Em outras palavras, build systems podem ser complexos. Assim, se compilação em C (e C++) parecia complicada, sempre é possível ficar ainda mais complexo.

Uma alternativa para projetos simples é criar um shell script. Em Linux, opções incluem bash, zsh, csh e fish. Em Windows, opções incluem .bat (para cmd) e PowerShell.

O princípio escrever a linha de compilação no script e utilizá-lo quando necessário. O mínimo que o arquivo precisa conter é a linha para compilação. Algo possivelmente desejável é configurar o PATH dentro do shell script.

Contudo, algumas técnicas são interessantes e úteis. Existem técnicas e recursos avançados para compilação, como compilação incremental, que compilam apenas arquivos alterados desde a última compilação, e algo muito interessante conhecido como hot swap ou run-time compilation (um exemplo), que permite recompilar um programa em execução.

Compilador e Editor de Texto

Deve-se usar contas de root ou de administrador apenas para instalar o compilador. Após instalá-lo, use uma conta de usuário comum, sem privilégios mais altos, para usar o compilador e programar. Da mesma forma, sempre execute os programados criados com uma conta de usuário comum.

Linux

C é parte de toda distribuição Linux, porque o kernel é majoritariamente escrito na linguagem. Assim, existem distribuições que já forneçam um compilador para C pré-instalado.

Para começar a programar na linguagem, deve-se escolher um compilador. Uma opção tradicional é o GNU Compiler Collection (GCC). Outra opção é o Clang.

Os exemplos abaixo descrevem como instalar o gcc em algumas distribuições Linux.

1. Arch Linux:

   Provavelmente não será necessário instalar o GCC no Arch Linux. Em todo caso:

   pacman -S gcc glibc

   O pacote gcc inclui os compiladores gcc (para C) e g++ (para C++).

2. Debian, Ubuntu ou distribuições baseadas nas anteriores:

   apt-get install build-essential
   # Caso também se queira instalar as páginas de manual:
   apt-get install manpages-dev

   O pacote build-essential inclui os compiladores gcc (para C) e g++ (para C++).

3. Fedora:

   dnf install gcc glibc

   Caso se queira instalar o compilador g++ para C++, pode-se usar:

   dnf install gcc-c++ glibc

4. Gentoo:

   Provavelmente não será necessário instalar o GCC no Gentoo. Em todo caso:

   emerge --ask --oneshot sys-devel/gcc

   Acredito que Gentoo inclua g++ com gcc, mas não tenho certeza.

macOS

Em ambientes macOS, pode-se usar brew para instalar o GCC. Outra opção é instalar o IDE Xcode, que inclui Clang.

Windows

Uma implementação de GCC para Windows chama-se Minimalist GNU for Windows (MinGW). Dentre outros, pode-se instalar o MinGW pelo link anterior pelo projeto oficial, via Cygwin, MSYS2, ou usando Scoop e Chocolatey, mencionados no tópico sobre instalação de programas.

Tanto Scoop quanto Chocolatey podem instalar facilmente o compilador.

Caso não se use nenhum dos dois, optar por MSYS2 é conveniente por permitir o uso de outros programas como git. A página do projeto contém instruções para instalação.

Caso queira adicionar o compilador ao PATH, consulte instalação de programas.

Por conveniência, as instruções abaixo também descrevem como instalar MSYS2. Caso não se queira alterar o diretório de instalação (é importante que ele não tenha acentos nem espaços), pode-se simplesmente prosseguir com a instalação: Next, Next, Next, Next, Finish.

Para iniciar MSYS2, procure no menu Iniciar por msys e aperte enter quando aparecer MSYS2 MSYS. A opção abrirá o terminal Mintty, usando bash.

A instalação de programas é similar ao uso de pacman em Arch Linux. O primeiro passo é atualizar o sistema:

./pacman -Syu:: Synchronizing package databases...
 mingw32              1461.1 KiB   424 KiB/s 00:03 [#####################] 100%
 mingw64              1468.3 KiB   421 KiB/s 00:03 [#####################] 100%
 ucrt64               1609.9 KiB  1094 KiB/s 00:01 [#####################] 100%
 clang64              1452.3 KiB   446 KiB/s 00:03 [#####################] 100%
 msys                  387.5 KiB   357 KiB/s 00:01 [#####################] 100%
:: Starting core system upgrade...
resolving dependencies...
looking for conflicting packages...

Packages (5) filesystem-2021.06-2  mintty-1~3.5.1-1  msys2-runtime-3.2.0-15
             pacman-6.0.1-3  pacman-mirrors-20210902-1

Total Download Size:    9.38 MiB
Total Installed Size:  45.57 MiB
Net Upgrade Size:       0.21 MiB

:: Proceed with installation? [Y/n]
Y

A primeira atualização fechará o terminal. Abra-o novamente (via menu Iniciar). Desta vez, use:

./pacman -Su:: Starting core system upgrade...
 there is nothing to do
:: Starting full system upgrade...
resolving dependencies...
looking for conflicting packages...

Packages (28) bsdtar-3.5.2-1  ca-certificates-20210119-3  curl-7.79.1-1
              gdbm-1.21-1  glib2-2.68.4-1  gnupg-2.2.29-1  gzip-1.11-1
              icu-69.1-1  less-590-1  libcurl-7.79.1-1  libedit-20210714_3.1-1
              libexpat-2.4.1-1  libgcrypt-1.9.4-1  libgdbm-1.21-1
              libidn2-2.3.2-1  libnghttp2-1.45.1-1  libopenssl-1.1.1.l-1
              libp11-kit-0.24.0-1  libreadline-8.1.001-1  libsqlite-3.36.0-2
              libssh2-1.10.0-1  libxml2-2.9.12-2  msys2-keyring-1~20210904-1
              nano-5.9-1  openssl-1.1.1.l-1  p11-kit-0.24.0-1  tzcode-2021c-1
              wget-1.21.2-1

Total Download Size:   22.70 MiB
Total Installed Size:  79.53 MiB
Net Upgrade Size:       0.24 MiB

:: Proceed with installation? [Y/n]
:: Proceed with installation? [Y/n]
Y

Agora você poderá instalar outros programas. Para instalar o MinGW:

pacman -S --needed base-devel mingw-w64-x86_64-toolchain

Quando se perguntar o que se deseja instalar, pode-se pressionar enter para instalar tudo (all).

Após o término da instalação, pode-se fechar o MSYS2. Para iniciar o gcc, procure por MSYS MinGW 64-bit no menu Iniciar. No console, ele será chamado gcc, assim como ocorre em Linux.

Doravante, os programas de linha de comando serão similares aos usados em Linux.

O próximo passo é localizar seus arquivos no terminal. Para obter uma lista de discos do seu computador, você pode usar o comando df.

dfFilesystem     1K-blocks      Used Available Use% Mounted on
C:/msys64      145706840 108812024  36894816  75% /
D:             257564668 254681332   2883336  99% /d
E:             811839484 775074060  36765424  96% /e

No exemplo anterior, o diretório C:\msys64\ está em /. O drive C:\ está em /c/. O drive D:\ em /d/ e assim por diante. O número de unidades de disco pode variar em seu computador. Ele dependerá do número de discos e partições disponíveis em sua máquina.

Com as informações anteriores, para acessar arquivos na área de trabalho de uma conta chamada Franco, você pode navegar para /c/Users/Franco/Desktop/.

cd /c/Users/Franco/Desktop/
# Caso queira listar arquivos e diretórios da área de trabalho:
ls -l

Agora você poderá compilar arquivos salvos na área de trabalho. Escolha uma pasta de acordo com as suas necessidades.

Além de MinGW, MSYS2 possui milhares de pacotes para programação prontos para uso, listados neste link.

Alternativas para instalar o compilador em Windows incluem:

• O novo Subsistema Windows para Linux);
• Chocolatey ou Scoop;
• Usar um IDE com o compilador integrado (por exemplo, Code::Blocks).

Teste de Ambiente

Com o compilador instalado, pode-se começar a programar em C (e em C++, para a maioria dos sistemas anteriores). Para usar o compilador, use o arquivo executável obtido ou digite gcc (o nome pode variar no Windows, dependendo da instalação; por exemplo, ele pode ser mingw) em um interpretador de linha de comando (requer configuração de PATH para arquivos baixados manualmente; clique aqui para informações para como configurá-lo).

Diferentemente linguagens interpretadas, C é uma linguagem compilada e, portanto, não se inicia o compilador para se programar na linguagem. Como descrito em Compiladores e Programas, cria-se um arquivo de código-fonte que será passado como parâmetro para o compilador para a geração de um programa (na forma de arquivo binário executável).

Como feito para JavaScript, Python e Lua, esta seção apresentará os mesmos exemplos para fins de teste e comparações entre linguagens.

Assim, para começar, pode-se criar um arquivo com o seguinte conteúdo:

#include <stdio.h>

int main()
{
    printf("Olá, meu nome é Franco!\n");

    return 0;
}

Escolha um nome para o arquivo (por exemplo, ola.c) e prepare-se para compilá-lo:

gcc ola.c -o ola.exe

O resultado será um programa chamado ola.exe, na forma de um arquivo executável. Para uma melhor integração, escolha (ou omita) a extensão de acordo com o seu sistema operacional:

1. Linux:

   gcc ola.c -o ola

2. Windows (escolha entre gcc ou mingw, dependendo da instalação):

   gcc ola.c -o ola.exe

3. macOS:

   gcc ola.c -o ola

Para executar seu programa:

1. Linux:

   ./olaOlá! Meu nome é Franco.

2. Windows:

   # Para uso no `cmd.exe`:
   ola.exeOlá! Meu nome é Franco.

   Se estiver usando MSYS2 com bash ao invés de cmd, o processo será como no Linux, ou seja, executa-se o programa com ./ola.exe:

   # Para uso no `MSYS2`:
   ./ola.exeOlá! Meu nome é Franco.

3. macOS:

   ./olaOlá! Meu nome é Franco.

Erro: Stray Character in Program

Em alguns sistemas operacionais (provavelmente em Windows) e compiladores (na linha de comando ou IDE), é possível que a compilação falhe com um mensagem como error: stray '\###' in program caso se tente copiar e colar o código-fonte com acentos. O que ocorre é uma diferença de codificação entre o texto do arquivo de código-fonte e o texto que fora copiado desta página da Internet e colado no editor. Existem três opções para prosseguir:

1. Configure seu editor de texto para usar a mesma codificação adotada nesta página: Unicode Transformation Format 8-bit (UTF-8). A codificação padrão usada pelo Windows para línguas latinas chama-se Windows-1252. É importante não misturar caracteres em diferentes codificações em um arquivo de código-fonte. UTF-8 é uma boa opção para compatibilidade com todos os sistemas operacionais modernos;
2. Se você copiou e colou o código, apague e escreva o texto você mesmo. Essa é uma forma simples, embora inconveniente, de contornar o problema;
3. Remova caracteres acentuados ou outros símbolos especiais de cadeias de caracteres e comentários.

Onde Estão os Acentos?

Em alguns sistemas operacionais (provavelmente em Windows), a acentuação podem não funcionar ao rodar o programa. Ao invés de uma letra acentuada, provavelmente aparecerão caracteres incorretos (ou letras gregas). Por exemplo, Olß, meu nome Ú Franco!. Em alguns casos, podem aparecer dois ou mais caracteres incorretos quando deveria aparecer apenas um. Algo como: Ol├í, meu nome ├® Franco!.

Novamente, trata-se de problemas de codificação e decodificação de texto. C considera cadeias de caracteres (palavras e texto) como arrays (vetores) de bytes em codificação American Standard Code for Information Intrechante (ASCII). Cada caractere do tipo char possui exatamente 1 byte (8 bits). Com um byte, é possível representar, no máximo, 256 caracteres. ASCII codifica um caractere por byte, então a representação funciona adequadamente.

Como o nome sugere, ASCII codifica apenas caracteres da língua inglesa. Contudo, existem outros idiomas além de Inglês -- e muito mais que 256 possíveis símbolos para caracteres.

UTF-8 permite codificar caracteres em diferentes idiomas e é retro-compatível com ASCII para caracteres da língua inglesa. Contudo, caracteres em UTF-8 podem ocupar vários bytes (de um a quatro, mais especificamente). Ou seja, único caractere codificado em UTF-8 pode ter múltiplos bytes. Por exemplo, um caractere acentuado como á em UTF-8 possui 2 bytes. Em ASCII, o valor corresponderia a dois caracteres ao invés de um único.

Assim, dependendo da codificação adotada para a escrita do texto no código-fonte e da decodificação escolhida para o programa, os resultados podem ser diferentes.

Para corrigir o problema, deve-se configurar o locale, que define opções para localização de formatos (cadeias de caracteres, formatos de números, moedas...). Para realizar a configuração, pode-se usar a função setlocale() (documentação). Após a definição do valor correto para a codificação de texto, os resultados deverão aparecer corretamente no console.

Infelizmente, o valor correto pode variar de acordo com sistema operacional, codificação adotada ou mesmo configuração de conta de usuário. Alguns possíveis exemplos para Português do Brasil incluem:

• Em Linux:
  • "pt_BR.utf8";
  • "pt_BR.UTF8";
  • "pt_BR.UTF-8";
  • "pt_BR.ISO-8859-1".
• Em Windows:
  • "Portuguese";
  • "Portuguese_Brazil.1252";
  • "pt_BR";
  • "pt-BR";
  • "pt".

Uma alternativa é usar "" para a configuração da máquina da pessoa usando o computador. Por exemplo, caso o sistema dela esteja configurado para usar Português do Brasil, "" retornará algo como pt_BR.UTF-8 em Linux ou Portuguese_Brazil.1252 em Windows.

Caso o sistema operacional de seu computador não esteja em Português, e Português não seja a configuração de locale escolhida para o sistema operacional, você deverá usar um valores não-vazios (isto é, diferentes de "") listados anteriormente.

#include <locale.h>
#include <stdio.h>

int main()
{
    // "": padrão do sistema operacional.    setlocale(LC_ALL, "");    // Caso seu sistema não esteja em Português, tente algo como:    // setlocale(LC_ALL, "pt_BR.utf8"); // ou "pt_BR.UTF-8"    // setlocale(LC_ALL, "Portuguese"); // ou "Portuguese_Brazil.1252" ou "pt_BR"                                        // ou "pt-BR" or "pt"
    printf("Olá, meu nome é Franco!\n");

    return 0;
}

Logo, se você quiser usar acentos e outros símbolos especiais corretamente, lembre-se dos ajustes necessários para locale().

De Volta aos Testes

Após a questão dos acentos, pode-se criar o segundo arquivo com código-fonte em C para continuar a tradição das linguagens anteriores. Nas linguagens compiladas, ele seria o primeiro script como um arquivo de código-fonte para criar um programa. Assim, o nome poderia primeiro-programa.c. Neste caso, tecnicamente, este não será seu primeiro programa. Assim, caso queira numerá-lo corretamente, altere o nome. Caso o nome de arquivo escolhido tenha espaços, escreva o parâmetro do compilador entre aspas (por exemplo, como gcc "Nome com Espaços.c" -o "Meu Programa.exe").

#include <locale.h>
#include <stdio.h>

int main()
{
    // "": padrão do sistema operacional.
    setlocale(LC_ALL, "");
    // Caso seu sistema não esteja em Português, tente algo como:
    // setlocale(LC_ALL, "pt_BR.utf8"); // or "pt_BR.UTF-8"
    // setlocale(LC_ALL, "Portuguese"); // ou "Portuguese_Brazil.1252" ou "pt_BR"
                                        // ou "pt-BR" or "pt"

    printf("Meu Primeiro Programa em C\n");
    printf("Olá! Meu nome é Franco.\n");
    printf("O programa saber fazer contas.\n");
    printf("Veja só: %d\n", 1 + 1);
    printf("Tchau!\n");

    return 0;
}

Para compilar e executar seu programa:

1. Linux:

   gcc primeiro-programa.c -o primeiro-programa./primeiro-programaMeu Primeiro Programa em C
   Olá! Meu nome é Franco.
   O programa saber fazer contas.
   Veja só: 2
   Tchau!

2. Windows (se estiver usando MSYS2 com bash ao invés de cmd, o processo será como no Linux, ou seja, executa-se o programa com ./primeiro-programa.exe):

   gcc primeiro-programa.c -o primeiro-programa.exeprimeiro-programa.exeMeu Primeiro Programa em C
   Olá! Meu nome é Franco.
   O programa saber fazer contas.
   Veja só: 2
   Tchau!

3. macOS:

   gcc primeiro-programa.c -o primeiro-programa./primeiro-programaMeu Primeiro Programa em C
   Olá! Meu nome é Franco.
   O programa saber fazer contas.
   Veja só: 2
   Tchau!

Parabéns! Se você chegou até aqui, agora você entende como um IDE compila e executa programas por trás das cenas. A próxima seção mostra como IDEs tornam o processo mais simples, especialmente para iniciantes.

IDEs

As considerações feitas sobre o uso de IDE para Python valem para C (e C++). Aliás, elas são ainda mais relevantes para C (e C++). O uso de um IDE facilita a compilação e a execução de programas em desenvolvimento. Caso não se tenha familiaridade com a linha de comando, o uso de um IDE permitirá focar em atividades de programação ao invés de aprender como usar um shell.

Assim, a opção de executar código com um clique ou uma tecla é bastante conveniente para C (and C++). Em particular, procure pela opção de executar um projeto com um clique (normalmente sobre um ícone de triângulo (🢒) comumente usado como play, tocar ou reproduzir em eletroeletrônicos) ou com uma tecla (comumente F5). Além disso, lembre-se de atalhos para editores de texto, como Ctrl n para criar novos arquivos (Arquivo / Novo ou File / New em inglês) e Ctrl o (Arquivo / Abrir ou File / Open em inglês) para abrir arquivos existentes.

C e C++ são linguagens que possuem vários IDEs de alta qualidade. Entretanto, muitas deles podem ser complexos para iniciantes. Encontrar um meio termo entre funcionalidades e facilidade de uso pode ser importante.

Para começar, Code::Blocks é uma boa opção e talvez uma das mais simples. A opção mais simples possivelmente seja Dev-C++, embora não seja, necessariamente, uma das melhores.

De forma geral, qualquer IDE que simplifique os processos de compilação e execução de programas são potencialmente úteis para iniciantes. Conforme se adquirir experiência e prática, você pode explorar outras opções e escolher a que preferir. Quando se chegar a este ponto, minha recomendação é escolher o IDE que tiver a melhor integração com um depurador para seus casos de uso.

Code::Blocks

Possivelmente uma excelente opção para iniciantes usando Windows, Code::Blocks equilibra facilidade de uso com funcionalidades. O IDE é mais moderno que Dev-C++ ao mesmo tempo que mais simples que opções como Visual Studio. A integração com depurador também está melhorando nas últimas versões.

Além disso, é possível obter versões de Code::Blocks que incluam o compilador mingw no Windows, o que remove a necessidade de configurar o compilador antes de usá-lo. Para isso, basta escolher as opções de download que incluam o termo -mingw no nome do arquivo.

Para instalar o Code::Blocks em sistemas Windows (20.03 é a versão do dia do acesso; o valor pode variar):

• Na página inicial, clique em Downloads;
• Em seguida, clique em Download the binary release;
• Na próxima página, escolha um dos arquivos:
  • Para sistemas 64-bit (adequado para a maioria dos casos, caso tenha um computador muito antigo, escolha a opção de 32-bit):
    • Arquivo de instalação: codeblocks-20.03mingw-setup.exe.
    • Arquivo para descompactar e usar o executável codeblocks.exe (ou CbLauncher.exe): codeblocks-20.03mingw-nosetup.zip.
  • Para sistemas 32-bit:
    • Arquivo de instalação: codeblocks-20.03-32bit-setup.exe;
    • Arquivo para descompactar e usar o executável codeblocks.exe (ou CbLauncher.exe): codeblocks-20.03-32bit-nosetup.zip.

Caso se opte por baixar via FossHUB, a opção com compilador será acompanhada do texto including compiler.

Para o arquivo de instalação, a opção mais simples é fazer uma instalação completa: Full: All plugins, all tools, just everything. Caso o IDE não encontre o compilador após a instalação, clique em Settings / Compiler / Global Compiler Settings. Escolha GNU GCC Compiler. Em seguida, escolha Reset defaults (algo como restaurar padrões).

Para criar um arquivo de código-fonte usando Code::Blocks, clique em File / New / Empty File (atalho: Ctrl Shift N), escreva o código e salve o arquivo. Para compilar e executar o programa, clique no ícone da engrenagem com um triângulo de play (ou use o atalho: F9).

Caso queira criar um projeto com vários arquivos, clique em File / New / Project.... Em seguida, escolha Console application, depois Next >, escolha a linguagem (C ou C++), clique em Next >. Escolha um título para seu projeto e um diretório para armazenar os arquivos. Clique em Next >. Na próxima tela, mantenha as duas opções ativas (Debug e Release), então clique em Finish.

O processo para compilar e executar é o mesmo usado para arquivos. A forma mais fácil é usar o atalho F9.

Caso queira traduzir o IDE para Português, clique em: Settings / Environment / View. Marque a opção Internationalization, escolha o idioma e reinicie (feche e reabra) o IDE.

É importante notar que o idioma do IDE não afeta a saída de programas.

Assim, caso se queira utilizar caracteres que não façam parte da língua inglesa, é necessário ajustar o locale com setlocale().

Dev-C++

Dev-C++ é um IDE bastante tradicional entre iniciantes começando a programar em C e C++. Ele também resiste ao tempo. Lançando em 1998, o IDE está na quarta geração de ramificações:

1. Última atualização em 2005: Bloodshed Dev-C++ (o original);
2. Última atualização em 2012: wxDev-C++;
3. Última atualização em 2016: Orwell Dev-C++;
4. Última atualização em 2021: Embarcadero Dev-C++.

Como as primeiras opções da lista estão sem atualizações há anos, escolha última opção da lista para obter a versão mais atual, caso se deseje usar Dev-C++.

Na minha opinião, um dos motivos para o sucesso é a facilidade para compilar e criar um programa. Outros IDEs (como Code::Blocks) agora apresentam facilidade similar, mas Dev-C++ foi o pioneiro.

Dev-C++ não é o melhor, nem o mais completo IDE para C e C++, mas é um dos mais simples de usar. Em primeiro lugar, Dev-C++ inclui o compilador mingw pronto para uso. Em segundo, ao invés de requerer a criação de um projeto, basta criar um novo arquivo, escrever o código, e utilizar a opção de compilar e executar para usar o programa resultante.

Usabilidade e facilidade de uso são importantes de software. Dev-C++ é uma demonstração de que facilitar o acesso e o uso podem ser mais importantes que ter um sistema com melhores funcionalidades, mas de maior complexidade.

Pessoalmente, recomendaria o uso de Code::Blocks ao invés de Dev-C++. Todavia, para atividades iniciais de aprendizado, Dev-C++ é uma opção válida.

KDevelop

Para Linux, KDevelop é outra boa opção para desenvolvimento C e C++. O IDE tem versões em desenvolvimento para Windows e macOS, podendo servir como alternativa no futuro para esses sistemas operacionais.

Infelizmente, a versão experimental para Windows não fornece um compilador embutido, algo que pode dificultar a instalação por iniciantes. Embora existam instruções para a configuração, elas requerem configurações para PATH (para aprender como configurar o PATH, veja instalação de programas).

Por outro lado, caso se use Linux, KDevelop pode ser fácil de configurar, pois os gerenciadores de pacotes comumente adicionam compiladores ao PATH após a instalação.

Qt Creator

Assim como KDevelop, Qt Creator uma boa opção para todos os sistemas operacionais, mas também pode requer a instalação manual de um compilador (e, portanto, configuração de PATH).

Qt Creator tenta identificar por compiladores e depuradores instalados na máquina. Caso não se encontre nenhum, deve-se seguir os passos disponíveis na documentação para configurar o compilador.

O acesso à página de downloads para obter o IDE pode ser confuso. Para acessá-la mais facilmente, você pode usar este link ou este link para arquivos de instalação offline e escolher Qt Creator na página.

Também é possível obter o IDE via GitHub, algo que pode ser desejável por não requerer a criação de uma conta. O download via GitHub também permite obter arquivos com compilador incluído para Windows. Para obtê-los, verifique pelas opções com MinGW (para GCC) ou MSVC (para o compilador C++ da Microsoft) nos nomes dos arquivos.

Visual C++ / Visual Studio

No Windows, pode-se usar Visual Studio, um IDE Microsoft (apenas Visual Studio; não confundir com Visual Studio Code, apresentado em editores de texto). Antigamente, a versão para C e C++ chama-se Visual C++, e Visual Studio referia-se ao programa com suporte a múltiplas linguagens de programação. Atualmente, Visual Studio engloba todos os antigos IDEs Visual em um único programa. A versão gratuita chama-se Visual Studio Community.

Visual Studio é uma opção popular para uso profissional de C++ no e para Windows. Assim, caso você decida programar profissionalmente C++ em Windows, é possível que você utilize Visual Studio em ambientes corporativos.

Versões mais recentes simplificaram os processos de criação de projetos. Contudo, não se pode criar um arquivo e compilá-lo. Deve-se criar um projeto (por vezes chamado solução no IDE) e utilizá-lo (mesmo caso o projeto tenha um único arquivo de código-fonte).

O depurador do Visual Studio é um dos mais completos (dentre as opções gráficas) para C e C++. O compilador utilizado pelo IDE (MSVC) para C++ é moderno, embora nem sempre tão atualizado quando GCC e Clang. Para C, o compilador era bastante defasado se comparado a outras opções, mas a situação parece ter melhorado em 2020.

De qualquer modo, mesmo o suporte precário a C de versões antigas do Visual Studio é suficientes para aprender a linguagem. A maior desvantagem era a falta de alternativas seguras para funções depreciadas da biblioteca padrão de C.

Para instalar a versão gratuita, escolha Community 2019 ao selecionar a opção Download Visual Studio with C++. Para a instalação, marque a opção Desktop development with C++ (algo como desenvolvimento para desktop com C++). A opção permite programar tanto em linguagem C quanto em linguagem C++ (ao contrário das opções, a programação em linguagem C também usará o compilador C++).

Para criar um novo projeto:

1. Escolha Create a new project;
2. Escolha Console App e clique Next;
3. Escolha um nome e diretório para o projeto, depois clique em Create;
4. Para compilar e executar, clique no ícone de play ou aperte F5. F5 executa o programa com o modo depuração habilitado. Caso se deseje executar o programa sem o modo de depuração, pode-se usar Ctrl F5.

Caso você seja estudante de uma universidade ou faculdade em curso de exatas (especialmente Ciência da Computação, Engenharia de Computação ou Sistemas de Informação), você pode ser elegível para usar outras versões e/ou sistemas da Microsoft gratuitamente pelo projeto Microsoft Azure Dev Tools for Teaching (antigo DreamSpark e Imagine). Contudo, é necessário verificar com sua instituição de ensino se ela possui parceria com a empresa.

Xcode

A Apple fornece o IDE Xcode para macOS. Caso você queira compilar projetos para dispositivos da Apple, você precisará usar o IDE (tecnicamente, existem alternativas de cross-compiling usando Linux, mas não sei se são aceitas pela Apple Store).

Como não uso macOS, não tenho muito a comentar. Contudo, caso você use, Xcode provavelmente seja a opção padrão para se usar no sistema operacional.

Outras Opções

Existem várias outras opções de IDEs para C e C++, dentre as quais é possível citar:

• Geany;
• CodeLite;
• Eclipse;
• Netbeans;
• CLion.

Primeiros Passos para Começar a Programar em C

Os trechos de código a seguir ilustram alguns recursos da linguagem C. Neste momento, não é necessário entendê-los totalmente; o propósito é apresentar recursos e a sintaxe da linguagem.

Existem duas formas de usar o código. Você pode:

1. Escrever e executar o código no IDE de sua escolha;
2. Escrever o código usando um editor de texto, gerar um programa usando o arquivo com o código em um compilador, e executar o programa gerado em seu computador.

A forma mais simples e rápida é usar um IDE.

Os exemplos são os mesmos adotados para JavaScript. Logo, você poderá comparar linguagens, e observar semelhanças e diferenças entre elas.

Conhecendo C por Meio de Experimentação

1. Escrita de texto:

   // gcc 1.c -o p1
   #include <stdio.h>
   
   int main()
   {
       printf("Uma linha.\n");
       printf("Outra linha.\n");
       printf("Uma linha.\nOutra linha.\n");
   
       return 0;
   }

   Para compilar e executar sem um IDE, crie um arquivo chamado 1.c com o conteúdo anterior e digite:

   gcc 1.c -o p1
   ./p1

   Você pode escolher outro nome para o arquivo de código-fonte (.c) e para o executável a ser compilado. Nos próximos exemplos, a linha de compilação estará comentada na primeira linha do código-fonte.

   Caso você não queira criar um arquivo para cada exemplo, você pode apagar o conteúdo e escrever o código do próximo exemplo. Caso você queira armazenar uma cópia cada exemplo, (neste momento) é necessário criar arquivos individuais.

2. Comentários (texto ignorado pelo compilador; documentação):

   // gcc 2.1.c -o p2.1
   #include <stdio.h>
   
   int main()
   {
       printf("Compilador processa\n"); // Compilador ignora.
   
       return 0;
   }

   // gcc 2.2.c -o p2.2
   int main()
   {
       /* <- Aqui começa o comentário.
          Ele pode ter várias linhas.
       Aqui ele termina -> */
   
       return 0;
   }

   // gcc 2.3.c -o p2.3
   int main()
   {
       /* Ele também pode começar e terminar na mesma linha. */
   
       return 0;
   }

   // gcc 2.4.c -o p2.4
   int main()
   {
       // Contudo, para isso, é mais fácil usar este estilo de comentário.
   
       return 0;
   }

3. Cálculos matemáticos:

   • Soma, subtração, multiplicação e divisão (documentação):

     Em C, divisão de dois números inteiros resulta em um número inteiro (o resto é truncado). Para fazer uma divisão real, ao menos um dos números deve ser real. Por exemplo, compare os valores das divisões 6 / 4 e 6 / 4.0.

   // gcc 3.1.c -o p3.1
   #include <stdio.h>
   
   int main()
   {
       printf("%d\n", 1 + 1);
       printf("%d\n", 2 - 2);
       printf("%d\n", 3 * 3);
       printf("%f\n", 4 / 4.0); // O que ocorre caso se tente dividir por 0? Faça o teste!
   
       return 0;
   }

   • Expressões matemáticas:

   // gcc 3.2.c -o p3.2
   #include <stdio.h>
   
   int main()
   {
       printf("%f\n", 1 + 2 - 3 + (4 * 5) / 6.0);
   
       return 0;
   }

   • Potenciação (documentação: pow()):

   // gcc 3.3.c -lm -o p3.3
   #include <stdio.h>
   #include <math.h>
   
   int main()
   {
       printf("%f\n", pow(5, 2));
   
       return 0;
   }

   • Raiz quadrada (documentação: sqrt()):

   // gcc 3.4.c -lm -o p3.4
   #include <stdio.h>
   // Em alguns compiladores, pode ser necessário remover o comentário da linha abaixo
   // #define _USE_MATH_DEFINES
   // para usar M_PI.
   #include <math.h>
   
   int main()
   {
       printf("%f\n", sqrt(25));
   
       return 0;
   }

   • Operações trigonométricas, como seno (documentação: sin() e M_PI):

   // gcc 3.5.c -lm -o p3.5
   #include <stdio.h>
   #include <math.h>
   
   int main()
   {
       printf("%f\n", sin(M_PI / 2.0)); // Seno.
   
       return 0;
   }

4. Comparações (1 significa verdadeiro; 0 significa falso; para ser mais preciso, 0 significa falso e qualquer valor que não seja zero corresponde a verdadeiro):

   • Igualdade (documentação; strcmp()):

   // gcc 4.1.c -o p4.1
   #include <stdio.h>
   
   int main()
   {
      printf("%d\n", 1 == 2); // Igual: os dois iguais são necessários!
      printf("%d\n", 1 != 2); // Diferente.
   
       return 0;
   }

   // gcc 4.2.c -o p4.2
   #include <stdio.h>
   #include <string.h> // strcmp() requer muito cuidado...
   // Use apenas para aprendizado; use em programas para distribuição apenas caso saiba
   // o que está fazendo.
   
   int main()
   {
       printf("%d\n", !strcmp("Franco", "Franco")); // Resultado 0 significa igual; !0 == 1 para verdadeiro.
       printf("%d\n", strcmp("Franco", "Franco") != 0);
       printf("%d\n", strcmp("Franco", "Seu Nome") != 0);
       // C considera que letras minúsculas são diferentes de maiúsculas (e vice-versa).
       printf("%d\n", 'F' == 'f'); // Caracteres únicos em C são números inteiros.
       printf("%d\n", 'F' != 'f');
       printf("%d\n", !strcmp("Franco", "franco"));
       printf("%d\n", strcmp("Franco", "franco") != 0);
   
       return 0;
   }

   • Outras comparações (documentação):

   // gcc 4.3.c -o p4.3
   #include <stdio.h>
   
   int main()
   {
       printf("%d\n", 1 < 2); // Menor.
       printf("%d\n", 1 > 2); // Maior.
       printf("%d\n", 1 <= 2); // Menor ou igual.
       printf("%d\n", 1 >= 2); // Maior ou igual.
   
       return 0;
   }

5. Variáveis e atribuição (documentação; fprintf()):

   Variáveis são como caixinhas que armazenam valores colocados dentro delas. Efetiva-se um armazenamento usando o operador de atribuição, que é um único igual (=) em C.

   // gcc 5.1.c -o p5.1
   #include <stdio.h>
   
   int main()
   {
       int x = 123;
       printf("%d\n", x);
   
       return 0;
   }

   // gcc 5.2.c -o p5.2
   #include <stdio.h>
   
   int main()
   {
       float resultado = 123.456 + 987.654;
       printf("%f\n", resultado);
   
       return 0;
   }

   Deve-se notar que a declaração de variáveis pode ser feita uma única vez por nome escolhido. Entretanto, pode-se mudar seu valor quantas vezes forem necessárias.

   // gcc 5.3.c -o p5.3
   #include <stdio.h>
   
   int main()
   {
        char nome[32] = {'\0'};
        snprintf(nome, sizeof nome, "Franco");
        printf("%s\n", nome);
        snprintf(nome, sizeof nome, "Franco Garcia");
        printf("%s\n", nome);
   
       return 0;
   }

   // gcc 5.4.c -o p5.4
   #include <stdio.h>
   
   #define COMPRIMENTO_MAXIMO 32
   
   int main()
   {
       char variaveis_podem_variar[COMPRIMENTO_MAXIMO] = {'\0'};
       snprintf(variaveis_podem_variar, COMPRIMENTO_MAXIMO, "Franco");
       printf("%s\n", variaveis_podem_variar);
       snprintf(variaveis_podem_variar, COMPRIMENTO_MAXIMO, "Seu Nome");
       printf("%s\n", variaveis_podem_variar);
       snprintf(variaveis_podem_variar, COMPRIMENTO_MAXIMO, "Outro Nome");
       printf("%s\n", variaveis_podem_variar);
   
       return 0;
   }

   // gcc 5.5.c -o p5.5
   #include <stdio.h>
   
   int main()
   {
       int valor_logico = 1;
       printf("%d\n", valor_logico);
       valor_logico = 0;
       printf("%d\n", valor_logico);
       valor_logico = (1 + 1 == 2);
   
       return 0;
   }

6. Constantes (documentação):

   // gcc 6.1.c -o p6.1
   #include <stdio.h>
   
   #define PI 3.14159
   
   int main()
   {
       printf("%f\n", PI);
   
       return 0;
   }

   // gcc 6.2.c -o p6.2
   #include <stdio.h>
   
   const float E = 2.71828;
   
   int main()
   {
       printf("%f\n", E);
       E = 0; // Erro; o valor de uma constante é inalterável após definido.
   
       return 0;
   }

7. Erros:

   // gcc 7.c -o p7
   #include <stdio.h>
   
   int main()
   {
       print(Ooops!) // Texto deve estar entre aspas duplas.
       pri("Nome incorreto para printf");
       printf("%d\n", 1 / 0);
       printf("%d\n", 0 / 0);
   
       return 0;
   }

8. Cadeias de caracteres (strings) para palavras e texto (documentação):

   // gcc 8.1.c -o p8.1
   #include <stdio.h>
   
   int main()
   {
       printf("Ok, cadeia de caracteres válida\n");
       printf("%c\n", 'A'); // Único caractere.
       printf("Ok, também é" " uma cadeia de" " caracteres válida" "\n");
   
       return 0;
   }

   // gcc 8.2.c -o p8.2
   #include <stdio.h>
   
   int main()
   {
       printf("Para 'misturar' aspas, use diferentes das externas.\n");
       printf("Caso contrário, você precisa escapá-las com uma contrabarra, assim: \". A contrabarra é necessária.\n");
   
       return 0;
   }

9. Operações lógicas (documentação):

   // gcc 9.c -o p9
   #include <stdio.h>
   
   int main()
   {
       printf("%d\n", 1 && 1); // Operação lógica "e" ("and").
       printf("%d\n", 1 || 1); // Operação lógica "ou" ("or").
       printf("%d\n", !1); // Operação lógica "não" ("not").
   
       return 0;
   }

10. Condições (documentação):

    // gcc 10.1.c -o p10.1
    #include <stdio.h>
    #include <string.h>
    
    #define COMPRIMENTO_MAXIMO 256
    
    int main()
    {
        char navegador[COMPRIMENTO_MAXIMO] = {'\0'};
        snprintf(navegador, COMPRIMENTO_MAXIMO, "Firefox");
        if (!strcmp(navegador, "Firefox"))
        {
            printf("Mozilla Firefox.\n");
        }
    
        return 0;
    }

    // gcc 10.2.c -o p10.2
    #include <stdio.h>
    #include <string.h>
    
    #define COMPRIMENTO_MAXIMO 256
    
    int main()
    {
        char meu_navegador[COMPRIMENTO_MAXIMO] = {'\0'};
        snprintf(meu_navegador, COMPRIMENTO_MAXIMO, "Seu Navegador");
        if (!strcmp(meu_navegador, "Firefox"))
        {
            printf("Você usa um navegador da Mozilla.\n");
        }
        else
        {
            printf("Você usa outro navegador.\n");
        }
    
        return 0;
    }

    // gcc 10.3.c -o p10.3
    #include <stdio.h>
    #include <ctype.h>
    #include <string.h>
    
    #define COMPRIMENTO_MAXIMO 256
    
    int main()
    {
        char eu_uso[COMPRIMENTO_MAXIMO] = {'\0'};
        snprintf(eu_uso, COMPRIMENTO_MAXIMO, "X");
    
        int indice = 0;
        while ((indice < COMPRIMENTO_MAXIMO) && eu_uso[indice] != '\0')
        {
            eu_uso[indice] = tolower(eu_uso[indice]);
            ++indice;
        }
    
        if (!strcmp(eu_uso, "firefox"))
        {
            printf("Você usa um navegador da Mozilla.\n");
        }
        else if ((!strcmp(eu_uso, "chrome")) || (!strcmp(eu_uso, "chromium")))
        {
            printf("Você usa um navegador do Google.\n");
        }
        else if (!strcmp(eu_uso, "edge"))
        {
            printf("Você usa um navegador da Microsoft.\n");
        }
        else if (!strcmp(eu_uso, "safari"))
        {
            printf("Você usa um navegador da Apple.\n");
        }
        else if (!strcmp(eu_uso, "internet explorer"))
        {
            printf("Você deveria usar um navegador mais moderno...\n");
        }
        else
        {
            printf("Você usa outro navegador.\n");
        }
    
        return 0;
    }

11. Repetições ou laços (documentação: for, while, e do...while):

    // gcc 11.1.c -o p11.1
    #include <stdio.h>
    
    int main()
    {
        int i;
        for (i = 0; i < 5; i = i + 1)
        {
            printf("%d\n", i);
        }
    
        return 0;
    }

    // gcc 11.2.c -o p11.2
    #include <stdio.h>
    
    int main()
    {
        int j = 0;
        while (j < 5)
        {
            printf("%d\n", j);
            ++j; // O mesmo que j = j + 1 e similar a j++ (existem algumas pequenas diferenças)
        }
    
        return 0;
    }

    // gcc 11.3.c -o p11.3
    #include <stdio.h>
    
    int main()
    {
        int k = 0;
        do
        {
            printf("%d\n", k);
            k++;
        }
        while (k < 5);
    
        return 0;
    }

12. Funções (documentação):

    // gcc 12.c -o p12
    #include <stdio.h>
    
    int minha_funcao(int x, int y)
    {
        int resultado = x + y;
        return resultado;
    }
    
    int main()
    {
        // Uma função é um bloco de código que realiza um processamento arbitrário
        // conforme definido pela programadora ou pelo programador.
        // Após a definição, pode-se executar a função quando se quiser, por meio
        // de uma chamada de função.
        int z = minha_funcao(12, -34); // Este é um exemplo de uma chamada de função.
        printf("%d\n", z);
        printf("%d\n", minha_funcao(1, 2)); // Este é outro.
    
        return 0;
    }

13. Tipos de dados (documentação):

    // gcc 13.c -o p13
    #include <stdio.h>
    
    #define COMPRIMENTO_MAXIMO 256
    
    int main()
    {
        int numero_inteiro = 1;
        int outro_numero_inteiro = -1;
        float numero_real = 1.23;
        int valor_logico = 1; // ou 0; 0 é falso, qualquer outro valor é true
        char cadeia_caracteres[COMPRIMENTO_MAXIMO] = {'\0'}; // \0 marca o final de uma string.
        snprintf(cadeia_caracteres, COMPRIMENTO_MAXIMO, "Texto aqui. Quebras de linha usam\nou seja, isto estará\n na terceira linha.");
    
        return 0;
    }

14. Entrada (documentação: fgets(), strcspn() e sscanf()):

    // gcc 14.c -o p14
    #include <stdio.h>
    #include <string.h>
    
    #define COMPRIMENTO_MAXIMO 256
    
    int main()
    {
        // Quando se solicitar a entrada de um valor, escreva um e aperte `enter`.
        printf("Qual é o seu nome? ");
        char seu_nome[COMPRIMENTO_MAXIMO] = {'\0'};
        fgets(seu_nome, COMPRIMENTO_MAXIMO, stdin);
        seu_nome[strcspn(seu_nome, "\r\n")] = '\0';
        printf("Quantos anos você tem? ");
        char sua_idade_texto[COMPRIMENTO_MAXIMO] = {'\0'};
        fgets(sua_idade_texto, COMPRIMENTO_MAXIMO, stdin);
        int sua_idade;
        sscanf(sua_idade_texto, "%d", &sua_idade);
    
        printf("%s\n", seu_nome);
        printf("%d\n", sua_idade);
        printf("Olá, %s!\n", seu_nome);
        printf("Você tem %d anos.\n", sua_idade);
    
        return 0;
    }

Parabéns! Você Já Pode Escrever Qualquer Programa em C

Bem... Provavelmente não. Possivelmente faria conhecer ponteiros para se poder escrever quaisquer programas sem maiores limitações. Além disso, C é uma linguagem que requer o entendimento de como o hardware funciona para minimizar o risco de erros. Ainda assim, erros ocorrerão.

Contudo, o título da seção está tecnicamente correto.

Não acredita? Você pode encontrar a explicação na introdução à linguagem JavaScript.

Em resumo, aprender a sintaxe de uma linguagem não é suficiente para resolver problemas com ela. O aprendizado de lógica de programação e o desenvolvimento de habilidades de pensamento computacional são muito mais importantes que a sintaxe. De fato, quando se tem dúvidas sobre a sintaxe, basta consultar a documentação. Não é preciso decorá-la.

Após aprender uma primeira linguagem de programação, aprender outras linguagens (que adotem paradigmas semelhantes aos da primeira) é relativamente simples. Para constatar a afirmação, pode-se abrir uma nova janela em seu navegador e deixá-la lado a lado com esta. Em seguida, pode-se comparar os blocos de código escritos em C (nesta janela) e em Python (na segunda janela).

Caso se deseje fazer comparações entre mais linguagens de programação, pode-se escolher:

• C;
• C++;
• GDScript (Godot Engine);
• Java;
• JavaScript;
• Lua;
• LISP;
• Python;
• Prolog;
• SQL (SQLite).

Próximos Passos

Com o ambiente de desenvolvimento configurado, você pode continuar sua jornada de desenvolvimento de sistemas.

Para evitar repetições, recomendo a leitura da página sobre configurações de ambiente para JavaScript. Mesmo que você não tenha interesse na linguagem, muitas discussões são relevantes para quaisquer linguagens de programação. Além disso, você entenderá uma forma de criar páginas para a Internet e poderá criar conteúdo para seu navegador.

Até GDScript (para Godot Engine), os tópicos descrevem configurações de ambientes de desenvolvimento para algumas linguagens de programação. Após GDScript, o foco torna-se conceitos básicos para o aprendizado de programação.