Primeiros programas.

(1)

Primeiros programas.

(2)

Objetivos da aula

•Revisar as atividades "edição", "compilação", ("correção" e)

"execução".

•Revisar os primeiros elementos de linguagem C já vistos.

•Aprender a escrever valores.

•O conceito de variável.

•Atribuição e sequência.

(3)

Objetivos da aula

"execução".

(4)

Revisar os passos para programar

• Determinar o que devo programar:

• Escrever uma receita que permita realizar a tarefa demandada.

• Codificar esta receita na linguagem de programação C que realize esta receita.

‣ _{Não esquecer de se re-ler.} • Compilar

‣ _{Corrigir enquanto há erro} • Executar

(5)

Determinar o que devo programar

• Programe um aplicativo que imprime no terminal Ja eh a segunda aula...

(6)

Escrever uma receita que realize a tarefa demandada.

‣ _{Aqui é muito simples:}

✓ imprimir um texto dado ("Ja eh a segunda aula") pode ser feito

usando o método pré-definido printf.

✓ podemos usar duas vezes o comando printf para imprimir as duas

linhas do texto.

(7)

Revisar os passos para programar

• Codificar esta receita na linguagem de programação C. ‣ _{A codificação aqui é quase direta}

✓ (para quem conhece a linguagem...)

‣ _{Não esquecer de se re-ler.}

‣ _{Verifique algumas regras simples:}

✓ Não foi esquecido nenhum ";"?

✓ Foram incluídos os arquivos cabeçalhos necessários?

‣ _Cola:

#include <stdio.h> main ()

{

(8)

Compilar

• Corrigir enquanto há erro

• Cola

(9)

Executar

• Corrigir enquanto o resultado não for satisfatório.

• Cola

(10)

Objetivos da aula

"execução".

(11)

Revisão da linguagem C

•A estrutura do código fonte de um programa C é a seguinte:

1.inclusão de arquivo cabeçalho 2.método principal versão da apostila: main () { sequência de comandos }

#include <nome do arquivo cabeçalho>

int main () {

sequência de comandos

(12)

Arquivos cabeçalhos

•stdio.h

‣ _{para imprimir (e ler)}

(13)

Sequência de comandos

•comando

•obs. 1: Bom estilo de programação: ‣ _{escrever um comando por linha.} ‣ _{fazer uma margem a esquerda.}

(14)

Texto

•Qualquer texto entre duas aspas duplas, desde que esteja em uma

linha só.

•Obs. 1

‣ _{Quebras de linha são representadas com \n} •Obs. 2

‣ _{Para escrever mais de uma linha, usamos mais de um comando}

printf.

•Dúvida:

‣ _{Como codificar a escrita de um texto que contem uma (ou mais)}

aspa dupla?

(15)

Objetivos da aula

"execução".

(16)

Impressão de valores

•O comando printf pode ser usado para imprimir valores inteiros.

•Incluir no texto \n indica ao comando que deve incluir uma quebra

de linha.

•Incluir no texto %i (ou %d) indica ao comando que seguira um

número inteiro que deverá ser impresso.

•Pode haver quantos %i quanto o programador desejar. Ele deve,

porem, colocar na sequência do texto a mesma quantidade de números inteiros.

(17)

Impressão de valores com o comando printf - 1

#include <stdio.h> int main ()

{

printf("%i, the answer to the ultimate question of life\n", 42); printf("the Universe, and everything, from Douglas Adams'\n"); printf("series The Hitchhiker's Guide to the Galaxy.\n");

return 0; }

(18)

Impressão de valores com o comando printf - 2

#include <stdio.h> int main () { printf("%i + %i = %i\n", 0, 1, 2); return 0; }

(19)

Objetivos da aula

"execução".

(20)

DIM0108.0 - Conceitos e Técnicas de Programação

Arquitetura de von Neumann

se também às discussões do projeto desse novo computador e ficou responsável por redigir o documento com a descrição dessas idéias. Com a publicação desse trabalho [17]5, divulgado contendo apenas seu nome, essa organização interna de um computador passou a ser conhe-cida como “arquitetura de von Neumann”, apesar de Turing, Zuse, Eckert e Mauchly terem contribuído ou já apresentado idéias semelhantes. Esse trabalho obteve grande circulação no meio acadêmico e seu sucesso como proposta de implementação de um novo computador foi imediato. Até nossos dias, essa organização ainda é usada nos projetos de computadores mais conhecidos.

2.2 Arquitetura de von Neumann

As idéias publicadas por John von Neumann foram revolucionárias a ponto de estabelecer um novo paradigma de concepção de computadores para a época e que permanece válido até os nossos dias. Informalmente, a maneira de organizar os componentes que constituem um computador é chamada arquitetura do computador. Assim, como a maioria dos computadores atuais segue o modelo proposto por von Neumann, veremos aqui uma breve descrição da assim chamada arquitetura de von Neumann.

Nesse modelo, um computador é constituído por três componentes principais: (i) a unidade central de processamento ou UCP6, (ii) a memória e (iii) os dispositivos de entrada e saída. A UCP, por sua vez, é composta pela unidade lógico-aritmética ou ULA e pela unidade de controle ou UC. Esses três componentes principais estão conectados e se comunicam através de linhas de comunicação conhecidas como barramento do computador.

Podemos ilustrar a arquitetura de von Neumann como na figura 2.1.

memória

UCP UC ULA

entrada saída

Figura 2.1: Arquitetura de von Neumann.

A unidade central de processamento é responsável pela execução das instruções armaze-nadas, também chamadas de programa. Atualmente, o termo UCP é quase um sinônimo de

(21)

Variáveis são compartimentos de memória

•Quando um programa lê um valor, ele deve usar um compartimento

da memória para guardá-lo.

•Para guardar valores para serem usados em etapas ulteriores do

processamento, um programa deve usar também compartimentos de memória.

•A forma mais simples de se ter um compartimento de memória é

(22)

O que caracteriza uma variável

•Uma variável é um compartimento de memória que pode guardar

um valor só.

‣ _{A variável possui um nome que identifica este compartimento;}

‣ _{A variável possui um tipo que determina quais valores ela guarda}

(por enquanto: int);

‣ _{A variável possui um valor que é o valor guardado no}

compartimento de memória;

‣ _{A variável possui um escopo que determina onde o programador}

(23)

Sintaxe de declaração de variável

•<declaração de variável> ::=

<tipo> <nome> "=" <expressão> ";" | <tipo> <nome> ";"

•<tipo> ::= "int"

•<nome> sequência de letras, caracter underline e dígitos, começando

com uma letra ou um caracter underline.

•<expressão> ::=

<literal inteiro>

•<literal inteiro> sequência de dígitos.

•Exemplos:

‣ _{int resposta = 42;} ‣ _{int i_0;}

(24)

Semântica de declaração de variável

•Duas versões:

‣ _{tipo nome = expressão;}

‣ _{tipo nome;}

•Aloca um compartimento de memória cuja capacidade permite

representar um valor do tipo dado.

•Associa o nome dado a este compartimento de memória.

•Se houve uma inicialização, avalia a expressão e armazena o valor

resultante naquele compartimento de memória.

‣ _{Até agora o único tipo de expressão que vimos é o literal inteiro.} ‣ _{A avaliação de um literal inteiro é o próprio inteiro representado.} •Se não houve inicialização, o valor do compartimento de memória

(25)

Um exemplo com variáveis inicializadas

#include <stdio.h> int main () { /* declaracao de variaveis */ int n = 14; int m = 23; int s = 0;

/* comandos de impressao dos valores de n e m */ printf("n = %i\n", n);

printf("m = %i\n", m); printf("s = %i\n", s); return 0;

(26)

Exemplo com variáveis não inicializadas

#include <stdio.h> int main () { int n = 14; int m = 23; int s; printf("n = %i\n", n); printf("m = %i\n", m); printf("s = %i\n", s); return 0; }

(27)

Objetivos da aula

"execução".

(28)

Atribuição

•Uma vez declarada uma variável, é possível acessar o conteúdo do

compartimento de memória correspondente:

‣ _leitura ‣ _escrita

•A leitura do valor guardado é realizada colocando o nome da

variável em uma expressão.

•A escrita de um novo valor no compartimento de memória é

(29)

Leitura

•<expressão> ::=

<literal inteiro>

| <nome>

•A leitura do valor guardado é realizada colocando o nome da

variável em uma expressão.

‣ _{A avaliação de uma expressão nome é o conteúdo do}

compartimento de memória associado com aquele nome.

#include <stdio.h> int main () { int n = 14; int m = 23; int s = n + m;

printf("n = %i, m = %i, s = %i\n", n, m, s); return 0;

(30)

Escrita

•A escrita de um novo valor no compartimento de memória é

realizada com um comando de atribuição.

•Sintaxe:

•<comando> ::=

<comando de impressão>

| <comando de atribuição>

•<comando de atribuição> ::= <nome> "=" <expressão> ";" •Semântica

nome = expressão;

‣ _A_expressão_{é avaliada, seja v o valor resultante.}

‣ _{O compartimento de memória associado com o nome dado passa a}

(31)

Programa exemplo

#include <stdio.h> int main () { int n = 14; int m = 23; int s; s = n; n = m; m = s; printf("n = %i\n", n); printf("m = %i\n", m); return 0; }

(32)

Sequência

•A forma mais simples de combinar comandos é através de uma

sequência: •<comando> ::= <comando de impressão> | <comando de atribuição> | <comando> <comando> •A semântica de comando1 comando2 é: ‣ _executar_comando1_{, e}

‣ _{depois executar}_comando2_.

(33)

Objetivos da aula

"execução".

• Atribuição e sequência.

(34)

Tipos

•Linguagens de programação oferecem a possibilidade de manipular

dados de diferentes tipos, e também de definir a representação de novos tipos de dados.

‣ _{É o papel do compilador transformar esses dados na representação}

binária na qual eles são efetivamente manipulados pelo computador.

•Por enquanto, todos os dados manipulados serão de um único tipo:

int.

•O tipo int é um dos tipos da linguagem usados para representar

(35)

O tipo

int

•Os valores do tipo int são números inteiros.

•Em C, o tipo int permite representar inteiros na faixa [INT_MIN,

INT_MAX], onde, geralmente:

‣ _{INT_MIN}_{= −2.147.483.648} ‣ _{INT_MAX}_{= 2.147.483.647}

•Existe operadores pré-definidos para combinar valores do tipo int.

•Correspondem aos operadores matemáticos clássicos: soma,

(36)

Programa que informa os limites do tipo

int

.

#include <stdio.h>

#include <limits.h>

int main () {

printf("INT_MIN = %i\n", INT_MIN); printf("INT_MAX = %i\n", INT_MAX); return 0;

(37)

Os operadores para o tipo

int

(38)

Observações

•Há dois operadores de divisão: ‣ _{quociente: /}

‣ _{resto: %}

•Não necessariamente o resultado de uma operação é

matematicamente correto:

‣ _{quando o valor matemático não está na faixa dos valores}

respresentáveis, o resultado está errado.

‣ _{esse erro é chamado de transbordamento (overflow).}

•C não possui mecanismos específicos para determinar se ocorreu

(39)

Programa exemplo

#include <stdio.h> int main () { int a = 54; int b = 3; int soma; int subtracao; int produto; int quociente; int resto; soma = a + b; subtracao = a - b; produto = a * b; quociente = a / b; resto = a % b;

printf("%i, %i, %i, %i, %i\n",

(40)

Programa exemplo

#include <stdio.h> int main () { int fat5; fat5 = 1; fat5 = 2 * fat5; fat5 = 3 * fat5; fat5 = 4 * fat5; fat5 = 5 * fat5; printf("%i\n", fat5); return 0; } #include <stdio.h> int main () { int fat5; fat5 = 1 * 2 * 3 * 4 * 5;

(41)

Exercício

•Considere o trecho de programa seguinte:

‣ _{int x = 2;} comando

printf("%i\n", x);

•Defina comando sujeito às seguintes restrições:

‣ _{a execução do trecho de código deve imprimir 8.}

(42)

Exercício

•Supondo que as variáveis x e y armazenam respectivamente dois

valores, digamos A e B.

•Após executar o trecho de código seguinte qual o valor de x? qual o

valor de y?

‣ _{x = x + y;}

y = x - y; x = x - y;

(43)

Resumo...

•<declaração de variável> ::=

<tipo> <nome> "=" <expressão> ";" | <tipo> <nome> ";"

•<comando> ::=

<comando de impressão>| <comando de atribuição>

| <comando> <comando>

•<comando de atribuição> ::= <nome> "=" <expressão> ";" •<expressão> ::=

| <expressão> "*" <expressão>