INTRODUÇÃO À COMPUTAÇÃO (IC)

UD III – Variáveis e operadores

SUMÁRIO
1. VARIÁVEIS
a. Tipos básicos de dados
b. Utilizando variáveis
c. printf( ) e scanf( )
d. Constantes
e. Escopo e visibilidade
2. OPERADORES
a. Lista de operadores
b. Regras de precedência
c. Utilizando operadores
d. Operações com operandos de mesmo tipo
e. Operações com operandos de tipos diferentes
f. Conversão de tipos
VARIÁVEIS
VARIÁVEIS | Tipos básicos de dados

● char: o valor armazenado é um caractere. Caracteres 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 (4 bytes). São
conhecidos normalmente como números reais.
● double: número em ponto flutuante de precisão dupla (8 bytes).
● 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.
VARIÁVEIS | Tipos básicos de dados

Extrato da
TABELA ASCII
(American
Standard Code
for Information
Interchange)
VARIÁVEIS | Tipos básicos de dados
VARIÁVEIS | Tipos básicos de dados
#include <stdio.h>
int main(){
printf("Tamanhos em bytes:\n");
printf("char = %d\n", sizeof(char));
printf("unsigned char = %d\n", sizeof(unsigned char));
printf("signed char = %d\n", sizeof(signed char));
printf("int = %d\n", sizeof(int));
printf("unsigned int = %d\n", sizeof(unsigned int));
printf("signed int = %d\n", sizeof(signed int));
printf("short int = %d\n", sizeof(short int));
printf("unsigned short int = %d\n", sizeof(unsigned short int));
printf("signed short int = %d\n", sizeof(signed short int));
printf("long int = %d\n", sizeof(long int));
printf("unsigned long int = %d\n", sizeof(unsigned long int));
printf("signed long int = %d\n", sizeof(signed long int));
printf("float = %d\n", sizeof(float));
printf("double = %d\n", sizeof(double));
printf("long double = %d\n", sizeof(long double));
return 0;
}
VARIÁVEIS | Tipos básicos de dados

● Existem prefixos que alteram o tamanho máximo de um tipo básico.

○ Signed
○ Unsigned
○ Short
○ Long
VARIÁVEIS | Tipos básicos de dados

● Cálculo dos valores mínimos e máximos de um tipo de N bits

○ Signed
mín = -1 * 2N-1 máx = 2N-1 -1

Ex: char (8 bits): mín = -1*28-1 = -128 & máx = 28-1 -1 = 127

○ Unsigned
mín = 0 máx = 2N -1
Ex: unsigned char (8 bits): mín = 0 & máx = 28 -1 = 255
VARIÁVEIS | Tipos básicos de dados

REPRESENTAÇÃO DE NÚMEROS NEGATIVOS

● Quando o tipo é signed, o dígito mais significativo é igual a “0”, se for

positivo (sem sinal), e igual “1”, quando for negativo.
VARIÁVEIS | Tipos básicos de dados

REPRESENTAÇÃO DE NÚMEROS NEGATIVOS

● Uma forma muito comum para representar o inteiro negativo é o

formato “complemento dois” (two complement). Ele é feito da seguinte
forma:
○ Toma-se a forma binária do módulo o número;
○ Trocam-se todos os 0s por 1s e vice-versa;
○ Adiciona-se um bit.

● Ex1: 00001111 = 15 &

11110000 + 00000001 = 11110001 = -27 + 26 + 25 + 24+ 20 = - 15
Ex2: 01111000 = 120 &
10000111 + 00000001 = 10001000 = -27+23 = -120
VARIÁVEIS | Tipos básicos de dados

REPRESENTAÇÃO DE NÚMEROS NEGATIVOS

● O “complemento dois” previne a existência de “dois zeros”. A soma de

dois números sinalizados torna-se uma simples adição binária.
● Ex: -15 + 7 = 11110001 + 00000111 = 11111000 =
= -27 + 26 + 25 + 24+ 23 = -8
VARIÁVEIS | Tipos básicos de dados

REPRESENTAÇÃO DE NÚMEROS REAIS

● Para números reais, há duas formas de armazenamento: ponto fixo e

ponto flutuante.

● No armazenamento em ponto fixo, todos os números reais possuem a

mesma quantidade de casas decimais.

● Isto limita o amplitude da faixa de números utilizável.

VARIÁVEIS | Tipos básicos de dados

REPRESENTAÇÃO DE NÚMEROS REAIS

● Os números em ponto flutuante possuem o seguinte formato

N = (-1)S x M x 2E-127

● Onde
○ S é o sinal (s = 0 ou 1), representado por um único bit.
○ M (mantissa) é uma série de bits representando um valor entre 0 e 1
(ou 1 e 2).
○ E é uma série de bits representando um número inteiro.
● Em variáveis float, são reservados 8 bits para E e 23 para M.
● Variáveis double reservam 11 bits para E e 52 para M.
VARIÁVEIS | Tipos básicos de dados
VARIÁVEIS | Utilizando 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 (identificador)
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).
VARIÁVEIS | Utilizando variáveis

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;
● Exemplos:
○ int i;
○ unsigned int a, b, c;
○ unsigned short int dia, mes, ano;
○ double salario;

Todas as variáveis em C devem ser

declaradas antes de serem usadas.
VARIÁVEIS | Utilizando variáveis

NOMES DAS VARIÁVEIS

● Regras básicas:
○ 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.

É boa prática escolher nomes que significam

alguma coisa e indiquem a função da variável.
Por exemplo: valor, soma, total, nome, raio.
VARIÁVEIS | Utilizando variáveis

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 execução da função

Durante a declaração da variável int funcao() {

int i, j;
float raio;
int i=0, j=10; char c;
float raio=2.54; i = 0;
char c='d'; j = 10;
raio = 2.54;
c = 'd';
...
}
VARIÁVEIS | Utilizando variáveis

PRÁTICA

Implementar um programa que calcula

a área e o comprimento de um círculo
VARIÁVEIS | Utilizando variáveis

#include <stdio.h>

// Uma técnica de se definir uma constante utilizando diretiva de pré-compilação

// O seu valor NÃO poderá ser alterado no decorrer do programa
#define PI 3.14159265;

int main ( ) {
float raio;
double area, comprimento;

printf ("Digite o raio do seu circulo (cm): ");

scanf ("%f", &raio);

area = (raio*raio)*PI;
comprimento = raio*2*PI;

printf ("A area do seu circulo eh %.2f ", area);

printf ("O comprimento do seu circulo e: %.2f cm\n\n", comprimento);
return 0;
}
VARIÁVEIS | Utilizando variáveis

// Outra solução

#include <stdio.h>
#include <math.h>

int main(){
//Outra forma de se declarar uma constante
//O seu valor NÃO poderá ser alterado no decorrer do programa
const double pi = 4 * atan(1);
int raio =0;
printf("Entre com o raio do circulo :");
scanf("%f",&raio);
printf("Perimetro do circulo = %f\n", 2*pi*raio);
printf("Area do circulo = %f\n", pi*raio*raio);
return 0;
}
VARIÁVEIS | Imprimindo variáveis com printf()

● A função printf(), da biblioteca padrão stdio.h, permite imprimir variáveis

com formatação através da utilização de especificadores de formato
começados pelo símbolo %, localizados dentro da string a ser impressa.

Exemplo:

#include <stdio.h>
int main(){
float salario = 5123.4567;
printf("%s = R$ %.2f", "Salario", salario);
// Imprime: Salario = R$ 5123.46
return 0;
}
VARIÁVEIS | Lendo variáveis com scanf()

● A função scanf(), da biblioteca padrão stdio.h, permite ler a entrada do

teclado utilizando a seguinte sintaxe:
○ scanf("%X", &Y)
■ "%X" é o especificador de formato que define o tipo utilizado
■ Y é o nome da variável que armazenará o valor, devendo ser
sempre precedida de &
Exemplo:

#include <stdio.h>
int main(){
float salario = 0.0;
printf("Digite o valor do salario: ");
scanf("%f", &salario);
printf("%s = R$ %.2f", "Salario", salario);
return 0;
}
VARIÁVEIS | printf() e scanf()
ESPECIFICADORES DE FORMATO COMUNS

ESPECIFICADOR TIPO ESPECIFICADOR TIPO

%c char %f float

%d signed int %lf double

%i (signed) int %e ou %E (%g ou %G) Notação científica

%u unsigned int %x ou %X Hexadecimal

%hi short int %s String

%hu short unsigned int %p Ponteiro

%l ou %ld ou %li long int

%lu unsigned long

VARIÁVEIS | printf() e scanf()

ESPECIFICADORES DE FORMATO ESPECÍFICOS - printf()

ESPECIFICADOR SAÍDA

%.Xf ou %.Xlf Ponto flutuante com X casas decimais

%.Xe ou %.XE Número em notação científica com X casas decimais

%.Xs Primeiros X caracteres da string

%Xd Inteiro sinalizado com X espaços reservados para sua impressão

%0Xd Inteiro sinalizado com X espaços reservados para sua impressão, com zeros à
esquerda.

%X.Yf ou %X.Ylf Ponto flutuante com X espaços reservados para impressão e Y casas decimais

%n Número de caracteres impressos por printf() ou lidos por scanf()

%% Imprime %

... ...
VARIÁVEIS | printf() e scanf()

PEGADINHA!!!
#include<stdio.h>
int main() {
printf("Digite um caracter: ");
char ch1;
scanf("%c",&ch1);
printf("O caracter digitado foi %c\n", ch1);
printf("Digite outro caracter: ");
char ch2;
scanf("%c",&ch2);
printf("O caracter digitado foi %c", ch2);
return 0;
}
VARIÁVEIS | printf() e scanf()

#include<stdio.h>
int main() {
printf("Digite um caracter: ");
char ch1;
scanf("%c",&ch1);
printf("O caracter digitado foi %c\n", ch1);
printf("Digite outro caracter: ");
char ch2; Colocar um espaço
scanf(" %c",&ch2); em branco antes do
%c!!!
printf("O caracter digitado foi %c", ch2);
return 0;
}
VARIÁVEIS | printf() e scanf()

#include<stdio.h>
int main() {
printf("Digite um caracter: ");
char ch1;
scanf("%c",&ch1);
printf("O caracter digitado foi %c\n", ch1);
printf("Digite outro caracter: ");
char ch2; getchar() limpa o
getchar(); caracter Enter do
buffer de entrada.
scanf("%c",&ch2);
printf("O caracter digitado foi %c", ch2);
return 0;
}
VARIÁVEIS | printf() e scanf()

O que acontece?

#include<stdio.h> #include<stdio.h>
int main() { int main() {
double x = 0.; int i = 'c';
printf("x = %d\n", x); printf("%d\n" , i);
printf("x = %c\n", x); return 0;
return 0; }
}
VARIÁVEIS | printf() e scanf()

O que acontece?

#include<stdio.h> #include<stdio.h>
int main() {
int main() { printf("Velocidade da Luz no Vacuo = %e m/s", 299792458.);
int i = 0x0A; return 0;
printf("%d" , i); }

return 0;
}
VARIÁVEIS | printf() e scanf()

O que acontece?

#include<stdio.h> #include<stdio.h> #include<stdio.h>

int main() { int main() { int main() {
float x = 2.4; double x = 2.4; double x = 2.4;
scanf("%lf", &x); scanf("%f", &x); scanf("%lf", &x);
printf("%f",x); printf("%lf",x); printf("%lf",x);
return 0; return 0; return 0;
} } }
VARIÁVEIS | Constantes

● Constante: é um nome que corresponde a um valor fixo.

● Existem duas formas de declarar uma constante:
○ Através da diretiva de pré-compilação #define
■ Neste caso, a constante é chamada de constante simbólica e é,
geralmente, declarada em letras maiúsculas
■ Exemplo: #define PI 3.14
○ Através do modificador de acesso const
■ Neste caso, a variável pode apenas receber um valor inicial, não
podendo ser alterada durante a execução do programa.
■ Exemplo: const int a = 10;
VARIÁVEIS | Constantes

● Diferenças entre declarar constantes com const e #define:

○ #define:
■ é uma diretiva que informa ao pré-processador que o símbolo
que a segue deve ser substituído pelo valor que aparece depois
dele
● Exemplo: #define PI 3.14
○ indica ao pré-processador que onde ocorrer a palavra PI
no código, a mesma será substituída por 3.14
■ Não existe fisicamente na memória
○ const:
■ Como é um modificador de acesso, a constante declarada
dessa forma é realmente uma variável, existindo fisicamente na
memória
VARIÁVEIS | Constantes

● Constantes caracteres: possuem 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.
VARIÁVEIS | Constantes

● 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.
○ Em alguns 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:
■ 234L
■ 320000L
■ -120000L
VARIÁVEIS | Constantes

● Constantes Hexadecimais: 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: 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)
VARIÁVEIS | Constantes

● Constantes em ponto flutuante:

○ 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.
○ Exemplos:
■ +23.45e-10
■ 123.45
■ 123.45E+10
■ 123.45F
VARIÁVEIS | 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.
 VARIÁVEIS | Escopo e visibilidade

EXEMPLO
#include <stdio.h>
int i = 1; // definido num nível externo
int main ( ) {
printf(“%d\n”, i); // imprime 1
{
int i = 2, j = 3;
printf(“%d %d\n”, i, j); // imprime 2 e 3
{
int i = 0;
printf(“%d %d\n”, i, j); // imprime 0 e 3
}
printf(“%d\n”, i); // imprime 2
}
printf (“%d\n“, i); // imprime 1
return 0;
}
OPERADORES
OPERADORES | Lista de operadores
OPERADORES | Precedência de operadores

● Quando dois ou mais operadores se encontram em uma expressão as

operações são efetuadas uma de cada vez respeitando algumas regras
de precedência.
○ No caso dos operadores aritméticos, as regras são as mesmas da
matemática elementar.
Exemplo:

Expressão Valor Ordem

1+2-3 0 +-

24 - 3 * 5 9 * -

4-2*6/4+1 2 */-+

6 / 2 + 11 % 3 * 4 11 /%*+
OPERADORES | Precedência de operadores

● A ordem de precedência dos operadores pode ser quebrada

utilizando-se os parênteses, que possuem a mais alta precedência

Exemplo:

Expressão Valor Ordem

1 + (2 - 3) 0 -+

(24 - 3) * 5 105 -*

(4 - 2 * 6) / 4 + 1 -1 *-/+

6 / ((2 + 11) % 3) * 4 24 +%/*

OPERADORES | Regras de precedência
OPERADORES | Operadores de Atribuição Aritmética

● Muitas vezes, deseja-se alterar o valor de uma variável realizando alguma

operação aritmética com ela.
○ Exemplos:
■ i = i + 1;
■ val = val * 2;
● Para realizar tais operações de forma otimizada, são utilizados os Operadores
de Atribuição Aritmética:
○ São instruções otimizadas da linguagem C para otimizar a atribuição
aritmética:
■ Operadores: +=, -=, *=, /=, %=
■ Sintaxe:
● var (+=, -=, *=, /=, %=) exp;
○ var é o identificador da variável
○ exp é uma expressão válida
OPERADORES | Operadores de Atribuição Aritmética

● Exemplos:

Atribuição Aritmética Instrução Equivalente

i += 1; i = i + 1;

j -= val; j = j - val;

num *= 1 + k; num = num * (1 + k);

troco /= 10; troco = troco / 10;

resto %= 2; resto = resto % 2;

● O operador de atribuição aritmética tem precedência menor que a

maioria dos operadores (ver tabela de precedências).
OPERADORES | Operadores de Incremento e Decremento

● Operador que incrementa (++) ou decrementa (--) uma variável em 1

unidade.
● Existem duas variações para este operador:
○ PRÉ (++nome_variavel ou --nome_variavel): o valor será
incrementado/decrementado na instrução em que a variável estiver
contida.
○ PÓS (nome_variavel++ ou nome_variavel--): o valor será
incrementado/decrementado na próxima instrução.
● Exemplo: #include <stdio.h>
int main( ){
int i = 0, j = 0;
printf("%d\n", ++i); //Imprime 1
printf("%d\n", j++); //Imprime 0
printf("%d\n", --i); //Imprime 0
printf("%d\n", j--); //Imprime 1
return 0;
}
OPERADORES | Atribuição Múltipla

● O operador de atribuição ( = ) pode ser utilizado para atribuir um valor a

múltiplas variáveis em uma única instrução.
○ Sintaxe: var_1 = [ var_2 = … ] expressão;
■ var_1, var_2, … são os identificadores de variáveis;
■ expressão é uma expressão válida.
○ Exemplo:
■ int x = y = z = 0;
● As atribuições múltiplas ocorrem da direita para a esquerda:
○ Em int x = y = z = 0, o valor 0 é atribuído primeiro a z, depois a y e, por
último, a z.
● O operador de atribuição possui a mesma precedência dos operadores de
atribuição aritmética.
OPERADORES | Atribuição Múltipla

● Deve-se tomar cuidado com as conversões de tipo e limites de intervalo para

atribuições de tipos diferentes.
Exemplo:
#include <stdio.h>

int main(){
int i, j, k;
double max, min;

i = j = k = 1;
max = min = 0;

max = i = 3.56;

printf("i = %d e max = %f \n", i, max);

return 0;
}
OPERADORES | Operadores Lógicos e Relacionais

● Na linguagem C, uma variável possui os seguintes valores lógicos:

○ Falso: se o seu valor é igual a zero;
○ Verdadeiro: se seu valor é diferente de zero.
● Os operadores lógicos são:
○ && : e (and);
○ || : ou (or);
○ ! : não (not).

A B !A A && B A || B

0 0 1 0 0

1 0 0 0 1

0 1 1 0 1

1 1 0 1 1
OPERADORES | Operadores Lógicos e Relacionais

● Quais são as saídas do programa?

#include <stdio.h>

int main(){
int A = 0;
float B = 0.1;
char C = 0;
int D = 123;

printf("!A = %d e !B = %d \n", !A, !B);

printf("B && C = %d e C || D = %d \n", B && C, C || D );
printf("!(((A && B) || C) && D) = %d \n", !(((A && B) || C) && D));

return 0;
}
OPERADORES | Operadores Lógicos e Relacionais

● Os operadores relacionais permitem a comparação de valores.

● São os seguintes:
○ < : menor que;
○ <= : menor ou igual que;
○ == : igual a;
○ != : diferente de;
○ >= : maior ou igual a ;
○ > : maior que.
● O resultado de uma comparação (ou operação lógica) será:
○ 0 , se a condição testada for falsa;
○ 1 , se a condição testada for verdadeira.
OPERADORES | Operadores Lógicos e Relacionais

● Quais são as saídas do programa?

#include <stdio.h>

int main(){
int A = 102;
float B = 102.0;
char C = 'a';
int D = 50;

printf("A é maior ou igual a B? %d \n", A >= B);

printf("A é diferente de B? %d \n", A != B);
printf("C é maior que D? %d \n", C > D );

return 0;
}
OPERADORES | Operadores Lógicos e Relacionais

● Precedência dos operadores lógicos e relacionais:

OPERADOR

< <= > >=

== !=

&&

||

?:
OPERADORES | Operadores Bit a Bit

● ~ (NOT) : ~0 = 1 ● ^ (XOR) : 0 ^ 0 = 0
~1 = 0 0^1=1
1^0=1
● & (AND) : 0 & 0 = 0 1^1=0
0&1=0
1&0=0 ● << (Shift-left) :
1&1=1 0010 1100 << 2 = 1011 0000

● | (OR) : 0|0=0 ● >> (Shift-right) :

0|1=1 0010 1100 >> 2 = 0000 1011
1|0=1
1|1=1
Operadores bit a bit só são usados com tipos
char, int (e variantes)!!!
OPERADORES | Operadores Bit a Bit

● Deslocamentos simples à esquerda são multiplicações por 2

1 = 0000 0001 << 1 = 0000 0010 = 2
2 = 0000 0010 << 1 = 0000 0100 = 4
9 = 0000 1001 << 1 = 0001 0010 = 18

● Deslocamentos simples à direita são divisões inteiras por 2

2 = 0000 0010 >> 1 = 0000 0001 = 1
8 = 0000 1000 >> 1 = 0000 0100 = 4
19= 0001 0011 >> 1 = 0000 1001 = 9
OPERADORES | Operadores Bit a Bit

#include <stdio.h>
int main(){
unsigned char A = 2; // A = 0010
unsigned char B = 7; // B = 0111

unsigned char auxA = ~A; //Por quê?

printf("~A = %u\n", auxA); // ~0000 0010 = 1111 1101 = 253
printf("A & B = %u\n", A & B); //0000 0010 & 0000 0111 = 0010 = 2
printf("A | B = %u\n", A | B); //0000 0010 | 0000 0111 = 0111 = 7
printf("A ^ B = %u\n", A ^ B); //0000 0010 ^ 0000 0111 = 0101 = 5
printf("B << A = %u\n", B << A); //0000 0111 << 0000 0010 = 0001 1100 = 28
printf("B >> A = %u\n", B >> A); //0000 0111 >> 0000 0010 = 0000 0001 = 1
return 0;
}
OPERADORES | Operador sizeof()

● O operador sizeof() é um operador unário que retorna o tamanho em bytes da

expressão ou tipo fornecido como parâmetro.

Sintaxe: sizeof(expressão) ou sizeof(tipo)

Obs: Caso a expressão seja apenas uma única variável, os parênteses podem
ser omitidos. No caso da entrada ser um tipo, os parênteses são obrigatórios.

● Por exemplo, suponha que o tipo float ocupa 4 bytes em certa máquina, então a
função sizeof(float) retorna o valor 4.
OPERADORES | Operador sizeof()

● Exemplo:
#include <stdio.h>
#define DIM 10
int main() {
int i=0;
float f=3.0;
char c='a';
int v[DIM]; //Vetor de inteiros – Veremos vetores mais adiante no curso.
printf("Tamanho em bytes de alguns tipos\n");
printf("Tamanho de int = %d bytes\n", sizeof (i));
printf("Tamanho do float = %d bytes\n", sizeof (f));
printf("Tamanho do double = %d bytes\n", sizeof (double));
printf("Tamanho do char = %d bytes\n", sizeof (c));
printf("Tamanho do vetor de %d inteiros = %d bytes\n", DIM, sizeof (v));
return 0;
}
OPERADORES | Operação com operandos de mesmo tipo

● Qual o tipo do valor resultante de uma operação binária (com dois

operandos)?
○ Depende dos tipos dos seus operandos.

● Quando uma operação é composta por operandos de mesmo tipo, o

tipo do resultado é o mesmo.
○ Ex: dois operandos do tipo int → resultado é do tipo int
OPERADORES | Operação com operandos de tipos diferentes

● Por outro lado, uma operação pode ser composta por operandos de
tipos diferentes.
○ Ex: Sejam as variáveis abaixo e a operação de multiplicação entre elas.
int a;
float x;
(a * x) → essa operação possui 2 tipos diferentes envolvidos

● Qual o tipo do valor resultante nesse caso?

● Quando uma operação é composta por operandos de tipos diferentes,

o tipo do resultado deve englobar o cálculo da operação da forma mais
eficiente nos registradores.
OPERADORES | Operação com operandos de tipos diferentes

● Em operações binárias entre tipos diferentes, o tipo resultante depende

do tipo dos seus operandos.

Operador 1 Operador 2 Resultado

double char, int, float double
float char, int float
char int int
OPERADORES | Operação com operandos de tipos diferentes

● Ex 1: Se um dos operandos é double e o outro não, este é convertido

para double e o resultado é double. O mesmo vale para os demais tipos.

● Ex 2: operação entre char e int. 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 na conversão para
minúscula.
OPERADORES | Operação com operandos de tipos diferentes

ATENÇÃO

A atribuição (operador =) é uma operação distinta da

expressão avaliada à direita e ocorre com menor prioridade.

Dessa forma, o valor da expressão à direita será

armazenado no tipo da variável à esquerda do operador,
podendo ocorrer truncamento.

Veja o exemplo do código a seguir.

OPERADORES | Operação com operandos de tipos diferentes

Quais são os valores de x e de y? Analise o código abaixo.

#include <stdio.h>

int main(){

float x, y = 0.0;

x = 3*1/10;
printf("x = %f \n" , x);

y = 3.0*1/10;
printf("y = %f \n" , y);

return 0;
}
OPERADORES | Operação com operandos de tipos diferentes

Quais são os valores de x e de y?

#include <stdio.h>

int main(){

float x, y = 0.0;

x = 3*1/10; //1ª operação: 3*1; 2ª operação: 3/10; 3ª operação: x recebe 0

printf("x = %f \n" , x);

y = 3.0*1/10; //1ª operação: 3.0*1; 2ª operação: 3.0/10; 3ª operação: x recebe 0.3

printf("y = %f \n" , y);

return 0;
}
 OPERADORES | Operação com operandos de tipos diferentes

#include <stdio.h>

int main(){
char ch = 'a';
int num = 3;

printf("O caracter ch = '%c' em ASCII é %d e tem tamanho de %d byte(s)\n", ch, ch, sizeof(ch));
printf("O numero num = %d tem tamanho de %d byte(s)\n", num, sizeof(num));
printf("ch + num = %d (tamanho = %d byte(s))\n\n", ch+num, sizeof(ch + num));

float fl = 10.0;
double db = 10.0;

printf("O float fl = %.2f e tem tamanho de %d byte(s)\n", fl,sizeof(fl));

printf("O double db = %.2lf tem tamanho de %d byte(s)\n", db, sizeof(db));
printf("fl + db = %.2f (tamanho = %d byte(s))\n", fl+db, sizeof(fl + db));

return 0;
}
OPERADORES | Conversão de tipos

● A conversão explícita de tipos (type casting) ocorre quando

colocamos à esquerda de uma variável, ou expressão
aritmética, o tipo, entre parênteses, para o qual ela será
convertida temporariamente.
Ex:
int lado1, lado2, lado3;
float perimetro;
…………
perimetro = (float)(lado1 + lado + lado3);
OPERADORES | Conversão de tipos

ATENÇÃO

O valor a ser atribuído a uma variável não é capaz de

alterar seu tipo declarado, nem mesmo após uma
conversão de tipos.
OPERADORES | Conversão de tipos

/* Conversao explicita */ /* Conversao implicita */

#include<stdio.h> #include<stdio.h>
int main( ) int main( )
{ {
float res; float res;
int n1, n2, n3; int n1, n2, n3;
printf(“Digite tres numeros inteiros\n”); printf(“Digite tres numeros inteiros\n”);
scanf(“%d%d%d”, &n1, &n2, &n3); scanf(“%d%d%d”, &n1, &n2, &n3);
res = (float)(n1 + n2 + n3)/3; res = (n1 + n2 + n3)/3.0;
printf(“A media eh %.2f “, res); printf(“A media eh %.2f “, res);

return 0; return 0;
} }
VARIÁVEIS E OPERADORES

PRÁTICA

Implementar um programa que resolva equações do

2o grau da forma ax2 + bx + c, sendo a, b, c ∈ ℝ

Dica: Usar funções da biblioteca <math.h>

double sqrt(double arg)
double pow(double x, double y) //opcional
 VARIÁVEIS E OPERADORES

PRÁTICA

Ex: x2 - x - 12 = 0 => a = 1, b = -1, c = -12

x = (-b ± √(b2 - 4*a*c))/ (2*a) = (-(-1) ± √((-1)2-4.1.(-12)))/(2*1)
x = (1 ± √(1 +48))/2 = (1 ± √49)/2 = (1 ± 7)/2
x1 = (1 + 7)/2 = 8/2 = 4
x2 = (1 - 7)/2 = -6/2 = -3
VARIÁVEIS E OPERADORES
#include <stdio.h>
#include <math.h>
int main(){
double a, b, c;
printf("Digite o coeficiente a: ");
scanf("%lf", &a);
printf("Digite o coeficiente b: ");
scanf("%lf", &b);
printf("Digite o coeficiente c: ");
scanf("%lf", &c);
double x1, x2;
x1 = (-b + sqrt(pow(b,2) - 4*a*c))/(2*a);
x2 = (-b - sqrt(pow(b,2) - 4*a*c))/(2*a);
printf("x1 = %.3lf\n", x1);
printf("x2 = %.3lf\n", x2);
return 0;
}
VARIÁVEIS E OPERADORES
“Faça as coisas o mais simples que você puder,
porém não se restrinja às mais simples.”
Albert Einstein