Olá e seja bem-vindo.
Neste vídeo, mostrarei a você como criar e executar o programa do vídeo anterior.
Se você se lembra, tínhamos um pequeno programa que basicamente pedia ao usuário para digitar seu número favorito
e depois imprimia esse número favorito.
Portanto, com base em vídeos anteriores, você deve entender que há muitas etapas para criar um programa que possa ser executado.
Você precisa compilar, vincular e, em seguida, criar o binário.
Portanto, até esse ponto, conseguimos compilar com sucesso.
Não vemos nenhum erro.
Agora, precisamos basicamente pegar todas as dependências externas para esse programa, escrever o arquivo de cabeçalho
padrão e quaisquer outras bibliotecas fornecidas pela linguagem de programação C.
Você pega tudo isso, que podem ser muitos arquivos O, e pega todo esse código externo para criar um único
executável.
Certo?
Portanto, aqui temos nosso código-fonte.
Você verá que o código-fonte está meio que agrupado.
Na verdade, você pode tornar esse código um pouco mais legível adicionando algumas novas linhas, algo como
isto.
Isso apenas o torna um pouco mais legível.
Agora, como mencionei, já o compilamos.
Só para refrescar sua memória, você pode compilar um arquivo de código-fonte de várias maneiras diferentes.
Você pode clicar com o botão direito do mouse no arquivo de origem e dizer compilar, ou pode selecionar o arquivo
de origem, ir até a compilação e dizer compilar o arquivo atual.
Se selecionarmos nosso projeto, você verá muitas opções diferentes relacionadas à construção.
Você vê construir, reconstruir, limpar, parar, construir.
Primeiro, vamos falar sobre limpeza.
O Clean basicamente eliminará todos os arquivos antigos que você tinha.
Portanto, lembre-se de antemão, nos vídeos anteriores, que um programa em C, quando é compilado, compila cada arquivo de origem,
e um programa pode consistir em muitos arquivos de origem.
Main dot C Há outros arquivos também?
Há programas que contêm milhares e milhares de arquivos de código-fonte em C.
Depois de compilar todos esses arquivos C, ele cria todos os arquivos antigos e, em seguida, você pega esses
arquivos antigos e os vincula para criar um único executável.
Agora, quando você seleciona o projeto, define o projeto e diz limpar, o que você está fazendo
é basicamente excluir todos os arquivos antigos, excluir quaisquer artefatos extras, excluir o
executável do programa e começar do zero.
Basicamente, você está obtendo um espaço de trabalho limpo que pode recompilar, reconstruir, revincular e recriar
o próprio programa.
Normalmente, você deve usar o clean se estiver encontrando erros e talvez queira apenas recompilar
todos os arquivos de origem, pois, normalmente, quando você executa um compilador C, se o código não for alterado e você tentar compilá-lo,
ele geralmente não o recompila.
Portanto, se você estiver enfrentando problemas, tiver muitos arquivos de origem, estiver vendo erros
que não fazem sentido.
Pode ser bom começar de um estado limpo, ir para o limpo, limpar tudo.
Você diz limpo e ele mostrará exatamente isso.
Basicamente, ele remove tudo de sua pasta de depuração de compilação.
Novamente, todos esses pontos são o executável que você está começando do zero.
É uma boa maneira de resolver qualquer tipo de dependência ou qualquer tipo de problema sem precisar recompilar todo
o projeto novamente e começar do zero.
Portanto, depois de executar o clean, não temos nada compilado ou construído, e podemos passar por ele e compilar arquivos
individuais dizendo compile e clicando em cada arquivo.
Se você tiver muitos arquivos de origem, essa não é uma boa maneira de chegar ao executável final.
Normalmente, o que acontece é que você deve se certificar de que tem o projeto do aplicativo
e, em geral, basta dizer construir, e isso percorrerá todo o código-fonte do projeto e construirá todos os arquivos.
Assim, quando você clicar em compilar, verá que ele vai pegar todos os códigos-fonte e reconstruir.
Da mesma forma, se você clicar com o botão direito do mouse e disser reconstruir, isso não reconstruirá todos os arquivos ou
reconstruirá apenas os arquivos que foram alterados.
Assim, você pode dizer construir, o que facilita um pouco mais do que compilar cada arquivo de origem.
Na verdade, a compilação compilará novamente todos os arquivos de origem, mas também os vinculará para que você possa ver
isso na saída, certo?
Se você for à janela de saída da compilação, verá que primeiro estamos emitindo um comando GCC dash C, que
é o sinalizador para compilação no ponto C principal. Em seguida, passamos parâmetros para otimização da arquitetura
64, alguns padrões de depuração C e 99 avisos para todos os avisos.
E, em seguida, usamos o traço o para vincular ao Main. arquivo cpp.
Basicamente, também vamos incluir alguns diretórios de inclusão.
E, na próxima etapa, emitimos o dash zero para fazer a vinculação a todas as dependências externas.
Nesse caso, não temos muitos, apenas temos basicamente links, estamos fazendo links estáticos com
o Dash L e estamos basicamente criando esse texto de lista de objetos.
O mais importante aqui é que ele está realmente criando um executável chamado nosso primeiro programa.
Veja.
Assim, o building executa as duas etapas de um programa em C, certo?
Ele o compila, vincula e cria o executável.
Portanto, isso torna as coisas mais fáceis com a compilação, em vez de compilar tudo no início.
Agora, talvez você queira compilar arquivos individuais apenas para ver o que está acontecendo, para ter certeza de que o código-fonte
está correto e que você não está pronto para a vinculação.
Você pode ter cinco arquivos aqui.
Você seleciona cada um deles e diz: "Ok, acabei de escrever um código, vamos compilá-lo,
verificar se está tudo certo e, em seguida, vou para o próximo arquivo, compilo-o e, por fim, você constrói tudo".
Agora que temos um executável de programa real criado, podemos executar nosso programa.
Portanto, certifique-se de que seu programa, seu projeto, esteja ativo e destacado e, em seguida,
vá até a compilação e simplesmente diga executar.
Agora, quando você selecionar executar, provavelmente verá uma janela pop-up que diz: "Deseja construir novamente e executar?
Agora você já construiu, portanto, não precisa fazer isso.
Você pode simplesmente dizer executar.
Você pode marcar a caixa de seleção para garantir que isso não seja sempre exibido.
E quando você foge, nem sempre se recupera.
Depende de você.
Isso consome algum tempo de processamento da CPU para reconstruir tudo, mas você provavelmente não está preocupado com isso.
Portanto, você sempre pode dizer construir e executar e não ter um pop-up ou pode apenas executar.
Agora, se selecionarmos executar, ele pegará o executável e o executará.
E o que você notará é que ele solicita que você insira seu número favorito, o usuário.
Assim, basta digitar o número 45, pressionar o botão Enter no teclado e ele exibirá
apenas o número 45.
Mais uma vez, um programa muito simples solicita entrada, exibe, gera saída e, em seguida, você pode pressionar qualquer tecla para
continuar e fechar a janela.
Agora, se voltarmos à visualização do espaço de trabalho, à janela do espaço de trabalho, ao painel do espaço de trabalho, como
quiser chamá-lo, você perceberá que temos três projetos, certo?
Nosso primeiro programa está em destaque.
Esse é o projeto ativo.
Os outros projetos ainda têm seus arquivos de origem, certo?
Ponto principal C, à direita.
E nossos outros projetos são praticamente padronizados.
Olá, código mundial.
Mas o que você não vê é que não vê nenhum dos arquivos de objeto, os arquivos de ponto
zero, não vê o arquivo executável, nada disso.
Agora você pode visualizá-las clicando na guia Explorer e pode especificar uma pasta para abrir.
Normalmente, essa deve ser a pasta raiz de onde você está criando todos os seus espaços de trabalho.
Então, normalmente, eu os coloco, acho que os coloco em documentos dentro de documentos.
Tenho meus espaços de trabalho.
Você verá que há muitas coisas aqui.
Portanto, normalmente, você deseja colocá-lo localmente, mas você verá que tem o espaço de trabalho um e o espaço de trabalho
dois, e verá que esse espaço de trabalho tem o arquivo dot code light.
Na verdade, provavelmente será melhor abrir os arquivos exatos do espaço de trabalho, certo?
Porque, na verdade, esse é o único interesse que nos interessa.
O espaço de trabalho dois é o que nos interessa.
Então, vamos selecionar a pasta, o espaço de trabalho dois e, em seguida, vamos fechar os documentos existentes para que possamos
ir em frente e dizer fechar.
Portanto, agora temos o espaço de trabalho dois e podemos ver todos os nossos executáveis para todos
os nossos projetos e todos os nossos arquivos.
Assim, você percebe que há uma pasta de luz de código ali.
Esse diretório de luz de código contém apenas algumas das preferências para o espaço de trabalho e assim por diante.
Temos nossa pasta de depuração de compilação.
Ele contém nosso diretório binário, que contém nosso executável, e você notará que também temos um diretório do primeiro programa do R, que
está dentro da depuração de compilação, porque esse espaço de trabalho, esse projeto foi compilado, e você verá que lá temos nossos
arquivos de objeto e quaisquer outras dependências que foram compiladas nessa
lista de objetos.
Na verdade, temos nosso primeiro projeto de programa, certo?
E isso diz respeito ao nosso arquivo de origem e a quaisquer outros arquivos make e assim por diante.
E você vê a mesma coisa para os outros projetos.
E, na parte inferior, você verá comandos de compilação, ponto JSON.
Geralmente é usado para conclusão de código.
Você vê um arquivo make e, em seguida, um arquivo de espaço de trabalho.
Mas a guia Explore nos ajuda a ver todo o layout do nosso espaço de trabalho, todos os nossos projetos, tudo o que foi criado, todos os arquivos
de configurações do projeto e todos os arquivos de origem do projeto, além de todas as dependências dos arquivos de autocompletar
código e assim por diante para o próprio espaço de trabalho.
E então falamos sobre limpeza, certo?
A limpeza pode realmente excluir tudo, todos os arquivos de objeto no executável.
Portanto, se voltarmos à visualização do espaço de trabalho e destacarmos nosso primeiro projeto de programa, quando clicarmos
com o botão direito do mouse e dissermos limpar, isso excluirá todos eles.
Portanto, agora, se você voltar à guia Explorer e acessar a depuração de compilação, verá tudo o que está
lá porque não foi atualizado.
Portanto, você pode atualizar essa exibição.
Então, vou clicar com o botão direito do mouse em nosso espaço de trabalho e vou dizer atualizar a pasta de depuração de compilação.
Então, isso geralmente é excluído, mas não há nada dentro dele, certo?
Você pode ter uma lixeira novamente.
Normalmente, isso é limpo.
Depende das permissões, mas você não tem nenhum arquivo antigo.
Você não tem seu executável depois de fazer uma limpeza.
Agora, novamente, se voltarmos ao espaço de trabalho, você poderá ver esse pequeno menu suspenso que informa o que construir,
se está construindo para depuração ou se está construindo para lançamento.
Quando você constrói para depuração, ele inclui informações de depuração no próprio executável do programa.
Isso geralmente acontece quando você está desenvolvendo seu código.
Você deseja informações de depuração e, caso precise executar o depurador, etc.
Nem sempre é bom fazer isso quando você libera algum programa para o campo ou para um cliente em modo de produção,
para que você possa alterar a versão para versão quando estiver construindo e quiser distribuir esse programa
em algum lugar.
Então, ao criá-lo, você notará que, se for para a guia explorar, verá novamente uma atualização.
Você verá uma pasta de versão de compilação e ela não terá as informações de depuração, portanto, você não precisará se preocupar
com isso.
Basicamente, se você tiver informações de depuração, poderá gerar um arquivo de núcleo e poderá ter
hackers que poderão obter informações sobre seu código-fonte.
Portanto, você só constrói a depuração para o modo de depuração quando está desenvolvendo e a altera para o modo de lançamento
quando talvez esteja lançando o programa para um cliente.
Novamente, isso depende se você está trabalhando em algum lugar ou se está trabalhando para um funcionário, se está
realmente entregando algum código em algum lugar.
Normalmente, você não modifica nada na guia Explorer.
Ele apenas lhe dá uma visão do que foi criado, dos seus executáveis e assim por diante.
Novamente, mencionei que você vê alguns arquivos auxiliares.
Você pode dar uma olhada em alguns desses aspectos.
Alguns desses itens serão gerados automaticamente.
Você pode ver um arquivo make aqui.
E esse é, na verdade, um arquivo make que pode ser gerado dependendo das configurações do seu projeto.
Esse é um arquivo make para todo o espaço de trabalho.
Você pode examinar programas específicos e ver alguns dos arquivos make que são gerados novamente, mas, normalmente, você
não quer mexer em nada disso.
Isso apenas fornece novamente um arquivo make para compilação.
Às vezes, quando há erros, você pode examinar o arquivo make para ver exatamente o que está acontecendo.
Talvez algo não tenha sido gerado corretamente.
Às vezes, códigos como esse apresentam alguns bugs, dependendo do sistema de fabricação que você usa.
Mais uma vez, geralmente usamos o sistema de criação de arquivos do UNIX se você estiver no Windows e, se estiver
no Linux ou no Mac OS, basta usar o padrão.
Então é basicamente isso, certo?
É possível fechar esses arquivos, mas você pode ver o que está acontecendo no Explorer e nas exibições do espaço de trabalho.
Agora, na exibição Workspace, novamente, se você selecionar um projeto, também poderá dizer stop, build.
Portanto, às vezes, a compilação e a construção do executável podem levar muito tempo.
Ou seja, se você tiver milhares de arquivos, poderá estar construindo por 30 minutos.
Portanto, stop, build permite que você pare de construir qualquer coisa, compilar e vincular qualquer coisa, qualquer
um dos projetos.
Mais uma vez, é útil para quando o processo de compilação é longo, mas normalmente não se vê isso em alguns dos códigos que
escreveremos para a nossa classe.
Outra coisa que pode ser interessante é que, se você destacar a visualização do espaço de trabalho, poderá criar todos
os projetos de uma só vez.
Você pode dizer construir o espaço de trabalho ou limpar o espaço de trabalho e excluir todas as dependências de todos os projetos.
Mas se você disser construir o espaço de trabalho, isso criará todos os projetos, independentemente de ele estar ativo,
e é isso que você vê na janela de saída.
Certo.
Estamos construindo o Projeto três, o Projeto dois e o nosso primeiro programa.
E assim, novamente, apenas um rápido resumo de como você pode realmente criar e executar seu código a partir do projeto ativo,
algumas das configurações e como você pode ver a guia Explorer.
Obrigado.