Olá a todos.
Neste vídeo, configuraremos as luzes de código para que funcionem com o compilador que instalamos.
Portanto, obviamente, o pré-requisito para este vídeo é que o compilador esteja instalado e o code light esteja
instalado.
Muito bem, vamos começar.
Tenho um ícone aqui.
Atalho para a luz de código.
Vou clicar duas vezes nele para abrir a luz de código pela primeira vez e ela diz: Welcome to the setup wizard (Bem-vindo
ao assistente de configuração).
Vamos executar o assistente de configuração.
Você só precisa fazer isso uma vez.
Em seguida, selecionarei seu perfil de desenvolvimento, que será C, C plus plus development.
Selecionarei a próxima.
E agora podemos procurar um compilador.
Vamos fazer isso.
Ele provavelmente não encontrará o compilador que instalamos porque nem sempre encontra compiladores pré-instalados,
mas vamos tentar.
E, se ele encontrar, ótimo; se não encontrar, instalaremos manualmente.
Portanto, de qualquer forma, estamos cobertos.
Então, vou selecionar a verificação e ele diz que não foi possível localizá-la.
Não tem problema.
Você gostaria de instalar um agora?
Não, já o instalamos, portanto, selecionarei next.
Você pode ver que ele encontrou o compilador Rust.
Essa é uma linguagem de programação diferente e não há problema algum nisso.
Você pode simplesmente ignorar isso.
Selecionarei a próxima.
Escolha o esquema de cores que você deseja.
Vou usar esse esquema padrão.
Normalmente, eu usaria o esquema escuro porque é mais agradável aos olhos, mas vou usar
este porque acho que fica melhor no vídeo.
Selecionarei a próxima.
Essa caixa de diálogo está lhe perguntando sobre espaços em branco, recuos e assim por diante.
Basta deixar os padrões como estão e clicar em concluir. A luz de código será fechada e, em seguida, será aberta novamente.
Portanto, a primeira coisa que temos de fazer é instalar manualmente o compilador na linha de código,
já que ele não encontrou o compilador na configuração.
É muito fácil clicar em configurações e depois em configurações de construção.
Em seguida, clicamos nesse símbolo azul de mais.
Pode estar verde na sua tela.
Isso depende do fato de você ter o tema claro ou o tema escuro.
Portanto, queremos clicar nesse ponto.
Lembre-se de que estamos na guia de compiladores.
Quero clicar nessa opção, e ela diz Adicionar um compilador existente.
Então, vou fazer isso.
Portanto, depois de pressionar o sinal de mais, você verá esta caixa de diálogo.
Queremos navegar até o caminho onde instalamos o compilador Cygwin C.
Então, eu o instalei na unidade C.
Portanto, vá até a unidade C, selecione-a e, em seguida, acesse o Cygwin 64 ou onde quer que você o tenha instalado.
Por padrão, ele está em C Cygwin 64 e, dentro do Cygwin 64, você tem o diretório bin.
A partir daí, basta selecionar a pasta e, aqui, você pode nomeá-la. Vamos chamá-la de Cygwin
Just para que saibamos qual é a pasta.
E nós dizemos, ok.
Nesse ponto, se você selecionar a guia Ferramentas ou se ela já estiver selecionada, verá todas as
configurações de compilação preenchidas para você.
Algumas delas não estão corretas, portanto, você precisa corrigi-las.
O compilador C plus plus com o qual você não se importa, não precisa se preocupar.
Ainda não instalamos isso.
Mas, para o compilador C, o ideal é usar o GCC.
Portanto, se você selecionar o compilador C e, em seguida, o ponto, ponto, ponto, poderá navegar novamente
até o diretório bin e selecionar GCC dot exe.
Então, você vai até lá e usa o GCC dot exe, que executará o compilador GCC para o nome do assembly.
Você pode, novamente, usar o ponto, ponto ponto ou digitá-lo no programa
que deseja executar como ASX.
Para o nome do assembler, o vinculador que você deseja usar GCC.
Portanto, novamente, você pode editar manualmente ou clicar no ponto, ponto, ponto.
Você só quer ter certeza de que esse é o GCC dot exe para o vinculador de objeto compartilhado.
Novamente, usaremos o GCC.
Então, novamente, podemos usar o ponto ponto ponto ponto ou apenas dizer GCC ponto x traço compartilhado traço minúsculo
f escolha para o arquivador que vamos usar novamente RDX.
Com a RCU como um argumento de programa.
O make que vamos usar é o make X dentro do bin.
Portanto, isso deve estar correto.
Caso contrário, deve ser make dot x.
E para o gdb, queremos modificá-lo novamente para usar o gdb, de modo que possamos ir para o ponto ponto ponto ponto e ir para o gdb.
Dot XY e podemos usar isso.
E então você quer ter certeza de que essas configurações são realmente importantes.
Portanto, talvez você queira pausar o vídeo novamente para ter certeza de que tudo está correto.
O C mais o compilador não importa.
Compilador C GCC x nome do montador ASX Xqcs Xqcs Xqcs compartilhado para o objeto compartilhado no arquivo.
A. x.
Então, você pode ir em frente, clicar em aplicar e clicar em.
Está bem.
Tudo bem.
Então, no Codelab, deixe-me fazer isso aqui em tela cheia.
Na luz de código, temos várias janelas aqui, e falarei sobre isso com mais detalhes em vídeos futuros.
Temos uma visualização de espaço de trabalho e é nela que criamos espaços de trabalho, uma coleção de projetos para que possamos ter um
espaço de trabalho com o Projeto Um e o Projeto Dois e assim por diante.
E cada um desses projetos é um programa que vamos escrever aqui.
Podemos criar um novo espaço de trabalho, abrir um espaço de trabalho, e você também pode acessar muitas dessas
coisas nas guias.
Nessas interfaces de usuário modernas, geralmente há quatro ou cinco maneiras de fazer a mesma coisa.
Então, vamos criar um novo espaço de trabalho.
Vou selecionar new para garantir que você tenha um espaço de trabalho C plus plus.
É isso que estaremos fazendo.
Vou clicar em ok.
Agora, qual é o caminho para meu espaço de trabalho?
Vou colocá-lo diretamente na minha pasta de usuário, bem aqui.
E o que eu quero fazer é criar uma nova pasta na qual eu possa criar todos os meus espaços de trabalho.
Então, vamos fazer isso.
Vou entrar aqui e, bem na minha pasta inicial, vou criar uma nova pasta e vou chamá-la de espaços
de trabalho ou meus espaços de trabalho ou o que você preferir.
O que é realmente importante aqui é que não haja espaços, caracteres especiais, ands e pontos e todos os tipos de caracteres
estranhos.
Dê a ele um nome bem simples, como espaços de trabalho.
E isso será bom.
É isso aí.
Então, eu tenho a pasta.
Eu vou escolher.
E qual é o nome do meu espaço de trabalho?
Bem, esse espaço de trabalho será, digamos, o espaço de trabalho um ou a Seção um ou como quisermos chamá-lo.
Vou chamá-lo de Espaço de trabalho um.
E você pode ver aqui embaixo onde o espaço de trabalho será criado e ele criará um arquivo de espaço de trabalho,
certifique-se de que essa pequena verificação esteja marcada, crie o espaço de trabalho em um diretório separado.
Dessa forma, temos diretórios separados para todos os nossos espaços de trabalho e isso nos mantém bem organizados.
Eu selecionarei.
Está bem.
E você pode ver que essa janela desapareceu.
É uma grande área branca aqui e ali está nosso espaço de trabalho, nosso primeiro espaço de trabalho.
Agora não podemos fazer muito com um espaço de trabalho.
Precisamos de um projeto dentro do espaço de trabalho para que eu possa selecionar meu espaço de trabalho e criar um novo projeto de arquivo.
Ou eu poderia clicar com o botão direito do mouse no espaço de trabalho e dizer novo projeto, e é isso que farei.
Tudo bem.
Provavelmente, a parte mais importante deste vídeo é a configuração do projeto.
Então, qual é o nome do meu novo projeto?
Vou chamá-lo de Projeto um.
Certifique-se de criar o projeto em sua própria pasta.
E agora vamos preencher esses menus suspensos aqui.
Qual é a categoria?
Que tipo de aplicativo estamos criando?
Será um aplicativo de console.
Esse é um aplicativo não gráfico que é executado no prompt de comando.
O próximo item a ser selecionado é o tipo.
E o tipo será basicamente um GCC executável simples.
Esse é um programa em C, portanto, um simples GCC executável.
O compilador que vamos usar, acabamos de criar o compilador que vamos usar e esperamos
que você o tenha nomeado Cygwin.
Portanto, você pode simplesmente selecionar o Cygwin.
Se você deixasse como padrão, teria que selecionar esse nome.
O depurador que usaremos é um novo depurador GDB, e o sistema de compilação
que usaremos é o Makefile generator Unix do Code Light.
Portanto, mais uma vez, essas são configurações muito importantes.
Então, novamente, dê uma olhada nessas patas se precisar, mas as categorias devem ser do
tipo console, executável simples, compilador GCC, depurador cygwin, depurador GDB e o sistema de compilação
deve ser code light, gerador makefile unix.
Então, vamos em frente e acertamos.
Está bem.
Portanto, o que você deve notar é que, dentro da pasta do projeto um, agora há um arquivo de código-fonte
criado chamado Main dot C dot C é a extensão das linguagens de programação C.
Assim, ele foi criado automaticamente para você e você pode clicar duas vezes nele e verá que
o editor aparece com uma pequena guia project one main dot C e você verá que este é um código C.
O código C não é importante neste momento.
Estamos apenas configurando nosso ambiente.
Estamos tentando nos certificar de que podemos construir, compilar e tudo o mais.
Se você tentar editar esse arquivo, perceberá que, ao escrever no código, há um pequeno
círculo vermelho ali em cima, o que significa que o arquivo não foi salvo.
Você sempre deve se certificar de que ele foi salvo antes de compilar e construir, de modo que possa pressionar Ctrl s para salvá-lo
e verá que o vermelho desaparecerá.
Certo?
Ou, se quiser salvá-lo também, você pode ir até Arquivo e dizer Salvar arquivo.
Portanto, esse ponto vermelho informa se o código-fonte foi salvo ou não.
Novamente, esse é o código C.
Você não precisa se preocupar com isso.
Vamos tentar criar e compilar.
Portanto, você tem o ponto C principal e perceberá que pode alterar as configurações do compilador real e coisas
do gênero selecionando a chave inglesa aqui em cima.
Portanto, se você selecionar a chave inglesa aqui em cima.
Aqui você verá todas as configurações do projeto e alguns itens serão preenchidos automaticamente para você.
Para que você possa generalizar, verá algumas das coisas que definimos automaticamente quando instalamos
o compilador do Cygwin.
Portanto, você vê que o gerador de Makefile é um código leve, gerador de Makefile, compilador UNIX, Cygwin e assim
por diante.
Na verdade, a maioria delas pode ser marcada como padrão e, talvez, analisaremos muitas dessas configurações
em um vídeo posterior, mas, em geral, você deve ver basicamente o que foi feito antes das configurações do
compilador.
Se você selecionar o compilador à esquerda, perceberá que há alguns argumentos de linha de comando
que podem ser passados.
Não precisamos nos preocupar com o C plus plus, mas para as opções do compilador C, se você selecionar
o ponto, ponto, ponto, provavelmente será uma boa ideia selecionar de fato.
Os recursos do C 99.
Portanto, você pode usar como Boolean e coisas do gênero.
Voltaremos a falar sobre isso mais tarde.
Portanto, se você disser ativar os recursos do C 99, isso passará um argumento padrão do C 99.
E se houver mais alguma coisa, acho que não precisamos de mais nada.
As opções do compilador.
Isso é muito bom para que você possa bater.
Está bem.
E então você notará que ele acabou de ser aprovado no STD igual a C 99.
Todo o resto também pode permanecer o mesmo se você for para o vinculador.
Com relação às opções do vinculador, talvez você queira ir novamente ao ponto, ponto, ponto das opções do vinculador e selecionar
apenas vinculação estática.
Dessa forma, não teremos problemas de biblioteca mais tarde com a marca de vinculação que verifica a estática, vincula a estática
e bate novamente.
Está bem.
Portanto, abordaremos isso com mais detalhes posteriormente.
Mas tudo deve estar configurado agora para que possamos realmente tentar compilar e executar nosso código.
Então, vamos em frente e clicar em aplicar e.
Está bem.
E agora vemos nosso código-fonte.
Portanto, agora podemos tentar criar ou compilar nosso código.
Portanto, se formos até a compilação e dissermos construir o projeto, você verá que o código está sendo compilado
e não haverá erros.
Porque esse é apenas um modelo de código C.
Agora, se você adicionar alguma sintaxe ou algo assim, salvar o arquivo e tentar criá-lo novamente,
poderá ver um erro real.
E você também quer ter certeza de que seu código seja compilado seguindo tudo.
Portanto, podemos basicamente modificar o código-fonte.
Diga algo como Hello testing e, em seguida, vá em frente e crie o projeto.
Você sempre pode limpar e compilar e falaremos sobre essas opções mais tarde, mas vamos apenas
compilar o projeto e você verá que não há erros e que toda a nossa configuração foi definida corretamente.
Agora, se você tiver algum erro, ele pode ser, e não é nenhum erro de sintaxe, algo errado com
a configuração.
Você terá que voltar e acessar as configurações, acessar as configurações de compilação e verificar
se todas as ferramentas e caminhos estão corretos.
Você deseja usar o GCS para garantir que o arquivo make seja make dot exe e que todo o diretório make
seja blink.
Primeiro, verifique todas essas configurações para ter certeza de que estão corretas e, depois,
se ainda tiver problemas, volte para a guia wrench e vá novamente para general.
Certifique-se de usar o code light, o gerador de arquivos make, o UNIX, você sabe, o cygwin.
Mais uma vez, tudo isso deve funcionar por padrão, mas você pode ir e talvez brincar com as coisas.
Se você continuar tendo erros, publique algo nas perguntas e respostas se não conseguir resolver o problema.
Mas, a essa altura, você deve estar construindo com sucesso.
Agora que compilei o programa com sucesso, posso executá-lo e ver qual é
o resultado.
Portanto, posso destacar o projeto bem aqui no Workspace Project run e posso ir até
a opção de menu em build e dizer run.
E quando eu fizer isso, o programa tentará ser executado.
Essa caixa será exibida por padrão.
Você pode selecionar a opção "lembrar" para que ele não me pergunte novamente.
Você não precisa criar uma execução novamente.
Você pode simplesmente executar porque, como já construímos, são duas etapas.
Ou você pode dizer construir e executar novamente.
De qualquer forma, não há problema, mas você não precisa compilar novamente se já o fez.
Portanto, vou dizer apenas executar.
E agora o que você verá é uma espécie de janela do DOS com a saída do programa, que diz
"Hello, testing" na parte superior.
É um pouco difícil de ler, mas diz "Olá, teste" e também contém informações adicionais.
Ele diz que o programa foi encerrado com código X zero.
Isso é bom porque significa que não houve problemas com a execução do código e que ele retornou zero.
Portanto, há um zero ali.
Ele também informa quanto tempo o programa realmente levou para ser executado e, em seguida, pressione qualquer tecla para continuar.
Agora, se executássemos esse programa a partir da linha de comando, não veríamos essa saída extra.
Veríamos apenas "hello testing", porque esse é o resultado do código-fonte.
Mas a luz do código de identificação vem com algumas informações extras que é bom ter, mas não precisamos realmente
dessas informações, então podemos ir em frente e pressionar qualquer tecla para continuar e essa caixa desaparecerá assim.
E é assim que podemos executar nosso programa.
E agora eles também estão, você notará que na parte inferior há várias guias e informações diferentes.
As duas guias mais importantes aqui são a guia de saída e a guia de compilação.
A guia de saída informa mais ou menos o que está acontecendo.
Ele diz que seu programa foi encerrado e assim por diante, e você está executando as coisas.
A guia de compilação é basicamente o que acontece quando você a compila.
Portanto, se sempre que você compilar, disser construir e disser construir o projeto, você perceberá que ele informa
como compilar.
Nesse caso específico, está faltando um ponto e vírgula.
Portanto, há um erro aí.
E ele informa que há um erro.
Portanto, em uma compilação bem-sucedida, digamos que adicionamos o ponto e vírgula, dizemos "seguro" e compilamos novamente.
O que você deve notar em uma compilação bem-sucedida é que você vê o comando exato que está sendo executado, que já definimos
em nossas configurações, certo?
Veja bem, GCC dot x dash C é para compilar.
Ele está compilando nosso arquivo de código-fonte, main dot C, e está usando os argumentos do programa que definimos
nas configurações do build G dwarf two standard C 99 dash wall.
Certo.
Tudo está se encaixando, todas essas configurações.
E ele também tem o GCC X, que está vinculando a opção dash o.
E então você vê o traço de ponto estático, que também adicionamos.
Portanto, tudo isso está se juntando por meio das configurações.
Como acabei de mostrar, se a compilação não for bem-sucedida e houver um erro.
Assim, por exemplo, como eu disse anteriormente, você não tem o ponto-e-vírgula, está faltando
agora, quando compilar, verá que há um erro.
Não há ponto e vírgula de fato.
Ele informa que o erro esperava um ponto e vírgula antes do retorno.
E isso acontece muito, certo?
Esses erros de sintaxe são o que você acaba vendo.
E, normalmente, se você tiver um problema para executar o programa, é isso que você pode postar na guia Perguntas
e Respostas da compilação.
E eu posso realmente ver o que está acontecendo para ajudá-lo.
Mas erros de sintaxe são comuns quando você escreve seu código C.
Portanto, para entender o compilador e os erros do compilador, vamos falar sobre isso em um vídeo
futuro.
Mas essa guia de compilação é importante para ver a saída e se a compilação foi bem-sucedida
ou se há erros.
Novamente, erros comuns, sem o ponto e vírgula.
Às vezes, os alunos esquecem que o D e o padrão são o mesmo.
Portanto, eles têm o ponto e vírgula.
Eu guardo e eles constroem, você sabe.
E você notará que a seta vermelha se move porque a seta vermelha indica onde está o erro.
Na verdade, o compilador lhe dirá.
Portanto, nesse caso, você digitou incorretamente IO padrão. H, que é um pacote C que você pode incluir, certo?
E se estiver faltando o ponto e vírgula, a seta vermelha estaria aqui, certo?
Mas, novamente, você salva a compilação e executa novamente, certo?
Assim, depois de corrigir esses erros, podemos criar o projeto novamente ou reconstruir os projetos é outra opção.
Bem, ele reconstrói tudo.
Ele o limpa e o reconstrói.
E então você pode ver os resultados.
Você pode ver que não há erros.
E, novamente, você pode executá-lo como antes, criar um executor e simplesmente executar.
Portanto, é assim que você pode compilar e executar seu programa e definir todas as suas configurações.
Agora, se você tiver qualquer problema, envie uma mensagem para as Perguntas e Respostas.
Muitas dessas perguntas já foram feitas e respondidas, portanto, você pode dar uma
olhada nelas, seja por erros de configuração no ambiente de compilação ou por erros de sintaxe no código
real.
Você sabe, há vários tipos de erros de sintaxe que podem ocorrer.
E aprenderemos isso ao longo do curso, como escrever código C adequado.
Mas a guia de compilação é importante, a guia de saída é importante.
Nas próximas aulas, veremos como você pode configurar um modelo para que não precise necessariamente
fazer todas essas configurações e assim por diante.
Ao criar projetos, você pode simplesmente criar o mesmo projeto várias vezes.
Talvez você não entenda o código aqui, mas esperamos que, ao final desta palestra, você consiga entender.
Coloque isso em funcionamento e execute um programa C simples.
Obrigado.