|
|
| Linha 1: |
Linha 1: |
| − | =Introdução a linguagem C =
| |
| | | | |
| − | ;OBJETIVOS
| |
| − |
| |
| − | :O aluno será capaz de:
| |
| − |
| |
| − | :* Descrever o processo de compilação;
| |
| − | :* Diferenciar código fonte, objeto e executável;
| |
| − | :* Compilar, executar pequenos programa em C usando o gcc/CodeBlocks;
| |
| − | :* Declarar e usar variáveis locais inteiras e reais; e
| |
| − | :* Usar as funções de entrada e saída: ''scanf()'' e ''printf()''.
| |
| − |
| |
| − |
| |
| − | ;METODOLOGIA
| |
| − |
| |
| − | :A aula será expositiva e dialogada, utilizando apresentação de texto base na Internet, onde serão mostrados exemplos testados programas no microcomputador do laboratório de informática.
| |
| − |
| |
| − |
| |
| − | ;INTRODUÇÃO
| |
| − |
| |
| − | :A linguagem C foi criada por Dennis Ritchie, em 1972, no centro de Pesquisas da Bell Laboratories. Sua primeira utilização importante foi a reescrita do Sistema Operacional UNIX, que até então era escrito em assembly. Em meados de 1970 o UNIX saiu do laboratório para ser liberado às universidades. Foi o suficiente para que o sucesso da linguagem atingisse proporções tais que, por volta de 1980, já existiam várias versões de compiladores C oferecidas por diversas empresas, não sendo mais restritas apenas ao ambiente UNIX, como também compatível a outros sistemas operacionais. O C é uma linguagem de propósito geral, sendo adequada à programação estruturada. No entanto é mais utilizada para escrever compiladores, analisadores léxicos, bancos de dados, editores de texto, e <b>sistemas embarcados</b>.
| |
| − |
| |
| − | :A linguagem C pertence a uma família de linguagens cujas características são: portabilidade, modularidade, compilação separada, recursos de baixo nível, geração de código eficiente, confiabilidade, regularidade, simplicidade e facilidade de uso.
| |
| − |
| |
| − | :Fonte: [ftp://ftp.unicamp.br/pub/apoio/treinamentos/linguagens/c.pdf] - Centro de Computação - UNICAMP
| |
| − |
| |
| − | :*[http://pt.wikipedia.org/wiki/C_%28linguagem_de_programa%C3%A7%C3%A3o%29#Hist.C3.B3ria Histórico Completo]
| |
| − | :*[http://pt.wikipedia.org/wiki/C_%28linguagem_de_programa%C3%A7%C3%A3o%29#Vis.C3.A3o_geral Características da Linguagem]
| |
| − | :*O C K&R (uma especificação informal da linguagem) e o [http://www.ansi.org/ ANSI] C
| |
| − | :*Linguagem [http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_imperativa imperativa] e [http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_procedural procedural].
| |
| − |
| |
| − |
| |
| − |
| |
| − | ==Algumas linguagens de programação==
| |
| − |
| |
| − | Na prática, é inviável desenvolver programas complexos em <b>LINGUAGEM DE MÁQUINA</b>. Em geral, utilizamos linguagens de <b>ALTO NÍVEL</b> que podem, de alguma forma, serem traduzidas (compiladas) para a linguagem de baixo nível ou interpretadas em tempo de execução.
| |
| − |
| |
| − | ;EXEMPLOS
| |
| − |
| |
| − | * Linguagem C
| |
| − | * Fortran
| |
| − | * Basic
| |
| − | * C++
| |
| − | * Pascal
| |
| − | * Java
| |
| − | * Python
| |
| − | * PHP
| |
| − |
| |
| − |
| |
| − | <blockquote style="background:#F0F8FF; border: 2px solid #0000CD; margin-left: 0px; margin-right: 0px; padding: 1em; width:500px">
| |
| − | <b>Por que utilizaremos a linguagem C?</b><br>
| |
| − | É uma linguagem muito usada na implementação de produtos <br>
| |
| − | eletrônicos, incluindo àqueles voltados às Engenharias. <br>
| |
| − | </blockquote>
| |
| − |
| |
| − | =Visão geral do processo de compilação com gcc =
| |
| − |
| |
| − |
| |
| − | * Linguagens compiladas (ex: C, Pascal) versus linguagens interpretadas (ex: PHP, Basic)
| |
| − |
| |
| − |
| |
| − | [[imagem:prog1_graduacao_fluxograma1.png|540px|center|border]]
| |
| − | <center>
| |
| − | Figura 1 - Processo de compilação de um programa em linguagem C.
| |
| − | </center>
| |
| − |
| |
| − |
| |
| − | <blockquote style="background:#F0F8FF; border: 2px solid #0000CD; margin-left: 0px; margin-right: 0px; padding: 1em; width:500px">
| |
| − | <b>Funcionamento:</b>
| |
| − | :Quando o <b>gcc</b> é chamado, ele normalmente realiza<br>
| |
| − | :quatro etapas para gerar o código executável:<br>
| |
| − | :pré-processamento, compilação, montagem e ligação.<br>
| |
| − | :Sempre nesta ordem.<br>
| |
| − | :Os primeiros três estágios são feitos com base no<br>
| |
| − | :arquivo fonte de entrada. No quarto estágio ele <br>
| |
| − | :produz um arquivo objeto.<br>
| |
| − |
| |
| − | </blockquote>
| |
| − |
| |
| − |
| |
| − | <!-- [[imagem:ProcessoCompilacao.jpg|700px|center]] -->
| |
| − |
| |
| − | == Compilando um programa C==
| |
| − |
| |
| − | Poderíamos usar o compilador da coleção [http://en.wikipedia.org/wiki/GNU_Compiler_Collection gcc] do [http://en.wikipedia.org/wiki/GNU_Project projeto GNU].<br>
| |
| − | O manual completo do gcc pode ser encontrado [http://gcc.gnu.org/ aqui].
| |
| − |
| |
| − | :Vamos utilizar o CodeBlocks para ser utilizado nos computadores com Windows.
| |
| − |
| |
| − | ::[https://www.ime.usp.br/~jose/codeblocks/codeblocksintro.html Introdução ao CodeBlocks]
| |
| − |
| |
| − | :Também pode ser utilizado um GCC on line:
| |
| − |
| |
| − | :: https://www.onlinegdb.com/
| |
| − |
| |
| − | O processo de desenvolvimento do programa, independente do SO, envolve:
| |
| − |
| |
| − | *Editar o programa com um editor de texto tal como o ''vi'' ou ''gedit''.
| |
| − | *Salvar o programa com a terminação ".c" (ou ".h" se for um cabeçalho).
| |
| − |
| |
| − |
| |
| − | <b>NOTA (linux)</b>: crie um diretório para trabalhar nos exercícios que se seguem:
| |
| − |
| |
| − | <pre>
| |
| − | $ mkdir Exercicios
| |
| − | $ cd Exercicios
| |
| − | </pre>
| |
| − |
| |
| − | ;EXEMPLO: Digite o código abaixo e salve em um arquivo com o nome "teste.c".
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | printf("Alo Mundo\n");
| |
| − | }
| |
| − |
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | <b>Compilar:</b> Gerar executável do programa usando o gcc:
| |
| − |
| |
| − | <pre>
| |
| − | $ gcc teste.c -o teste
| |
| − | </pre>
| |
| − |
| |
| − | <b>Testar o programa:</b>
| |
| − |
| |
| − | <pre>
| |
| − | $ ./teste
| |
| − | </pre>
| |
| − |
| |
| − | :Nota: o atributo <b>-o</b> permite que se forneça um nome para o executável diferente de <b>a.out</b>
| |
| − |
| |
| − | É possível somente compilar (gerar código objeto):
| |
| − |
| |
| − | <pre>
| |
| − | $ gcc -c teste.c
| |
| − | </pre>
| |
| − |
| |
| − |
| |
| − | Observe os subprodutos listando com detalhes:
| |
| − |
| |
| − | <pre>
| |
| − | $ ls -l
| |
| − | </pre>
| |
| − |
| |
| − | ==Estrutura do Programa em C==
| |
| − |
| |
| − |
| |
| − | Um programa em C pode ser visto como um conjunto de uma ou mais funções:
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | printf("Alo Mundo\n");
| |
| − | }
| |
| − |
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | No programa acima temos uma única função: a função ''main()''
| |
| − | Uma função é um pedaço de código delimitado por chaves e com um nome.<br>
| |
| − | Todo programa C bem comportado deve ter um função ''main''.<br>
| |
| − | A primeira instrução desta função é o ponto de entrada do código do usuário.<br>
| |
| − | A primeira instrução do programa acima é uma chamada a uma função da biblioteca: o ''printf()''.<br>
| |
| − | Esta função permite mostrar dados no terminal.<br>
| |
| − |
| |
| − | :Nota: Não é possível colocar instruções fora de funções!
| |
| − |
| |
| − | Vamos ver algumas variações do Alo Mundo:
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | printf("Alo Mundo 1\n");
| |
| − | printf("Alo Mundo 2\n");
| |
| − | printf("Alo Mundo 3\n");
| |
| − | printf("Alo Mundo 4\n");
| |
| − | printf("Alo Mundo 5\n");
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | e
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | printf("Alo Mundo 1");
| |
| − | printf("Alo Mundo 2\n");
| |
| − | printf("Alo Mundo 3\n\n");
| |
| − | printf("Alo Mundo 4\n");
| |
| − | printf("Alo Mundo 5\n");
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | ==Elementos definidos pela linguagem C==
| |
| − |
| |
| − | ;IDENTIFICADORES: Um identificador é um símbolo definido pelo usuário que pode ser um rótulo (label), uma constante, um tipo, uma variável, um nome de programa ou subprograma (procedimento ou função). Normalmente devem começar com um caractere alfabético e não podem conter espaços em branco, podendo ter no máximo 32 caracteres, não havendo distinção entre maiúsculas e minúsculas.
| |
| − |
| |
| − | :Pode-se utilizar:
| |
| − |
| |
| − | :*Letras (alfanuméricas) Aa até Zz;
| |
| − | :*Dígitos (numéricos) - 0 até 9;
| |
| − | :*Operadores ('+', '-', '/', '*', '%');
| |
| − | :*Tipos de dados (int, char, float).
| |
| − |
| |
| − | ;COMENTÁRIOS: Os comentários no programa fonte não têm função nenhuma para o compilador e serve apenas para aumentar a legibilidade e clareza do programa, podem ser inseridos com “//” que valem de onde começam até o fim da linha ou com “/*” e “*/”, sendo considerado comentário tudo entre “/*” e “*/”.
| |
| − |
| |
| − | ;ENDENTAÇÃO: A endentação também não tem nenhuma função para o compilador e serve para tornar a listagem do programa mais claro dando hierarquia e estrutura ao programa.
| |
| − |
| |
| − | ;CONSTANTES: Constantes são valores declarados no início do programa e que não se alteram na execução do programa. Podem ser expressas em qualquer base numérica.
| |
| − |
| |
| − | ;VARIÁVEIS: Uma declaração de variável consiste do nome do tipo de dado seguido do nome da variável. Todas as variáveis devem ser declaradas antes de serem usadas. As variáveis devem ser declaradas no início de cada função, procedimento ou início do programa.
| |
| − |
| |
| − |
| |
| − | Observe nestes exemplos a ordem de execução das instruções e o uso do caracter de nova linha.
| |
| − |
| |
| − | =Declarando variáveis inteiras e reais locais=
| |
| − |
| |
| − |
| |
| − | No "c" temos que declarar as variáveis que serão utilizadas no programa.<br>
| |
| − | Se estas variáveis forem declaradas DENTRO da função elas serão "vistas" somente localmente <br>
| |
| − | (escopo local). Este conceito será estendido para blocos de códigos posteriormente.<br>
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | /* aqui começam as declarações de variáveis */
| |
| − | int x; /* declaração de uma variável inteira */
| |
| − | float y; /* declaração de uma variável real */
| |
| − |
| |
| − | /* aqui começam as instruções do programa principal */
| |
| − | x=5; /* atribuindo o valor 5 (constante) a variável x */
| |
| − | y=6.5;
| |
| − | printf("Soma=%f",x+y);
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | No exemplo anterior criamos duas variáveis : ''x'' e ''y''. <br>
| |
| − | Lembrando que variáveis podem ser vistas como um lugar que pode armazenar um valor. <br>
| |
| − | Para simplificar ainda mais, podemos imaginar a variável como uma CAIXA onde podemos armazenar um valor.<br>
| |
| − | A CAIXA possui um nome e um tipo. O nome IDENTIFICA a CAIXA enquanto o tipo da variável determina a <br>
| |
| − | natureza dos valores que podemos armazenar na CAIXA:
| |
| − |
| |
| − | +-----+
| |
| − | <nowiki>|</nowiki> 5 | x
| |
| − | +-----+
| |
| − |
| |
| − | A variável ''x'' é do tipo ''int'' e, portanto, está apta a armazenar valores inteiros. <br>
| |
| − | Já a variável y é do tipo float e está apta a receber valores reais.
| |
| − |
| |
| − | +-----+
| |
| − | <nowiki>|</nowiki> 6.5 | y
| |
| − | +-----+
| |
| − |
| |
| − | Observe que as instruções de atribuição acima envolvem constantes também.
| |
| − |
| |
| − | ==Funções de entrada e saída de dados==
| |
| − |
| |
| − |
| |
| − | No 'C' não existe instrução especialmente para leitura ou saída de dados.<br>
| |
| − | Este procedimento é realizado através de funções da biblioteca.<br>
| |
| − | Na sequência são mostradas duas funções "clássicas" de entrada e saída <br>
| |
| − | de dados: o ''printf()'' - já apresentado - e o ''scanf()''. <br>
| |
| − | Esta última função permite entrada de dados.<br>
| |
| − |
| |
| − |
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − |
| |
| − | int x; /* declaração de uma variável inteira */
| |
| − | float y; /* declaração de uma variável real */
| |
| − |
| |
| − | printf ("Entre com o valor de x ");
| |
| − | scanf("%d",&x);
| |
| − |
| |
| − | printf ("Entre com o valor de y ");
| |
| − | scanf("%f",&y);
| |
| − |
| |
| − | printf ("O valor de x é %d\n",x);
| |
| − | printf ("O valor de y é %f\n",y);
| |
| − | }
| |
| − |
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | ;A função <b>printf()</b> tem a seguinte forma geral
| |
| − |
| |
| − |
| |
| − | ::<i>printf(string_de controle,lista_de_argumentos)</i>;
| |
| − |
| |
| − |
| |
| − | {| class="wikitable" style="background-color:#ffffff; text-align: center;"
| |
| − | ! style="background:#0000CD; color:white;" | Código
| |
| − | ! style="background:#0000CD; color:white;" | Significado
| |
| − | |-
| |
| − | ! style="text-align: center;" | %d
| |
| − | |Interio
| |
| − | |-
| |
| − | ! style="text-align: center;" | %f
| |
| − | |Float
| |
| − | |-
| |
| − | ! style="text-align: center;" | %c
| |
| − | |Caractere
| |
| − | |-
| |
| − | ! style="text-align: center;" | %%
| |
| − | |Coloca um % na tela
| |
| − |
| |
| − | |}
| |
| − |
| |
| − |
| |
| − | ;A função <b>scanf()</b> tem a seguinte forma geral
| |
| − |
| |
| − |
| |
| − | ::<i>scanf(string_de controle,lista_de_argumentos)</i>;
| |
| − |
| |
| − |
| |
| − | Uma variação do uso do ''printf'' neste exemplo é:
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − |
| |
| − | int x; /* declaração de uma variável inteira */
| |
| − | float y; /* declaração de uma variável real */
| |
| − |
| |
| − | printf ("Entre com o valor de x ");
| |
| − | scanf("%d",&x);
| |
| − |
| |
| − | printf ("Entre com o valor de y ");
| |
| − | scanf("%f",&y);
| |
| − |
| |
| − | printf ("O valor de x é %d e o valor de y é %f\n",x, y);
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | ==Construindo expressões no C==
| |
| − |
| |
| − |
| |
| − | ;Operador de Atribuição
| |
| − |
| |
| − | O operador de atribuição ''='' é utilizado para atribuir valores para variáveis.<br>
| |
| − | Veja o exemplo abaixo. Dois números do tipo float são lidos para as variáveis ''x'' e ''y'' e <br>
| |
| − | a média é calculada e colocada na variável média.
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | float x,y;
| |
| − | float media;
| |
| − |
| |
| − | printf("Entre com x\n");
| |
| − | scanf("%f", &x);
| |
| − | printf("Entre com y\n");
| |
| − | scanf("%f", &y);
| |
| − | media = (x+y)/2;
| |
| − | printf("Valor de media = %f\n",media);
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | Um diferencial do C com relação a outras linguagens é que a atribuição pode ser realizada várias vezes dentro de uma mesma instrução. <br>
| |
| − | Veja o exemplo:
| |
| − |
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | int x,y,w;
| |
| − |
| |
| − | x=1;
| |
| − | w=y=x+1;
| |
| − | printf("x=%d y=%d w=%d\n", x,y,w);
| |
| − |
| |
| − | w=2*y=x+1;
| |
| − | printf("x=%d y=%d w=%d\n", x,y,w);
| |
| − |
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | NOTE que o código:
| |
| − | w=2*y=x+1;
| |
| − | produz um erro de compilação:
| |
| − | erro: ''lvalue required as left operand of assignment''
| |
| − |
| |
| − | Ver conceito de lvalue e rvalue [http://en.wikipedia.org/wiki/Value_%28computer_science%29 aqui].
| |
| − |
| |
| − | O problema é que A ESQUERDA do sinal de atribuição sempre deve existir uma referência a uma área de memória (normalmente uma variável).<br>
| |
| − | A semântica da atribuição é copiar o valor computado a direita PARA a área referenciada a esquerda.<br>
| |
| − |
| |
| − | ;Operadores aritméticos
| |
| − |
| |
| − | Os operadores aritméticos básicos são àqueles apresentados na aula anterior.
| |
| − |
| |
| − | {| class="wikitable" style="background-color:#ffffff; text-align: center;"
| |
| − | ! style="background:#0000CD; color:white;" | Operador
| |
| − | ! style="background:#0000CD; color:white;" | Significado
| |
| − | |-
| |
| − | ! style="text-align: center;" | +
| |
| − | |adição
| |
| − | |-
| |
| − | ! style="text-align: center;" | -
| |
| − | |subtração
| |
| − | |-
| |
| − | ! style="text-align: center;" | *
| |
| − | |multiplicação
| |
| − | |-
| |
| − | ! style="text-align: center;" | /
| |
| − | |divisão
| |
| − | |-
| |
| − | ! style="text-align: center;" | %
| |
| − | |módulo
| |
| − | |-
| |
| − | ! style="text-align: center;" | ++
| |
| − | |incremento
| |
| − | |-
| |
| − | ! style="text-align: center;" | --
| |
| − | |decremento
| |
| − |
| |
| − | |}
| |
| − |
| |
| − | =Usando o gdb para depurar programas=
| |
| − |
| |
| − |
| |
| − | ;O que é o depurador?
| |
| − | :Em geral, o depurador (''debugger'') é um utilitário que executa o programa de destino em um ambiente controlado, onde você pode controlar a execução do programa e ver o estado do programa quando o programa é pausado. O GDB é esse depurador, que é usado para depurar programas C / C ++.
| |
| − |
| |
| − | Vamos trazer um exemplo de uso do depurador no Linux e no GDB online. Também é possível utilizá-lo no Codebloks e em outros compiladores.
| |
| − |
| |
| − |
| |
| − | ==Linux==
| |
| − |
| |
| − | A GNU desenvolveu o ''debugger gdb'' que é hoje amplamente utilizado por desenvolvedores.
| |
| − |
| |
| − | [http://www.gnu.org/software/gdb/documentation/ Documentação do GDB]
| |
| − |
| |
| − | Seja o programa armazenado no arquivo teste.c:<syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | int x,y;
| |
| − |
| |
| − | x = 2;
| |
| − | y = 0;
| |
| − | while (y<5)
| |
| − | x++;
| |
| − | printf ("Valor de x = %d\n",x);
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − |
| |
| − | Para que um programa possa ser depurado, devemos compilá-lo da forma:
| |
| − |
| |
| − | $ gcc -g teste.c -o teste
| |
| − |
| |
| − |
| |
| − | O flag <b>-g</b> garante que seja incorporada informação simbólica e textual para a depuração.
| |
| − |
| |
| − | O gdb pode então ser chamado da forma:
| |
| − |
| |
| − | $ gdb teste
| |
| − |
| |
| − | Um breakpoint pode ser colocado em qualquer linha ou entrada de função do programa. Para colocar
| |
| − | um breakpoint na entrada da função pode-se fazer:
| |
| − |
| |
| − | (gdb) b main
| |
| − |
| |
| − | Para executar o programa basta fazer o comando run:
| |
| − |
| |
| − | (gdb) r
| |
| − |
| |
| − | A execução para no ''breakpoint''. A instrução mostrada ainda vai ser executada.
| |
| − |
| |
| − | Para acompanhar o valor de variáveis pode-se colocá-las em display:
| |
| − |
| |
| − | (gdb) display x
| |
| − | (gdb) display y
| |
| − |
| |
| − |
| |
| − | Para execução passo a passo pode-se utilizar o comando next:
| |
| − |
| |
| − | (gdb) n
| |
| − |
| |
| − |
| |
| − | Para ver o conteúdo de uma variável pode-se ainda fazer o comando print:
| |
| − |
| |
| − | (gdb) print x
| |
| − |
| |
| − | Podemos setar também o valor das variáveis com o comando <b>set variable</b> da seguinte maneira:
| |
| − |
| |
| − | (gdb) set variable y=10
| |
| − |
| |
| − | Para sair do gdb:
| |
| − |
| |
| − | (gdb) q
| |
| − |
| |
| − | Confirme com ''Yes''.
| |
| − |
| |
| − | ==GDB online==
| |
| − |
| |
| − | Para você é que novo no mundo da programação explicaremos resumidamente o uso do depurador (''debugger''') do GDB online, sendo que esta ferramenta fornece uma interface para usar GDB em ambiente de nuvem de seu navegador.
| |
| − |
| |
| − | ;Como posso controlar a execução do programa?
| |
| − | :Podemos dizer ao depurador quando pausar um programa definindo pontos de interrupção. Para definir um ponto de interrupção, clique na área em branco vista no lado esquerdo do número da linha no editor. Quando você clica nela, ela deve exibir um círculo vermelho; o que significa que o ponto de interrupção foi definido nesse número de linha. A Figura 2 mostra de como fica definido os break.
| |
| − |
| |
| − | [[imagem:Fig010_PR1022804.png|center]]
| |
| − | <center>
| |
| − | Figura 2 - Uso do ''breakpoint''.
| |
| − | </center>
| |
| − |
| |
| − | Você deve clicar na frente do número da linha para criar um ''breakpoint''. Perceba que na frente da linha 10 apareceu uma "bolinha vermelha". Depois de definir o ponto de interrupção, ao iniciar o programa no modo de depuração, ele pausará a execução quando o programa atingir a linha onde o ponto de interrupção foi definido.
| |
| − |
| |
| − | [[imagem:Fig011_PR1022804.png|center]]
| |
| − | <center>
| |
| − | Figura 3 - ''Breakpoint'' na linha 10 e programa pausado.
| |
| − | </center>
| |
| − |
| |
| − | ;Passo 1: Agora podemos usar os comandos passo a passo para executar o programa linha a linha. Ao invés de clicar no botão '''Run''' clique no botão '''Debug'''.
| |
| − |
| |
| − | [[imagem:Fig012_PR1022804.png|center]]
| |
| − | <center>
| |
| − | Figura 4 - Área do depurador na parte de baixo da tela do programa.
| |
| − | </center>
| |
| − |
| |
| − | ;Passo 2
| |
| − | # start – Executa o programa até o primeiro ponto de interrupção;
| |
| − | # continue – Retoma a execução do programa até que o próximo ponto de interrupção seja alcançado;
| |
| − | # step over – Executa o programa linha por linha, mas não entrar na chamada de função (se houver);
| |
| − | # step into – Executa o programa linha a linha entrando na função (se houver);
| |
| − | # step out – Retomar a execução do programa até que a função atual (se houver) seja concluída.
| |
| − |
| |
| − | ;O que posso ver quando o programa é pausado?
| |
| − | :Você pode ver a pilha de chamadas e os valores das variáveis locais da função atual. A pilha de chamadas mostra a cadeia de chamadas de função. Como pode ser visto na imagem abaixo, a função “principal” main().
| |
| − |
| |
| − | [[imagem:Fig013_PR1022804.png|center]]
| |
| − | <center>
| |
| − | Figura 5 - ''Call Stack - Local Variables - Display Expressions - Breakpoints and Watchpoints''.
| |
| − | </center>
| |
| − |
| |
| − | A janela de variáveis locais (''Local Variables'') mostra os valores das variáveis locais da função atual. Conforme mostrado na Figura 5, o valor de “x” é 2, “y” é 0.
| |
| − |
| |
| − | ;Passo 3
| |
| − |
| |
| − | Clicando uma vez em '''continue''' o valor de “x” passa para 3, “y” não é alterado e continua 0. E assim por diante.
| |
| − |
| |
| − | Agora temos controle e olho na execução do programa, para que possamos inspecionar o fluxo de execução do programa. Pontos de interrupção, comandos de revisão e exibições de variáveis são recursos básicos do depurador.
| |
| − |
| |
| − | ;Resumo:
| |
| − |
| |
| − | #colocar o ''breakpoint''
| |
| − | #clicar em ''Debug''
| |
| − | #clicar em ''Start''
| |
| − | #acompanhar o valor das variáveis
| |
| − | #clicar em ''continue'' (voltar para etapa anterior)
| |
| − | #clicar em ''stop''
| |
| − |
| |
| − | ;Lembrando: Que esse programa está em ''loop'' infinito.
| |
| − |
| |
| − | =Exercícios=
| |
| − |
| |
| − | ;Implementar um programa em C para:
| |
| − |
| |
| − | #Receber a resistência em ohms de 2 resistores e então calcular a resistência série e paralela dos mesmos.
| |
| − | #Ler dois números inteiros para dentro de duas variáveis alfa e beta. O programa deve trocar os conteúdos destas variáveis (o que estiver em alfa para beta e vice-versa).
| |
| − | #Converter graus Farenheit em Celsius.
| |
| − | #Ler dois números inteiros e imprimir o resto da média entre os dois.
| |
| − | #Calcular a área e comprimento de uma circunferência dado o raio.
| |
| − |
| |
| − | {{collapse top|bg=#E6E6FA| Resposta: 1}}
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | float R1,R2;
| |
| − | float Req;
| |
| − |
| |
| − | printf("\nDigite a valor de R1: ");
| |
| − | scanf("%f",&R1);
| |
| − | printf("\nDigite a valor de R2: ");
| |
| − | scanf("%f",&R2);
| |
| − | Req=(R1*R2)/(R1+R2);
| |
| − | printf("\nResistencia equivalente=%f",Req);
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − | {{collapse bottom}}
| |
| − |
| |
| − | {{collapse top|bg=#E6E6FA| Resposta: 4}}
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | int a,b,resto;
| |
| − |
| |
| − | printf("\nDigite a valor de a: ");
| |
| − | scanf("%d",&a);
| |
| − | printf("\nDigite a valor de b: ");
| |
| − | scanf("%d",&b);
| |
| − | resto=(a+b)%2;
| |
| − | printf("\nResto da media de dois numeros=%d\n",resto);
| |
| − | }
| |
| − | </syntaxhighlight>
| |
| − | {{collapse bottom}}
| |
| − |
| |
| − | {{collapse top|bg=#E6E6FA| Resposta: 5}}
| |
| − | <syntaxhighlight lang=c>
| |
| − | #include <stdio.h>
| |
| − |
| |
| − | void main()
| |
| − | {
| |
| − | float area,raio;
| |
| − | const float pi=3.1415;
| |
| − |
| |
| − | printf("Digite o valor do raio: ");
| |
| − | scanf("%f",&raio);
| |
| − |
| |
| − | area=pi*raio*raio;
| |
| − |
| |
| − | printf("O valor da área da circunferencia eh: %f",area);
| |
| − | }
| |
| − |
| |
| − |
| |
| − | </syntaxhighlight>
| |
| − | {{collapse bottom}}
| |
| − |
| |
| − | =Referências=
| |
| − |
| |
| − | [1] https://www.ime.usp.br/~jose/codeblocks/codeblocksintro.html
| |
| − |
| |
| − | [2] https://www.lucidchart.com/
| |
| − |
| |
| − | [3] https://programacaodescomplicada.files.wordpress.com/2013/04/debugger.pdf
| |
| | | | |
| | | | |
