Apostila C
275 pág.

Apostila C


DisciplinaMétodos e Técnicas de Programação22 materiais161 seguidores
Pré-visualização45 páginas
pode ser facilmente depurado seguindo os passos
abaixo:
1. Primeiramente, vamos colocar dois pontos de parada ou breakpoints
no programa, nas linhas 13 e 23. Isso pode ser feito de duas manei-
ras: clicando do lado direito do nu´mero da linha, ou colocando-se o
cursor do mouse na linha que se deseja adicionar o breakpoint e
selecionar a opc¸a\u2dco Toggle breakpoint (F5). Um breakpoint e´ iden-
tificado por uma bolinha vermelha na linha;
14
2. Iniciamos o debugger com a opc¸a\u2dco Start (F8). Isso fara´ com que o
programa seja executado normalmente ate´ encontrar um breakpoint.
No nosso exemplo, o usua´rio devera´ digitar, no console, o valor lido
pelo comando scanf() e depois retornar para a tela do Code::Blocks
onde o programa se encontra pausado. Note que existe um tria\u2c6ngulo
amarelo dentro do primeiro breakpoint. Esse tria\u2c6ngulo indica em
que parte do programa a pausa esta´;
3. Dentro da opc¸a\u2dco Debugging windows, podemos habilitar a opc¸a\u2dco
Watches. Essa opc¸a\u2dco ira´ abrir uma pequena janela que permite ver
o valor atual das varia´veis de um programa, assim como o valor pas-
15
sado para func¸o\u2dces. Outra maneira de acessar a janela Watches e´
mudar a perspectiva do software para a opc¸a\u2dco Debugging, no menu
View, Perspectives;
4. A partir de um determinado ponto de pausa do programa, podemos
nos mover para a pro´xima linha do programa com a opc¸a\u2dco Next line
(F7). Essa opc¸a\u2dco faz com que o programa seja executado passo-a-
passo, sempre avanc¸ando para a linha seguinte do escopo onde nos
encontramos;
5. Frequentemente, pode haver uma chamada a uma func¸a\u2dco constru\u131´da
pelo programador em nosso co´digo, como e´ o caso da func¸a\u2dco fato-
rial(). A opc¸a\u2dco Next line (F7) chama a func¸a\u2dco, mas na\u2dco permite que
a estudemos passo-a-passo. Para entrar dentro do co´digo de uma
func¸a\u2dco utilizamos a opc¸a\u2dco Step into (Shift+F7) na linha da chamada
da func¸a\u2dco. Nesse caso, o tria\u2c6ngulo amarelo que marca onde estamos
no co´digo vai para a primeira linha do co´digo da func¸a\u2dco (linha 4);
16
6. Uma vez dentro de uma func¸a\u2dco, podemos percorre\u2c6-la passo-a-passo
com a opc¸a\u2dco Next line (F7). Terminada a func¸a\u2dco, o debugger vai
para a linha seguinte ao ponto do co´digo que chamou a func¸a\u2dco (linha
16). Caso queiramos ignorar o resto da func¸a\u2dco e voltar para onde
estavamos no co´digo que chamou a func¸a\u2dco, basta clicar na opc¸a\u2dco
Step out (Shift+Ctrl+F7);
7. Para avanc¸ar todo o co´digo e ir direto para o pro´ximo breakpoint,
podemos usar a opc¸a\u2dco Continue (Ctrl+F7);
8. Por fim, para parar o debugger, basta clicar na opc¸a\u2dco Stop debug-
ger.
1.3 ESQUELETO DE UM PROGRAMA EM LINGUAGEM C
Todo programa escrito em linguagem C que vier a ser desenvolvido deve
possuir o seguinte esqueleto:
Primeiro programa em linguagem C
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) {
4 p r i n t f ( \u2018 \u2018 He l lo World \n \u2019 \u2019 ) ;
5 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
6 return 0;
7 }
17
A primeira vista este parece ser um programa fu´til, ja´ que sua u´nica fina-
lidade e´ mostrar na tela uma mensagem dizendo Hello World, fazer uma
pausa, e terminar o programa. Pore´m, ele permite aprender alguns dos
conceitos ba´sicos da lingaugem C, como mostra a figura abaixo:
Abaixo, e´ apresentada uma descric¸a\u2dco mais detalhada do esqueleto do pro-
grama:
\u2022 Temos, no in\u131´cio do programa, a regia\u2dco onde sa\u2dco feitas as declarac¸o\u2dces
globais do programa, ou seja, aquelas que sa\u2dco va´lidas para todo o
programa. No exemplo, o comando #include <nome da biblioteca>
e´ utilizado para declarar as bibliotecas que sera\u2dco utilizadas pelo pro-
grama. Uma biblioteca e´ um conjunto de func¸o\u2dces (pedac¸os de co´digo)
ja´ implementados e que podem ser utilizados pelo programador. No
exemplo anterior, duas bibliotecas foram adicionadas ao programa:
stdio.h (que conte´m as func¸o\u2dces de leitura do teclado e escrita em
tela) e stdlib.h;
\u2022 Todo o programa em linguagem C deve conter a func¸a\u2dco main(). Esta
func¸a\u2dco e´ responsa´vel pelo in\u131´cio da execuc¸a\u2dco do programa, e e´ den-
tro dela que iremos colocar os comandos que queremos que o pro-
grama execute.
\u2022 As chaves definem o in\u131´cio \u201c{\u201d e o fim \u201c}\u201d de um bloco de coman-
dos / instruc¸o\u2dces. No exemplo, as chaves definem o in\u131´cio e o fim do
programa;
\u2022 A func¸a\u2dco main foi definida como uma func¸a\u2dco int (ou seja, inteira), e
por isso precisa devolver um valor inteiro. Temos enta\u2dco a necessi-
18
dade do comando return 0, apenas para informar que o programa
chegou ao seu final e que esta´ tudo OK;
\u2022 A func¸a\u2dco printf() esta´ definida na biblioteca stdio.h. Ela serve para
imprimir uma mensagem de texto na tela do computador (ou melhor,
em uma janela MSDOS ou shell no Linux). O texto a ser escrito deve
estar entre \u201caspas duplas\u201d, e dentro dele podemos tambe´m colocar
caracteres especiais, como o \u201c\n\u201d, que indica que e´ para mudar de
linha antes de continuar a escrever na tela;
\u2022 O comando system(\u201cpause\u201d) serve para interromper a execuc¸a\u2dco do
programa (fazer uma pausa) para que voce\u2c6 possa analisar a tela de
sa\u131´da, apo´s o te´rmino da execuc¸a\u2dco do programa. Ela esta´ definida
dentro da biblioteca stdlib.h;
\u2022 A declarac¸a\u2dco de um comando quase sempre termina com um ponto
e v\u131´rgula \u201c;\u201d. Nas pro´ximas sec¸o\u2dces, no´s veremos quais os comandos
que na\u2dco terminam com um ponto e v\u131´rgula \u201c;\u201d;
\u2022 Os pare\u2c6nteses definem o in\u131´cio \u201c(\u201d e o fim \u201c)\u201d da lista de argumentos
de uma func¸a\u2dco. Um argumento e´ a informac¸a\u2dco que sera´ passada
para a func¸a\u2dco agir. No exemplo, podemos ver que os comandos
main, printf e system, sa\u2dco func¸o\u2dces;
1.3.1 INDENTAC¸A\u2dcO DO CO´DIGO
Outra coisa importante que devemos ter em mente quando escrevemos
um programa e´ a indentac¸a\u2dco do co´digo. Trata-se de uma convensa\u2dco de
escrita de co´digos fonte que visa modificar a este´tica do programa para
auxiliar a sua leitura e interpretac¸a\u2dco.
A indentac¸a\u2dco torna a leitura do co´digo fonte muito mais fa´cil
e facilita a sua modificac¸a\u2dco.
A indentac¸a\u2dco e´ o espac¸amento (ou tabulac¸a\u2dco) colocado antes de comec¸ar
a escrever o co´digo na linha. Ele tem como objetico indicar a hierarquia
do elementos. No nosso exemplo, os comandos printf, system e return
possuem a mesma hierarquia (portanto o mesmo espac¸amento) e esta\u2dco
todos contidos dentro do comando main() (da\u131´ o porque\u2c6 do espac¸amento).
O ideal e´ sempre criar um novo n\u131´vel de indentac¸a\u2dco para
um novo bloco de comandos.
19
A indentac¸a\u2dco e´ importante pois o nosso exemplo anterior poderia ser es-
crito em apenas tre\u2c6s linhas, sem afetar o seu desempenho, mas com um
alto grau de dificuldade de leitura para o programador:
Programa sem indentac¸a\u2dco
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) { p r i n t f ( \u2018 \u2018 He l lo World \n \u2019 \u2019 ) ; system ( \u2018 \u2018 pause \u2019 \u2019 )
; return 0;}
1.3.2 COMENTA´RIOS
Um comenta´rio, como seu pro´prio nome diz, e´ um trecho de texto inclu\u131´do
dentro do programa para descrever alguma coisa, por exemplo, o que
aquele pedac¸o do programa faz. Os comenta´rios na\u2dco modificam o fun-
cionamento do programa pois sa\u2dco ignorados pelo compilador e servem,
portanto, apenas para ajudar o programador a organizar o seu co´digo.
Um comenta´rio pode ser adicionado em qualquer parte do co´digo. Para
tanto, a linguagem C permite fazer comenta´rios de duas maneiras diferen-
tes: por linha ou por bloco.
\u2022 Se o programador quiser comentar uma u´nica linha do co´digo, basta
adicionar // na frente da linha. Tudo o que vier na linha depois do //
sera´ considerado como comenta´rio e sera´ ignorado pelo compilador.
\u2022 Se o programador quiser comentar mais de uma linha do co´digo, isto
e´, um bloco de linhas, basta adicionar /* no comec¸o da primeira linha
de comenta´rio e */ no final da u´ltima linha de comenta´rio. Tudo o que
vier depois do s\u131´mbolo de /* e antes do */ sera´ considerado como
comenta´rio e sera´ ignorado pelo compilador.
Abaixo, tem-se alguns exemplos de comenta´rios em um programa:
20
Exemplo: comenta´rios no programa
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main