Your SlideShare is downloading. ×
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Ud3
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
306
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
4
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Unidade Didática III Variáveis e Operadores
  • 2. Tipos Básicos de Dados:  char: Caracter: O valor armazenado é um caractere. Caracateres geralmente são armazenados em códigos (normalmente o código ASCII). int: Número inteiro é o tipo padrão e o tamanho do conjunto que pode ser representado normalmente depende da máquina em que o programa está rodando. float: Número em ponto flutuante de precisão simples. São conhecidos normalmente como números reais.
  • 3. Tipos Básicos de Dados: double: Número em ponto flutuante de precisão dupla   void: Este tipo serve para indicar que um resultado não tem um tipo definido. Uma das aplicações deste tipo em C é criar um tipo vazio que pode posteriormente ser modificado para um dos tipos anteriores.
  • 4. Modificadores dos Tipos Básicos: Modificadores podem ser aplicados a estes tipos. Estes modificadores são palavras que alteram o tamanho do conjunto de valores que o tipo pode representar. Por exemplo, um modificador permite que possam ser armazenados números inteiros maiores. Um outro modificador obriga que só números sem sinal possam ser armazenados pela variável. A Tabela a seguir mostra todos os tipos básicos definidos no padrão ANSI.
  • 5. Constantes: Constantes são usadas em expressões para representar vários tipos de valores. Em C existem regras rígidas para determinar como devem ser escritos estes valores. Constantes Inteiras São valores numéricos sem ponto decimal, precedidos ou não por um sinal. Não é possível separar o sinal do valor numérico. Exemplo: 1997, -3, +5, 0 e -32000 Exemplos de erros: 1,234 (Não é possível vírgula.) - 345 (Não é possível separar sinal e o valor numérico.) 23 (Não é possível usar notação de expoentes.)
  • 6. Constantes Caracteres Uma constante caractere é um único caractere escrito entre ', como em 'a', podendo participar normalmente de expressões aritméticas. O valor que entra na expressão é o do código usado para representar o caractere.
  • 7. Constantes Inteiras Longas São constantes armazenadas em um número maior de bits. Para diferenciá-las de constantes inteiras comuns acrescenta- se um L ao final do número. Nos compiladores modernos o número de bytes usados para armazenar os valores inteiros é o mesmo tanto para tipos inteiros ( int) quanto para tipos inteiros longos ( long int). Por esta razão esta diferença entre constantes inteiras perde a razão de ser. Exemplos de constantes inteira longas, são: 234L 320000L -120000L
  • 8. Constantes em Ponto Flutuante São também conhecidos como constantes reais. Cada constante de ponto flutuante é considerada ser do tipo double. Uma constante em ponto flutuante é normalmente representada com ponto decimal, precedidas ou não de um sinal, podendo ser seguidas por um expoente. São exemplos de constantes em ponto flutuante. +23.45e-10 123.45 123.45E+10 123.45F
  • 9. Constantes Hexadecimais São constantes representadas na base 16. Normalmente são representadas com um 0x ou 0X antecedendo o número. Exemplos: 0xF (15), 0x25 (37) e 0XAB (171). Constantes Octais São constantes representadas na base 8. Normalmente são representadas sempre sem sinal e devem iniciar com um algarismo 0. Exemplos: 025 (21), 077 (63) e 011 (9)
  • 10. Variáveis Para manipular dados dos mais diversos tipos, é necessário poder armazená-los na memória e poder referenciá-los quando for preciso. É por isso que existem as variáveis, que nada mais são do que um espaço reservado na memória, e que possuem um nome para facilitar a referência, onde seu conteúdo pode ser alterado durante a execução do programa. As variáveis podem ser de diversos tipos (int, char, float, double, etc).
  • 11. Variáveis Nomes das Variáveis Existem algumas regras básicas que regulam o batismo de variáveis.  Todo nome só pode conter letras e dígitos;  O caractere "_" é contado como uma letra;  Todo primeiro caractere deve ser sempre uma letra;  Letras maiúsculas e minúsculas são consideradas caracteres diferentes. Palavras reservadas não podem ser usadas como nome de variáveis.
  • 12. É boa política escolher nomes que significam alguma coisa e indiquem a função da variável. Por exemplo: valor, soma, total, nome, raio. Declaração de variáveis: Para serem usadas, as variáveis precisam ser declaradas de modo que o compilador possa reservar espaço na memória para o valor a ser armazenado. A forma geral de uma declaração é: tipo lista_de_variaveis ; IMPORTANTE: Todas as variáveis em C devem ser declaradas antes de serem usadas.
  • 13. Exemplos: int i; unsigned int a, b, c; unsigned short int dia, mes, ano; double salario;
  • 14. Atribuição de valores às variáveis Após ser declarada, a variável pode receber valores. O operador de atribuição "=" indica que o valor à direita será atribuído à variável. O valor inicial pode ser atribuído de duas formas: Durante a declaração da variável: int i=0, j=10; float raio=2.54; char c='d';
  • 15. Durante execução da função: int funcao() { int i, j; float raio; char c; i = 0; j = 10; raio = 2.54; c = 'd'; ... }
  • 16. Ponto fixo Denotamos um número de ponto fixo quando especificamos o número de casas para a parte inteira e fracionária. Exemplo: Ponto fixo 1.15 (Um bit para a parte inteira e quinze para a parte fracionária). Neste caso sempre teremos números menores que dois, pois como está reservado somente um bit para a parte inteira, o maior valor que esse bit pode valer é 1. A parte fracionária começa do 2^-1 e vai até o 2^-15. Esses valores são interpretados literalmente. Exemplo: o binário 1010 0000 0000 0000 corresponde a 2^0 + 2^-2 = 1.25.
  • 17. Ponto flutuante (IEEE 754) Precisão simples Possui 32 bits Uso dos bits:  Sinal - Um bit que indica se o número é positivo (0) ou se é negativo (1).  Expoente - Um byte que contem o expoente. O expoente corresponde a soma do expoente com 127 (ou seja, para encontrar o verdadeiro valor do expoente, deve-se subtrair esse byte de 127. Atenção: o expoente com valor zerado (00h) ou todo ativado (FFh) tem significado especial expoente.
  • 18. Parte fracionária - Representa a parte fracionária do número. E a parte inteira do número? Resposta: O ponto flutuante proposto pela IEEE 754 sugere que usemos números em notação científica de modo que (em binário): 101.11 x 2 ^ 15 = 1.0111 x 2 ^ 17 Ou seja: quando trabalhamos com notação científica, se temos um número que tenha mais de uma casa inteira, mechemos no expoente de modo que fique com uma. Assim ganhamos uma casa pro expoente.
  • 19. PRÁTICA:
  • 20. #include <stdio.h> EXEMPLO: #include <stdlib.h> #define PI 3.14159265; int main (void) { float raio; double area, comprimento; printf ("Digite o raio do seu circulo:n cmr"); scanf ("%f", &raio); area = (raio*raio)*PI; comprimento = raio*2*PI; system ("cls"); printf ("A area do seu circulo e: %.2f cmn", area); printf ("O comprimento do seu circulo e: %.2f cm", comprimento); printf ("nn"); system ("pause"); }
  • 21. Escopo e visibilidade A visibilidade de um identificador determina as porções do programa no qual este identificador pode ser referenciado, ou seja, o seu escopo. Um identificador é visível somente dentro de seu escopo, que pode ser limitado para o arquivo, função, bloco, ou protótipo de função no qual ele aparece. Assim, o escopo de um identificador é a parte do programa no qual o seu nome pode ser usado.
  • 22. #include <stdio.h> EXEMPLO: int i = 1; // definido num nível externo int main (void) { printf(“%dn”, i); { int i = 2, j = 3; printf(“%d %dn”, i, j); // imprime 2 e 3 { int i = 0; printf(“%d %dn”, i, j); // imprime 0 e 3 } printf(“%dn”, i); // imprime 2 } printf (“%dn“, i); // imprime 1 return 0; }
  • 23. Modificadores de Tipo de Acesso Controlam a forma como as variáveis podem ser modificadas ou acessadas:  const  volatile Obs: Na declaração, esses modificadores devem preceder o tipo das variáveis. const: faz com que a variável possa apenas receber um valor inicial, não podendo ser alterada durante a execução do programa. Exemplo: const int a= 10;
  • 24. Modificadores de Tipo de Acesso volatile: é usado quando uma variável precisa ser alterada de forma não explícita no código do programa. Por exemplo, uma variável que armazena o tempo real do sistema, sendo alterada pela rotina de relógio do sistema operacional, e não por um comando de atribuição, precisa ser declarada como volatile. Exemplo da declaração: volatile char *address=0x3b;
  • 25. Especificadores de Classe de Armazenamento Além dos modificadores vistos acima, que informam ao compilador a forma de acessar ou alterar uma variável, existe também os especificadores de classe de armazenamento, que informam ao compilador a forma como a variável deve ser armazenada. Há quatro especificadores em C:  extern  static  register  auto
  • 26. Especificadores de Classe de Armazenamento O especificador extern diz ao compilador que a variável indicada foi declarada em outro arquivo que não podemos incluir diretamente, por exemplo o código de uma biblioteca padrão. Isso é importante pois, se não colocarmos o modificador extern, o compilador irá declarar uma nova variável com o nome especificado, "ocultando" a variável que realmente desejamos usar. É usado para variáveis globais não estáticas. extern float sum; extern int count; float returnSum (void) { count++; return sum; }
  • 27. Especificadores de Classe de Armazenamento As variáveis declaradas como static dependem se são globais ou locais:  Variáveis globais static funcionam como variáveis globais dentro de um módulo, ou seja, são variáveis globais que não são (e nem podem ser) conhecidas em outros módulos (arquivos). Isto é útil se quisermos isolar pedaços de um programa para evitar mudanças acidentais em variáveis globais.  Variáveis locais estáticas são variáveis cujo valor é mantido de uma chamada da função para a outra. int count (void) { static int num = 0; num++; return num; }
  • 28. Especificadores de Classe de Armazenamento O especificador register informa ao compilador que a variável deve ser armazenada em um registrador da CPU, e não na memória. Isto aumenta consideravelmente a velocidade de acesso. Inicialmente, somente as variáveis int e char poderiam ser register. O padrão ANSI então determinou que qualquer tipo pode utilizar o especificador register. Como alguns tipos de dados não cabem em um registrador, o compilador trata variáveis register de forma que o acesso seja o mais rápido possível. (Somente variáveis locais podem ser register). O uso do especificador auto é redundante. Todas as variáveis que não possuem um especificador são auto por default.
  • 29. Operadores:
  • 30. Regras de Precedência
  • 31. Operador sizeof() O operador sizeof() é um operador unário que retorna o tamanho em bytes da expressão ou tipo fornecido como parâmetro. Por exemplo, suponha que o tipo float tenha quatro bytes então a função sizeof(float) retorna o valor quatro. Para se calcular o tamanho de bytes de uma expressão não é necessário o uso de parênteses.
  • 32. Exemplo #define DIM 10 #include ... int main() { int i=0; float f=3.0; char c='a'; int v[DIM]; printf("Tamanho em bytes de alguns tiposn"); printf("Tamanho de int %dn", sizeof i); printf("Tamanho do float %dn", sizeof f); printf("Tamanho do double %dn", sizeof (double)); printf("Tamanho do char %dn", sizeof c); printf("Tamanho do vetor de %d inteiros e %dn", DIM, sizeof v); }
  • 33. Conversão de Tipos Quando operandos de tipos diferentes aparecem em expressões eles são convertidos para um tipo comum, que permita o cálculo da expressão da forma mais eficientes. Por exemplo, uma operação que envolva um tipo inteiro e um float, o valor inteiro é convertido para float. As conversões ocorrem somente quando necessário. Assim, em uma divisão de inteiros o resultado é do tipo inteiro. Ex.: A expressão 1/4*4 tem como resultado o valor inteiro 0. Já que a primeira expressão executada 1/4 tem como resultado 0.
  • 34. Conversão de Tipos Operandos do tipo char e int podem ser livremente misturados em expressões aritméticas. Os tipos char são convertidos para int (conjunto de caracteres na tabela ASCII). Exemplo: A conversão de uma letra maiúscula para minúscula pode ser facilmente implementada com o comando: c = c - 'A' + 'a'; // A letra armazenada na variável c é subtraída do código da letra maiúscula 'A', fornecendo a posição desta letra no alfabeto. Em seguida este valor é somado ao código da letra minúscula 'a' resultando da conversão para minúscula. As conversões aritméticas ocorrem de maneira quase que natural.
  • 35. Correspondência entre: Decimal, Hexadecimal, Octal e Caracter
  • 36. Conversão de Tipos Em operações binárias as seguintes conversões ocorrem quando diferentes tipos estão envolvidos: char é convertido para int float é convertido para double Então se algum dos operandos é double o outro é convertido para double e o resultado é double. Isto vale para os demais tipos. Assim, o resultado de uma expressão ao ser avaliado é convertido para o tipo da variável onde o resultado será armazenado. Um resultado float ao ser carregado em uma variável do tipo int causa o truncamento da parte fracionária porventura existente.
  • 37. EXEMPLO:

×