+ --c - Divisão de Ciência da Computação

Capítulo III – Declarações e
Comandos de Atribuição
3.1 – Identificadores e palavras reservadas
3.2 – Elementos de comandos de atribuição
3.3 – Constantes
3.4 – Variáveis e suas declarações
3.5 – Declaração de tipos
3.6 – Operadores de expressões
3.7 – Funções e macros da biblioteca de C
3.8 – Expressões e atribuições especiais de C
3.6 – Operadores de expressões
3.6.1 – Precedência e associatividade de operadores

Na expressão aritmética
12 + 3 * 10
primeiro realiza-se a multiplicação, depois a soma

O resultado é 42

Diz-se que o operador ‘*’ tem precedência sobre o operador
‘+’

Se a precedência fosse do operador ‘+’, o resultado seria 150

Na expressão aritmética
10 - 3 - 2
primeiro realiza-se a subtração 10 - 3 = 7 e depois a subtração
7-2=5

Diz-se que o operador ‘-’ tem associatividade à esquerda

Caso fosse realizada primeiro a subtração
3-2=1
e depois
10 - 1 = 9
dir-se-ia que essa associatividade era à direita
Tabela de precedência e associatividade dos operadores da
linguagem C
Obs.: a precedência decresce de cima para baixo
Exemplo: ordem de execução dos operadores de uma
expressão
Exercício 3.6.1:
1. Seja a expressão
x = 3.4*(4.2+6.1) > 20-(8 * 3) && log(pow(10,3)) > exp(5-3);
Mostrar seu esquema de execução, tal como no slide anterior,
deixando claro seu resultado
3.6.2 – Operandos e resultados de operações
aritméticas

Os operadores +, -, * e / admitem operandos inteiros, reais
e caracteres

O resultado dessas operações depende dos tipos de seus
operandos:

Se pelo menos um for real, o resultado é real

Em caso contrario é inteiro

Na divisão, se os dois operandos forem inteiros ou
caracteres, a parte fracionária é eliminada

Exemplo:

Operador %: resto da divisão do primeiro pelo segundo
operando:



7/3=2
Não admite operandos reais
O resultado é inteiro
Exemplo:
7%3=1

Operador sizeof: seja o programa
Tamanhos de tipos
i+j: 4 bytes
char: de1 bytes
bytes
sizeof: fornece o número
de seu operando, queint:
pode 4serbytes
short: 2 bytes
uma expressão ou um
tipo de
long:
4 bytes
float: 4 bytes
variável, entre parêntesis
double: 8 bytes
#include <stdio.h>
#include <stdlib.h>
int main () {
short i; int j;
printf ("Tamanhos de tipos\n\n");
Pressione ........
printf ("
i+j:%3d bytes\n", sizeof (i+j));
Resultado
printf ("
char:%3d bytes\n", sizeof(char));
printf ("
int:%3d bytes\n", sizeof(int));
printf ("
short:%3d bytes\n", sizeof(short));
printf ("
long:%3d bytes\n", sizeof(long));
printf (" float:%3d bytes\n", sizeof(float));
printf (" double:%3d bytes\n", sizeof(double));
printf ("\n\n"); system ("pause"); return 0;
}
3.6.3 – Operandos e resultados de operações
relacionais e lógicas

Na Linguagem C, os operandos das operações relacionais e
lógicas podem ser inteiros, reais ou caracteres

Seu resultado é 1 ou 0, simulando respectivamente True ou
False.

Em operações lógicas, todo operando diferente de 0 (zero) é
convertido para 1, seja ele inteiro, real ou caractere
Exemplo: operações lógicas com inteiros e reais:
452 || 0 = 1
3.6 && 2.0 = 1
17502 && 0.0 = 0
! 5.7 = 0
Tabela verdade dos operadores lógicos em C:
3.6.4 – Conversão de tipos

Muitas vezes é desejável mudar o tipo do resultado de uma
expressão

Por exemplo, a divisão de dois inteiros resulta num inteiro

Mas pode ser desejável obter a parte fracionária do
resultado
Exemplo:
Programa
#include <stdio.h>
#include <stdlib.h>
int main () {
float x, y, z;
x = 20 / 7;
y = (float)20 / 7;
z = (int)(2.5 * 4.3);
printf ("x = %g; y = %g; z = %g",
x, y, z);
printf ("\n\n"); system ("pause");
return 0;
}
x = 2;
y = 2.85714; z = 10
O
valor de
20/7 é 2 (inteiro)
Outras
importantes
conversões de tipos serão
(float)20
converte
20 para
apresentadas
em capítulos
real
posteriores
Então o valor de (float)20/7
é 2.85714 (real)
O valor de (2.5 * 4.3) é 10.75
(real)
(int) (2.5 * 4.3) converte o
resultado de (2.5 * 4.3) para
inteiro
Digite algo:
Resultado
Então o valor de
(int) (2.5 * 4.3) é 10 (inteiro)
Capítulo III – Declarações e
Comandos de Atribuição
3.1 – Identificadores e palavras reservadas
3.2 – Elementos de comandos de atribuição
3.3 – Constantes
3.4 – Variáveis e suas declarações
3.5 – Declaração de tipos
3.6 – Operadores de expressões
3.7 – Funções e macros da biblioteca de C
3.8 – Expressões e atribuições especiais de C
3.7 – Funções e macros da biblioteca
de C
A biblioteca de funções da Linguagem C é dividida em
inúmeros arquivos, dentre eles:

stdio.h: funções básicas de entrada e saída

math.h: funções matemáticas

conio.h: funções para controle do teclado e vídeo

ctype.h: macros para testes de caracteres

string.h: funções para manipulação de cadeias de caracteres

E muitos outros ... (Ver o help dos ambientes)
3.7.1 – Funções matemáticas do math.h
ceil(x) e floor(x): teto e piso de x

Calculam valores inteiros mas o resultado é double

Exemplo:
ceil(y) = 37281715684.000000;
floor(y) = 37281715683.000000;
#include <stdio.h>
Pressione . . .
#include <math.h>
Resultado
#include <stdlib.h>
int main () {
double y = 37281715683.51;
printf ("ceil(y) = %f;\nfloor(y) = %f;", ceil(y), floor(y));
printf ("\n\n "); system ("pause");
return 0;
}
Exercício 3.7.1:
1. Escrever em C as seguintes atribuições:
3.7.2 – Macros para testes de caracteres do ctype.h

O resultado de cada macro é ≠0 (equivalente a 1, em
operações lógicas) ou 0 (zero)

Em vez de escrever if (isalpha(c) == 1) ....., deve-se escrever
if (isalpha(c)) .....
uma frase encerrada por enter:
Exemplo: escritaDigite
das letras
maiúsculas digitadas
abcd
+-*&
EFGH
123456
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
EFGHIJKLMN
#include <stdlib.h>
Digite algo para encerrar:
void main () {
char c;
printf ("Digite uma frase encerrada por enter:\n\n\t");
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
%faIJxyzKLMN!@#$
Resultado
Buffer do teclado:

Em algumas operações de leitura, o computador para,
esperando o operador digitar zero ou mais caracteres
encerrados por <enter>

Nessas operações, enquanto o <enter> não for digitado, o
computador não continua

Não é o caso da execução das funções getch e getche (a
serem vistas mais adiante)
Buffer do teclado:

Os caracteres digitados encerrados pelo <enter> são
depositados numa região da RAM denominada buffer do
teclado

O <enter> também é depositado (no final)

Em C, o buffer do teclado é referenciado por stdin
Buffer do teclado:

A função scanf retira desse buffer os caracteres para sua
leitura

Se o buffer estiver vazio, o computador espera a digitação

Caso contrário, caracteres são retirados do buffer, sem a
necessidade de o computador parar

O programa anterior usa a função scanf
_
Seja a execução deste
programa
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
printf ("Digite uma frase encerrada por enter:\n\n\t");
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
Vídeo
c
?
Buffer do teclado
Digite uma frase encerrada por enter:
_
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
printf ("Digite uma frase encerrada por enter:\n\n\t");
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
Vídeo
c
?
Buffer do teclado
Digite uma frase encerrada por enter:
_
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
?
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
O buffer do teclado está vazio
printf ("\n\n"); system ("pause");
return 0;
Espera-se a digitação de algo
}
encerrado por <enter>
Digite uma frase encerrada por enter:
_
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
?
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
O operador digita:
}
abcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
Digite uma frase encerrada por enter:
abcd
_
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
?
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
abcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
O operador digita:
}
abcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
Digite uma frase encerrada por enter:
abcd
_
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
?
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
abcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
scanf retira o primeiro caractere
printf ("\n\n"); system ("pause");
do buffer e o coloca em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
_
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘a’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
bcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
scanf retira o primeiro caractere
printf ("\n\n"); system ("pause");
do buffer e o coloca em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘a’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
bcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘a’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
bcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Conteúdo de c não é
}
caractere de controle
printf ("\n\n"); system ("pause");
!iscntrl(c) é Verdade
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘a’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
bcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Conteúdo de c não é letra
}
maiúscula
printf ("\n\n"); system ("pause");
isupper(c) é Falso
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘a’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
bcd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
scanf retira o primeiro caractere
printf ("\n\n"); system ("pause");
do buffer e o coloca em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘b’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
cd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
scanf retira o primeiro caractere
printf ("\n\n"); system ("pause");
do buffer e o coloca em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘b’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
cd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘b’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
cd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Conteúdo de c não é letra
}
maiúscula
printf ("\n\n"); system ("pause");
isupper(c) é Falso
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘b’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
cd +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
scanf retira o primeiro caractere
printf ("\n\n"); system ("pause");
do buffer e o coloca em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘c’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
d +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
scanf retira o primeiro caractere
printf ("\n\n"); system ("pause");
do buffer e o coloca em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c
‘c’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
d +-*& EFGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
Tudo se repete até que o caractere
printf ("\n\n"); system ("pause");
‘E’ seja colocado em c
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c ‘E’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
FGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Conteúdo de c é letra
}
maiúscula
printf ("\n\n"); system ("pause");
isupper(c) é Verdade
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
E_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c ‘E’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
FGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
E_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c ‘E’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
FGH 123456 %faIJxyzKLMN!@#$<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Assim os caracteres do buffer são
lidos
}
printf ("\n\n"); system ("pause");
As letras maiúsculas são escritas
return 0;
Tudo termina no <enter>
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
EFGHIJKLMN_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c ‘E’
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
<enter>
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Assim os caracteres do buffer são
lidos
}
printf ("\n\n"); system ("pause");
As letras maiúsculas são escritas
return 0;
Tudo termina no <enter>
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
EFGHIJKLMN_
#include <stdlib.h>
void main () {
char c;
printf ("Digite uma frase encerrada por enter:\n\n\t");
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
%faIJxyzKLMN!@#$
Vídeo
c
<enter>
Buffer do teclado
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
EFGHIJKLMN_
#include <stdlib.h>
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c <enter>
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
Conteúdo de c é caractere
}
de controle
printf ("\n\n"); system ("pause");
!iscntrl(c) é Falso
return 0;
}
Digite uma frase encerrada por enter:
abcd
+-*&
EFGH
123456
%faIJxyzKLMN!@#$
#include <stdio.h> Letras maiusculas digitadas:
#include <ctype.h>
EFGHIJKLMN
#include <stdlib.h>
Pressione qualquer tecla para continuar. . . _
void main () {
char c;
Vídeo
printf ("Digite uma frase encerrada por enter:\n\n\t");
c <enter>
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
Buffer do teclado
printf ("%c", c);
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
void main () {
char c;
printf ("Digite uma frase encerrada por enter:\n\n\t");
scanf ("%c", &c);
printf ("\nLetras maiusculas digitadas:\n\n\t");
while (!iscntrl (c)) {
if (isupper (c))
printf ("%c", c);
Fim da execução!!!
scanf ("%c", &c);
}
printf ("\n\n"); system ("pause");
return 0;
}
Exercício 3.7.2:
1. Fazer um programa que, sem usar variáveis indexadas,
solicite a digitação de uma frase encerrada por um <enter>,
leia caractere por caractere dessa frase e escreva no vídeo
todas as cadeias de caracteres não brancos da mesma, cada
uma numa linha. Por exemplo, se a cadeia digitada for
r12&)
23pgy; #$*8qtlx +jx6(
<enter>
o programa deve escrever no vídeo o seguinte:
r12&)
23pgy;
#$*8qtlx
+jx6(
Capítulo III – Declarações e
Comandos de Atribuição
3.1 – Identificadores e palavras reservadas
3.2 – Elementos de comandos de atribuição
3.3 – Constantes
3.4 – Variáveis e suas declarações
3.5 – Declaração de tipos
3.6 – Operadores de expressões
3.7 – Funções e macros da biblioteca de C
3.8 – Expressões e atribuições especiais de C
3.8 – Expressões e atribuições
especiais de C
3.8.1 – Operações de acréscimo e decréscimo
unitário

Variavel = Variavel + 1; pode ser substituído por
Variavel ++;

Variavel = Variavel – 1; pode ser substituído por
Variavel --;

ou ++ Variavel;
ou
-- Variavel;
Variavel pode ser inteira, real ou caractere
Outras propriedades dos operadores ++ e --:

Variavel ++, ++ Variavel, Variavel -- e -- Variavel são
expressões calculáveis

(Variavel ++) é diferente de (++ Variavel)

Depois de ambas expressões, o valor de Variavel recebe um
acréscimo unitário

O valor da expressão (Variavel ++) é o valor anterior de
Variavel

O valor da expressão (++ Variavel) é o novo valor de
Variavel
O operador -- tem propriedades análogas
Exemplo: seja o programa:
#include <stdio.h>
#include <stdlib.h>
Resultado:
int main () {
a = 0; b = -5; c = 1; d = 7; e = 2;
y = 5; z = 4;
int i = 0, a, b, c, d, e;
float x = 5.0, y, z;
Pressione . . .
a = i; b = i++ - 5; c = i;
d = ++i + 5; e = i;
printf ("a = %d; b = %d; c = %d; d = %d; e = %d;",
a, b, c, d, e);
y = x--;
printf ("\ny = %g;", y);
z = --y;
printf (" z = %g;", z);
printf ("\n\n"); system ("pause");
return 0;
}
Exercício 3.8.1:
1. Sem utilizar ambiente de programação em C, dizer o que será
escrito no vídeo com a execução do seguinte trecho de
programa:
int a, b = 0, c = 0;
a = ++b + ++c;
printf (“%d %d %d\n”, a, b, c);
a = b++ + c++;
printf (“%d %d %d\n”, a, b, c);
a = ++b + c++;
printf (“%d %d %d\n”, a, b, c);
a = b-- + --c;
printf (“%d %d %d\n”, a, b, c);
3.8.2 – Expressões contendo atribuições

Em C, Variavel = Expressao (sem o ponto-e-vírgula ‘;’)
é considerada uma expressão calculável

Seu valor é o valor calculado de Expressao

Pode ser usada como sub-expressão em expressões maiores

Efeito colateral: Variavel recebe o valor de Expressao
Exemplo: seja o programa:
#include <stdio.h>
#include <stdlib.h>
int main () {
int a, b, c;
c = (a = 2) * (b = 3);
printf ("a = %d; b = %d; c = %d;", a, b, c);
printf ("\n\n"); system ("pause");
return 0;;
}
Resultado:
a = 2; b = 3; c = 6;
Pressione . . .

Esta característica é usada para compactar várias atribuições
numa só

Exemplos:
a = b + c;
d = e – f;
g = a * d + h;
a = 1;
b = 1;
c = 1;
g = (a = b + c) * (d = e – f) + h;
a = b = c = 1;
O operador ‘=’ tem
associatividade à direita
3.8.3 – Outros operadores de atribuição

Operadores: +=, -=, *=, /= e %=

Significado:
Expressão especial
Variavel += Expressao
Variavel -= Expressao
Variavel *= Expressao
Variavel /= Expressao
Variavel %= Expressao
Expressão equivalente
Variavel = Variavel + Expressao
Variavel = Variavel - Expressao
Variavel = Variavel * Expressao
Variavel = Variavel / Expressao
Variavel = Variavel % Expressao
Exemplo: seja o programa:
#include <stdio.h>
#include <stdlib.h>
int main () {
int a = 2, b = 3, c = 41;
a += 5; b *= 3; c %= a + b;
printf ("a = %d; b = %d; c = %d;", a, b, c);
printf ("\n\n"); system ("pause");
return 0;
}
Resultado:
a = 7; b = 9; c = 9;
Pressione . . .
Exercício 3.8.3:
1. Sem utilizar ambiente de programação em C, dizer o que será
escrito no vídeo com a execução do seguinte trecho de
programa:
int a = 1, b = 2, c = 3, d = 4, e, f, g;
g = (a += ++d + (b *= (e = (f = d++ - --c)* ++b)) - --f) - ++d;
printf ("a = %d; b = %d\nc = %d; d = %d\ne = %d; f = %d\ng = %d",
a, b, c, d, e, f, g);
3.8.4 – Operador vírgula

Em C, um conjunto de subexpressões separadas por
vírgula é considerado uma expressão calculável

As subexpressões são calculadas da esquerda para a direita e
o valor da expressão total é o valor da última delas
Exemplo: seja o programa:
#include <stdio.h>
#include <stdlib.h>
int main () {
int a, b, c, x;
x = (a = 5, b = 3, c = a * b);
printf ("a = %d; b = %d; c = %d; x = %d;", a, b, c, x);
printf ("\n\n"); system ("pause");
return 0;
}
Resultado:
a = 5; b = 3; c = 15; x = 15;
Pressione . . .