1 / 59

Prof.: José Eustáquio Rangel de Queiroz rangel@dsc.ufcg.br, rangeldequeiroz@gmail

Técnicas de Programação. Revisão Conceitual II. Operadores e Funções. Prof.: José Eustáquio Rangel de Queiroz rangel@dsc.ufcg.edu.br, rangeldequeiroz@gmail.com. Carga Horária: 60 horas. Roteiro I. Operadores Aritméticos Relacionais Lógicos Bit-a-Bit Condicional ? Para Apontadores

rainer
Télécharger la présentation

Prof.: José Eustáquio Rangel de Queiroz rangel@dsc.ufcg.br, rangeldequeiroz@gmail

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Técnicas de Programação Revisão Conceitual II Operadores e Funções Prof.:José Eustáquio Rangel de Queiroz rangel@dsc.ufcg.edu.br, rangeldequeiroz@gmail.com Carga Horária:60 horas

  2. Roteiro I • Operadores • Aritméticos • Relacionais • Lógicos • Bit-a-Bit • Condicional ? • Para Apontadores • De Alteração de Tipos (Cast) • Sizeof

  3. Roteiro II • Funções • Generalidades • Regras de Escopo de Variáveis • Passagem de Parâmetros • Protótipos • Classes de Armazenamento • Arquivos-cabeçalhos • Recursão

  4. Operadores I Operadores Aritméticos e Incrementais - Subtração/Menos unitário + Adição * Multiplicação / Divisão % Módulo divisão -- Decremento ++ Incremento

  5. Operadores II Operadores Aritméticos e Incrementais - Prioridades + - - * / % ++ -- - +

  6. Operadores III Operadores Relacionais > Maior do que >= Maior ou igual a < Menor do que <= Menor ou igual a == Igual a != Diferente de

  7. Operadores IV Operadores Lógicos && E (AND) || Ou (OR) ! Não (NOT)

  8. Operadores V Operadores Relacionais e Lógicos - Prioridades || - && == != > >= < <= ! +

  9. Operadores VI • Sistema Binário Sistema de numeração de base 2 • Disponibilidade de apenas 2 dígitos 0 e 1 • Exemplo 1011 = 1.23 + 0.22 + 1.21 + 1.20 = 11 • Bit Dígito Binário • Representação eletrônica a partir de chaves (ligada/ desligada) • Byte Agrupamento de 8 bits

  10. Operadores VII Exercício 1 – Conversão de decimal para binário ou vice-versa • Escrever um programa em C que receba do usuário um número inteiro positivo, representável em até 2 Bytes e o converta do sistema decimal para binário ou vice-versa • O usuário deverá poder escolher a base de referência para a conversão – 10 ou 2 • O programa deverá ser verificar, uma vez selecionada a base, se o número digitado pode ser convertido • O programa deverá incluir mensagens de erro elucidativas, a fim de instruir o usuário no processo de entrada dos dados

  11. Operadores VIII Operadores Bit-a-Bit & E (AND) | Ou (OR) ^ Ou Exclusivo (XOR) ~ Complemento de 1 >> Deslocamento para a direita << Deslocamento para a esquerda

  12. Operadores IX Operadores Bit-a-Bit • Operações em nível de números como padrões de bits • Para cada bit, x e y AND, OR, XOR e NOT OperadorUNÁRIO

  13. Operadores X Operadores Bit-a-Bit – OU Exclusivo (XOR) a|b a^b b a 0 0 0 0 1 0 1 1 1 1 0 1 1 1 1 0

  14. Operadores XI Exemplo 1

  15. Operadores XII Operações LógicasversusBit-a-Bit • Operações Lógicas 37&&2461 37||2461 !370 • Operações Bit-a-Bit 37&24636 37|246247 ~37218

  16. Operadores XIII Mascaramento e Configuração Máscaras Bits configurados

  17. Operadores XIV Exemplo 2 - Redução de 256 níveis de cinza para 16 com máscaraAND

  18. Operadores XV Exemplo 2 – Resultado do mascaramento de bits sobre uma imagem digital 256 16 Imagem original Imagem quantizada para 4 bits

  19. valor x após a execução de x Operadores XVI Operadores Bit-a-Bit – Multiplicação e Divisão com Operadores de Deslocamento char x; X=7; 00000111 7 x2 X<<1; 00001110 14 x4 X<<2; 00111000 56 /2 X>>1; 00011100 28 /4 X>>2; 00000111 7

  20. Operadores XVII Operador<< Movimentação de padrões de bits para a esquerda • Deslocamento de 1 bit para a esquerda ⇒Multiplicação do valor codificado por 2 • Exemplo Impossibilidade de representação com 1 Byte

  21. Operadores XVIII Operador>> Movimentação de padrões de bits para a direita • Deslocamento de 1 bit para a direita ⇒Divisão do valor codificado por 2 • Exemplo

  22. Operadores XIX Operadores Bit-a_Bit - Prioridades ~ - >> << & ^ | +

  23. Operadores XX Operador Condicional ? • Forma geral Exp1?Exp2:Exp3; • Descrição • SeExp1 for VERDADEIRAExp2 se torna o resultado da operação. • SeExp1 for FALSAExp3 se torna o resultado da operação.

  24. Operadores XXI Operadores Condicional ? • Exemplo • Qual o valor atribuído a y na execução do trecho de programa abaixo ? x = 10; y = x > 9 ? 100 : 200

  25. Operadores XXII Operadores para Apontadores & Retorna endereço da variável a que precede * Conduz ao valor da variável a que precede x y y = &x; 111A 111A x *y = 100; 100 111A

  26. Operadores XXIII Operadores de Apontadores - Exemplo z p p=&z; 20 10 1010 1010 *p=10; z=*p+10;

  27. #include “stdio.h” void main(void) { int destino, fonte; int *m; fonte = 10; m = &fonte; destino = *m; printf(“%d”, destino); } Operadores XXIV Operadores de Apontadores - Exemplo Qual o valor armazenado na variável destino após a execução do programa ?

  28. Operadores XXV Operador de Alteração de tipo (Cast) • Cast Alteração temporária do tipo de uma variável int main(void) { int i = 5, j = 4; double f; f = (double)i / j; f = i / (double)j; f = (double)i / (double)j; f = (double)(i / j); return 0; } Se qualquer dos operandos for alterado para double, o outro será automaticamente alterado A divisão de inteiros será efetuada e seu resultado, 1, será alterado para double, 1.00000

  29. Operadores XXVI Operadorsizeof • sizeof Mecanismo para a determinação de quantos bytes uma variável ocupa #include <stdio.h> int main(void) { long teste; printf("\“teste\" ocupa %u bytes\n", sizeof(teste)); printf(“Uma variavel short ocupa %u bytes\n", sizeof(short)); printf(“Uma variavel double ocupa %u bytes\n", sizeof double); return 0; } “teste" ocupa 4 bytes Uma variavel short ocupa 2 bytes Uma variavel double ocupa 8 bytes

  30. Operadores XXVII Tabela de Precedência/Associatividade Operador Associatividade ___________________________________________________________________________________________________ () [ ] -> . esquerda para direita ! ~ ++ -- - + (cast) * & sizeofdireita para esquerda * / % esquerda para direita + - esquerda para direita << >> esquerda para direita < <= >= > esquerda para direita == != esquerda para direita & esquerda para direita | esquerda para direita ^ esquerda para direita && esquerda para direita || esquerda para direita ?:direita para esquerda = += -= *= /= %=etcdireita para esquerda , esquerda para direita

  31. Funções I Filogenia de Linguagens de Programação Fortran (1954) LISP (1957) Algol (1958) CPL1 (U Cambridge, 1963) BCPL2 (MIT, 1967) Simula (1967) B (Bell Labs, 1969) C (Bell Labs, 1970) Scheme (1975) C++ (Bell Labs, 1983) Objective C Java (Sun, 1995) 1 Combined Programming Language 2 Basic Combined Programming Language

  32. /* Bibliotecas */ #include <stdio.h> . . . /* Constantes, variáveis e tipos globais */ const float PI=3.141592654; . . . /* Programa Principal */ int main() { /* Declaração das variáveis */ int x,y; . . . /* Programa propriamente dito */ scanf("%d",&x); . . . return 0; /* para indicação de execução bem-sucedida */ } Funções II Estrutura de um Programa em C

  33. Funções III Funções em C • Propósito: • Decomposição de tarefas computacionais extensas em tarefas menores. Bloco A Bloco B Bloco C • Definição 1: • Funções são blocos de programa com início e fim. C permite aninhamento de blocos. Delimitadores de blocos:{}

  34. Funções IV Funções em C • Definição: • Funções são blocos precedidos de um cabeçalho que consiste em: • nomeda função; • lista de parâmetrosouargumentoscom respectivos tipos; • tipo do valor de retorno(se houver algum).

  35. tipo_de_retornonome_da_função(declaração_de_parâmetros){corpo_da_função}tipo_de_retornonome_da_função(declaração_de_parâmetros){corpo_da_função} Funções V Funções em C • Forma geral: • Tipo default:int • Declaração de parâmetros: tipo nome1, tipo nome2, ... , tipo nomeN

  36. /* Exemplo */ #include <stdio.h> int EPar(int a) { if (a%2) /* Verifica se a for divisivel por 2 */ return 0;  /* Retorna 0 se a nao for divisivel por 2*/ else         return 1;  /* Retorna 1 se a for divisivel por 2 */ } Funções VI Comandoreturn return valor_de_retorno;oureturn; • Forma geral:

  37. Funções VII Exercício 2 Escreva a função'EDivisivel(int a, int b)'(tome como base EPar(int a)). A função deverá retornar 1 se o resto da divisão de a por b for zero. Caso contrário, a função deverá retornar 0.

  38. Funções VIII Regras de Escopo de Variáveis • Variáveis declaradas em um bloco externo são também válidas no bloco interno ao primeiro. • Variáveis declaradas em um bloco são GLOBAIS para todos os blocos internos e LOCAIS para o próprio bloco. • Uma variável declarada dentro de um bloco só é conhecida dentro daquele bloco (e dos blocos internos a ele).

  39. Funções IX Regras de Escopo de Variáveis - Exemplo Bloco A float y; • y é variável GLOBAL para B e C. • x é variável LOCALde B e de C. • x de B e x de C são variáveis distintas, invisíveis em A. Bloco B int x; Bloco C int x;

  40. Funções X Chamada de Funções • Uma função só é executada sob chamada. int main() int f(int x)

  41. int main() /* Programa principal também é função */ { int a, b, c; a = -10; b = 5; c = 5 + abs(a); /* chamada à função abs */ printf("%d",c); return 0; /* OK */ } Funções XI Chamada de Funções – Exemplo main()

  42. int abs(int x) /* cabeçalho */ {/* inicio do bloco da função */ int res; if (x >= 0) res = x; else res = -x; return res; } Funções XII Chamada de Funções – Exemplo abs()

  43. Funções XIII Passagem de Parâmetros • Em C, a passagem de parâmetros é sempre por valor (cópia local da variável original). • A função recebe uma cópia temporária e particular de cada argumento e, portanto, não pode afetar o argumento original da função chamada.

  44. int main() { int x; x = 5; IncImprime(x); printf("%d",x); return 0; } Funções XIV Passagem de Parâmetros – Exemplomain()

  45. void IncImprime(int valor) { valor++; printf("%d",valor); } Funções XV Passagem de Parâmetros – ExemploIncImprime()

  46. /* Bibliotecas */ #include <stdio.h> /* Variáveis, constantes e tipos globaisa todas as funções */ const float PI = 3.141592654; /* Protótipos (cabeçalhos) das funções */ float maior(float a, float b); /* Programa principal */ int main(){ float x,y, m; scanf("%f",&x); scanf("%f",&y); m = maior(x,y); printf("Maior = %f\n", m); return 0; } /* Corpo das funções */ float maior(float a, float b){ if (a>b) return a; else return b; } Funções XVI

  47. Funções XVII Protótipos de Funções • Protótipo de uma função que não retorna nada: void nome_da_função(declaração_de_parâmetros); • Protótipo de uma função que não têm parâmetros: tipo_de_retorno nome_da_função(void); • Protótipo de uma função que não tem parâmetros e não retorna nada: void nome_da_função(void);

  48. Funções XVIII Classes de Armazenamento Automática autoExtern externEstática staticAutomática auto

  49. void main() /* cabeçalho */ {/* inicio do bloco externo */ int y=5; { /* inicio do bloco interno */ int y; y=15; printf(“No bloco interno, y=%d\n”,y); } /* término do bloco interno */ printf(“No bloco externo, y=%d\n”,y); } /* término do bloco externo */ Funções XIX Classe Automática auto • Padrão para variáveis declaradas dentro de uma função • Sem especificação quanto à classe de armazenamento

  50. int y; void main() {/* inicio da função main*/ y=5; func(); printf(“Na funcao main, y=%d\n”,y); } /* término da função main*/ func() {/* inicio da função func*/ y=15; printf(“Na funcao func, y=%d\n”,y); } /* término da função func*/ Funções XX Classe Externa extern • Variáveis declaradas fora de uma função • Valor acessível (visível) a todas as funções do módulo no qual ocorre sua definição

More Related