Você não precisa usar C todos os dias para respeitá-lo. A linguagem é onipresente. Ele alimenta o kernel do seu sistema operacional, impulsiona dispositivos incorporados e serve como camada fundamental para gigantes como Python, Java e C++. Se você é um programador, provavelmente escreve em linguagens de nível superior na maior parte do tempo. Isso é bom. Mas saber como aprender C oferece uma vantagem que poucas outras habilidades podem igualar. Não se trata apenas de escrever código eficiente; trata-se de compreender a máquina.
Ao entender C, você para de tratar seu computador como uma caixa mágica. Você começa a ver o gerenciamento de memória, a coleta de lixo e as restrições de hardware como conceitos tangíveis. Essa visibilidade ajuda você a escrever um código melhor em qualquer linguagem. É a diferença entre saber dirigir um carro e saber consertar seu motor.
Para os profissionais de TI, os benefícios são ainda mais diretos. A administração do sistema geralmente envolve scripts e manutenção de ambientes complexos. A maioria dos shells (os ambientes de execução controlada onde os scripts são executados) são baseados em C. O C shell (ou csh) continua sendo uma adaptação popular para profissionais de TI que precisam manipular sistemas operacionais em um nível baixo. Compreender a estrutura subjacente dessas ferramentas torna a solução de problemas mais rápida e menos adivinhada.
As origens do C e do UNIX
Para entender por que C está estruturado dessa maneira, é preciso observar seu nascimento. O início da década de 1970 foi uma época caótica para a programação. Se você quisesse conversar com o hardware, você usava a linguagem assembly. Foi prolixo. A depuração foi um pesadelo. Adicionar recursos exigia um trabalho manual e tedioso que retardava o desenvolvimento.
Ken Thompson e Dennis Ritchie, da Bell Labs, precisavam de uma maneira melhor. Eles estavam trabalhando no sistema operacional UNIX. Sua primeira tentativa de uma linguagem de alto nível foi chamada B, construída sobre a linguagem de programação do sistema BCPL. Quando a Bell Labs adquiriu um PDP-11 da Digital Equipment Corporation, Thompson ajustou B para atender às demandas do novo hardware. O resultado foi C.
Não foi apenas uma nova sintaxe. Foi uma mudança na filosofia. Em 1973, C era estável o suficiente para que todo o kernel do UNIX fosse reescrito nele. Esta foi uma jogada ousada. Provou que linguagens de alto nível poderiam lidar com tarefas de baixo nível sem sacrificar o desempenho.
Padronização e o “Livro Branco”
No início, C era uma espécie de oeste selvagem. Diferentes programadores criaram seus próprios dialetos. Para corrigir isso, os desenvolvedores passaram a década de 1980 criando padrões. O primeiro grande marco foi “The C Programming Language”, de Brian Kernighan e Dennis Ritchie. Os fãs de C chamam isso de K&R, ou “Livro Branco”.
A versão original de C, derivada do livro K&R, ainda hoje é chamada de K&R C.
O livro se tornou o guia definitivo. A sua segunda edição, publicada em 1988, continua a ser uma referência para muitos. Mas os livros não são padrões. O American National Standards Institute (ANSI) lançou o padrão X3.159-1989 em 1989. A Organização Internacional para Padronização (ISO) seguiu com ISO/IEC 9899:1990 em 1990.
Esses padrões deram ao C sua identidade moderna. Você poderá ver referências a C89, C90 ou C99 na documentação. Estes são apenas um resumo do padrão lançado naqueles anos. Quando alguém diz “ANSI C”, geralmente está se referindo ao padrão de 1989. Essa padronização permitiu que C se espalhasse além dos Bell Labs. Tornou-se uma ferramenta universal, não proprietária.
O Legado: C++ e Java
O sucesso de C criou um efeito cascata. Os computadores ficaram mais rápidos. Os aplicativos ficaram mais complexos. Os programadores precisavam de formas de gerir esta complexidade sem reinventar a roda.
Digite C++. Foi necessário C e adicionou recursos de programação orientada a objetos (OOP). Isso permitiu que os desenvolvedores reutilizassem o código de forma mais eficaz. Ele otimizou a capacidade de lidar com projetos de software em grande escala com muitas peças móveis. Java seguiu um caminho semelhante, emprestando muito da sintaxe de C e simplificando o gerenciamento de memória.
Essas linguagens não substituíram C. Elas confiaram nela. C permaneceu como ponte entre o código do aplicativo e o hardware. É a base invisível. Sem C, as linguagens de alto nível que você usa diariamente não teriam uma maneira consistente de se comunicar com a máquina.
Por que C ainda é relevante
O argumento contra C é que ele é antigo. É manual. É perigoso. Você pode travar seu sistema em uma única linha de código se errar um ponteiro. Mas esse perigo é também o seu poder. C oferece controle total. Não esconde coisas de você.
Para os desenvolvedores, isso significa uma visão mais profunda. Quando você sabe como a memória é alocada em C, entende por que seu script Python fica lento. Você vê a sobrecarga. Você vê a coleta de lixo em tempo real. Esse conhecimento permite otimizar. Ele permite que você escreva programas que não apenas funcionem, mas que funcionem com eficiência.
Para especialistas em TI, trata-se de controle. As linguagens de script são convenientes. Eles são rápidos para escrever. Mas quando algo quebra na pilha, você precisa entender o que está acontecendo nos bastidores. C fornece esse contexto. Explica por que um shell se comporta de determinada maneira. Explica como um sistema operacional gerencia recursos.
Aprender C não significa se tornar um programador C. Trata-se de se tornar um programador melhor. É sobre ver os fios. E depois de ver os fios, você nunca mais poderá deixar de vê-los.
C não é executado diretamente. Você não pode simplesmente clicar duas vezes em um arquivo de origem e vê-lo dançar na tela. É uma linguagem compilada. Isso significa que você deve primeiro traduzir o texto legível por humanos em instruções executáveis pela máquina. Este processo envolve um compilador. O compilador verifica seu código, verifica erros de sintaxe e, se estiver satisfeito com o que vê, exibe um arquivo executável. Esse é o binário que o computador realmente executa.
Você pode escrever código C em praticamente qualquer editor de texto. Os usuários do Windows podem usar o Bloco de Notas como padrão. Os usuários de Mac costumam usar o TextEdit. O pessoal do Linux pode preferir o gedit. A ferramenta não importa tanto quanto o resultado. Você está criando um arquivo de texto simples. A mágica acontece na próxima etapa.
Encontrando e configurando seu compilador
Antes de escrever uma única linha de lógica complexa, você precisa das ferramentas certas. Se você usa macOS ou uma distribuição Linux como o Ubuntu, você já tem o que precisa. Você só precisa instalar as ferramentas de desenvolvimento do seu sistema operacional. Isso lhe dá acesso a um compilador C.
Estas são ferramentas de linha de comando. Você não encontrará um botão brilhante para clicar no menu do aplicativo. Você abrirá uma janela de terminal. A partir daí, você digita comandos. O comando padrão geralmente é cc ou gcc. Após o comando, você digita opções e argumentos. Estas são as instruções que dizem ao compilador o que fazer.
Ou se você estiver usando o GCC:
É simples. Também é implacável se você cometer um erro.
IDEs para Windows e necessidades de plataforma cruzada
As linhas de comando não são para todos. Se você preferir uma interface gráfica ou estiver no Windows, talvez queira um Ambiente de Desenvolvimento Integrado (IDE). Um IDE agrupa tudo. Você escreve código. Você compila. Você depura isso. Você faz tudo em uma janela. Os erros são destacados. As correções são mais fáceis de encontrar.
Para Windows, o Microsoft Visual C++ é uma opção forte. Ele lida com C e C++. É poderoso. Também é caro se você não estiver usando a edição comunitária gratuita.
Eclipse é outra escolha popular. É grátis. É baseado em Java, mas se estende para suportar C e muitas outras linguagens. Ele roda em Windows, Mac e Linux. Se você já está no ecossistema Eclipse, adicionar o plugin C/C++ é uma etapa lógica.
Por que as versões do compilador são importantes
A versão do compilador que você usa não é um detalhe menor. É crítico. Você deve usar uma versão do compilador igual ou mais recente que o padrão da linguagem C no qual seu código se baseia. Se você tentar compilar código C99 ou C11 moderno com um compilador antigo, ele falhará. Ele não entenderá a nova sintaxe.
Se você estiver usando um IDE, verifique as configurações do seu projeto. Certifique-se de que o IDE esteja configurado para direcionar a versão C específica que você está usando. Se você estiver no terminal, você passa essas informações por meio de argumentos de linha de comando.
Quebrando um comando GCC
Vejamos um exemplo real. Este comando é como você controla explicitamente o processo de compilação.
Esta linha informa ao compilador exatamente o que fazer. Divida:
gcc: Chama a coleção de compiladores GNU. É o motor.-std=c99: Isso define o padrão. Diz ao gcc para usar a versão C99 da linguagem C. Sem isso, o padrão poderá ser um padrão mais antigo e mais restritivo.-o myprogram.exe: Define o nome do arquivo de saída. Sem o sinalizador-o, o gcc nomeará seu executável comoa.outpor padrão. Isso não é muito descritivo.myprogram.c: Este é o seu arquivo fonte. A entrada.
O comando efetivamente diz: “Pegue myprogram.c, compile-o usando regras C99 e salve o resultado como myprogram.exe.”
Opções de navegação
Existem centenas de opções disponíveis para o gcc e outros compiladores. Você não precisa memorizá-los. Você não precisa usar todos eles. Mas você precisa saber que eles existem.
Procure a documentação do seu compilador específico. Procure sinalizadores que otimizem o desempenho. Procure sinalizadores que aumentem os níveis de alerta. Cada opção adicionada altera o comportamento do binário final.
Escrevendo seu primeiro programa C
Agora que o compilador está instalado e configurado, você está pronto para codificar. A barreira à entrada é baixa. Os conceitos são fundamentais.
Comece com a estrutura básica. Todo programa C precisa de uma função principal. Precisa de cabeçalhos. Precisa de uma declaração de retorno. Estes são os ossos.
Este é o programa C válido mais simples. Inclui uma biblioteca padrão de entrada/saída. Ele define uma função principal. Ele imprime uma string. Ele retorna zero para indicar sucesso.
Salve este arquivo como hello.c. Compile-o.
Execute-o.
Você deverá ver “Hello, World” na tela. Você acabou de escrever, compilar e
A anatomia de um programa Hello World
Comece com um arquivo de texto em branco. Nomeie-o como sample.c. Não o nomeie sample.txt. Se o padrão do seu editor for .txt, o compilador irá rejeitá-lo. Você precisa da extensão .c para sinalizar que este é um código-fonte C, não um documento de texto.
Aqui está o código. Está vazio. Mínimo.
Compile-o. Execute-o. O computador imprime uma string e sai. Bastante simples. Mas olhe mais de perto. Cada personagem aqui tem um trabalho.
A linha um é um comentário. As tags /* e */ dizem ao compilador para ignorar tudo dentro delas. Os humanos lêem isso. A máquina não. É para você ou para quem mantém esse código posteriormente.
A linha dois é onde as coisas ficam reais. #include extrai uma biblioteca. Especificamente, a biblioteca padrão de entrada/saída. Este arquivo contém definições para funções como printf. Você não está escrevendo a lógica para imprimir na tela. Você está apenas informando ao compilador onde encontrar as instruções que já existem.
A linha três define o ponto de entrada. int principal(). Todo programa C precisa disso. É a primeira coisa que o sistema operacional chama. A palavra-chave int significa que a função retorna um número inteiro. Os parênteses estão vazios aqui, mas isso é um detalhe para mais tarde.
As linhas quatro e sete são colchetes. { e }. Eles envolvem o corpo da função. Alguns desenvolvedores colocam a chave de abertura na mesma linha de main(). Outros, como este exemplo, colocam-no em sua própria linha. Isso não muda a forma como o código é executado. Isso apenas muda a aparência. E em C, a legibilidade é importante porque você ficará olhando para isso por muito tempo. O recuo ajuda. Use espaços.
A linha cinco chama printf. Esta função reside na biblioteca stdio.h que você incluiu anteriormente. É preciso um argumento de string. Observe o \n no final. Essa é uma sequência de escape. Não imprime uma barra invertida e um n. Move o cursor para a próxima linha. Sem ele, seu prompt de comando ficaria estranho logo após sua saída. E olhe para o ponto e vírgula. ;. Cada declaração deve terminar com um. Perca, e o compilador engasga.
A linha seis é o sinal de saída. retorne 0;. Quando main termina, ele devolve um valor ao sistema operacional. Zero significa sucesso. Diferente de zero geralmente significa que algo quebrou. Você pode não usar esse valor em seu código, mas o sistema usa. Quando você testa scripts ou executa programas em trabalhos em lote, o sistema operacional verifica esse zero. É o sinal verde de que o processo foi concluído sem travar.
Compilando a partir da linha de comando
Agora que você tem o código, precisa transformá-lo em algo que a CPU entenda. Você precisa de um compilador. Vamos supor que você esteja usando gcc.
Abra seu terminal. Navegue até a pasta onde você salvou sample.c. Digite isto:
Divida o comando. gcc é a ferramenta do compilador. -o significa saída. Você está dizendo como nomear o arquivo resultante. sample.exe é esse nome. sample.c é o arquivo de entrada.
Se você digitou um ponto e vírgula errado, esta linha falhará. A saída será uma parede de texto vermelho. É um erro de sintaxe. Você digitou algo errado. Talvez você tenha esquecido uma citação. Talvez você tenha perdido um aparelho. Corrija o código. Salvar. Execute o comando novamente. É um ciclo.
Se funcionar, um novo arquivo aparecerá. amostra.exe. Este é o executável. Não é mais um texto legível por humanos. É código de máquina.
Executando o executável
Não fique apenas olhando para o novo arquivo. Execute-o.
O ./ é importante. Ele diz ao shell para procurar o executável no diretório atual. Se você omitir, o sistema poderá procurar no seu caminho e não conseguir encontrá-lo, ou pior, encontrar o caminho errado.
Quando ele é executado, você vê o texto. Então o cursor se move. Então você está de volta ao prompt de comando.
Esse é o ciclo de vida. Escrever. Compilar. Correr. Quebrar. Consertar. Repita.
Não é mágica. É apenas um conjunto de regras muito rígido. Você os segue e o computador faz exatamente o que você manda. Você os ignora e isso não faz nada.
Mas esta é apenas a superfície. Você viu uma função. Você viu uma biblioteca. Você viu um valor de retorno. Os blocos de construção estão lá. A verdadeira complexidade surge quando você começa a ligá-los.
Se você está tentando entender conceitos de programação C, você não está sozinho. É uma linguagem que exige precisão. Você não apenas escreve código; você gerencia a memória, define tipos e informa à CPU exatamente o que fazer. Não há mágica aqui. Apenas lógica.
Aqui está um resumo do que realmente acontece quando você compila um programa C.
Como funcionam as funções em C
Vamos começar com funções em C. Em muitas linguagens modernas, estes são chamados de métodos. Em C, são funções. Uma função é um bloco de código. Isso faz uma coisa. Quando seu programa é executado, ele executa esses blocos.
Você pode definir diversas funções. Você pode chamá-los de outras funções. Isso permite dividir um programa enorme em seções gerenciáveis e reutilizáveis.
A estrutura básica é assim:
Todo programa C precisa de pelo menos uma função: main. O compilador procura esse nome específico para iniciar a execução. Mesmo que main chame outras funções, é o ponto de entrada.
Considere este exemplo simples:
Possui um tipo de retorno inteiro. Sem parâmetros. Duas declarações. O comando printf envia texto para a tela. O return 0 informa ao sistema que o programa terminou com sucesso.
Passando parâmetros para funções
Outras funções precisam de definições e chamadas. Uma chamada de função é uma instrução dentro de outra função. Ele nomeia a função. Inclui parênteses. Se a função espera dados, você deverá fornecê-los. Isso é chamado de passagem de parâmetros.
O que é um parâmetro? São dados de um tipo específico. A função precisa disso para funcionar. As funções C podem aceitar um número ilimitado de parâmetros. Eles também são chamados de argumentos.
Cada parâmetro requer um tipo de dados e um nome de variável. Vários parâmetros são separados por vírgulas.
Veja esta função:
São necessários dois números inteiros. Isso os duplica. Isso os adiciona. Ele retorna o resultado. Simples. Eficaz.
Variáveis e tipos de dados
Variáveis são espaços reservados. Eles representam valores que você ainda não conhece. Você precisa de flexibilidade. Você não quer codificar números em sua lógica. C lida com isso como álgebra.
Mas C é mais rigoroso. Você deve definir tipos de dados. Isso informa ao compilador quanta memória deve ser alocada. Diz à CPU como interpretar os bits.
Cada tipo de dados tem um tamanho. É medido em bits ou bytes binários. Tem regras. Se você escolher o tipo errado, seu programa poderá travar ou produzir resultados inúteis. Escolher os tipos de dados corretos em C é fundamental para desempenho e correção.
Operações e Fluxo de Controle
Você realiza aritmética em números. Você concatena strings. C possui operações integradas para essas tarefas.
Mas o fluxo de controle é onde reside a lógica.
Loops repete ações. Eles se repetem com base nas condições. C fornece várias estruturas de loop:
– enquanto
– fazer/enquanto
– para
– continuar /pausa
– goto (use com cuidado)
Também possui condicionais:
– se/então/senão
– interruptor/caso
Essas estruturas permitem direcionar o caminho do programa. Faça alguma coisa. Verifique uma condição. Repita. Quebre se necessário.
Estruturas de dados e memória
Quando você tem muitos dados, você precisa de estruturas de dados em C. Você precisa resolver isso. Pesquise.
Uma estrutura de dados é uma forma estruturada de representar vários dados do mesmo tipo. O mais comum é uma matriz. É uma lista indexada de um determinado tamanho.
C possui bibliotecas para estruturas comuns. Mas você também pode escrever o seu próprio. Você pode definir suas próprias funções. Você tem controle total.
Esse controle tem um custo. C exige que você lide com ponteiros. Requer que você gerencie a memória. Não há coleta de lixo em C. Se você alocar memória, deverá liberá-la. Esqueça de fazer isso e você terá um vazamento de memória.
Operações do pré-processador
Antes mesmo de o compilador ver seu código, o pré-processador é executado. Ele lhe dá instruções.
Ele substitui valores constantes. Inclui código de bibliotecas. Você viu isso com #include. Ele extrai definições padrão.
Isso não faz parte do executável final. É uma fase de configuração. Ele prepara seu código para compilação.
Por que isso é importante
Esta visão geral pode parecer densa. Se você é novo em programação, há muito para absorver. Mas estes são os blocos de construção.
Você não pode escrever C sem entender funções em C. Você não pode gerenciar dados sem tipos de dados. Você não pode controlar o fluxo sem loops.
A linguagem não segura sua mão. Dá-lhe ferramentas. Você decide como usá-los.
A seguir, nos aprofundaremos em como essas peças se encaixam em um programa maior. A estrutura é importante. A sintaxe é importante. Mas a lógica é mais importante.
Como você aborda o aprendizado de um novo idioma? Você começa com variáveis? Ou você vai direto para as funções? O caminho é você quem define.
Você pode descartar uma definição de função em qualquer lugar de um programa C, desde que não esteja aninhada dentro de outra função. Mas existe uma regra estrita. Você precisa informar ao compilador que a função existe antes de tentar usá-la. É aqui que entra o protótipo da função. É uma instrução colocada no topo do seu código. Ele reflete a primeira linha da sua definição de função real. Em C, você não precisa nomear os parâmetros nessa instrução de primeira linha. Você só precisa dos tipos de dados. Aqui está a aparência de doubleAndAdd como protótipo:
int doubleAndAdd(int, int);
Pense nos protótipos funcionais como a lista de embalagem de uma nova peça de mobiliário. Você não começaria a construir uma estante sem verificar a caixa de todos os parafusos e prateleiras. O compilador faz a mesma coisa. Ele verifica o protótipo antes de montar seu programa. Isso garante que todas as peças estejam lá.
Se você estiver trabalhando com sample.c, adicione o protótipo, a definição e a chamada para doubleAndAdd. Compile-o. Execute-o. Veja como funciona. O código fica assim:
Cobrimos a estrutura básica. Agora precisamos falar sobre dados. Que tipos de dados você pode manipular em C? Quais operações são permitidas neles?
Declarações de Função vs. Protótipos
Os programadores C mais antigos os chamarão de declarações de função. Você ouvirá muito esse termo. Usamos protótipo de função aqui porque a distinção é importante. Uma declaração tradicional não exigia parâmetros. Apenas um tipo de retorno, um nome e parênteses vazios foram suficientes. Um protótipo é diferente. Fornece detalhes específicos ao compilador. Diz ao compilador quantos parâmetros existem. Ele informa quais são os tipos de dados desses parâmetros. Essas informações extras evitam erros. É a melhor prática moderna. Aplica-se a C e muitas outras linguagens. Sem ele, o compilador está adivinhando. Com ele, o compilador sabe exatamente o que esperar.
Os tipos de dados são os blocos de construção. As operações são as ferramentas. Estamos passando da estrutura para a substância.
Os computadores veem os dados como binários brutos. É apenas um fluxo de uns e zeros. Seu disco rígido, memória e processador não se importam com o significado por trás desses bits. Somente o software em execução na máquina fornece contexto a esses bilhões de dígitos.
C se destaca aqui. É uma das poucas linguagens de alto nível que permite manipular dados em nível de bit e, ao mesmo tempo, interpretá-los com base em regras específicas.
Como C define tipos de dados
Um tipo de dados é essencialmente um livro de regras. Diz ao compilador como interpretar uma sequência de bits. Ele define o tamanho dos dados e como operações como adição ou multiplicação devem funcionar neles.
O tamanho de um tipo de dados em C depende do processador. Isso não foi corrigido.
Considere o tipo int padrão. Em um processador de 16 bits, um número inteiro tem 16 bits. Mude para um processador de 32 ou 64 bits e o mesmo int se tornará 32 bits. Essa variação é uma parte essencial da compreensão dos tipos de dados em C.
Assinado vs. Não assinado: o problema do intervalo
Como C lida com números positivos e negativos é outro detalhe crítico.
Um tipo assinado reserva um bit para indicar o sinal. Isso reduz seu alcance pela metade. Em um sistema de 16 bits:
- Um
unsigned intvaria de 0 a 65.535. - Um
signed intvaria de -32.768 a 32.767.
Se o seu cálculo levar uma variável além desses limites, C nem sempre o impedirá. Isso pode causar um transbordamento. Você precisa escrever código extra para lidar com isso manualmente. Ignorar isso leva a bugs.
Tipos primitivos e matrizes
Os programadores C selecionam os tipos de dados com base nas necessidades do programa. A linguagem fornece tipos de dados primitivos. Eles estão integrados. Eles formam a base.
Para obter uma lista completa desses tipos e regras de conversão, você precisará de um guia de referência. Mas existe uma estrutura que preenche a lacuna entre os primitivos e a organização complexa: o array.
Uma matriz é uma lista virtual. Todos os elementos devem ser do mesmo tipo de dados. Você não pode redimensionar um array depois de criado. Você pode copiar seu conteúdo em um array maior ou menor.
Strings e arquivos de cabeçalho
Embora as matrizes numéricas sejam comuns, as matrizes de caracteres possuem recursos exclusivos. Nós os chamamos de cordas.
Uma string armazena texto. Ele permite que seu programa salve a entrada do usuário ou a saída de impressão. Como a manipulação de strings envolve um conjunto específico de operações, C inclui um arquivo de cabeçalho dedicado: string.h. Ele contém as funções típicas que você precisa para trabalhar com texto.
A precedência do operador é importante
C inclui operações integradas encontradas na maioria das linguagens. Mas a ordem das operações nem sempre é intuitiva se você vem de uma formação diferente.
Você precisa saber a precedência do operador. Esta é a ordem em que o compilador avalia as expressões matemáticas.
Veja este exemplo:
(2+5)*3 é igual a 21.
2+5*3 é igual a 17.
C realiza a multiplicação antes da adição. Os parênteses substituem esse comportamento padrão. A má compreensão da precedência leva a uma lógica incorreta.
Etapas práticas para alunos
Se você está aprendendo C, não fique apenas superficial.
- Familiarize-se com todos os tipos de dados primitivos.
- Memorize a precedência da operação.
- Experimente operações de tipo misto.
Tente misturar números inteiros e flutuantes. Veja como C lida com a conversão. É a única maneira de internalizar as regras.
Isso cobre os princípios básicos de como C lida com dados e operações. Mas escrever programas do zero sempre é ineficiente. O próximo passo lógico é a reutilização.
Você não reinventa a roda para cada programa C. Você não deve começar do zero.
C é básico. Ele reduz tudo ao essencial. Ele não vem com funções integradas de entrada de teclado ou saída de tela. Se quiser imprimir no console, você estará por conta própria, a menos que use uma biblioteca.
As bibliotecas resolvem isso. Eles abrigam blocos de código reutilizáveis. Use-os.
Bibliotecas padrão versus bibliotecas personalizadas em C
Já vimos a biblioteca de E/S padrão. É chamado de stdio. O compilador carrega-o através da diretiva #include. Ele extrai dados do arquivo de cabeçalho stdio.h.
Os mantenedores de C agrupam bibliotecas padrão para E/S, matemática, manipulação de tempo e operações de string. Você encontrará os detalhes da biblioteca padrão C89 em qualquer boa referência. C99 adicionou mais. Procure essas atualizações se precisar de recursos modernos.
Mas você também pode escrever o seu próprio.
Dividir seu código em módulos reutilizáveis traz benefícios. Arquivos mais curtos são mais fáceis de ler. A depuração se torna menos dolorosa. Os testes são mais isolados.
Para vincular uma biblioteca, você adiciona uma linha #include.
Para bibliotecas padrão, use colchetes angulares. Isso diz ao compilador para procurar nos diretórios do sistema.
Para suas próprias bibliotecas personalizadas, use aspas duplas. O compilador verifica primeiro o diretório local.
Observe a sintaxe. Você não precisa de ponto e vírgula no final de uma instrução #include. Não é uma chamada de função. É uma diretiva de pré-processador.
Escrever uma biblioteca não é mágica. As definições de função são idênticas às do seu programa principal. A diferença está no processo de construção.
Você compila o código da sua biblioteca em um arquivo objeto. Termina em .o. Você cria um arquivo de cabeçalho. Termina em .h. O cabeçalho contém protótipos de funções. Declara o que as funções fazem sem implementá-las.
Ao construir seu programa principal, você faz referência ao arquivo de cabeçalho na linha #include. Você passa o arquivo objeto para o comando do compilador. O vinculador os conecta.
Essa abordagem modular mantém seu código limpo. Ele separa a interface da implementação.
Ponteiros: O Núcleo do Gerenciamento de Memória C
Nós cobrimos o básico. Agora passamos para a memória.
Quando um programa C é executado, ele reside na RAM. Cada dado possui um endereço específico. Variáveis não são apenas contêineres. São locais.
Quando você chama uma função, o código é carregado na memória. Ele funciona. Ele retorna.
Por padrão, C passa parâmetros por valor. Ele copia os dados. A função funciona na cópia. A variável original no programa principal permanece intacta.
Às vezes é isso que você quer.
Outras vezes, você precisa alterar os dados originais. Você precisa modificar a variável em seu local de memória original.
Para fazer isso, você passa um ponteiro. Você passa o endereço. Isto é “passagem por referência”.
Os ponteiros estão por toda parte em C. Você não pode usar C de forma eficaz sem eles.
Um ponteiro é uma variável. Mas ele armazena um endereço. Ele aponta para outro dado. Também tem um tipo. O tipo informa ao computador quantos bytes devem ser lidos naquele endereço.
Identificar ponteiros no código pode ser complicado. Até os especialistas sentem falta deles.
Quando você declara um ponteiro, é óbvio. Você usa um asterisco. Este é o operador indireto.
Aqui, i é um número inteiro. p é um ponteiro para um número inteiro.
Nenhum dos dois tem valor ainda.
Atribua um número a i.
Agora faça p apontar para i. Você usa o operador address-of. É um e comercial (& ).
O & significa “endereço de”. Você não precisa saber o endereço real da memória. Ele muda toda vez que você executa o programa. O compilador descobre isso.
Se você pular &, atribuirá o valor 3 ao ponteiro. Isso é um bug. O ponteiro agora contém o número 3, não a localização de i.
Usando ponteiros corretamente em C
O uso de ponteiros introduz complexidade. Você está gerenciando a memória diretamente.
O compilador não o salvará de erros.
Se você desreferenciar um ponteiro nulo, seu programa travará. Se você acessar uma memória que não possui, ocorrerá uma falha de segmentação. É feio.
Mas o poder é real. Você pode transmitir grandes estruturas de dados sem copiá-las. Você pode modificar variáveis além dos limites da função. Você pode construir listas vinculadas, árvores e estruturas de dados complexas.
Dominar os ponteiros é a diferença entre escrever scripts simples e construir sistemas robustos. Não é opcional. É a base.
Passe um ponteiro, não o valor em si.
Você pode trocar um ponteiro por sua variável sempre que eles compartilharem um tipo de dados. Isso é importante em chamadas de função e matemática. Pegue int b. Você pode escrever b = *p + 2;. O asterisco diz ao compilador para desreferenciar p. Ele captura o valor real no endereço de memória. Não o endereço em si. Essa distinção é tudo.
Sem ponteiros, dividir o código em funções fora de main é quase impossível. Você ficaria preso a códigos espaguete ou variáveis globais. Considere uma variável h para altura em centímetros. Você deseja que uma função setHeight solicite a entrada do usuário.
Isso parece razoável. Não é. A função recebe uma cópia de h. Isso muda a cópia. O h original permanece intacto. Quando a função termina, essa cópia desaparece. Sua altura permanece não inicializada ou zero.
Para realmente atualizar h, a função precisa de uma referência. Especificamente, um ponteiro. Altere a lista de parâmetros para aceitar um endereço.
Agora você tem duas maneiras de chamar isso.
Primeiro, use o operador de endereço & diretamente em h.
setHeight(&h);
Segundo, crie um ponteiro intermediário.
Ambos funcionam. Eles apontam para o mesmo lugar na memória. Isso revela um desafio central de indicadores. Vários ponteiros podem fazer referência ao mesmo valor. Mude um e todos eles verão a mudança.
Isso é bom ou ruim? Depende da sua intenção. É poderoso para atualizar o estado compartilhado. É perigoso se você perder o controle de qual ponteiro controla os dados. Uma gravação acidental corrompe tudo que aponta para ela.
Dominar ponteiros não é opcional. É a diferença entre escrever C e escrever em C. Pratique até que o layout da memória pareça intuitivo. Até que você possa ver a pilha e o heap sem olhar um diagrama.
Os recursos de linguagem que abordamos até agora existem na maioria dos idiomas modernos. Python tem referências. Java possui identificadores de objetos. C++ possui ponteiros inteligentes. Mas C exige outra coisa. Exige que você mesmo gerencie a memória. Nenhum coletor de lixo para limpar a bagunça. Não há tempo de execução para evitar vazamentos. A seguir, veremos como C força você a lidar com a alocação e desalocação de memória com precisão cirúrgica.
Por que o controle de memória ainda é importante em C
A versatilidade de C decorre de sua capacidade de redução. A linguagem permite remover um programa até que ele seja executado em hardware mínimo. Isso não foi apenas nostalgia. Os primeiros computadores eram fracos. Hoje, a procura de produtos electrónicos de baixo consumo – telemóveis, pequenos dispositivos médicos – traz de volta essa restrição. C continua sendo a escolha certa quando você precisa de controle granular sobre o uso de memória.
A compreensão disso começa com a forma como um programa reside na RAM. Quando você inicia um executável, ele é carregado na memória e começa a executar instruções por meio do processador. As funções são carregadas em blocos de memória específicos à medida que são executadas. Eles abandonam esses blocos quando terminam. Cada novo ponto de dados consome espaço durante a vida útil do programa.
Explicação da alocação dinâmica de armazenamento
Para gerenciar esse caos, você precisa de alocação dinâmica de armazenamento. Isso significa reservar memória somente quando necessário e liberá-la imediatamente depois. Muitas linguagens lidam com isso automaticamente com a coleta de lixo. C não. C requer gerenciamento explícito.
A biblioteca padrão fornece as ferramentas. Você controla o ciclo de vida.
- malloc : Abreviação de alocação de memória. Reserva um bloco de memória de tamanho específico. Ele retorna um ponteiro para esse bloco. Você usa isso para estruturas de dados como arrays, não para números inteiros únicos como
int i. - calloc : Semelhante ao malloc, mas também limpa a memória no momento da reserva.
- realloc : Redimensiona um bloco de memória alocado anteriormente.
- free : Força o programa a liberar a memória atribuída a um ponteiro específico.
A melhor prática é simples: alocar com malloc, grátis com grátis.
Se você alocar memória, mesmo que temporariamente, ela permanecerá na RAM até que o sistema operacional seja limpo. Para manter o espaço ocupado pequeno, libere a memória antes que a função seja encerrada. Isso evita vazamentos de memória. Um vazamento de memória ocorre quando um programa consome cada vez mais memória até parar ou travar. Porém, não libere o que você precisa posteriormente na mesma função. Perder dados é pior que um vazamento.
C vs C++ e conceitos básicos
C é o mesmo que C++? Não. C++ estende C. Não é a mesma linguagem. A programação C é um conceito para a criação de software portátil e eficiente. Baseia-se na linguagem C desenvolvida no Bell Labs na década de 1970.
C é poderoso e versátil. Adapta-se a diversas aplicações. Compreender a sua estrutura e história revela porque permanece único. O idioma oferece recursos que faltam em outros idiomas.
Para obter mais orientações, explore recursos de programação adicionais. Isso aprofundará sua jornada em C.
