LINGUAGEM DE PROGRAMAÇÃO C (38)

Prévia do material em texto

Laboratório de Programação 
02
Ambiente de Desenvolvimento e Revisão da Linguagem C
Prof. Carlos Eduardo de Barros Paes
Prof. Julio Arakaki
Departamento de Computação
PUC-SP
Code::Blocks
• Ambiente integrado de desenvolvimento (IDE - Integrated
Development Environment)
• O Code::Blocks é um software livre (sob GNU General Public License) 
multiplataforma (Windows, Linux, Mac e etc..)
• Também pode ser usado para o desenvolvimento de programas em 
outras linguagens (Ex: Python)
• URL da ferramenta: http://www.codeblocks.org/
• Tutorial: Profa. Juliana Kaizer Vizzotto (UFSM)
Code::Blocks
• Vamos utilizar a IDE para realizas as operações mais simples
• Criar um projeto, compilar, executar e depurar
Code::Blocks
• Na figura abaixo podemos verificar a aparência da IDE. A parte direita é usada principalmente para a edição de arquivos. 
Como é um editor com abas, podemos editar vários arquivos ao mesmo tempo. Abaixo do editor, temos a janela de 
mensagens, que imprime principalmente os resultados de compilação de programas. Na parte esquerda temos a aba com 
as informações do projeto com seus arquivos
Code::Blocks
• Para criar um projeto, deve-se selecionar a opção “File >> New >> Project “. Para construir o projeto, precisamos 
basicamente colocar um nome e um diretório para armazenamento, assim como selecionar a linguagem (C ou C++) e o 
tipo de aplicação
• O tipo de aplicação mais adequado é chamado de “Console Application “, como mostra a figura abaixo
Code::Blocks
• Na sequência seleciona-se a linguagem de programação a ser utilizada no projeto. A IDE oferece por default as linguagens 
C ou C++.
• Depois de selecionar a linguagem é necessário escolher um nome para o projeto e um diretório para armazenamento, 
como ilustrado a seguir.
Code::Blocks
• A seguir é necessário selecionar um compilador para ser utilizado, assim como modos de compilação:
Code::Blocks
• Em geral os perfis oferecidos inicialmente pela IDE são adequados para os nossos 
projetos de aula, i.e., utilizar o compilador `GNU CGG compiler`. O debug servirá 
para o processo de análise do programa. Como o próprio nome diz, o processo de 
debug é a fase de busca e redução de bugs no programa.
• Pronto! Após clicar em `finish`, o projeto foi criado, assim como o arquivo 
`main.c` (do inglês, main significa principal), que aparecerá no diretório escolhido 
como arquivo principal de compilação.
• Agora que o projeto foi criado, você pode observá-lo na aba `Management`. Se 
você clicar sobre o projeto, ele vai abrir os arquivos criados automaticamente 
com a criação do projeto. Você pode criar no arquivo `main.c` para editá-lo na 
aba de edição à direita.
Code::Blocks
Linguagem C é
• Propóstio geral
• Estruturada
• Procedural / imperativa
• Para uso com o Unix
• Muito usada para desenvolver sistemas e aplicativos
• Disponível para muitas plataformas
• Padronização ANSI (American National Standards Institute)
Linguagem C é
• Considerada de nível médio
• C permite manipular bits, bytes e endereços de memória como uma 
linguagem de baixo nível
• C possui construções e rotinas como linguagens de alto nível
• C é para profissionais; Uso primário para desenvolvimento de 
sistemas
Estrutura de um programa em C
Programa C
• Directivas ao Pré-Processador
- Includes
- Macros
• Declarações Globais
- Funções
- Variáveis
• Definição das Funções
main ()
{ /* begin */
} /* end */
Estrutura de um programa em C
/* Primeiro Programa em C */
#include <stdio.h>
main() 
{
printf(“Meu primeiro programa em C\n”);
} 
Estrutura de um programa em C
/* Primeiro Programa em C */ comentários
#include <stdio.h> /*biblioteca de E/S */
main() /*função principal – inicio do programa*/
{ /*marca início da função*/
printf(“Meu primeiro programa em C\n”); 
/*função para escrever na tela*/
} /*marca fim da função*/
Processo de Compilação em C
• O processo de compilação, na verdade, se dá em duas 
etapas:
• Fase de tradução: programa-fonte é transformado em um 
programa-objeto.
• Fase de ligação: junta o programa-objeto às instruções 
necessárias das bibliotecas para produzir o programa 
executável.
Programa
Fonte Compilador
Programa 
Objeto
Ligador
Programa 
Executável
Programa 
Objeto das 
Bibliotecas
Bibliotecas
• Conjunto de funções que permitem realizar tarefas específicas.
• Biblioteca padrão C - ANSI - funções básicas.
• As primeiras linhas do programa indicam as bibliotecas utilizadas
#include “minha_biblioteca.h” ou
#include <minha_biblioteca.h>
17
Dicas
• Termine todas as linhas com ;
• Sempre salve o programa antes de compilar
• Sempre compile o programa antes de executar
• Verifique também a linha anterior, que pode ser a responsável pelo 
erro, especialmente se faltar o ;
• Use comentários, iniciados por //
Declarações
• Declaram as variáveis e seus tipos
• Os nomes das variáveis devem conter apenas letras, dígitos e o 
símbolo _
• Os principais tipos são: int, float, double e char
• Exemplos
int n;
int quantidade_valores;
float x, y, somaValores;
char sexo;
char nome[40];
C diferencia letras maiúsculas de minúsculas!
int n, N;
n é diferente de N!
19
Comando de atribuição
• Atribui o valor da direita à variável da esquerda
• O valor pode ser:
• uma constante,
• uma variável ou 
• uma expressão
• Exemplos
x = 4; --> lemos x recebe 4
y = x + 2;
y = y + 4;
valor = 2.5;
sexo = 'F'
20
Entrada e Saída de Dados
21
Entrada de Dados
• Função scanf 
scanf ("formatos", &var1, &var2,...)
Exemplos:
int i, j;
float x;
char c;
scanf("%d", &i);
scanf("%d %f", &j, &x);
scanf("%c", &c);
scanf("%s", nome);
%d inteiro
%f float
%lf double
%c char
%s palavra
22
Operadores Matemáticos
Decrementa em 1 o valor de xx----
Incrementa em 1 o valor de xx++++
Resto da divisão de x por yx % y %
Divide x por yx / y /
Multiplica x e yx * y*
Subtrai y de xx – y -
Soma x e yx + y+
ComentárioExemploOperador
23
Saída de Dados
• Função printf
printf ("formatos", var1, var2,...)
Exemplos:
int i, j;
float x;
char c;
printf("%d", i);
printf("%d, %f", j, x);
printf("%c", c);
printf("%s", nome);
%d inteiro
%f float
%lf double
%c char
%s palavra
24
Operadores de Atribuição
Equivale a x = x % yx %= y%=
Equivale a x = x / yx /= y /=
Equivale a x = x * yx *= y *=
Equivale a x = x – yx -= y-=
Equivale a x = x + yx += y +=
Atribui o valor de y a xx = y=
ComentárioExemploOperador
25
Funções Matemáticas
Tangente de xtan(x)tan
Raiz quadrada de xsqrt(x)sqrt
Seno de xsin(x)sin
Calcula x elevado à potência ypow(x, y)pow
Logaritmo decimal de xlog10(x)log10
Logaritmo natural de xlog(x)log
Arredonda o número deal para baixo; floor(3.2) é 3floor(x)floor
Valor absoluto de xfabs(x)fabs
e elevado à potencia xexp(x)exp
Cosseno de x (x em radianos)cos(x)cos
Arredonda o número real para cima; ceil(3.2) é 4ceil(x)ceil
ComentárioExemploFunção
#include <math.h>
26
Operadores Relacionais
O conteúdo de x é maior que o de yx > y>
O conteúdo de x é menor que o de yx < y <
O conteúdo de x é maior ou igual ao de yx >= y >=
O conteúdo de x é menor ou igual ao de yx <= y<=
O conteúdo de x é diferente do de yx != y !=
O conteúdo de x é igual ao de yx == y==
ComentárioExemploOperador
As expressões relacionais em C retornam :
• 1 se verdadeiro e;
• 0 se falso.
27
Operadores Lógicos
• && (E lógico): retorna verdadeiro se ambos os operandos são 
verdadeiros e falso nos demais casos.
Exemplo: if( a>2 && b<3).• || (OU lógico): retorna verdadeiro se um ou ambos os 
operandos são verdadeiros e falso se ambos são falsos.
Exemplo: if( a>1 || b<2).
• ! (NÃO lógico): usada com apenas um operando. Retorna 
verdadeiro se o operando é falso e vice-versa.
Exemplo: if( !var ).
Estrutura
Sequencial
Estrutura
com desvio condicional
Estrutura
Iterativa
Estruturas de Controle
Todas as linguagens imperativas incluem um seletor 
unidirecional. O seletor unidirecional do C, chamado 
instrução lógica IF, tem a forma:
IF (<expressão booleana>) <instrução>
Neste caso apenas um comando está sujeito à condição 
do comando IF. 
Seleção Unidirecional
Seleção Unidirecional
Outra forma de se vincular mais de uma instrução em um 
comando de seleção é utilizar instruções compostas
Abaixo está descrita a sintaxe para uma seleção 
bidirecional em C/C++:
if (<expressão booleana>) {
{<instrução>}
} else {
{<instrução>}
}
Caso o resultado da expressão booleana seja verdade a 1ª 
instrução será executada e a 2ª instrução não. E caso seja 
falsa a 1ª não será executada e a 2ª sim.
No lugar destas instruções poderiam ser colocadas 
instruções compostas para que mais de um comando 
estivesse vinculado ao comando if em cada situação.
#include <stdio.h>
void main() {
int x, totPAR=0, totIMPAR=0;
printf(“Entre com um número:”);
scanf(“%d”,&x);
if ((x % 2) == 0){
printf(“O número é par!”);
totPAR += x;
} else {
printf(“O número é ímpar!”);
totIMPAR += x;
}
printf(“Total par:%d, total impar:%d”,totPAR,totIMPAR);
}
Veja um exemplo de utilização de uma seleção Bidirecional 
e instruções compostas:
Seleção Bidirecional
De acordo com o resultado da expressão inteira uma das 
instruções será executada. Se o resultado for 1, a primeira 
instrução é executada, se for 2 a segunda e assim por 
diante.
Seleção Múltipla
A seleção múltipla em C tem a seguinte forma:
switch (<expressão>) {
{case <expressão constante 1>:{<instrução 1> }}
default:
{<instrução> }
}
Seleção Múltipla
Um problema com esta estrutura é que os blocos de 
instruções em cada “case” iniciam sua execução e 
terminam ao final do switch, então neste caso deveremos 
utilizar o comando break que desviará a execução do 
código para a próxima instrução depois do fim do bloco.
Introduzindo o comando break ao final de cada bloco de 
instruções do comando switch teremos como resultado:
switch (<expressão>) {
{case <expressão constante>:{<instrução> };break;}
default:
<instrução>
}
Exemplo
#include <stdio.h>
void main ()
{
int num;
printf ("Digite um numero: ");
scanf ("%d",&num);
switch (num) {
case 9: printf ("\n\nO numero e igual a 9.\n");
break;
case 10:printf ("\n\nO numero e igual a 10.\n");
break;
case 11:printf ("\n\nO numero e igual a 11.\n");
break;
default: printf ("\n\nO numero nao e nem 9 nem 10 nem 11.\n");
}
}
Instruções Iterativas
Instruções Iterativas lógicas com pré-teste
Estruturas de Controle
Pré-teste
Instruções Iterativas lógicas com pós-teste
Estruturas de Controle
Pós-teste
Instruções Iterativas com contagem
Estruturas de Controle
inicia, controla 
e incrementa 
o contador
Laços Controlados por Contador
Uma instrução iterativa de controle de contagem tem uma 
variável de laço, na qual o valor da contagem é mantido. Ela 
também possui alguns meios de especificar os valores 
inicial e terminal da variável de laço e a diferença entre seus 
valores seqüenciais, freqüentemente chamados stepsize, As 
especificações iniciais, as terminais e os stepsize de um 
laço são chamados de parâmetros do laço.
Estruturas de Controle
Na linguagem C ou C++ a forma geral é:
for (<expressão1>; <expressão2>; <expressão3>)
<corpo do laço>
O corpo do laço pode ser: uma instrução única; uma 
instrução composta ou uma instrução nula.
A primeira expressão é avaliada uma única vez quando se 
inicia o loop. Normalmente é utilizada para inicializações.
A segunda expressão é o controle do laço avaliada antes de 
cada execução do corpo do mesmo.
A terceira expressão é executada depois da execução do 
corpo do laço. Normalmente utilizada para incrementos de 
variáveis.
Estruturas de Controle
Laços Controlados por Contador
Exemplo típico da utilização do laço de contagem:
for (indice = 0; indice <= 10; indice++)
soma = soma + lista [indice];
Pode-se utilizar instruções múltiplas no caso da linguagem 
C e C++. Veja o exemplo:
for ( cont1 = 0, cont2=0.0;
cont1 <= 10 && cont2 <= 100.0;
soma = ++cont1 + cont2, cont2 *= 2.5);
Estruturas de Controle
Laços Controlados por Contador
Laços Controlados Logicamente
Muitas vezes não sabemos exatamente a quantidade de 
vezes que um determinado laço será executada, portanto, a 
utilização de laços controlados por contador não são os 
mais adequados.
Nestes casos, são utilizados os laços controlados 
logicamente. A continuidade da repetição do laço depende 
de uma expressão lógica.
Estruturas de Controle
Questões de projeto
O controle deverá ser de pré ou pós teste?
O laço controlado logicamente deverá ser uma forma 
especial de laço de contagem ou uma instrução lógica 
independente?
Exemplos:
while (<expressão>)
<corpo do laço>
ou
do
<corpo do laço>
while (<expressão>)
Estruturas de Controle
Laços Controlados Logicamente
Uma instrução lógica 
independente seria o caso 
de que a expressão lógica 
do laço não depende de 
uma variável contadora.
Localização do controle do laço
Quando devemos colocar o controle do laço no início ou no 
final do corpo? Ao colocar o controle no início, o teste será 
efetuado antes da execução do corpo, e por isso mesmo, 
corre o risco de não ser executado nenhuma vez. No caso 
de colocar o controle na base, o corpo do laço será 
executado pelo menos uma vez.
Existem situações em que é conveniente para o 
programador posicionar o controle do laço no interior do 
corpo ao invés de no início ou na base. Por isso, algumas 
linguagens oferecem essa capacidade.
Estruturas de Controle
Laços Controlados Logicamente
O C e o C++ possuem o comando continue que desvia a 
execução do programa da sua localização dentro do corpo 
do laço até o final do corpo. Este comando não encerra a 
execução do loop.
No caso do comando break a execução do código também 
é desviada para o final do corpo do laço, porém, o laço será 
terminado.
Estruturas de Controle
Laços Controlados Logicamente
Os exemplos abaixo ilustram a utilização do continue e do 
break. No primeiro caso um valor negativo que seja lido a 
partir da função getnext será ignorado e portanto, não 
acumulado na variável soma. No segundo caso um valor 
negativo encerra o loop.
Estruturas de Controle
while (soma < 1000) {
getnext(valor);
if (valor<0) continue;
soma+=valor;
}
while (soma < 1000) {
getnext(valor);
if (valor<0) break;
soma+=valor;
}
Laços Controlados Logicamente