Depois de toda essa teoria e conversação, vamos começar construindo o código escrito nas últimas nove partes desta série. Esta parte de nossa série pode realmente atendê -lo, mesmo que você tenha aprendido C em outro lugar, ou se você acha que seu lado prático do desenvolvimento C precisa de um pouco de força. Veremos como instalar o software necessário, o que o software diz e, mais importante, como transformar seu código em zeros e um. Antes de começarmos, convém dar uma olhada em nossos artigos mais recentes sobre como personalizar seu ambiente de desenvolvimento:

• Introdução ao editor Vim
• Introdução ao EMACS
• Personalizando o VIM para o desenvolvimento
• Personalizando EMACs para desenvolvimento

Construindo seu programa

Lembre -se da primeira parte de nossa série de desenvolvimento C? Lá descrevemos o processo básico que ocorre quando você compila seu programa. Mas, a menos que você trabalhe no desenvolvimento do compilador ou em algumas outras coisas de nível realmente baixo, você não estará interessado em quantas instruções do JMP o arquivo de assembler gerado, se houver, se houver. Você só vai querer saber como ser o mais eficiente possível. É disso que se trata essa parte do artigo, mas estamos apenas arranhando a superfície, devido à extensão do sujeito. Mas um programador C de nível básico saberá depois de ler tudo isso necessário para funcionar com eficiência.

As ferramentas

Além de saber exatamente o que você deseja alcançar, você precisa estar familiarizado com as ferramentas para alcançar o que deseja. E há muito mais nas ferramentas de desenvolvimento do Linux do que o GCC, embora por si só seja suficiente para compilar programas, mas seria uma tarefa tediosa à medida que o tamanho do seu projeto aumenta. É por isso que outros instrumentos foram criados, e veremos aqui o que são e como obtê -los. Eu já mais do que sugeri que você leia o manual do GCC, então só presumirei que você fez.

fazer

Imagine que você tem um projeto de vários arquivos, com muitos arquivos de origem, os trabalhos. Agora imagine que você deve modificar um arquivo (algo menor) e adicionar algum código a outro arquivo de origem. Seria doloroso reconstruir todo o projeto por causa disso. Veja por que a criação foi criada: com base em registros de data e hora, ele detecta quais arquivos precisam ser reconstruídos para chegar aos resultados desejados (executáveis, arquivos de objeto ...), nomeados alvos. Se o conceito ainda parecer sombrio, não se preocupe: depois de explicar um makefile e os conceitos gerais, tudo parecerá mais fácil, embora o avançado faça conceitos pode ser indutor de dor de cabeça.

Make tem esse nome exato em todas as plataformas em que trabalhei, sendo muitas distantes Linux, *BSD e Solaris. Portanto, independentemente do gerente de pacotes que você está usando (se houver), seja adequado*, yum, zypper, Pacman ou emerge, basta usar o comando de instalação e fazer como argumento e é isso. Outra abordagem seria, em distos com gerentes de pacotes com suporte de grupo, para instalar todo o grupo/padrão de desenvolvimento C/C ++. Falando em idiomas, eu queria desmascarar um mito aqui, que diz o Makefiles (o conjunto de regras que fazem seguir para alcançar o alvo) é usado apenas por desenvolvedores de C/C ++. Errado. Qualquer idioma com um compilador/intérprete capaz de ser invocado do shell pode usar as instalações do Make's Make. De fato, qualquer projeto que precise de atualização baseado em dependência possa usar. Portanto, uma definição atualizada de makefile seria Um arquivo que descreve os relacionamentos e dependências entre os arquivos de um projeto, com o objetivo de definir o que deve ser atualizado/recompilado, caso um ou mais arquivos na cadeia de dependência mudem. Entendendo como a criação de obras é essencial para qualquer desenvolvedor de C que trabalhe no Linux ou Unix - sim, as ofertas comerciais do Unix fazem também, embora provavelmente alguma versão que difere do GNU Make, que é o nosso assunto. "Versão diferente" significa mais de números, significa que um BSD Makefile é incompatível com um gNU makefile. Portanto, verifique se você tem o GNU instalado se você não estiver em uma caixa Linux.

Na primeira parte deste artigo, e alguns subsequentes, usamos e conversamos sobre partes do YEST, um pequeno programa que exibe a data de ontem por padrão, mas faz muita data bacana/coisas relacionadas ao tempo. Depois de trabalhar com o autor, Kimball Hawkins, nasceu um pequeno makefile, com isso que trabalharemos.

Primeiro, vamos ver alguns princípios básicos sobre o makefile. O nome canônico deve ser GNUMAKEFILE, mas se não existe tal arquivo, ele procura nomes como makefile e makefile, nessa ordem, ou assim a página manual diz. A propósito, é claro que você deve lê -lo e lê -lo novamente, depois leia mais um pouco. Não é tão grande quanto o GCC e você pode aprender muitos truques úteis que serão úteis mais tarde. O nome mais usado na prática, no entanto, é makefile, e eu nunca vi nenhuma fonte com um arquivo chamado GnumakeFile, verdade seja contada. Se, por vários motivos, você precisar especificar outro nome, use make -f, como este:

 $ make -f mymakefile

Aqui está o makefile do YEST, que você pode usar para compilar e instalar o referido programa, porque ainda não é enviado pelo SourceForge. Embora seja apenas um programa de dois arquivos - a fonte e a mangueira - você verá que a marca se torna útil já.

# Makefile para compilar e instalar o YEST Uname: = $ (shell uname -s) cc = gcc cflags = -wall cp = cp rm = rm rmflags = -f gzip = gzip versão = yest -2.7.0.5 YEST: ifeq ($ (Uname), sunos) $ (cc) -dsunos $ (cflags) -o yest $ (versão).c outro $ (Cc) $ (cflags) -o yest $ (versão).c fim se Todos: Instalar o qual a instalação do ManInstall Instale: ManInstall $ (CP) YEST/USR/LOCAL/BIN MANINSTALL: $ (CP) $ (versão).MAN1 YEST.1 $ (gzip) YEST.1 $ (cp) YEST.1.gz/usr/share/man/man1/limpo: $ (rm) $ (rmflags) yest yew.1.gz deinstall: $ (rm) $ (rmflags)/usr/local/bin/yest/usr/share/man/man1/yest1.gz 

Se você olhar com cuidado para o código acima, você já observará e aprenderá várias coisas. Os comentários começam com os hashes e, como o Makefiles pode se tornar bastante enigmático, é melhor você comentar seus makefiles. Segundo, você pode declarar suas próprias variáveis ​​e então pode fazer bom uso deles. Em seguida, vem a parte essencial: alvos. Aquelas palavras que são seguidas por um cólon são chamadas de alvos, e alguém as usa como fazer [-f nome makefile] Target_name. Se você já instalou a partir da fonte, provavelmente digitou 'Faça instalar'. Bem, 'instalar' é um dos alvos no Makefile, e outros alvos comumente usados ​​incluem 'limpo', 'deinstall' ou 'all'. Outra coisa mais importante é que o primeiro alvo é sempre executado por padrão se nenhum alvo for especificado. No nosso caso, se eu digitar 'fazer', isso teria sido o equivalente a 'fazer o yest', como você pode ver, o que significa compilação condicional (se estivermos no Solaris/Sunos, precisamos de uma bandeira extra do GCC) e a criação de um executável chamado 'Yet'. Alvos como 'All' em nosso exemplo não estão fazendo nada sozinhos, apenas diga que eles dependem de outros arquivos/metas para estar atualizado. Assista à sintaxe, ou seja, coisas como espaços e guias, como make é bastante pretensioso sobre coisas assim.

Aqui está um curto makefile para um projeto que possui dois arquivos de origem. Os nomes de arquivos são src1.C e SRC2.C e o nome do executável precisa ser executivo. Simples, certo?

EXEC: SRC1.O SRC2.o gcc -o exec src1.O SRC2.o src1.O: SRC1.c gcc -c src1.c src2.O: SRC2.c gcc -c src2.c

O único alvo praticamente usado, que também é o padrão, é 'Exec'. Isto depende no SRC1.O e SRC2.o, que, por sua vez, depende dos respectivos .C arquivos. Então, se você modificar, digamos, src2.C, tudo o que você precisa fazer é executar novamente, o que notará que SRC2.C é mais novo que o resto e prossiga de acordo. Há muito mais a fazer do que coberto aqui, mas não há mais espaço. Como sempre, algum auto-estudo é incentivado, mas se você precisar apenas da funcionalidade básica, o acima servirá bem.

O script de configuração

Normalmente, não é apenas 'make &&ak install', porque antes que os dois existam uma etapa que gera o makefile, especialmente útil ao lidar com projetos maiores. Basicamente, referidos script verifica que você tem os componentes necessários para a compilação instalada, mas também leva vários argumentos que ajudam a alterar o destino dos arquivos instalados e várias outras opções (e.g. Suporte qt4 ou gtk3, suporte a arquivos PDF ou CBR, e assim por diante). Vamos ver em um breve olhar o que são esses scripts de configuração.

Você geralmente não escreve o script de configuração manualmente. Você usa o AutoConf e o Autorake para isso. Como os nomes sugerem, o que eles fazem é gerar configurar scripts e makefiles, respectivamente. Por exemplo, em nosso exemplo anterior com o programa mais aprofundado, realmente poderíamos usar um script de configuração que detecta o ambiente do sistema operacional e alterações, algumas fazem variáveis, e depois de tudo isso gera um Makefile. Vimos que as verificações mais feitas do seu ano se estivermos correndo no Sunos, e se formos, adiciona uma bandeira do compilador. Eu expandiria isso para verificar se estamos trabalhando em um sistema BSD e, em caso afirmativo, invocar GMake (GNU make) em vez do nativo, que é, como dissemos, incompatível com o GNU Makefiles. Ambas as coisas são feitas usando o AutoConf: escrevemos um pequeno configure.em Arquivo no qual dizemos ao AutoConf o que precisamos verificar, e geralmente você deve verificar mais do que a plataforma. Talvez o usuário não tenha o compilador instalado, sem fazer, sem bibliotecas de desenvolvimento que são importantes com tempo de compilação e assim por diante. Por exemplo, uma linha que verificaria a existência do tempo.h No sistema, os locais do cabeçalho padrão seriam assim:

 Ac_check_headers (tempo.h)

Recomendamos que você comece com um aplicativo não muito big, verifique o conteúdo da Tarball de origem e leia a configuração.em e/ou configurar.arquivos CA. Para tarballs que os têm, makefile.AM também é uma boa maneira de ver como um arquivo de automóvel se parece. Existem alguns bons livros sobre o assunto, e um deles é o “Gerente de projetos de Robert Mecklenburg com GNU Make”.

Dicas do GCC e sinalizadores de linha de comando usuais

Eu sei que o manual do GCC é grande e eu sei que muitos de vocês nem sequer leram. Eu tenho orgulho de ler tudo (tudo o que se refere ao hardware da IA ​​de qualquer maneira) e devo confessar que tive uma dor de cabeça depois. Então, novamente, há algumas opções que você deve saber, mesmo que você aprenda mais à medida que avança.

Você já encontrou a bandeira -o, que diz ao GCC o que o arquivo resultante e -C, que diz ao GCC para não executar o vinculador, produzindo assim o que o assembler toca, a saber, arquivos de objeto. Falando nisso, existem opções que controlam os estágios em que o GCC deve parar de execução. Então, para parar antes da fase de montagem, após a compilação em si, use -s. Na mesma linha, -e deve ser usado se você quiser parar o GCC logo após o pré -processamento.

É uma boa prática seguir um padrão, se não for para uniformidade, mas para bons hábitos de programação. Se você estiver no período formativo como desenvolvedor C, escolha um padrão (veja abaixo) e siga -o. O idioma C foi padronizado primeiro depois que Kernighan e Ritchie (RIP) publicaram “The C Programming Language” em 1978. Era um padrão não formal, mas em breve foi apelidado de K&R e respeitado. Mas agora é obsoleto e não recomendado. Mais tarde, nos anos 80 e 90, Ansi e ISO desenvolveram um padrão oficial, C89, seguido por C99 e C11. O GCC também suporta outros padrões, como GNUxx, onde xx pode ser 89 ou 99, como exemplos. Verifique o manual para obter detalhes, e a opção é '-std =', “aplicada” por '-Pedantic'.

As opções relacionadas a avisos começam com "-w", como '-wall' (diz ao GCC para permitir todos os erros, embora não estejam todos muito habilitados) ou '-werror' (trate os avisos como erros, sempre recomendados). Você pode passar argumentos suplementares para os programas que ajudam com as etapas intermediárias, como pré -processador, assembler ou ligante. Por exemplo, veja como passar uma opção para o vinculador:

 $ gcc [outras opções…] -wl,opção [Mais um conjunto de opções ...]

Da mesma forma e intuitivamente, você pode usar 'wa' para o assembler e 'wp' para o pré -processador. Tome nota da vírgula e do espaço branco que diz ao compilador que a parte pré -processadora/assembler/ligante terminou. Outras famílias úteis de opções incluem '-g' e amigos para depuração, '-o' e amigos para otimização ou '-idiretório' - sem espaço em branco - para adicionar um local contendo cabeçalho.

Conclusão

Eu recomendo que você reserve um tempo para ler este artigo, brincar com os exemplos e depois escrever o seu, aumentando a complexidade à medida que avança.

Aqui está o que você pode esperar a seguir:

• EU. C Desenvolvimento no Linux - Introdução
• Ii. Comparação entre C e outras linguagens de programação
• Iii. Tipos, operadores, variáveis
• 4. Controle de fluxo
• V. Funções
• Vi. Ponteiros e matrizes
• Vii. Estruturas
• Viii. E/S básico
• Ix. Estilo de codificação e recomendações
• X. Construindo um programa
• XI. Embalagem para Debian e Fedora
• Xii. Obtendo um pacote nos repositórios oficiais do Debian

Tutoriais do Linux relacionados:

• Coisas para instalar no Ubuntu 20.04
• Uma introdução à automação, ferramentas e técnicas do Linux
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Instale Arch Linux na estação de trabalho VMware
• Tutorial de depuração do GDB para iniciantes
• Bash Regex avançado com exemplos
• Sistema Linux Hung? Como escapar para a linha de comando e…
• Manipulação de big data para diversão e lucro Parte 1
• Expressões regulares do Python com exemplos
• Bash Loops com exemplos