Apostila complementar

356 views
268 views

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
356
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
12
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Apostila complementar

  1. 1. _______________________________________________________________________________________________ ANATOMIA DE UM PROGRAMA EM C++ A grande maioria dos programas desenvolvidos até hoje, não importando em qual Linguagem de Programa, possuem três fases básicas e distintas. São as fases de: • Entrada de Dados • Processamento de Dados em Informações • Saída dos Resultados ( Informações ) ENTRADA PROCESSAMENTO SAÍDA Entrada de Dados Fase na qual os Dados são inseridos no programa, seja via teclado, arquivo eletrônico ou qualquer outro dispositivo de entrada ( input ). Processamento de Dados em Informações Fase na qual os Dados fornecidos passam por análises, cálculos, seleções, etc. até obter- se o resultado desejado, ou seja, a Informação. Saída de Resultados ( Informações ) Fase na qual as Informações, ou seja, os Resultados são exibidos ao usuário tanto via monitor ou impressora, assim como arquivo eletrônico, ou qualquer outro dispositivo de saída ( output ). 1
  2. 2. _______________________________________________________________________________________________ ESTRUTURA DE UM PROGRAMA EM LINGUAGEM C++ A Linguagem C++, assim como muitas outras, possui uma estrutura bem definida, a qual deve ser seguida rigorosamente a fim de se obter um arquivo-fonte bem estruturado, fácil de ser entendido e consequentemente alterado caso for necessário. Observe as partes de um programa em Linguagem C++ e veja que várias dessas partes, permanecem inalteradas, ou com pouquíssimas alterações, em todos os arquivos-fonte. São parte que se repetem em todos os programas e com isso torna-se fácil começar ou até terminar um programa em Linguagem C++, tendo o programador apenas que praticamente inserir os comandos de Processamento de Dados em Informações, ou melhor dizendo, a “parte do meio” do programa. Observe o exemplo a seguir: #include <cstdio> #include <cstdlib> DECLARAÇÃO DAS BIBLIOTECAS QUE SERÃO UTILIZADAS NO PROGRAMA - PARTE COMUM A TODOS OS PROGRAMAS - DECLARAÇÃO DO MÉTODO MAIN ( ) – int main( ) PRINCIPAL - PARTE COMUM A TODOS OS PROGRAMAS - DELIMITADOR DE INÍCIO DO BLOCO DE { COMANDOS DO MÉTODO MAIN ( ) - PARTE COMUM A TODOS OS PROGRAMAS - DECLARAÇÃO DAS VARIÁVEIS QUE SERÃO UTILIZADAS NO PROGRAMA int a , b , c ; - PARTE COMUM A TODOS OS PROGRAMAS QUE USAM VARIÁVEIS - _______________________________________________________________________________________________ 2
  3. 3. _______________________________________________________________________________________________ ENTRADA DE DADOS printf ( " Digite o primeiro numero n " ) ; scanf( "%d" , &a ) ; GERALMENTE COMPOSTA POR COMANDO QUE EXIBEM MENSAGENS NA TELA (printf () ) E COMANDOS QUE LEÊM AS printf ( " Digite o segundo numero n " ) ; scanf( "%d" , &b ) ; ENTRADAS, VIA TECLADO, DOS USUÁRIOS ( scanf () ) E COMANDOS DE ATRIBUIÇÃO DE VALORES E VARIÁVEIS PROCESSAMENTO DE DADOS if ( a > b ) c = a ; GERALMENTE COMPOSTA POR COMANDOS DE ESTRUTURAS DE REPETIÇÃO, ESTRUTURAS DE CONDIÇÃO/COMPARAÇÃO, ESTRUTURAS DE else c = b ; MÚLTIPLA ESCOLHA, FÓRMULAS E FUNÇÕES DE CÁLCULOS SAÍDA DE RESULTADOS printf ( " Maior numero = %d n " , c ) ; GERALMENTE COMPOSTA POR COMANDO QUE EXIBEM MENSAGENS E VALORES NUMÉRICOS OU TEXTUAIS, NA TELA (printf () ) COMANDO QUE PROVOCA UMA PARADA NA EXECUÇÃO DO PROGRAMA, A FIM DO USUÁRIO VISUALIZAR A SAÍDA DE RESULTADOS system ( "PAUSE" ) ; - PARTE COMUM A TODOS OS PROGRAMAS QUE NECESSITEM DESTE ARTIFÍCIO - COMANDO DE RETORNO DO MÉTODO MAIN ( ) return 0 ; - PARTE COMUM A TODOS OS PROGRAMAS - _______________________________________________________________________________________________ 3
  4. 4. _______________________________________________________________________________________________ Compilador Um compilador é um programa de computador (ou um grupo de programas) que, a partir de um código fonte escrito em uma linguagem compilada, cria um programa semanticamente equivalente, porém escrito em outra linguagem, código objeto. O nome "compilador" é usado principalmente para os programas que traduzem o código de fonte de uma linguagem de programação de alto nível para uma linguagem de programação de baixo nível (por exemplo, linguagem de montagem assembly ou código de máquina). Um programa que traduz uma linguagem de programação de baixo nível para uma linguagem de programação de alto nível é um descompilador. Um programa que faz uma tradução entre linguagens de alto nível é normalmente chamado um tradutor, filtro ou conversor de linguagem. Um programa que faz uma tradução entre uma linguagem de montagem e o código de máquina é denominado montador. Um programa que faz uma tradução entre o código de máquina e uma linguagem de montagem é denominado desmontador. Em português, compilar significa, por exemplo: reunir obras literárias, documentos, escritos de vários autores, entre outros, compondo uma obra com esse material. Um compilador é um dos dois tipos mais gerais de tradutores, sendo que o segundo tipo que a ele deve ser comparado é um interpretador. _______________________________________________________________________________________________ 4
  5. 5. _______________________________________________________________________________________________ Características gerais dos Compiladores Normalmente, o código fonte é escrito em uma linguagem de programação de alto nível, com grande capacidade de abstração, e o código objeto é escrito em uma linguagem de baixo nível, como uma sequência de instruções a ser executada pelo processador. O processo de compilação é composto de análise e síntese. A análise tem como objetivo entender o código fonte e representá-lo em uma estrutura intermediária. A síntese constrói o código objeto a partir desta representação intermediária. A análise pode ser subdividida ainda em análise léxica, análise sintática e análise semântica. A síntese é mais variada, podendo ser composta pelas etapas de geração de código intermediário, otimização de código e geração de código final (ou código de máquina), e somente esta última etapa é obrigatória. Classicamente, um compilador traduz um programa de uma linguagem textual facilmente entendida por um ser humano para uma linguagem de máquina, específica para um processador e sistema operacional. Atualmente, porém, são comuns compiladores que geram código para uma máquina virtual que é, depois, interpretada por um interpretador. Em linguagens híbridas, o compilador tem o papel de converter o código fonte em um código chamado de byte code, que é uma linguagem de baixo nível. Um exemplo deste comportamento é o do compilador da linguagem Java que, em vez de gerar código da máquina hospedeira (onde se está executando o compilador), gera código chamado Java Bytecode. Um compilador é chamado de Just-in-time compiler (JIT) quando seu processo de compilação acontece apenas quando o código é chamado. Normalmente, o usuário tem a percepção que um compilador JIT é um interpretador. Muitos compiladores incluem um pré-processador. Um pré-processador normalmente é responsável por mudanças no código fonte destinadas de acordo com decisões tomadas em tempo de compilação. Por exemplo, um programa em C permite instruções condicionais para o pré-processador que podem incluir ou não parte do código caso uma assertiva lógica seja verdadeira ou falsa, ou simplesmente um termo esteja definido ou não. Tecnicamente, pré-processadores são muito mais simples que compiladores e são vistos, pelos desenvolvedores, como programas à parte, apesar dessa visão não ser necessariamente compartilhada pelo usuário. Outra parte separada do compilador que muitos usuários vêem como integrado é o linker, cuja função é unir vários programas já compilados de uma forma independente e unificá-los em um programa executável. Isso inclui colocar o programa final em um formato compatível com as necessidades do sistema operacional para carregá-lo em memória e colocá-lo em execução. _______________________________________________________________________________________________ 5
  6. 6. _______________________________________________________________________________________________ Fases da Compilação Análise Léxica A análise léxica é a primeira fase do compilador. A função do analisador léxico, também denominado scanner, é ler o código fonte, caractere a caractere, buscando a separação e identificação dos elementos componentes do programa fonte, denominados símbolos léxicos ou tokens. É também de responsabilidade desta fase a eliminação de elementos "decorativos" do programa, tais como espaços em branco, marcas de formatação de texto e comentários. Análise Sintática A análise sintática, ou análise gramatical é o processo de se determinar se uma cadeia de símbolos léxicos pode ser gerada por uma gramática. No caso de analisadores sintáticos top-down, temos a opção de escrevê-los à mão ou gerá-los de forma automática, mas os analisadores bottom-up só podem ser gerados automaticamente. A maioria dos métodos de análise sintática cai em uma dessas duas classes denominadas top-down e bottom-up. Entre os métodos top-down os mais importantes são a análise sintática descendente recursiva e a análise sintática preditiva não-recursiva. Entre os métodos de análise sintática bottom-up os mais importantes são a análise sintática de precedência de operadores, análise sintática LR canônico, análise sintática LALR e análise sintática SLR. Análise Semântica As análises léxicas e sintáticas não estão preocupadas com o significado ou semântica dos programas que elas processam. O papel do analisador semântico é prover métodos pelos quais as estruturas construídas pelo analisador sintático possam ser avaliadas ou executadas. As gramáticas livres de contexto não são suficientemente poderosas para descrever uma série de construções das linguagens de programação, como por exemplo, regras de escopo, regras de visibilidade e consistência de tipos. É papel do analisador semântico, assegurar que todas as regras sensíveis ao contexto da linguagem estejam analisadas e verificadas quanto à sua validade. Um exemplo de tarefa própria do analisador semântico é a checagem de tipos de variáveis em expressões. Um dos mecanismos comumente utilizados por implementadores de compiladores é a Gramática de Atributos, que consiste em uma gramática livre de contexto acrescentada de um conjunto finito de atributos e um conjunto finito de predicados sobre estes atributos. _______________________________________________________________________________________________ 6
  7. 7. _______________________________________________________________________________________________ DELIMITADORES DE BLOCOS DE COMANDOS Os delimitadores de blocos de comandos são símbolos especiais, dispostos em pontos estratégicos no corpo do programa a fim de (como o próprio nome já diz) delimitar um ou mais comandos do programa, ou seja, um bloco (conjunto) de comandos. Sua função principal é identificar um ou mais comandos que pertençam a uma determinada parte do programa, e assim, informar esta situação ao compilador. Uma vez informado desta situação, o compilador pode executar a análise léxica, sintática e semântica de todas as partes do programa, conhecendo a que parte do programa os comandos pertencem. Na Linguagem de Programação C++ (assim como na Linguagem C e Java) os símbolos utilizados para delimitar os blocos de comandos são abre chaves ( { ) e fecha chaves ( } ). O símbolo de abre chaves é utilizado para identificar o início de um bloco de comandos, e por sua vez, o símbolo de fecha chaves é utilizado para identificar o final de um bloco de comandos. É de extrema importância o correto uso das chaves ( { } ), pois a correta execução do programa está fortemente ligada ao uso das chaves. O uso incorreto das chaves pode ocasionar um mau funcionamento do programa e muitas vezes até o não funcionamento do mesmo. Chaves colocadas em locais impróprios podem levar tanto o compilador, quanto o programador a ler o programa de maneira equivocada e assim perde-se muito tempo até que se consiga achar e retirar este erro provocado pelo uso incorreto das chaves. Observe o exemplo a seguir. #include <cstdio> int main ( ) { <comando 1> <comando 2> ... <comando N > ; ; ; PAR DE CHAVES DELIMITANDO O MÉTODO PRINCIPAL DO PROGRAMA return 0 ; } Vale lembrar que as chaves trabalham em pares, ou seja, para cada símbolo de abre chaves, deve obrigatoriamente ter um símbolo de fecha chaves e ambos se completam. 7
  8. 8. _______________________________________________________________________________________________ Os delimitadores de blocos de comandos também são usados quando temos algumas estruturas especiais em nossos programas, como por exemplo: Estruturas de repetição ( comandos for , while , etc. ) Estruturas condicionais ( comando if ) Estrutura de múltipla escolha ( comando switch ) Nestes casos, podemos dizer que são os delimitadores que separam os comandos que estão dentro das estruturas citada a cima, dos comandos que pertencentes ao programa (método main() ) principal. Com isso, devemos observar outra característica dos delimitadores de blocos de comandos, que podemos dizer que é ditada pela seguinte regra: A última chave a ser fechada é a primeira chave que foi aberta ou também podemos dizer desta maneira: A primeira chave a ser fechada é a última que foi aberta Exemplo: Na página seguinte são apresentados o método main() e outras estruturas encontradas em programas. Observe que cada uma tem o seu par de delimitadores de blocos de comandos e com isso pode-se identificar cada parte do programa e determinar a que parte um comando especificado pertence. Observe também que a última chave a ser fechada (pertencente ao método main() ) no final do programa, foi a primeira chave a ser aberta no início do programa. Cada fecha chaves nas partes mais internas do programa ( estruturas de repetição, condição, múltipla escolha, etc. ) se refere a última abre chaves no início de cada estrutura, ou seja, observe como as chaves delimitam os blocos de comandos das estruturas e o próprio programa. _______________________________________________________________________________________________ 8
  9. 9. _______________________________________________________________________________________________ INCLUDE A cláusula include é uma diretiva de pré-processamento, ou seja, é uma instrução que informa o compilador que durante a compilação do arquivo-fonte, na fase de pré- processamento ( fase na qual o compilador simula o processamento ou execução do programa ) a linha onde a cláusula include se encontra, deverá ser substituída pelos códigos que compõe a biblioteca a qual o include se refere. Melhor dizendo, o include indica que o compilador deve incluir no arquivo-fonte, os comandos contidos dentro da biblioteca a qual o include faz a sua indicação. Lembrando que este processo ocorre durante a compilação do arquivo-fonte. Sintaxe do comando: # include < nome_da_biblioteca > Onde: # símbolo que precede a cláusula include,chamado de Sharp. include a cláusula. Instrução que inclui bibliotecas nos arquivos-fontes durante a sua compilação. < > símbolos que delimitam o nome da biblioteca que será incluída no arquivo fonte durante a sua compilação. nome_da_biblioteca o nome completo da biblioteca da Linguagem de Programação C++, que será incluída no arquivo- fonte durante a sua compilação. _______________________________________________________________________________________________ 9
  10. 10. _______________________________________________________________________________________________ O método main ( ) – principal O método main ( ) ( principal em Inglês ) é o primeiro método procurado pelo compilador no momento em o mesmo inicia a compilação de um arquivo-fonte (programa). Tanto na Linguagem de Programação C ou na Linguagem C++ o método main ( ) é o método principal do programa, método indispensável, até mesmo vital. O método main ( ) também é encontrado na Linguagem de Programação Java. O método main ( ) é responsável por “torna” o arquivo-fonte, um arquivo executável (programa), pois sem o método main ( ) o compilador apresentará um erro de compilação e impossibilitará a tradução do código-fonte para código executável. Todos os comandos que um programador desejar que sejam executados em seu programa, deverão obrigatoriamente estar dentro do método main ( ) ou ser de alguma forma referenciado diretamente dentro dele. Todos os comandos pertencentes ao método main ( ) devem obrigatoriamente estar delimitados dentro de uma bloco de comandos e para isso são utilizados os símbolos de abre-chaves ( { ) e fecha-chaves ( } ) para marcar o início e final do método main ( ) respectivamente. Sintaxe da declaração do método main ( ) : < tipo de retorno > main ( < tipo do argumento > ) { < bloco de comandos > } Onde: < tipo de retorno > é o tipo dado ( numérico ou textual ) de retorno que o método main ( ) tem que retornar ao Sistema Operacional ao final de sua execução. Geralmente encontramos programas com a cláusula int indicando que o método main () irá retornar um número inteiro ao final de sua execução. Nestes casos é comum encontrarmos também o comando return 0 ; que indica que ao final da execução do método main ( ) o número inteiro zero ( 0 ) será retornado ao Sistema Operacional, como zero é nulo, nada será alterado ou afetado no funcionamento ou desempenho do Sistema Operacional. _______________________________________________________________________________________________ 10
  11. 11. _______________________________________________________________________________________________ main ( ) é a cláusula propriamente dita. < tipo de argumento > é o tipo de dado ( numérico ou textual ) que poderá ser passado como argumento para o método main ( ) na hora em que a sua execução é requisitada. Geralmente na declaração do método main ( ) esta parte é omitida sem problema algum, ou é usada a cláusula void que significa “sem valor”. “{“ e “}” São os delimitadores de bloco de comandos. Exemplos: int main ( ) { < bloco de comandos > O MODO MAIS UTILIZADO return 0 ; } ou int main ( void ) { < bloco de comandos > return 0 ; } _______________________________________________________________________________________________ 11
  12. 12. _______________________________________________________________________________________________ O EDITOR DE PROGRAMAS DEV - C++ Fabricado pela Bloodshed, o programa DEV-C++ é um editor de programas em Linguagem C++. O DEV-C++ foi desenvolvido para ser uma ferramenta de apoio a implementação de programas em C++, ou seja, fornecer um ambiente de programação que seja rápido e completo. As vantagens de se trabalhar em um ambiente deste tipo são : • Fornecer ferramentas para gerenciamento de arquivos ( abrir, fechar, imprimir, salvar, etc. ) • Fornecer um editor de texto que identifique cada comando digitado, ou mensagens ou ainda comentários e fórmulas e atribua uma cor de fonte específica para cada tipo de informação. • Faça uma ligação entre o código-fonte do usuário e o compilador C++ a fim de proceder à compilação e a execução dos programas. • Fornecer ferramentas para edição de programas assim como, ferramentas para correção de erros encontrados na compilação. • Simular um ambiente propício a execução dos programas que estão sendo editados e assim o usuário não precisa sair do editor para compilar ou executar seus programas. Neste texto iremos apenas tratar de alguns dos comandos mais simples do DEV-C++, a fim de fazer com que o usuário de adapte ao uso do DEV-C++ com maior facilidade. Primeiro vamos executar o editor DEV-C++ e para isto basta clicar no Botão Start (Iniciar) após aparecer o Menu Iniciar, clicar no link All Programs (Todos os Programas ) e no Menu Programas clicar na opção Bloodshed Dev-C++ e no sub- menu clicar em DEV-C++. Resumidamente: Iniciar Todos os Programas Bloodshed Dev-C++ Dev-C++ _______________________________________________________________________________________________ 12
  13. 13. _______________________________________________________________________________________________ A seguir o Dev-C++ irá apresentar a sua interface na tela. O editor Dev-C++ segue o padrão Windows, ou seja, a sua interface é composta de várias barras ( título, menus, ferramentas, status, etc. ) e de uma Área de trabalho. Esta característica facilita em muito o entendimento e o posterior uso do editor. _______________________________________________________________________________________________ 13
  14. 14. _______________________________________________________________________________________________ Comando Novo Este comando inicia um novo arquivo. Para acessá-lo basta clicar no menu Arquivo, opção Novo e no sub-menu clicar na sub-opção Arquivo Fonte. O simplesmente pressionar as teclas de comando Ctrl + N _______________________________________________________________________________________________ 14
  15. 15. _______________________________________________________________________________________________ SEPARADOR DE LINHAS DE COMANDO Todas as Linguagens de Programação existentes possuem o chamado separador de linhas de comando para, como o próprio nome já diz, separar as linhas de comando do programa. Para que o compilador no momento em estiver executando a análise léxica, semântica e sintática, no processo de compilação, saiba onde termina e começa uma nova linha de comando. O separador de linhas de comando nada mais é que um símbolo que identifica o final de uma linha de comando. Nas Linguagens de Programação C, C++, Java e Pascal, o separador de linhas de comando é por definição o símbolo chamado ponto-e-vírgula ( ; ). Exemplos: #include <cstdio> #include <cstdlib> int main ( ) † printf ( “ ponto e virgula “ ) ; system ( “PAUSE” ) ; return 0 ; } SEPARADORES DE LINHAS DE COMANDO _______________________________________________________________________________________________ 15
  16. 16. _______________________________________________________________________________________________ O COMANDO printf ( ) ; O comando printf ( ) ; é utilizado para exibir tanto mensagens quanto valores numéricos, ou ambos, na tela do usuário do programa. Geralmente o comando printf ( ) ; está presente no início dos programas, mais especificamente na Entrada de Dados dos programas, pois como a sua função é apresentar mensagens aos usuários do programa. Estas mensagens podem e devem informar aos usuários, os dados que são necessários para a correta execução do programa. O comando printf ( ) ; também é utilizado no final do programa, mais especificamente na Saída de Resultados, pois como sabemos, o comando printf ( ) ; também pode apresentar além de mensagens, valores numéricos contidos, ou não, em variáveis. Para utilizarmos o comando printf ( ) ; devemos primeiro no início do código-fonte inserir a cláusula #include <cstdio> pois o comando printf ( ) ; encontra-se dentro da biblioteca de comandos cstdio. Sintaxe do comando printf ( ) ; printf ( “ < mensagem > “ , < valor > ) ; Onde: printf o comando propriamente dito. ( ) delimita os argumentos (complementos) passados ao comando para o seu correto funcionamento. “ “ delimita a mensagem textual que irá aparecer na tela do usuário. , (vírgula) separador de argumentos de um comando. ; (ponto-e-vírgula) indica o final da linha do comando printf ( ) ; < mensagem > Texto que irá aparecer na tela do usuário. < valor > Pode ser um ou mais valores numéricos, uma ou mais variáveis ou uma expressão aritmética contendo números ou variáveis, ou ainda, ambos. _______________________________________________________________________________________________ 16
  17. 17. _______________________________________________________________________________________________ VARIÁVEIS Variáveis são porções ( pedaços ) ou áreas ( espaços ) da memória RAM ( Random Access Memory – memória de acesso randômico ) do computador. As variáveis são utilizadas para armazenar dados ( números, letras, datas, hora, valores monetários, etc. ) durante o tempo em que um programa está sendo executado, portanto, quando um programa que será executado em um computador precisar fazer uso da entrada de dados, este programa certamente precisará ter em seu código-fonte, a definição e declaração do uso de variáveis. Resumindo, as variáveis ( porções de memória ) tem a finalidade de armazenar valores durante a execução de um programa, e estes valores podem ser alterados a qualquer momento e quantas vezes forem necessários, daí o nome ‘variável’ pois o valor dentro desta porção de memória pode variar durante a execução do programa. O uso de variáveis é muito fácil, para isto, basta declará-las dentro do código- fonte do programa. Ao se declarar uma variável, deve-se informar ao Compilador, o nome ( identificador ) da variável e o tipo de valores ( tipo de dados ) que esta variável irá armazenar. Imaginem que a memória RAM do computador fosse um grande armário, e neste armário nós mandamos colocar inúmeras gavetas. Essas gavetas, que são pedaços ( espaços ) do armário, seriam as variáveis. Para utilizarmos essas gavetas, devemos primeiro dar um nome para elas, e este nome deve ser usado para que possamos localizar uma gaveta. Em segundo, devemos saber quais os tipos de coisas que podemos guardar dentro das gavetas. Quando alguém precisar de alguma coisa, mandamos ir ao armário e informar o nome da gaveta onde está aquilo que se está precisando. Quando precisarmos guarda um novo item, vamos ao armário, selecionamos uma gaveta, damos um nome a ela e guardamos o novo item. O parágrafo acima, tenta descrever o uso de variáveis de memória nos códigos-fonte dos programas. Para tentar ilustrar o que foi dito, observe atentamente as imagens a seguir. _______________________________________________________________________________________________ 17
  18. 18. _______________________________________________________________________________________________ O computador e seus componentes Placa-Mãe onde encontramos a memória RAM Placa de memória RAM _______________________________________________________________________________________________ 18
  19. 19. _______________________________________________________________________________________________ ENDEREÇOS CONTEÚDO 036AB3 CDF782 72BD62 B43E23 30FA78 A memória RAM é formada por uma AB342C série de posições, ... ... onde dentro delas, ... ... ... ... podemos armazenar informações ... ... F16A64 ... ... ... ... ... Cada posição de memória F16A64 possui também um espaço para armazenar informações Cada posição de memória possui um endereço HEXADECIMAL O compilador C++, troca o endereço hexadecimal por um nome de variável “nome da variável” “tipo de dado da variável” (identificador), além disso, o compilador marca qual o tipo “conteúdo armazenado pela variável” de dado que aquela posição de memória irá armazenar. _______________________________________________________________________________________________ 19
  20. 20. _______________________________________________________________________________________________ O COMANDO scanf ( ) ; O comando scanf ( ) ; é utilizado para ler valores que são digitados pelos usuários e colocar esses valores digitados em suas respectivas variáveis. Geralmente o comando scanf ( ) ; está presente no início dos programas, mais especificamente na Entrada de Dados dos programas, pois como a sua função é ler valores de entrada via teclado, nada mais correto do que utilizá-lo para ler os valores de entrada digitados pelos usuários e colocar esses valores digitados em suas respectivas variáveis. É muito comum encontra antes de um comando scanf ( ) ; um comando printf ( ) ; exibindo uma mensagem ao usuário, solicitando a entrada de um determinado valor, e depois o comando scanf ( ) ; para ler a entrada do valor solicitado. Para utilizarmos o comando scanf ( ) ; devemos primeiro no início do código-fonte inserir a cláusula #include <cstdio> pois o comando scanf ( ) ; encontra-se dentro da biblioteca de comandos cstdio. Sintaxe do comando scanf ( ) ; scanf(“ <identificadores> “,<variáveis> ); Onde: scanf o comando propriamente dito. ( ) delimita os argumentos (complementos) passados ao comando para o seu correto funcionamento. “ “ delimita a lista de identificadores de tipos de variáveis que serão lidas pelo comando. , (vírgula) separador de argumentos de um comando. _______________________________________________________________________________________________ 20
  21. 21. _______________________________________________________________________________________________ COMANDO DE ATRIBUIÇÃO O comando de atribuição, como o próprio nome já diz, serve para atribuir algo a alguma coisa. No nosso caso, utilizamos para atribuir valores a uma variável. Na Linguagem de Programação C++ utiliza-se o símbolo de “igual” ( = ) como comando de atribuição. Sintaxe do comando de atribuição: < variável > = < valor > ; Onde: < variável > O nome de uma variável que irá receber um valor. = O comando de atribuição propriamente dito. < valor > O valor pode ser um número ( inteiro ou real ) ou pode ser textual ( caractere ou string ), pode ser o resultado de uma expressão aritmética ou mesmo o valor contido em outra variável. ; Separador de linhas de comandos. _______________________________________________________________________________________________ 21
  22. 22. _______________________________________________________________________________________________ OPERADORES ARITMÉTICOS Em uma hora qualquer, mais cedo ou mais tarde, algum programa terá que executar cálculos matemáticos e devido a este fato, que as Linguagens de Programação possuem entre os seus inúmeros comandos, instruções, cláusulas, métodos, procedimentos, funções e símbolos um conjunto especial denominado Operadores Aritméticos. Os Operadores Aritméticos são: Operador Símbolo Exemplo de uso Adição + 10 + 2 ou variávelX + 10 ou variávelX + variávelY Subtração – 10 – 2 ou variávelX – 10 ou variávelX – variávelY Multiplicação * 10 * 2 ou variávelX * 10 ou variávelX * variávelY Divisão / 10 / 2 ou variávelX / 10 ou variávelX / variávelY Módulo % 10 % 2 ou variávelX % 10 ou variávelX % variávelY Adição ( + ) : Utilizado na soma de dois ou mais números ou variáveis, ou ainda, números e variáveis todos juntos. Exemplos : 110 + 20 + 4 + 3920 100 + variávelX + 200 variávelX + variávelY + variávelZ variávelX + 230 + variávelZ variávelX + 450 + variávelZ + 300 + variávelY 500 + variávelX + 1200 + variávelY + variávelZ + 660 _______________________________________________________________________________________________ 22
  23. 23. _______________________________________________________________________________________________ Subtração ( – ) : Utilizado na subtração de dois ou mais números ou variáveis, ou ainda, números e variáveis todos juntos. Exemplos : 110 - 20 - 4 - 3920 100 - variávelX - 200 variávelX - variávelY - variávelZ variávelX - 230 - variávelZ variávelX - 450 - variávelZ - 300 - variávelY 500 - variávelX - 1200 - variávelY - variávelZ - 660 Multiplicação ( * ) : Utilizado na multiplicação de dois ou mais números ou variáveis, ou ainda, números e variáveis todos juntos. Exemplos : 110 * 20 * 4 * 3920 100 * variávelX * 200 variávelX * variávelY * variávelZ variávelX * 230 * variávelZ variávelX * 450 * variávelZ * 300 * variávelY 500 * variávelX * 1200 * variávelY * variávelZ * 660 _______________________________________________________________________________________________ 23
  24. 24. _______________________________________________________________________________________________ Divisão ( / ) : Utilizado na divisão de dois números ou variáveis, ou ainda, número por variável ou mesmo, variável por número. Exemplos : 110 / 20 100 / variávelX variávelX / variávelY variávelX / 30 Módulo ( % ) : Utilizado na divisão de dois números ou variáveis do tipo inteiro ( int ), ou ainda, número por variável ou mesmo, variável por número. O operador aritmético Módulo (%) retorna o RESTO de uma operação de divisão de números inteiros. Por exemplo: 10 % 3 irá retornar o valor 1 (um). Exemplos : 110 % 20 100 % variávelX variávelX % variávelY variávelX % 30 Observação: Operações de Potenciação e Radiciação são executadas por comandos (funções) da Linguagem C++ e não através de operadores (símbolos). _______________________________________________________________________________________________ 24
  25. 25. _______________________________________________________________________________________________ OPERADORES RELACIONAIS Os Operadores Relacionais é um conjunto de operadores, que são representados por diversos símbolos, e tem por funcionalidade a missão de verificar qual a relação existente entre dois ou mais números ou duas ou mais variáveis, ou ainda entre uma ou mais varáveis e um ou mais números. Os Operadores Relacionais são utilizados em conjunto com diversas estruturas de uma Linguagem de Programação, entre essas estruturas, podemos destacar as estruturas: Condicional, Múltipla Escolha e Repetição. Os Operadores Relacionais são: Operador Símbolo Exemplos de uso Igual == 1 == 1 ou X == 1 ou 1 == X ou X == Y Diferente != 1 != 2 ou X != 1 ou 1 != X ou X != Y Maior que > 2 > 1 ou 2 > X ou X > 2 ou X > Y Maior ou igual a >= 10 >= 2 ou 2 >= X ou X >= 1 ou X >= Y Menor que < 1 < 2 ou 2 < X ou X < 2 ou X < Y Menor ou igual a <= 2 <= 2 ou 2 <= X ou X <= 1 ou X <= Y _______________________________________________________________________________________________ 25
  26. 26. _______________________________________________________________________________________________ Utilização dos Operadores Relacionais Os Operadores Relacionais são utilizados em expressões relacionais, que por sua vez são montadas ( criadas ) pelos programadores, a fim de atende uma condição ou comparação necessária à execução do programa. Esta expressão relacional é compilada e quando executada, será “resolvida” pelo Processador da máquina em que o programa está sendo executado. O Processador executa as relações necessárias ( comparações ) e retorna um determinado valor. Este valor retornado só pode ser VERDADEIRO ( TRUE ) ou FALSO ( FALSE ), ou seja, o Processador após executar uma expressão relacional, só poderá retornar só, e somente só um desses dois valores: VERDADEIRO ou FALSO. Por exemplo: X = 1 ; X vale 1 ( X > 0 ) Esta expressão relacional verifica se o valor contido em X é maior que zero. Caso o valor de X seja realmente maior que zero, o Processador irá retornar como resultado da expressão relacional o valor VERDADEIRO ao programa que contém a expressão relacional. Caso o valor de X seja menor ou igual a zero, o Processador irá retornar como resultado da expressão relacional o valor FALSO ao programa que contém a expressão relacional. Muitas das decisões que são tomadas durante a execução de um programa em função dos dados de entrada ou dos resultados do processamento desses dados, ou ainda, pelos comandos dos usuários, são basicamente obtidas através de expressões relacionais que são executadas ( resolvidas ) pelo Processador . Em função do resultado ( VERDADEIRO ou FALSO ) retornado pelo Processador, podemos dar uma determinada direção na execução dos programas. Esta técnica é idealizada, projetada e construída pelos programadores de sistemas, e fazem uso de diversas estruturas de uma Linguagem de Programação. _______________________________________________________________________________________________ 26
  27. 27. _______________________________________________________________________________________________ Operadores Relacionais Igual ( == ) Utilizado para verificar se dois ou mais valores são iguais. Os valores podem ou não estar contidos em diferentes variáveis. Exemplos: X == Y X == 1 1 == X 1 == 1 1 == 0 Diferente ( != ) Utilizado para verificar se dois ou mais valores são diferentes entre si. Os valores podem ou não estar contidos em diferentes variáveis. Exemplos: X != Y X != 1 1 != X 1 != 1 1 != 0 _______________________________________________________________________________________________ 27
  28. 28. _______________________________________________________________________________________________ ESTRUTURA CONDICIONAL Estrutura Condicional, ou também muito conhecida como Estrutura de Decisão, é uma estrutura muito utilizada na programação de computadores, além de ser um ótimo recurso ou mesmo técnica de programação. A grande maioria dos programas, se não todos, atualmente possuem em algum momento ou lugar, uma estrutura condicional. Estrutura Condicional ou Estrutura de Decisão, nada mais é do que uma sequência de comando dispostos em ordem lógica, que analisam determinadas condições (valores, variáveis, comandos, etc.), daí o nome estrutura condicional, para realizar a tomada de uma decisão, daí também o nome estrutura de decisão, e esta decisão pode e dever com certeza mudar o fluxo de execução dos comandos do programa em questão. Por exemplo: Analise a descrição do programa abaixo: 1 – O programa deve ler o nome da pessoa. 2 – O programa deve ler a idade da pessoa. 3 – O programa deve verificar se a idade é maior que 18 anos. 3.1 – Caso a idade seja maior ou igual a 18 anos, o programa deve exibir uma mensagem com o texto: “Você já pode solicitar a sua habilitação”. 3.2 – Caso a idade seja menor que 18 anos, o programa deve exibir uma mensagem com o texto: ”Você deve aguardar até a maioridade para solicitar a sua habilitação”. 4 – O programa deve ler o RG da pessoa. 5 – ...etc... Veja que no item 3 da descrição do programa, existe uma verificação a ser feita. Dependendo da condição do valor da variável idade, o programa tem que exibir uma mensagem na tela, ou seja, em função do valor da variável idade ser maior ou igual a 18 anos, ou não (condição), o programa tem que tomar a decisão de qual mensagem exibir. Podemos também pensar da seguinte maneira: - Se for verdade que o valor lido para a variável idade for maior ou igual a 18 anos, então escreva na tela a mensagem: “Você já pode solicitar a sua habilitação”. ou ainda... - Se for verdade que o valor lido para a variável idade for menor do que 18 anos, então escreva na tela a mensagem: “Você deve aguardar até a maioridade para solicitar a sua habilitação”. 28
  29. 29. _______________________________________________________________________________________________ Fluxograma (representação gráfica) do programa. LER NOME LER IDADE Você deve aguardar Você já pode até a maioridade para solicitar a sua N IDADE >= S solicitar a sua habilitação habilitação 18 _______________________________________________________________________________________________ 29
  30. 30. _______________________________________________________________________________________________ INTRODUÇÃO AO COMANDO if O comando if ( se – em inglês ) é responsável por grande parte das estruturas condicionais ( decisão ) encontradas na maioria dos programas. O comando if basicamente “faz uma pergunta” ao processador, de modo que a resposta do mesmo, só possa ser verdadeiro ou falso, com isso o comando if tem por objetivo, orientar o processador para qual ou quais comandos deverão ser executados, dependendo da resposta a pergunta. Estas “perguntas” geralmente são compostas de uma comparação ou relação, entre variáveis e determinados valores (numéricos, literais, etc.) ou mesmo entre duas variáveis. Por sua vez, estas comparações ou relações fazem uso de Operadores Relacionais entre variáveis e determinados valores. Todos esses componentes, operadores relacionais, variáveis, valores e comando if, escritos de maneira ordenada e lógica, são responsáveis pelas Estruturas Condicionais ou Estruturas de Decisão. 30
  31. 31. _______________________________________________________________________________________________ Sintaxe do comando if if ( < condição > ) { < bloco de comandos > ; } Onde... if O comando if propriamente dito. ( ) Usa-se os parênteses para delimitar uma condição do comando if . < condição > Condição que será analisada pelo comando if junto ao processador. { } Delimitadores de bloco de comandos – usados para delimitar os comandos que serão executados caso a condição analisada pelo comando if seja verdadeira. Separa os comandos que dependem diretamente do comando if dos demais comandos do programa. < bloco de comandos > Bloco de comandos que serão executados caso a condição analisada pelo comando if seja verdadeira. ; (ponto-e-vírgula) – Separador de linha de comando. _______________________________________________________________________________________________ 31

×