ProgramacaoComputacional PDF

Introdução à Programação
Prof. Tarcisio Ferreira Maciel, Dr.-Eng.

(em colaboração com Darlan Cavalcante Moreira, M.-Eng.)
Universidade Federal do Ceará

Departamento de Engenharia de Teleinformática (DETI)
5 de junho de 2017
Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 1 / 348

Parte I
Introdução à computação

Introdução à computação
Conteúdo
1 Introdução à computação
Conceitos básicos de computadores
Elementos de hardware
Elementos de software
Organização de dados em SOs

Introdução à computação Conceitos básicos de computadores
Conteúdo

Introdução à computação Conceitos básicos de computadores
Para que computadores?[dSGSC08]
Contar e calcular Ü ações que remontam aos primórdios da humanidade (e.g.1 , usando os dedos)
Computador Ü dispositivo que faz cálculos e operações lógicas rapidamente

Surgiu paralelamente à necessidade humana crescente de realizar cálculos
Evoluiu rapidamente nos últimos anos
Ábacos (ancestrais dos computadores): datam de mais de 5.000 anos
Por volta de 1600: surgem os primeiros computadores/calculadoras (eletro)mecânicos(as)
Por volta de 1830: Babbage projeta a máquina diferencial, o 1o. computador
Por volta de 1940: surge o primeiro computador eletrônico à válvula
Por volta de 1960: surgem os computadores transistorizados
Por volta de 1970: surgem os microcomputadores (microprocessadores)
Por volta de 1975: surgem os computadores pessoais
Seguem hoje arquiteturas de hardware e software consagradas pelo uso
1
e.g. significa “por exemplo”
Introdução à computação Elementos de hardware
Conteúdo

Exemplo de computador comercial
Computador com processador i7 de 3,3 GHz

8 Gb de memória RAM
Disco rígido de 1 Tb
Leitor de Blu-Ray
Monitor de 23" Full HD (1920 × 1080)
Teclado padrão ABNT2
Mouse sem fio
Caixas de som de 8W RMS
Leitor de cartão embutido e 06 entradas USB
Microsoft Windows 10 (64 bits)
Microsoft Works
Microsoft Office (30 dias)


Leitor de Blu-Ray
Mouse sem fio
Microsoft Works

Arquitetura de Neumann
Hardware refere-se a todo e qualquer elemento físico que faça parte da máquina interna ou
externamente
A arquitetura de hardware da maioria dos computadores atuais
Inspirada na proposta de Neumann
Informação representada usando apenas dois estados: ligado / desligado, ativo / inativo, zero / um, /
Programas e dados armazenados na memória
Todo processamento realizado utilizando lógica binária
Dispositivos Unidade de Unidade Lógica Dispositivos

Mémoria Central
de Entrada Controle e Aritmética de Saída
Unidade Central de Processamento
Dispositivos de
Entrada e Saída

Unidade Central de Processamento (UCP)

Cérebro do computador
Comanda os periféricos por meio de comandos diretos ou de
interfaces
Memória central Ü informação a ser processada com alta
eficiência
Processador do computador
Exemplos de processadores
AMD Athlon, Phenom, Opterom, etc.
Intel Pentium, i3, i5, i7, Xeon, etc.
Pentium 4 (2000)
Unidade de Controle (UC)

Controla o fluxo das operações na UCP
Coordena a entrada e saída de dados internos e/ou obtidos dos periféricos
Unidade Lógica Aritmética (ULA) Ü Realiza todas as operações lógicas e aritméticas da UCP
Periféricos Ü vias de comunicação da UCP com o mundo exterior

Dispositivos de entrada : teclado, mouse, scanner, microfone, etc.
Dispositivos de saída : monitor, impressora, caixa de som, etc.
Dispositivos de entrada e saída: memória, disco rígido, touch screen, etc.

Memória principal
Memória do computador
“Periférico” de entrada e saída para armazenamento e recuperação de dados
Normalmente dividida em memória principal e memória secundária.
Memória principal
Armazena e recupera dados com extrema velocidade
Troca de dados eficiente com outros dispositivos
Dois tipos comuns: Random Access Memory (RAM) e Read-Only Memory (ROM)
Random Access Memory (RAM) – Memória de Acesso Aleatório

Não-persistente Ü se falta energia elétrica seu conteúdo é apagado
Considerada normalmente como “a memória” do computador (e.g., computador com 4 Gbytes de memória)
Armazena normalmente todos os dados de programa do computador
Read-Only Memory (ROM) – Memória Somente para Leitura

Persistente Ü guarda normalmente dados cruciais de configuração do computador
Basic Input/Output System (BIOS)

Memória secundária
Caracterizada por dispositivos/unidades de entrada e saída para armazenamento e recuperação

de dados em massa
Unidades de disco, disco rídigo, ou Hard Disk (HD)
Cartões de memória (flash)
Pen drives com acesso via Universal Serial Bus (USB)
Unidades de leitura e gravação de CDs, DVDs e/ou discos Blu-Ray

Introdução à computação Elementos de software
Conteúdo


Leitor de Blu-Ray
Mouse sem fio
Microsoft Works

Tipos de software
Software é todo e qualquer programa processado por um computador para executar uma tarefa
Um programa é um conjunto de instruções (comandos) e dados que são processados por uma
máquina (computador digital) para cumprir uma dada tarefa
Note que os conceitos de software e programa de certo modo se confundem
O software do computador é normalmente organizado em camadas [TW06]

Camadas baixas Ü programas que interagem diretamente c/ o hardware
Camadas intermediárias Ü interface entre o hardware e camadas mais altas
Camadas altas Ü programas que interagem diretamente c/ o usuário

Tipos de software
Basic Input/Output System (BIOS)

Armazenado em ROM integrada à placa-mãe do computador
Programas residentes que controlam/supervisionam operações básicas
Após ligar o computador, passa o controle para o Sistema Operacional (SO)
Sistema Operacional (SO) Navegador Repr. mídia
Planilha
Armazenado normalmente em disco
Compiladores Editores Interpretadores
Rege o acesso do usuário e programas aos recursos do
Sistema operacional
computador
Windows q, OS X , Linux ±, etc. Linguagem de máquina
Software aplicativo Microarquitetura
Normalmente condicionado pelo SO Dispositivos físicos

Realiza atividades específicas Adaptado de [TW06].
Navegador, editor de texto, cliente de e-mail, etc.

Tipos de software
O BIOS pode ser acessado pressionando-se certas teclas

durante o processo de boot, o que permite configurar alguns
Ao ligar o computador, o BIOS é iniciado. Ele verifica a
aspectos do hardware. Por exemplo, é possível escolher a
condição básica do hardware, configura-o, e finalmente passa
ordem dos dispositivos (dísco rígido, leitor de DVD/Blu-ray,
o controle do computador para o SO.
pendrive) que será seguida ao tentar transferir o controle para
o SO.

Introdução à computação Organização de dados em SOs
Conteúdo

Os SOs (como Windows e Linux) realizam normalmente a

interação entre usuário e computador
Os SOs empregam modelos “padrão” para organizar e acessar
informações hierarquicamente em um computador
Geralmente, as informações são armazenadas em:
Unidades
Normalmente associadas a discos rígidos
Identificados por letras no Windows (e.g., A:, C:)
C:\
Pastas (antigamente chamadas diretórios)
Subdivisão criada em uma unidade para organizar dados Documentos\
correlacionados Monografia.doc
Identificadas por um nome (e.g., Documentos, Imagens)
Relatório.doc
Arquivos
Imagens\
Conjunto de informações armazenado em uma pasta
Carnaval.jpg
Identificados por um nome e uma extensão (e.g., Monografia.doc)

Organização da informação em SOs
Os arquivos são acessados através de um endereço hierárquico especificando unidade → pasta →

subpasta → nome.extensão
No Windows, o arquivo Monografia.doc contido na pasta Documentos da unidade C: possui o

endereço C:\Documentos\Monografia.doc
Na década de 1990, os nomes de arquivo só podiam ter até 8 caracteres e a extensão até 3
caracteres sendo ligados por um ponto .
As extensões de 3 caracteres são usadas para identificar o tipo de arquivo
.txt: arquivo texto .wav: arquivo de áudio

.doc: documento (binário) .mp3: arquivo de áudio compactado
.bmp: imagem bitmap .h: arquivo de cabeçalho em C
.exe: programa executável .c: programa fonte em C/C++
.avi: arquivo de vídeo .cpp: programa fonte em C++

Os arquivos normalmente contém dados organizados segundo algum tipo de estrutura
Nos arquivos de bancos de dados, as informações são organizadas em registros

Nome Idade ··· Telefone
João 20 ··· 55555555
Maria 23 ··· 44444444
José 18 ··· 77777777
Os registros são compostos por campos: Nome, Idade, Telefone, etc.
O conteúdo de cada campo é composto por caracteres

Os caracteres pertencem à tabela ASCII (American Standard Code for Information Interchange /
Código Padrão Americano para o Intercâmbio de Informação) [DD12, Apênd. B]
O código ASCII é um subconjunto do Unicode que possui suporte para várias línguas
Cada caractere corresponde a um número entre:

0 e 127 Ü tabela ASCII padrão
128 a 255 Ü tabela ASCII estendida
A parte estendida da tabela ASCII pode variar (e.g., com o idioma)

Tabela ASCII padrão
0 1 2 3 4 5 6 7 8 9
0 nul soh stx etx eot enq ack bel bs ht
1 nl vt ff cr so si dle dc1 dc2 dc3
2 dc4 nak syn etb can em sub esc fs gs
3 rs us sp ! " # $ % & ‘
4 ( ) * + , - . / 0 1
5 2 3 4 5 6 7 8 9 : ;
6 < = > ? @ A B C D E
7 F G H I J K L M N O
8 P Q R S T U V W X Y
9 Z [ \ ] ˆ _ ’ a b c
10 d e f g h i j k l m
11 n o p q r s t u v w
12 x y z { | } ˜ del

Caracteres de controle na tabela ASCII padrão
Carac. Descrição Carac. Descrição

nul Caractere nulo soh Começo de cabeçalho de transmissão
stx Começo de texto etx Fim de texto
eot Fim de transmissão enq Interroga
ack Confirmação bel Sinal sonoro
bs Volta um caractere ht Tabulação horizontal
lf Passa para próxima linha vt Tabulação vertical
ff Passa para próxima página cr Passa para início da linha
so Shift-out si Shift-in
dle Data line escape dc1 Controle de dispositivo
dc2 Controle de dispositivo dc3 Controle de dispositivo
dc4 Controle de dispositivo nak Negativa de confirmação
syn Synchronous idle etb Fim de transmissão de um bloco
can Cancela em Fim de meio de transmissão
sub Substitui esc Escape
fs Separador de arquivo gs Separador de grupo
rs Separador de registro us Separador de unidade
sp Espaço em branco

Bits, bytes e seus múltiplos
MSB LSB
Dec. b3 b2 b1 b0 Hex.
Números de 0 a 255 podem ser representados 0 0 0 0 0 0
utilizando conjuntos de 8 dígitos binários 1 0 0 0 1 1
Cada dígito binário, em inglês BInary digiT, ou bit, 2 0 0 1 0 2
3 0 0 1 1 3
pode assumir valor 0 ou o valor 1
4 0 1 0 0 4
Um conjunto de 4 bits é chamado nibble e pode 5 0 1 0 1 5
assumir valores decimais entre 0 e 15 6 0 1 1 0 6
7 0 1 1 1 7
Cada conjunto de 8 bits é chamado byte (ou
8 1 0 0 0 8
octeto)
9 1 0 0 1 9
Múltiplos de byte 10 1 0 1 0 A
1024 bytes Ü 1 quilobyte (kb) 11 1 0 1 1 B
1024 quilobytes Ü 1 megabyte (Mb) 12 1 1 0 0 C
1024 megabytes Ü 1 gigabyte (Gb) 13 1 1 0 1 D
1024 gigabytes Ü 1 terabyte (Tb) 14 1 1 1 0 E
15 1 1 1 1 F

Visualização do arquivo main.cpp com editor hexadecimal

Parte II
Sistemas de numeração

Sistemas de numeração
Conteúdo
2 Sistemas de numeração
Sistema decimal
Sistema binário
Sistema octal
Sistema hexadecimal
Conversões entre binário, octal, e hexadecimal
3 Operações aritméticas no sistema binário

Sistemas de numeração Sistema decimal
Conteúdo
Sistema decimal
Sistema binário
Sistema octal
Sistema hexadecimal

Sistemas de numeração Sistema decimal
Sistema decimal
Um sistema de numeração possui uma base B e dígitos d para representar os números

Por exemplo, o sistema decimal possui base B igual a 10 e dígitos d de 0 a 9
O primeiro dígito em um sistema de numeração é sempre um 0, ou seja d = 0, 1, . . . , B − 1
Números maiores que B − 1 são representados usando notação posicional
Os dígitos d multiplicam a base B elevada à posição p ocupada pelo dígito gerando um valor d · B p
As posições são negativas à direita do separador da parte fracionária
Para a base 10, tem-se, por exemplo, o número 1.423, 33510 representado como
Posição p 3 2 1 0 −1 −2 −3 ...
Potência Bp 103 102 101 100 10−1 10−2 10−3 ...
Peso – 1000 100 10 1 0, 1 0, 01 0, 001 . . .
Dígito d 1 4 2 3 3 3 5 –
Valor d · B p 1000 400 20 3 0, 3 0, 03 0, 005 –
1000 + 400 + 20 + 3 + 0, 3 + 0, 03 + 0, 005 = 1.423, 335

Sistemas de numeração Sistema binário
Conteúdo
Sistema decimal
Sistema binário
Sistema octal
Sistema hexadecimal

Sistema binário: conversão binário/decimal
Para sistemas digitais, como os computadores, o sistema de numeração binário é utilizado (dígitos
0 e 1 apenas)
Cada dígito é denominado bit Ü abreviação de BInary digiT
Um conjunto de 4 bits é chamada nibble e um conjunto de 8 bits é chamado byte
No sistema binário, os dígitos estão associados a potências de 2
Seguindo o modelo anterior, um número binário pode ser facilmente convertido para um decimal,
como por exemplo o número 1110, 1012 (note que há parte fracionária)
Posição p 3 2 1 0 −1 −2 −3 ...
Posição Bp 23 22 21 20 2−1 2−2 2−3 ...
Peso – 8 4 2 1 0, 5 0, 25 0, 125 ...
Dígito d 1 1 1 0 1 0 1 –
Valor d · Bp 8 4 2 0 0, 5 0 0, 125 –
8 + 4 + 2 + 0 + 0, 5 + 0 + 0, 125 = 14, 625

Sistema binário: conversão decimal/binário
Conversões de decimal para uma outra base Ü mais complicadas que a conversão dessa base
para decimal [Bre08]
Conversão da parte inteira do número decimal para binário

1 Divida a parte inteira pela base, no caso 2
2 Armazene o resto como dígito do resultado
3 Repita os passos 1 e 2 com o quociente obtido no passo anterior até obter um quociente zero
4 Leia os dígitos representados pelos restos na ordem inversa de sua obtenção
Conversão da parte fracionária de um número decimal para binário

1 Multiplique a parte fracionária pela base, no caso 2
2 Salve a porção inteira do produto como um dígito do resultado
3 Repita os passos 1 e 2 usando a parte fracionária do produto obtido no passo anterior até que a parte
fracionária do produto se torne zero
4 Leia os dígitos representados pelas porções inteiras dos produtos na ordem direta de sua obtenção

Exemplos de conversão de decimal para binário
Considere a conversão do número 11, 12510 para binário

A conversão é feita em separado para a parte inteira e fracionária
Parte inteira
Parte fracionária
1110 = ????2
0, 12510 = ???2
11 2
1 5 2 0, 125 × 2 = 0, 25 → 0
1 2 2
0, 25 × 2 = 0, 5 → 0
0 1 2
1 0 0, 5 × 2 = 1, 0 → 1
0, 12510 = 0, 0012
1110 = 10112
Logo, temos que 11, 12510 = 1011, 0012

Multiplique o número pela base n vezes até que o resultado se torne inteiro
Converta o resultado para binário como se converte um número inteiro
Da direita para a esquerda, posicione uma vírgula à frente do n-ésimo dígito
Temos que 11, 125 × 2 = 22, 25 ⇒ 22, 25 × 2 = 44, 5 ⇒ 44, 5 × 2 = 89, e portanto n = 3
8910 = ????2
89 2
1 44 2
0 22 2
0 11 2
1 5 2
1 2 2
0 1 2
1 0
8910 = 10110012
Logo, temos que 11, 12510 = 1011, 0012

Alternativamente, pode-se converter de número inteiro de decimal para binário utilizando

subtrações sucessivas
Subtraia do número a maior potência 2p que se pode subtrair do mesmo
O número em questão quando em forma binária possuirá um bit 1 na posição p
Aplique sucessivamente o mesmo processo ao resto da subtração anterior até que o resto se torne
zero
As posições p das potências 2p que foram subtraídas nesse processo serão os bits 1 do número e
todas as demais serão zero
Por exemplo, temos que 89 − 26 = 25, 25 − 24 = 9, 9 − 23 = 1 e 1 − 20 = 0, de modo que os

bits das posições 0, 3, 4, e 6 serão 1 e os bits das posições 1, 2, e 5 serão 0
Logo, temos que 8910 = 10110012

Sistemas de numeração Sistema octal
Conteúdo
Sistema decimal
Sistema binário
Sistema octal
Sistema hexadecimal

Sistema octal: conversão octal/decimal
No sistema octal, os dígitos de 0 a 7 estão associados a potências de 8
Seguindo o modelo anterior, um número octal pode ser facilmente convertido para um decimal,
como por exemplo o número 125, 78 (note que há parte fracionária)
Posição p 2 1 0 −1 ...
Posição Bp 8 2 8 1 8 0 8 −1 ...
Peso – 64 8 1 0, 125 . . .
Dígito d 1 2 5 7 –
Valor d·B p 64 16 5 0, 875 –
64 + 16 + 5 + 0, 875 = 85, 875

Exemplo de conversão de decimal para octal
Considere a conversão do número 35, 14062510 para octal
Parte inteira Parte fracionária

0, 14062510 = ???8
3510 = ??8
35 8 0, 140625 × 8 = 1, 125 → 1
3 4 8
0, 125 × 8 = 1, 0 → 1
4 0
3510 = 438
0, 14062510 = 0, 118
Logo, temos que 35, 14062510 = 43, 118

Sistemas de numeração Sistema hexadecimal
Conteúdo
Sistema decimal
Sistema binário
Sistema octal
Sistema hexadecimal

Sistema hexadecimal: conversão hexadecimal/decimal
No sistema hexadecimal, os dígitos de 0 a 9 e de A a F estão associados a potências de 16
Seguindo o modelo anterior, um número hexadecimal pode ser facilmente convertido para um
decimal, como por exemplo o número 16A, C16 (note que há parte fracionária)
Posição p 2 1 0 −1 ...
Posição Bp 16 2 16 1 16 0 16−1 ...
Peso – 256 16 1 0, 0625 ...
Dígito d 1 6 A C –
Valor d·B p 256 96 10 0, 75 –
256 + 96 + 10 + 0, 75 = 362, 75

Exemplo de conversão de decimal para hexadecimal
Considere a conversão do número 109, 04687510 para hexadecimal
Parte inteira Parte fracionária

10910 = ??16 0, 04687510 = ???16
109 16
13(D) 6 16 0, 046875 × 16 = 0, 75 → 0
6 0 0, 75 × 16 = 12, 0 → C
10910 = 6D16 0, 04687510 = 0, 0C16
Logo, temos que 109, 04687510 = 6D, 0C16

Sistemas de numeração Conversões entre binário, octal, e hexadecimal
Conteúdo
Sistema decimal
Sistema binário
Sistema octal
Sistema hexadecimal

Conversão de binário/octal e de octal/binário
Para converter números binários para octal

1 Da direita para a esquerda, agrupe os bits em grupos de 3 bits
2 Converta cada grupo de 3 bits para o dígito octal correspondente
Por exemplo: 110101102 → |{z}

011 |{z} 110 → 3268
010 |{z}
3 2 6
Para converter números octais para binário

1 Da direita para a esquerda, tome um dígito octal
2 Converta o dígito octal para um grupo de 3 bits
Por exemplo: 3678 → |{z}

3 |{z} 7 → 111101112
6 |{z}
011 110 111

Conversão de binário/hexadecimal e de hexadecimal/binário
Para converter números binários para hexadecimal

1 Da direita para a esquerda, agrupe os bits em grupos de 4 bits
2 Converta cada grupo de 4 bits para o dígito hexadecimal correspondente
Por exemplo: 110101102 → 1101 |{z} → D616

|{z} 0110
D 6
Para converter números hexadecimais para binário

1 Da direita para a esquerda, tome um dígito hexadecimal
2 Converta o dígito octal para um grupo de 3 bits
Por exemplo: AF16 → |{z} F → 1010 11112

A |{z}
1010 1111

Operações aritméticas no sistema binário
Conteúdo

Operações lógicas
Adição de números binários
Subtração de números binários
Multiplicação de números binários

Operações aritméticas no sistema binário Operações lógicas
Conteúdo


Operações aritméticas no sistema binário Operações lógicas
Operações lógicas fundamentais
As operações aritméticas no sistema binário mantêm relação com as operações booleanas

Entre as operações booleanas (ou lógicas) mais utilizadas estão:
NOT (NEGAÇÃO) OR (OU)

AND (E) XOR (OU-EXCLUSIVO)
NOT AND OR XOR

NOT AND OR XOR
NOT 0 1 0 AND 0 0 0 OR 0 0 0 XOR 0 0

NOT 1 0 0 AND 1 0 0 OR 1 1 0 XOR 1 1
1 AND 0 0 1 OR 0 1 1 XOR 0 1
1 AND 1 1 1 OR 1 1 1 XOR 1 0

Operações aritméticas no sistema binário Adição de números binários
Conteúdo


Adições no sistema binário funcionam da mesma forma que no sistema decimal

Um dígito de uma parcela é adicionado ao dígito de mesma posição da outra parcela
Caso o valor da soma dos dígitos exceda a base, um dígito vai para a próxima posição (“vai N ”)
O processo acima é repetido para os dígitos da próxima posição mais o “vai N”, se existir
Exemplos na base 10 Exemplos na base 2

1 1
2 0 2 8 0 1
+ 7 + 7 (8 + 7) = 1 5 + 1 + 1 (1 + 1) = 210 = 1 02
2 7 3 5 0 1 1 0

Como só há os dígitos 0 e 1, não há soma de dois dígitos que seja maior que 210 = 102
Logo, nas somas de 1 e 1 sempre “vai 1”
Considerando-se as demais combinações de 0 e 1 temos
0+0=0
0+1=1
1+0=1
1 + 1 = 0 e “vai 1”
Usando essa regras, quaisquer dois números binários podem ser somados
1 1 1
1 0 1 1 0
+ 1 0 1 1
1 0 0 0 0 1

Como só há os dígitos 0 e 1, não há soma de dois dígitos que seja maior que 210 = 102
Logo, nas somas de 1 e 1 sempre “vai 1”
Considerando-se as demais combinações de 0 e 1 temos
0+0=0 (Observe que isso é uma operação XOR)
0+1=1
1+0=1
1 + 1 = 0 e “vai 1” (Observe que o “vai 1” é uma operação AND)
Usando essa regras, quaisquer dois números binários podem ser somados
1 1 1
1 0 1 1 0
+ 1 0 1 1
1 0 0 0 0 1

De acordo com o caso, pode acontecer vários

“vai 1” em uma soma de duas parcelas
1 1 1 Procedimento simples para soma com várias
1 1 1 parcelas
+ 1 1 1
1 1 1 0 1 Conte os dígitos 1 na coluna, começando pela coluna da
posição 0
Regra simples para soma de várias parcelas
2 Se a quantidade de dígitos 1 for ímpar o resultado é 1 e se
1 1 for par o resultado é 0
1 1 1 1 3 Para a próxima coluna, vão tantos 1 (“vai 1”) quanto a
1 1 1 metade dos dígitos 1 contados na coluna anterior
1 1 1
+ 1 1 1
1 0 1 0 1

Operações aritméticas no sistema binário Subtração de números binários
Conteúdo


Formação do complemento 2 de um número binário [DD12, Apêndice D.6]
Há vários métodos de realizar subtração entre números binários
O método considerado aqui é o da soma em complemento 2
Formação do complemento 2 de um número binário

1 Tome o número binário e inverta todos os bits: 0 → 1 e 1 → 0
2 Adicione um 1 ao número obtido no passo anterior
Exemplo
NOT +1
11001 −−→ 00110 −−→ 00111
NOT +1
10100 −−→ 01011 −−→ 01100
Observe que o número de bits foi preservado

Formação do complemento 2 de um número binário [DD12, Apêndice D.6]
Há vários métodos de realizar subtração entre números binários
O método considerado aqui é o da soma em complemento 2
Formação do complemento 2 de um número binário

1 Tome o número binário e inverta todos os bits: 0 → 1 e 1 → 0 (Observe que isso é uma operação NOT)
2 Adicione um 1 ao número obtido no passo anterior
Exemplo
NOT +1
11001 −−→ 00110 −−→ 00111
NOT +1
10100 −−→ 01011 −−→ 01100
Observe que o número de bits foi preservado

Para realizar a subtração usando o método do complemento 2

1 Forme o complemento 2 do subtraendo (com o mesmo número de dígitos do minuendo)
2 Some o minuendo e o subtraendo (já em complemento 2)
Exemplo 111102 − 101002 = ???2 ⇒ 3010 − 2010 = 1010
1 1 1 1 0
+ 0 1 1 0 0
61 0 1 0 1 0
Note que cortamos o “1” mais significativo aqui para manter o número de bits constante
Esse método permite que o mesmo hardware utilizado para somar seja utilizado para subtrair
De fato, os números inteiros negativos são mantidos na memória na forma de complemento 2

Operações aritméticas no sistema binário Multiplicação de números binários
Conteúdo


Multiplicações no sistema binário funcionam da mesma forma que no sistema decimal

Um dígito (começando pela posição menos significativa) de um fator multiplica todo o outro fator
O resultado é escrito e o procedimento é repetido com o próximo dígito (próxima posição)
O novo resultado é escrito abaixo do anterior deslocado de uma posição para a esquerda
No final as parcelas são somadas
Exemplo na base 10
2 0 7
× 1 0 2
4 1 4
0 0 0 ←
2 0 7 ←
2 1 1 1 4

Exemplo no sistema binário

1 1 1 0
× 1 0 1 1
1 1 1 0
1 1 1 0
0 0 0 0
1 1 1 0
1 0 0 1 1 0 1 0
Note que o produto de dois bits é equivalente a uma operação AND

Note que a soma de dois bits é igual a uma operação XOR
Note que multiplicar um número binário por um bit 1 em uma dada posição p é o mesmo que
deslocá-lo p posições para a esquerda
Cursos de eletrônica digital e arquitetura de computadores mostram como várias operações são
construídas usando como elementos-base circuitos simples que implementam as operações
lógicas
Parte III
Introdução aos algoritmos

Introdução aos algoritmos
Conteúdo
4 Introdução aos algoritmos

Conceitos de algoritmo
Estrutura sequencial
Estrutura condicional
Estrutura de repetição
Compilação e interpretação

Introdução aos algoritmos Conceitos de algoritmo
Conteúdo


Algoritmos
O conceito central de programação computacional é o de algoritmo

Conjunto de regras para a solução de um problema
Descrição de um padrão de comportamento, expresso em termos de um conjunto bem definido e finito
de ações básicas
Exemplos de algoritmos no dia-a-dia: relativamente imprecisos

Receitas Ü Acrescente sal e pimenta a gosto?
Instruções de montagem Ü Aperte os parafusos?
Partituras musicais Ü Qual a duração exata de cada nota?
Algoritmos para computador

Determinísticos
Cada entrada produz a mesma saída independente do momento da execução

Formas de descrever de algoritmos
Há várias formas de se descrever um algoritmo

Relato de um observador Ü muito simples, porém muito ambíguo
Português estruturado (PORTUGOL) Ü fácil de traduzir, porém ainda ambíguo
Linguagem gráfica (fluxograma) Ü fácil de visualizar, porém muito extenso
Linguagem de programação Ü menos simples, porém formal
Relato de um observador: divisão entre dois números
leia um valor para o dividendo;

leia um valor para o divisor;
se o divisor for diferente de zero então
calcule o quociente dividindo o dividendo pelo divisor;
imprima o quociente;
senão
imprima "Divisão por zero";

Formas de descrever de algoritmos
PORTUGOL: divisão entre dois números Fluxograma: divisão entre dois números
inicio inicio
inteiro dividendo , divisor , quociente ;
leia dividendo ;
leia divisor ;
se divisor <> zero entao leia D
quociente = dividendo / divisor ;
imprima quociente ;
senao
imprima " Divis ão por zero .";
fim - se ; leia d
fim .
C/C++: divisão entre dois números Abrir Projeto d <> 0
#include <iostream> // Biblioteca de E/S

using namespace std; q = D/d "Divisão por zero"
int main() { // Função Main -> Ponto de entrada para o programa
float dividendo, divisor, quociente; // Cria variáveis
cin >> dividendo; // Lê dividendo
cin >> divisor; // Lê divisor imprima q
if (divisor != 0) { // Se o divisor não é zero ...
quociente = dividendo/divisor; // .. calcula ...
cout << quociente; // ... e imprime quociente
} else { cout << "Divisão por zero"; } fim
return 0;
}

Aspectos estático e dinâmico de algoritmos
Dificuldade na concepção/entendimento de algoritmos

Compreender o relacionamento entre seus aspectos estático e dinâmico
Como ele se comporta para todas as possíveis entradas?
Visualizar a dinâmica das possíveis execuções do algoritmo
Simplificação na concepção/entendimento de algoritmos [DD12, Sec. 4.4]


Introdução aos algoritmos Estrutura sequencial
Conteúdo


Algoritmos são imperativos Ü um comando é executado no ponto em que ocorre

Primeira estrutura básica Ü estrutura sequencial ou comando simples
Fazer uma caipirinha

Fazer um sanduíche de queijo e presunto
“Põe açúcar no copo” ;
“Põe uma fatia de pão no prato” ;
“Põe fatias de limão no copo” ;
“Põe uma fatia de queijo sobre a de pão” ;
“Põe gelo picado no copo” ;
“Põe uma fatia de presunto sobre a de queijo” ;
“Põe a aguardente no copo” ;
“Põe uma fatia de pão sobre a de presunto” ;
“Mistura bem os ingredientes” ;
Em um algoritmo, o símbolo sequencial “;” tem duas funções

Separa um comando do outro
Estabelece que estes serão executados na ordem de aparição no texto
Observe que a ordem correta dos comandos é essencial

Em C/C++, todo comando simples é separado do próximo por ponto-e-vírgula
Aparentemente, não sugere grandes benefícios comparado ao simples relato de um observador

Algoritmos são imperativos Ü um comando é executado no ponto em que ocorre

Primeira estrutura básica Ü estrutura sequencial ou comando simples
Fazer uma caipirinha

Fazer um sanduíche de queijo e presunto
“Põe açúcar no copo” ;
“Põe uma fatia de pão no prato” ;
“Põe fatias de limão no copo” ;
“Põe uma fatia de queijo sobre a de pão” ;
“Põe gelo picado no copo” ;
“Põe uma fatia de presunto sobre a de queijo” ;
“Põe a aguardente no copo” ;
“Põe uma fatia de pão sobre a de presunto” ;
“Mistura bem os ingredientes” ;
Em um algoritmo, o símbolo sequencial “;” tem duas funções

Separa um comando do outro
Estabelece que estes serão executados na ordem de aparição no texto
Observe que a ordem correta dos comandos é essencial

Em C/C++, todo comando simples é separado do próximo por ponto-e-vírgula
Aparentemente, não sugere grandes benefícios comparado ao simples relato de um observador

Esta estrutura nos permite realizar comandos em uma sequência direta

Comandos simples Ü ler algo via teclado, imprimir algo na tela, etc.
Exemplo de programa usando apenas a estrutura sequencial Abrir Projeto
// Isso é um comentário
#include <iostream> // Biblioteca de entrada e saída
using namespace std; // Ativa o pacote padrão (std)
// Função principal
int main(int argc, char *argv[]) {
// Corpo do programa - Mostra "Hello World!" na tela
cout << "Hello World!" << endl;
// Finaliza a main e retorna
return 0;
}

Ex.: Adição de dois inteiros [DD10, Fig. 2.5] Abrir Projeto

using namespace std; // Ativa o pacote std (padrão)

int num1; // 1o. número a ser digitado p/ usuário
int soma; // Variável que armazenará a soma
cout << "Entre 1o. inteiro: "; // Mensagem

cin >> num1; // Lê um inteiro

soma = num1 + num2; // Atribui total

cout << "A soma é: " << soma << endl; // Imprime a soma
return 0; // Encerra a main e retorna zero

}

Introdução aos algoritmos Estrutura condicional
Conteúdo


Amplia as possibilidades de expressão em um algoritmo
Permite realizar uma ação somente se uma condição for respeitada

Uma dona-de-casa descasca batatas para o jantar [AdMGadCL94]
“traz a cesta com batatas do porão”;
“traz a panela do armário”;
se “a saia é clara” então “põe o avental”;
“descasca as batatas”;
“devolve a cesta ao porão”;
A ação de “pôr o avental” só é realizada se a “saia for de cor clara”
O resultado da condição pode variar para cada execução do algoritmo, porém o algoritmo ainda
descreve um padrão de comportamento único

Exemplo para estrutura condicional simples

Solução de uma equação de 2o. grau Abrir Projeto

#include <cmath> // Biblioteca matemática
float a, b, c, delta, x1, x2;
cout << "Digite a b c: ";
cin >> a >> b >> c; // Lê os coeficientes
delta = b*b - 4*a*c; // Calcula o discriminante
if (delta > 0) { // Raízes reais e distintas
x1 = (-b + sqrt(delta))/(2*a); // Calcula x1
x2 = (-b - sqrt(delta))/(2*a); // Calcula x2
cout << "x1 = " << x1 << ", x2 = " << x2 << endl;
}
}

Introdução aos algoritmos Estrutura de repetição
Conteúdo


A estrutura de repetição amplia ainda mais as possibilidades de expressão em um algoritmo
Ela permite repetir uma ação enquanto uma dada condição for respeitada
Para um número máximo de 50 batatas, o relato abaixo descreve o padrão de comportamento para
descascar um número suficiente de batatas para o jantar
se “quantidade de batatas é insuficiente” então “descasca uma batata”;
se “quantidade de batatas é insuficiente” então “descasca uma batata”; {50×}
...

A formulação anterior é funcional, porém pouco prática

Requer 50 inspeções em todos os casos
Requer que os mesmos comandos sejam escritos 50 vezes
É limitado a um número máximo de 50 batatas (mas e se forem necessárias mais?)
A estrutura de repetição permite solucionar esses problemas

enquanto “quantidade de batatas é insuficiente” faça “descasca uma batata”;

Estruturas de repetição com pré-teste Abrir Projeto
Imprimir os números de 1 a 100 inicio

using namespace std;
i=1
int main(int argc, char *argv[]) { F
unsigned short int i; // Declara a variável i i <= 100
V
i = 1; // Inicializa i com 1
i
while ( i <= 100 ) { // Enquanto i <= 100

cout << i << endl; // Imprime o valor de i i=i+1
i = i + 1; // Incrementa i de 1
}
fim
return 0; // Finaliza o programa
}

Introdução aos algoritmos Compilação e interpretação
Conteúdo


Como o computador executa nosso algoritmo?
Linguagem Linguagem Linguagem Linguagem

···
natural C/C++ assembler de máquina
Imprima “Hello
#include <iostream> .model tiny 01111111 01000101
World” na tela
using namespace std; .code 01001100 01000110
int main() { org 100h 00000010 00000001
cout << "Hello World\n"; main proc 00000001 00000000
return 0; mov ah,9 00000000 00000000
} mov dx,offset msg 00000000 00000000
int 21h 00000000 00000000
retn 00000000 00000000
msg db 'Hello world$' 00000010 ...
main endp
end main
Computador real Ü processa apenas comandos em linguagem de máquina

Baseada em bits, obscura, desconfortável e distante da linguagem natural para o programador
Linguagem de programação: está entre a linguagem natural e a linguagem de máquina
Sintaxe bem definida e semântica sem ambiguidades
Possibilita escrever e compreender algoritmos independente da pragmática usando uma linguagem
semelhante à natural e de fácil tradução para uma linguagem de programação
Requer um programa tradutor de linguagem de programação para linguagem de máquina

Compiladores [DD10, Seção 1.14]
Um programa tradutor deste tipo é chamado de

compilador Editor
Código-fonte
Um algoritmo escrito em uma linguagem de
programação é chamado de programa-fonte ou Pré-processador
código-fonte Código-fonte
modificado
O compilador converte o código fonte para linguagem Compilador
de máquina (ou para outra linguagem de programação)

Código-objeto
O compilador precisa então ser escrito uma única vez Ligador
para cada máquina e linguagem de programação

Programa executável
Compiladores oferecem alto desempenho Carregador

Compilação para linguagem de máquina é feita uma vez
O prográma pode ser executado inúmeras vezes Execução
Alternativa: linguagens interpretadas

Ambientes de Desenvolvimento Integrados (IDEs)
Para simplificar o processo de desenvolvimento de programas, normalmente é usado um

Ambiente de Desenvolvimento Integrado (IDE)
Um IDE é um software que normalmente integra, entre outros elementos:

Um editor de texto Ü para escrever o programa na forma de código-fonte
Um compilador (ou interpretador) Ü para traduzir o código-fonte para linguagem de máquina
Um depurador Ü para teste e validação do programa
Os IDEs atuais contam com interface gráfica (botões, menus, editor de texto integrado, etc.)
segundo os padrões do sistema operacional
Há vários IDEs (gratuitos e comerciais) para diferentes linguagens de programação compiladas e

interpretadas
Para o linguagem C/C++, sugere-se o Code Blocks, o CLion ou o Visual Studio Community

Parte IV
Estruturas de controle de fluxo

Conceitos básicos em C/C++
Conteúdo
5 Conceitos básicos em C/C++

Sintaxe básica
Entrada e saída de dados básicas em C++
Entrada e saída de dados básicas em C
Identificadores e tipos de dados
Declaração de variáveis
6 Operadores
7 Estrutura condicional e de repetição

Conceitos básicos em C/C++ Sintaxe básica
Conteúdo

Sintaxe básica
6 Operadores

A linguagem C/C++
A linguagem C
Linguagem de programação imperativa, estruturada, desenvolvida por Dennis Ritchie na Bell Labs in 1972
a partir da linguagem BCPL e B de 1967
Inicialmente projetada para o desenvolvimento de sistemas operacionais e compiladores
A linguagem/padrão C++
Proposta por Bjarne Stroustrup em 1979 como uma extensão da linguagem C para orientação a objetos
Atualmente é padronizada e atualizada regularmente para tornar a linguagem cada vez mais moderna
Regras de sintaxe adotadas em C/C++

Toda palavra reservada da linguagem é escrita em letra minúscula
Toda ação expressa por um comando é terminado com o símbolo de sequenciamento ;
Blocos de comandos (associados a um processo) são agrupadas dentro de um par de chaves { ... }

Palavras reservadas em C/C++
Palavras reservadas são elementos da linguagem que possuem finalidade pré-definida e

inalterável [DD10, pág. 42]
Novas keywords podem ser adicionadas em novas versões
auto double int switch

bool else long true
break enum register typedef
case extern return
union
char false short
unsigned
const float signed
continue for sizeof void
default goto static volatile

do if struct while

Estrutura de um programa em C/C++ Abrir Projeto
Programa em C/C++ Ü consiste de classes e funções que contêm variáveis e comandos definindo o
que deve ser computado
Biblioteca padrão de C/C++ Ü conjuntos de funções especializadas [DD12, Seção 6.6], [DD10, Seção
5.8]
Programa em linguagem C/C++

// Isso é um comentário
using namespace std; // Ativa o pacote padrão (std)
// Corpo do programa - Mostra "Hello World!" na tela
cout << "Hello World!" << endl;
// Finaliza a main e retorna
return 0;
}
A função main deve estar presente em todo programa em C/C++ e também é reservada

Conceitos básicos em C/C++ Entrada e saída de dados básicas em C++
Conteúdo

Sintaxe básica
6 Operadores

Conceitos básicos em C/C++ Entrada e saída de dados básicas em C++
Entrada e saída de dados usando cin e cout
Em C++ a entrada e saída de dados utiliza cin e cout da biblioteca iostream [Eck00, Eck03, Ad07]
Veja a biblioteca iomanip para formatação (setw, setprecision, etc.) [DD12, Cap. 15]
Entrada e saída de dados em C++

#include <iostream> // Inclui a biblioteca de entrada/saída
int matric;
char turma;
float nota;
cout << "Entre com a matrícula: ";
cin >> matric;
cout << "Entre com a turma: ";
cin >> turma;
cout << "Entre com a nota: ";
cin >> nota;
cout << "Matrícula: " << matric << ", Turma: " << turma << ", Nota: " << nota << endl;
return 0;
}

Conceitos básicos em C/C++ Entrada e saída de dados básicas em C
Conteúdo

Sintaxe básica
6 Operadores

A função scanf [Sch96, pág. 211]
Em C há várias funções para entrada de dados pelo teclado, entre elas é a função scanf
[DD10, Sch96, KR88]
scanf usa códigos para controlar a formatação dos dados a serem lidos
Protótipo da função scanf

int scanf(const char * format, ...);
O conteúdo digitado é lido respeitando o código de formatação
Exemplo para a função scanf

scanf("%u", &idade); scanf(" %u %f ", &matric , &nota );
scanf("%f", &salario);
scanf("%u%f", &matric, &nota);
Os valores digitados são armazenados nas variáveis cujos endereços de memória são fornecidos
O endereço de memória da variável idade é obtido usando o operador &, ou seja, o endereço é
idade
Para usar scanf e printf em programas C++ basta utilizar #include <cstdio>
Códigos de formatação para scanf [Sch96, pág. 212], [KR88, sec. 7.4]
Código Saída Exemplo

%d Inteiro com sinal int angulo;
%u Inteiro sem sinal unsigned int idade;
%f Número de ponto flutuante float nota;
%c, %s Caractere simples ou cadeia de caracteres char resposta; char nome[64];
#include <cstdio> // Exemplo de entrada de dados em C

#include <cstdlib>
unsigned int matric;
char turma;
float nota;
printf("Entre com a matrícula: ");
scanf("%u", &matric);
printf("Entre com a turma: ");
scanf("%c", &turma);
printf("Entre com a nota: ");
scanf("%f", &nota);
printf("Matrícula: %u, Turma: %c, Nota: %f\n", matric, turma, nota);
return 0;
}

A função printf
Em C há várias funções para saída de dados na tela do computador, entre elas a função printf
printf usa códigos para formatar os dados a serem impressos
int printf(const char * format, ...);
O conteúdo das variáveis é impresso na ordem em que estas aparecem e respeitando os códigos de
formatação Ü "%[flags][width][.precision][length]specifier"
Sintaxes da função printf

printf("Alô mundo !!!\n");
printf("%8.2f", salario); // Imprime com oito posições (incluindo duas casas decimais)
printf("Nome: %s, Idade: %u\n", nome, idade);
printf("Nome: %s , Idade: %u ", nome , idade );
Para usar scanf e printf em programas C++ basta utilizar #include <cstdio>

Códigos de formatação para printf [Sch96, pág. 204], [KR88, sec. 7.2]
Código Saída Exemplo

%d Inteiro com sinal 392
%u Inteiro sem sinal 7235
%e Notação científica 3.9265e+2
%f Número de ponto flutuante 392.65
%c Caractere simples 'a'
%s Cadeia de caracteres "sample"
%o Octal com sinal 610
%X Hexadecimal sem sinal 7FA
Saída de dados em C
#include <cstdio>
#include <cstdlib>
unsigned int matric = 1033001;
char turma = 'A';
float nota = 9.5;
printf("Matrícula: %u, Turma: %c, Nota: %f\n", matric, turma, nota);
return 0;
}

Conceitos básicos em C/C++ Identificadores e tipos de dados
Conteúdo

Sintaxe básica
6 Operadores

Identificadores em C/C++
Identificadores são nomes que o programador usa para representar elementos no código
São usados para definir, representar e se referir a variáveis, constantes, tipos e funções
Devem começar com um caractere de a-z, de A-Z, ou com _
Podem conter os caracteres de a-z, A-Z, 0-9 e _
Não podem ser palavras reservadas da linguagem
A linguagem C/C++ distingue entre caracteres maiúsculos e minúsculos
Exemplos de identificadores
A, num1, num2, __ID__
dia_da_semana, DIA_DA_SEMANA
1o_Lugar
dia da semana
lei#8192, aluno@ufc
main

Identificadores em C/C++
Identificadores são nomes que o programador usa para representar elementos no código
São usados para definir, representar e se referir a variáveis, constantes, tipos e funções
Devem começar com um caractere de a-z, de A-Z, ou com _
Podem conter os caracteres de a-z, A-Z, 0-9 e _
Não podem ser palavras reservadas da linguagem
A linguagem C/C++ distingue entre caracteres maiúsculos e minúsculos
Exemplos de identificadores
A, num1, num2, __ID__
dia_da_semana, DIA_DA_SEMANA
1o_Lugar Ü começa com número
dia da semana Ü contém espaço em branco
lei#8192, aluno@ufc Ü contém # e @
main Ü palavra reservada

Tipos de dados da linguagem C/C++ [DD12, Apêndice C], [Ad07, Pág. 22]
Tipos de dados têm um tamanho em bits e comportam valores em certas faixas

bool Ü 8 bits, lógicos ∈ {true, false}
char Ü 8 bits, inteiros ∈ [−127, 127]associados a caracteres
short int Ü 16 bits, inteiros ∈ [−32.767, 32.767], abreviado por short
int Ü 32 bits, inteiros ∈ [−2.147.483.647, 2.147.483.647]
long int Ü 64 bits, inteiros ∈ [−263 + 1, 263 − 1], abreviado por long
long long int Ü 128 bits, inteiros ∈ [−2127 + 1, 2127 − 1], abreviado por long long
float Ü 32 bits, reais no intervalo ±3, 4 · 10±38
double Ü 64 bits, reais no intervalo ±1, 7 · 10±308
long double Ü 128 bits, reais no intervalo ±1, 2 · 10±4932
void Ü tipo de dado utilizado para indicar vazio

Tipos de dados da linguagem C/C++ [DD12, Apêndice C], [Ad07, Pág. 22]
Tipos inteiros em C/C++ Ü alterados usando modificadores Ü unsigned

unsigned char Ü inteiros ∈ [0, 255]
unsigned short Ü inteiros ∈ [0, 65535]
unsigned int Ü inteiros ∈ [0, 4.294.967.295]
unsigned long Ü inteiros ∈ [0, 264 − 1]
unsigned long long Ü inteiros ∈ [0, 2128 − 1]
Sinal (bit 7) Sinal (bit 7) char
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 127
Sinal (bit 15) Sinal (bit 15) short int
0 0 0 0 0 ... 0 0 0 0 1 1 1 ... 1 1 1 32.767
Sinal (bit 31) Sinal (bit 31) int
0 0 0 0 0 ... 0 0 0 0 1 1 1 ... 1 1 1 2.147.483.647

Conceitos básicos em C/C++ Declaração de variáveis
Conteúdo

Sintaxe básica
6 Operadores

Declaração de variáveis em C/C++
Sintaxe para definição de variável em C/C++

tipo_de_dado nome_da_variável1;
tipo_de_dado nome_da_variável1, nome_da_variável2, ..., nome_da_variávelN;

unsigned char idade; // Variáveis inteiras (8 bits sem sinal)
bool emFerias; // Variável lógica
char sexo; // Variável para guardar um caractere
unsigned int cep; // Variável inteira (32 bits sem sinal)
float salario = 3630.75; // Pode-se atribuir valor na declaração
idade = 30;
emFerias = true; // Valor diferente de zero é verdadeiro
sexo = 'M'; // Atenção para o apóstrofo em lugar de aspas
cep = 62011000;
return 0;
} // Encerra a main e retorna zero para o SO

Atribuição de valores (operador =) e conversão implícita e explícita
Há conversão implícita dos tipos de menor capacidade para os de maior capacidade

bool → char → short → int → long → long long → float → double → long double
Conversão explícita ou type cast
Em C antecede-se o que se quer converter com o tipo desejado entre parênteses Ü (type)value
Em C++ (mais seguro) usa-se (por exemplo) Ü static_cast<type>(value)
Exemplos de conversões implícitas e explícitas

char letra = 'A';
short valor;
valor = letra; // Nessa caso, valor será 65 (valor de A na tabela ASCII)
short a = 2, b = 3;
float c;
// inteiro/inteiro resulta em inteiro, logo c será 0 pois 2/3 = 0.66 cuja parte inteira é 0
c = a/b;
// (float)a será float que dividido por inteiro resulta em float, logo c será 0.66
c = (float)a/b;
Caso a consistência entre valor atribuído e tipo de variável não seja mantida, o valor atribuído
pode ser truncado, convertido e armazenado inadequadamente na variável
Operadores
Conteúdo
6 Operadores
Operadores aritméticos
Operadores lógicos e relacionais
Operadores adicionais
Precedência de operadores em C
Principais funções matemáticas e de conversão

Operadores
Operadores
O computador se presta ao cálculo, o qual é realizado através do uso de operações matemáticas
Cada operação está associada a um operador
Os operadores seguem as mesmas regras gerais conhecidas da matemática
Há três tipos de operadores

Unários Ü agem sobre um parâmetro Ü −|{z}
10 (negativo)
parâmetro
Binários Ü agem sobre dois parâmetro Ü |{z}
10 + 10 (adição)
|{z}
parâmetro 1 parâmetro 2
Ternários Ü agem sobre três parâmetro

Operadores Operadores aritméticos
Conteúdo
6 Operadores

Operação Tipo Exemplo

Positivo + Unário int A; A = +10;
Negativo - Unário int A; A = -10;
Adição + Binário int A, B; A = 10; B = A + 10;
Subtração - Binário int A, B; A = 10; B = A - 10;
Multiplicação * Binário int A, B; A = 10; B = A * 10;
Divisão / Binário float A, B; A = 10.0; B = A / 10.0;
Resto % Binário int A, B; A = 10; B = A % 2;
Quociente / Binário int A, B; A = 10; B = A / 2;
Adição Multiplicação Divisão Resto

short A = 16; short A = 16; short A = 16; short A = 16;
short B = 3; short B = 3; short B = 3; short B = 3;
short C; short C; short C; short C;
C = A + B; C = A * B; C = A / B; C = A % B;
cout << "C = "; cout << "C = "; cout << "C = "; cout << "C = ";
cout << C << endl; cout << C << endl; cout << C << endl; cout << C << endl;
// C = 19 // C = 48 // C = 5 // C = 1

Ex.: Adição de dois inteiros [DD10, Fig. 2.5] Abrir Projeto


int soma; // Variável que armazenará a soma


soma = num1 + num2; // Atribui total

cout << "A soma é: " << soma << endl; // Imprime a soma

}

Exercício : Escreva um programa que calcule a média aritmética M de três notas N1 , N2 e N3 , de um aluno de Engenharia onde as
N1 + N2 + N3
notas são lidas pelo teclado e M = . Abrir Projeto
3

Exercício : Escreva um programa que calcule a média aritmética M de três notas N1 , N2 e N3 , de um aluno de Engenharia onde as
N1 + N2 + N3
notas são lidas pelo teclado e M = . Abrir Projeto
3
Solução :
#include <iostream>
int main() {
float Nota1, Nota2, Nota3, Media;
cout << "Digite a 1a. nota (de 0 a 10): ";

cin >> Nota1;
cin >> Nota2;
cin >> Nota3;
Media = (Nota1 + Nota2 + Nota3)/3;

cout << "A média é : " << Media << endl;
return 0;
}

Exercício : Escreva um programa que calcule a média aritmética ponderada M de três notas N1 , N2 e N3 com pesos P1 , P2 e P3
N1 P1 +N2 P2 +N3 P3
respectivamente, de um aluno de Engenharia onde as notas e seus pesos são lidos pelo teclado e M = P1 +P2 +P3
. Abrir
Projeto

Exercício : Escreva um programa que calcule a média aritmética ponderada M de três notas N1 , N2 e N3 com pesos P1 , P2 e P3
N1 P1 +N2 P2 +N3 P3
respectivamente, de um aluno de Engenharia onde as notas e seus pesos são lidos pelo teclado e M = P1 +P2 +P3
. Abrir
Projeto
Solução :
#include <iostream>
int main() {
float Nota1, Nota2, Nota3, Peso1, Peso2, Peso3, Media;
cin >> Nota1;
cout << "Entre com o peso da 1a. nota (> 0): ";
cin >> Peso1;
cin >> Nota2;
cin >> Peso2;
cin >> Nota3;
cin >> Peso3;
Media = (Nota1*Peso1 + Nota2*Peso2 + Nota3*Peso3) / (Peso1 + Peso2 + Peso3);
cout << "A média é : " << Media << endl;
return 0;
}

Alguns usos criativos para os operadores (1/3)

Ex.: Os operadores % e / para inteiros — Inversão de dígitos Abrir Projeto


int N, D1, D2, D3, D4;
cout << "Digite N (0 a 9999): ";

cin >> N;
D1 = N % 10; // Isola o dígito das unidades

D2 = (N / 10) % 10; // Isola o dígito das dezenas
D3 = (N / 100) % 10; // Isola o dígito das centenas
D4 = (N / 1000) % 10; // Isola o dígito dos milhares
cout << D1 << D2 << D3 << D4;
return 0;
}


Ex.: Os operadores % e / para inteiros — Dígitos do CPF Exemplo: Repetição Abrir Projeto
#include <iostream>
unsigned int CPF;
unsigned short int D1, D2, D3, D4, D5, D6, D7, D8, D9, V1, V2;
cout << "Digite os 09 primeiros digitos do CPF: ";
cin >> CPF; // Lê o CPF
D1 = (CPF / 1) % 10; // Isola os dígitos do CPF
D2 = (CPF / 10) % 10;
D3 = (CPF / 100) % 10;
D4 = (CPF / 1000) % 10;
D5 = (CPF / 10000) % 10;
D6 = (CPF / 100000) % 10;
D7 = (CPF / 1000000) % 10;
D8 = (CPF / 10000000) % 10;
D9 = (CPF / 100000000) % 10;
V1 = D9*1 + D8*2 + D7*3 + D6*4 + D5*5 + D4*6 + D3*7 + D2*8 + D1*9;
V1 = V1 % 11; // Calcula o primeiro dígito verificador
V2 = D9*0 + D8*1 + D7*2 + D6*3 + D5*4 + D4*5 + D3*6 + D2*7 + D1*8 + V1*9;
V2 = V2 % 11; // Calcula o primeiro dígito verificador
cout << "CPF com dígitos verificadores: " << CPF << "-" << V1 << V2 << '\n';
return 0;
}

Ex.: Os operadores % e / para inteiros — Conversão de base Abrir Projeto
#include <iostream> // Biblioteca de E/S início

using namespace std; // Ativa o pacote std
leia(n, b)
int numero, base, quociente, resto;
cout << "Digite um número decimal: ";
q←n
cin >> numero;
cout << "Digite a nova base: "; F
q>0
cin >> base;
V
quociente = numero;
r ← q mod b
// Dígitos impressos na ordem inversa
while (quociente > 0) { q ← q div b
resto = quociente % base;
quociente = quociente / base;
imprima(resto)
cout << resto;
}
return 0; // Encerra a main e retorna zero fim

Operadores Operadores lógicos e relacionais
Conteúdo
6 Operadores

Operadores lógicos
E && Binário bool A, B; A = true; B = (A && false);
Ou || Binário bool A, B; A = 1; B = (A || false);
Negação ! Unário bool A; A = true; if (!A) { A = false; }
Ou-exclusivo != Binário bool A, B; A = true; B = (A != false);
Operadores relacionais
Igual == Binário int A, B; bool C; A = 10; B = 5; C = (A == B);
Diferente != Binário int A, B; bool C; A = 10; B = 5; C = (A != B);
Maior que > Binário int A, B; bool C; A = 10; B = 5; C = (A > B);
Menor que < Binário int A, B; bool C; A = 10; B = 5; C = (A < B);
Maior ou igual a >= Binário int A, B; bool C; A = 10; B = 5; C = (A >= B);
Menor ou igual a <= Binário int A, B; bool C; A = 10; B = 5; C = (A <= B);

Verificar relações entre 2 inteiros [DD10, Fig. 2.13] Abrir Projeto

using namespace std; // Ativa o pacote std
int main(int argc, char *argv[]) { // Função principal
int num1; // 1o. número digitado pelo usuário
int num2; // 2o. número digitado pelo usuário
cout << "Entre dois inteiros e eu direi as relações que eles satisfazem: ";
cin >> num1 >> num2; // Lê 1o. e o 2o. inteiro
if (num1 == num2) { cout << num1 << " é igual a " << num2 << endl; }
if (num1 != num2) { cout << num1 << " não é igual a " << num2 << endl; }
if (num1 < num2) { cout << num1 << " é menor que " << num2 << endl; }
if (num1 > num2) { cout << num1 << " é maior que " << num2 << endl; }
if (num1 <= num2) { cout << num1 << " é menor ou igual a " << num2 << endl; }
if (num1 >= num2) { cout << num1 << " é maior ou igual a " << num2 << endl; }

}

Verificar os lados de um triângulo Abrir Projeto

float ladoA, ladoB, ladoC;
bool condicao1, condicao2, condicao3;
cout << "Digite os lados A B C do triângulo: ";
cin >> ladoA >> ladoB >> ladoC;
condicao1 = (ladoA < (ladoB + ladoC));
condicao2 = (ladoB < (ladoA + ladoC));
condicao3 = (ladoC < (ladoA + ladoB));
if ( condicao1 && condicao2 && condicao3 ) {
cout << "Os 3 lados formam um triângulo." << endl;
condicao1 = (ladoA == ladoB);
condicao2 = (ladoB == ladoC);
condicao3 = (ladoC == ladoA);
if ( condicao1 && condicao2 && condicao3 ) {
std::cout << "O triângulo é equilátero." << endl;
}
else if ( condicao1 || condicao2 || condicao3 ) {
std::cout << "O triângulo é isósceles." << endl;
}
}
}
Operadores Operadores adicionais
Conteúdo
6 Operadores

Alguns operadores unários adicionais


Incremento ++ Unário int A; A = 10; A++; ++A;
Decremento -- Unário int A; A = 10; A--; --A;
Adição e atribuição += Unário int A; A = 10; A += 10;
Subtração e atribuição -= Unário int A; A = 10; A -= 10;
Multiplicação e atribuição *= Unário int A; A = 10; A *= 10;
Divisão e atribuição /= Unário float A; A = 10.0; A /= 10.0;
Resto e atribuição %= Unário int A; A = 10; A %= 2;
Quando um operador de incremento (decremento) precede seu operando, o C/C++ executa a

operação de incremento (decremento) antes de usar o valor do operando
Quando um operador de incremento (decremento) vem após seu operando, o C/C++ usará o valor
do operando antes de incrementá-lo (decrementá-lo)

Operadores de pré-incremento e pós-incremento Abrir Projeto

using namespace std; // Namespace padrão
// Sutil diferença entre ++a e a++;
unsigned short a, b;
a = 10;
b = a++;
cout << "a = " << a << " b = " << b << endl;
a = 10;
b = ++a;
cout << "a = " << a << " b = " << b << endl;
a = 10;
b = (a = (a + 1));
cout << "a = " << a << " b = " << b << endl;
return 0;
}

Alguns operadores binários adicionais

Operadores bit-a-bit

E & Binário int A; A = 10; A = A & 2;
Ou | Binário int A; A = 10; A = A | 3;
Complemento ~ Unário int A; A = 10; A = ~A;
Ou-exclusivo ^ Binário int A; A = 10; A = A ^ 7;
Deslocamento p/ esquerda << Binário int A; A = 10; A = A << 2;
Deslocamento p/ direita >> Binário int A; A = 10; A = A >> 2;
E e atribuição &= Unário int A; A = 10; A &= 2;
Ou e atribuição |= Unário int A; A = 10; A |= 3;
Complemento e atribuição ~= Unário int A; A = 10; A ~= A;
Ou-exclusivo e atribuição ^= Unário int A; A = 10; A ^= 7;
Deslocamento p/ esquerda e atribuição <<= Unário int A; A = 10; A <<= 2;
Deslocamento p/ direita e atribuição >>= Unário int A; A = 10; A >>= 2;

Subtração por soma em complemento 2 Abrir Projeto

// A subtração em binário pode ser feita usando
// o complemento de 2: negação bit-a-bit do subtraendo,
// depois soma 1, depois soma com o minuendo
short int x = 30, y = 10;
cout << "30 - 10 = " << x - y << endl;
y = ~y; // Negação bit-a-bit do subtraendo

y = y + 1; // Soma 1
cout << "30 - 10 = " << x + y << endl; // Soma com o minuendo Saída do programa
return 0; 30 - 10 = 20
30 - 10 = 20
}

Multiplicação por 2 usando deslocamento de bits Abrir Projeto
x = 20; x = 20;
0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0
0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0
x = x >> 1; x = x << 1;

// Multiplicação e divisão por dois pode ser feita usando operações de
// deslocamento de bits << e >>, respectivamente
short int x = 30, y;
// Multiplicação por 2
y = x << 1;
cout << "x = " << x << ", y = " << y << endl;
// Divisão por 2
y = x >> 1;
cout << "x = " << x << ", y = " << y << endl; Saída do programa
x = 30, y = 60
return 0; x = 30, y = 15
}

Operadores Precedência de operadores em C
Conteúdo
6 Operadores

Operadores Precedência de operadores em C
Precedência de operadores [KR88, Tabela 2.1], [Str13, Sec. 10.3]
Operadores com maior precedência são executados primeiro

Tentem pensar qual é o valor de 3 + 2 * 2 + 1 == 2 << 2
Precedência Operadores
Primeiro Parênteses, funções
Segundo !, ~, ++, --, +, - (unários)
Terceiro *, /, %
Quarto +, - (binários)
Quinto >>, <<
Sexto <, <=, >=, >
Sétimo ==, !=
Oitavo & (bit-a-bit)
Nono ^ (bit-a-bit)
Décimo | (bit-a-bit)
Décimo primeiro &&
Décimo segundo ||
Décimo terceiro =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=

Operadores Principais funções matemáticas e de conversão
Conteúdo
6 Operadores

Principais funções matemáticas
A linguagem C/C++ inclui uma biblioteca de funções matemáticas (#include <cmath>) que inclui,
entre outras, as funções [DD10, Seção 5.8], [DD12, Seção 6.6]:
Ângulo em radianos para funções trigonométricas
cos : cosseno log10: logaritmo na base 10

sin : seno pow : potenciação
tan : tangente sqrt : raiz quadrada
acos: arco-cosseno
ceil : arredondar para cima
asin: arco-seno
atan: arco-tangente fabs : valor absoluto
exp : exponencial floor: arredondar para baixo
log : logaritmo natural fmod : resto da divisão (float)

Principais funções matemáticas
Cálculo da hipotenusa [Ad07, Q. 2.16] Ü sqrt Abrir Projeto Cálculo dos catetos Ü cos, sin, M_PI Abrir Projeto
#include <iostream> #include <iostream>

#include <cmath> #include <cmath>
using namespace std; using namespace std;
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
float c1, c2, h; float ang, c1, c2, h;
cout << "Cateto 1: "; cout << "Angulo: ";

cin >> c1; cin >> ang;
cout << "Cateto 2: "; cout << "Hipotenusa: ";
cin >> c2; cin >> h;
h = sqrt(c1*c1 + c2*c2); ang = (ang/180)*M_PI;
cout << "Hipotenusa: " << h; c1 = h*cos(ang);
cout << endl; c2 = h*sin(ang);
return 0; cout << "c1 = " << c1 << endl;
} cout << "c2 = " << c2 << endl;
return 0;
}

Algumas funções de conversão
#include <cstdlib> inclui funções que permitem converter entre texto e números
atoi : texto para int strtol : texto para long int
atol : texto para long int strtoul : texto para unsigned long int
atof : texto para double strtof : texto para float
strtod : texto para double
#include <cstdlib> #include <cstdlib>
int i = atoi("1200"); long int i1, i2;
long int l = atol("20000"); i1 = strtol("11111111", NULL, 2); // Base 2
double d = atof("1.23"); i2 = strtol("1100", NULL, 10); // Base 10
cout << i << " " << l << " " << d; unsigned int u1, u2;
return 0; u1 = strtoul("0xFFFF", NULL, 16);
} u2 = strtoul("200000", NULL, 10);
float f = strtof("1.23", NULL);
double d = strtod("2.46", NULL);
cout << i1 << " " << i2 << " " << u1 << " "
<< u2 << " " << f << " " << d << endl;
return 0;
}

Estrutura condicional e de repetição
Conteúdo
6 Operadores

Estruturas condicionais
Estruturas de repetição

Estrutura condicional e de repetição
Algoritmos e estruturas básicas de controle
Todo algoritmo expressando um raciocínio ou padrão de comportamento pode ser expresso

utilizando apenas três estruturas de controle básicas
A estrutura sequencial
A estrutura condicional, também chamada estrutura alternativa ou estrutura de decisão
A estrutura de repetição, também chamada laço
A estrutura sequencial se refere à simples sequência de comandos a serem executados um após o

outro em sua ordem de aparição
As estruturas condicional e de repetição requerem maior discussão

Estrutura condicional e de repetição Estruturas condicionais
Conteúdo
6 Operadores


A estrutura condicional envolve a execução de um ou mais comandos mediante a verificação de

uma condição
Há três formas básicas para a estrutura condicional

A estrutura condicional simples, onde os comandos são executados se e somente se a condição a ser
verificada for verdadeira
A estrutura condicional composta, onde determinados comandos são executados para o caso da
condição ser verdadeira e outros comandos distintos são executados caso a condição seja falsa
A estrutura de múltipla escolha, onde um conjunto de comandos é escolhido de acordo com o valor de
uma constante Ü cada conjunto de comandos é condicionado ao resultado da expressão ser igual ao(s)
valor(es) especificado(s)

Estruturas condicional simples
Fluxograma
A estrutura condicional simples executa determinados

comandos somente se uma dada condição for verdadeira F
condição
Sintaxe em C/C++
if ( condicao ) {
comando1; V
comando2; comando1;
// ... ...
comandoN;
comandoN;
}

Exemplo para estrutura condicional simples

Solução de uma equação de 2o. grau Abrir Projeto

cin >> a >> b >> c; // Lê os coeficientes
delta = b*b - 4*a*c; // Calcula o discriminante
x1 = (-b + sqrt(delta))/(2*a); // Calcula x1
x2 = (-b - sqrt(delta))/(2*a); // Calcula x2
cout << "x1 = " << x1 << ", x2 = " << x2 << endl;
}
}

Estruturas condicional composta
A estrutura condicional composta estende a estrutura simples introduzindo um conjunto de

comandos que é executado quando a condição é falsa, além do conjunto de comandos que é
executado quando a condição é verdadeira
Fluxograma
Sintaxe em C/C++
if ( condicao ) {
V F
condição comandoV1; // Condição é verdadeira
// ...
c1; ... cN; c1’; ... cN’; }
else {
comandoF1; // Condição é falsa
// ...
}

Ex.: Solução de uma equação do 2o. grau Abrir Projeto

cin >> a >> b >> c;
delta = b*b - 4*a*c;
x1 = (-b + sqrt(delta))/(2*a);
x2 = (-b - sqrt(delta))/(2*a);
cout << "x1 = " << x1 << ", x2 = " << x2 << endl;
} else {
if (delta == 0) { // Raízes reais e iguais
x1 = -b / (2*a);
cout << "x1 = x2 = " << x1 << endl;
} else { // Raízes complexas
cout << "As raízes são complexas." << endl;
}
}
}

Ex.: Situação de um aluno Ü Podemos ter “ifs” aninhados Abrir Projeto

float media, freq;
cout << "Digite a média (0.0 a 10.0): ";
cin >> media;
cout << "Digite a frequência (0.0 a 100.0): ";
cin >> freq;
if ((media >= 0) && (media <= 10) && (freq >= 0) && (freq <= 100)) {
if ( freq >= 75 ) {
if ( media >= 7.0 ) {
cout << "Aprovação por média." << endl;
} else {
if ( media >= 5.0 ) {
cout << "Aprovação final." << endl;
} else {
cout << "Reprovação por nota." << endl;
}
}
} else {
cout << "Reprovação por falta." << endl;
}
} else {
cout << "Dados inválidos." << endl;
}
return 0; // Sai do programa com valor de retorno 0
}

Exercício : Escreva um programa que avalie o resultado do jogo “Pedra, Papel e Tesoura”. O programa deve ler a escolha de dois
jogadores como inteiros não-negativos de 16 bits de acordo com os valores Pedra (1), Papel (2) e Tesoura (3). As regras são: Papel vence
Pedra, Tesoura vence Papel e Pedra vence Tesoura. Escolhas iguais para os jogadores resultam em empate. O programa deve imprimir
uma mensagem indicando “Jogador 1 venceu.”, “Jogador 2 venceu.”, ou “Empate.” de acordo com o caso. Abrir Projeto

Exercício : Escreva um programa que avalie o resultado do jogo “Pedra, Papel e Tesoura”. O programa deve ler a escolha de dois
jogadores como inteiros não-negativos de 16 bits de acordo com os valores Pedra (1), Papel (2) e Tesoura (3). As regras são: Papel vence
Pedra, Tesoura vence Papel e Pedra vence Tesoura. Escolhas iguais para os jogadores resultam em empate. O programa deve imprimir
uma mensagem indicando “Jogador 1 venceu.”, “Jogador 2 venceu.”, ou “Empate.” de acordo com o caso. Abrir Projeto
Solução :
#include <iostream>
int main() {
const short int Pedra = 1, Papel = 2, Tesoura = 3;
unsigned short Escolha1, Escolha2;
cout << "Escolha do jogador 1 [(1)-Pedra, (2)-Papel, (3)-Tesoura]: ";
cin >> Escolha1;
cout << "Escolha do jogador 2 [(1)-Pedra, (2)-Papel, (3)-Tesoura]: ";
cin >> Escolha2;
if (Escolha1 >= Pedra && Escolha1 <= Tesoura &&
Escolha2 >= Pedra && Escolha2 <= Tesoura) { // escolhas entre 1 e 3
if (Escolha1 != Escolha2) {
if ( (Escolha1 == Papel && Escolha2 == Pedra) ||
(Escolha1 == Tesoura && Escolha2 == Papel) ||
(Escolha1 == Pedra && Escolha2 == Tesoura) ) {
cout << "Jogador 1 venceu." << endl;
} else {
cout << "Jogador 2 venceu." << endl;
}
} else {
cout << "Empate." << endl;
}
}
return 0;
}

Exercício : Escreva um programa que leia como inteiros o dia, o mês e o ano de duas datas e determine se as duas estão em ordem
cronológica (ou seja, se a primeira data é anterior à segunda data). Imprima uma mensagem adequada em cada caso. Assuma que as duas
datas fornecidas serão válidas. Abrir Projeto

Exercício : Escreva um programa que leia como inteiros o dia, o mês e o ano de duas datas e determine se as duas estão em ordem
cronológica (ou seja, se a primeira data é anterior à segunda data). Imprima uma mensagem adequada em cada caso. Assuma que as duas
datas fornecidas serão válidas. Abrir Projeto
Solução :
#include <iostream>
int main() {
short int d1, d2, m1, m2, a1, a2;
cout << "Digite o dia, mês e ano da 1a. data na forma dd mm aaaa: ";
cin >> d1 >> m1 >> a1;
cout << "Digite o dia, mês e ano da 2a. data na forma dd mm aaaa: ";
cin >> d2 >> m2 >> a2;
if (a1 > a2) {
cout << "As datas não estão em ordem cronológica." << endl;
} else {
if ((a1 == a2) && (m1 > m2)) {
} else {
if ((a1 == a2) && (m1 == m2) && (d1 > d2)) {
} else {
if ((a1 == a2) && (m1 == m2) && (d1 == d2)) {
cout << "As datas são iguais." << endl;
} else {
cout << "As datas estão em ordem cronológica." << endl;
}
}
}
}
return 0;
}

O operador ternário
O operador ternário é da forma (condition) ? valueIfTrue : valueIfFalse;

Normalmente, o operador combina um if imediato e uma atribuição =
Os códigos abaixo são equivalentes
if convencional
int x = 4; Operador ternário
int y;
int x = 4;
if(x % 2 == 0) {
int y;
y = 1;
} else {
y = (x % 2 == 0) ? 1 : 0;
y = 0;
}

Estruturas de múltipla escolha

Sintaxe em C/C++
switch ( expressao ) {
case valorA1:
case valorA2:
// ...
case valorAN:
A estrutura de múltipla escolha executa um conjunto de comandos de comandoA1; // Caso A
acordo com a comparação entre o valor de uma expressão e um // ...
break;
conjunto de valores associados a diferentes casos case valorB1:
case valorB2:
Em C/C++ os valores associados a cada caso devem ser constantes // ...
case valorBN:
Em C/C++, os diferentes casos são separados pelo comando break comandoB1; // Caso B
// ...
Atenção, pois caso o comando break seja esquecido o programa break;
// ...
continua o seu fluxo pelos comandos subsequentes case valorN1:
case valorN2:
Você também poderia utilizar estruturas condicionais simples e/ou // ...
case valorNN:
composta Ü a escolha depende do programador comandoN1; // Caso N
// ...
break;
default:
comandoS1; // Caso senão
// ...
}

Ex.: Menu de operações aritméticas Abrir Projeto
1 #include <iostream>
2 using namespace std;
3 int main(int argc, char *argv[]) { 21 case '*':
4 int X, Y; 22 cout << X << " * " << Y
5 char oper; 23 << " = " << X * Y << endl;
6 cout << "Entre com o 1o. número (X): "; 24 break;
7 cin >> X; 25 case '/':
8 cout << "Entre com o 2o. número (Y): "; 26 if (Y != 0)
9 cin >> Y; 27 cout << X << " / " << Y
10 cout << "Escolha a operação: +, -, *, /\n"; 28 << " = " << (1.0 * X) / Y << endl;
11 cin >> oper; 29 else
12 switch (oper) { 30 cout << "Divisão por zero !!!" << endl;
13 case '+': 31 break;
14 cout << X << " + " << Y 32 default:
15 << " = " << X + Y << endl; 33 cout << "Operação inválida !!!" << endl;
16 break; 34 }
17 case '-': 35 return 0;
18 cout << X << " - " << Y 36 } // Encerra a main e retorna 0
19 << " = " << X - Y << endl;
20 break;

Ex.: Nomes dos meses Abrir Projeto

unsigned short int NumeroDoMes;
cout << "Entre com o número do mês (1 a 12): ";
cin >> NumeroDoMes;
switch (NumeroDoMes) {
case 1:
cout << "Janeiro";
break;
case 2:
cout << "Fevereiro";
break;
// ...
case 12:
cout << "Dezembro";
break;
default:
cout << "Mês inválido";
}
return 0; // Encerra a main e retorna 0
}

Exercício : Escreva um programa que leia um conceito na forma de um caractere A, B, C, D ou F e que imprima o significado do conceito
por extenso como “Excelente”, “Bom”, “Regular”, “Ruim”, ou “Insuficiente”. Utilize um bloco switch ... case e capture no mesmo os
casos com letras maiúsculas e minúsculas bem como conceitos inválidos. Abrir Projeto

Exercício : Escreva um programa que leia um conceito na forma de um caractere A, B, C, D ou F e que imprima o significado do conceito
por extenso como “Excelente”, “Bom”, “Regular”, “Ruim”, ou “Insuficiente”. Utilize um bloco switch ... case e capture no mesmo os
casos com letras maiúsculas e minúsculas bem como conceitos inválidos. Abrir Projeto
Solução :
17 case 'c':
18 case 'C':
19 cout << "Regular." << endl;
3 int main() {
20 break;
4 char conceito;
21 case 'd':
5 cout <<
22 case 'D':
6 "Entre o conceito [A, B, C, D ou F] : ";
23 cout << "Ruim." << endl;
7 cin >> conceito;
24 break;
8 switch (conceito) {
25 case 'f':
9 case 'a':
26 case 'F':
10 case 'A':
27 cout << "Insuficiente." << endl;
11 cout << "Excelente." << endl;
28 break;
12 break;
29 default:
13 case 'b':
30 cout << "Conceito inválido." << endl;
14 case 'B':
31 }
15 cout << "Bom." << endl;
32 return 0;
16 break;
33 }

Estrutura condicional e de repetição Estruturas de repetição
Conteúdo
6 Operadores


A estrutura de repetição envolve a execução de um ou mais comandos repetidamente enquanto

uma dada condição for respeitada
Há três formas básicas para a estrutura de repetição

A estrutura de repetição com pré-teste, onde a condição que limita a repetição está presente no início da
estrutura de modo que os comandos a serem repetidos são executados somente se a condição for
verdadeira
A estrutura de repetição com variável de controle, onde o número de repetições a realizar é conhecido e
está associado a uma variável de controle (contador)
A estrutura de repetição com pós-teste, onde a condição que limita a repetição está presente no final da
estrutura de modo que os comandos a serem repetidos são executados pelo menos uma vez antes da
condição ser verificada
Cada uma das estruturas de repetição pode ser transformada nas outras através de uma
reformulação adequada

Estruturas de repetição com pré-teste
Repete um conjunto de comandos enquanto a condição for verdadeira

A condição deve mudar para falsa eventualmente após rodar os comandos um certo número de
vezes Ü ou o programa nunca terminará
Se a condição inicialmente já for falsa nenhum comando é executado
Fluxograma
Sintaxe em C/C++ F
condição
while ( condicao ) {
comando1; V
// ... comando1;
comandoN; comando2;
...
} comandoN;

Estruturas de repetição com pré-teste Abrir Projeto
Imprimir os números de 1 a 100 inicio

i=1
V
i

}
fim
}

Imprimir os ímpares de 1 a 100 inicio

i=1
V
i

}
fim
}

Imprimir os pares de 1 a 100 inicio

i=2
V
i

}
fim
}

Exercício : Uma progressão aritmética é uma série de números da forma an+1 = an + r , onde o termo inicial a0 e a razão r da série são
conhecidos. Escreva um programa que leia o termo inicial a0 , a razão r e uma quantidade de termos N da série. O programa deve então
imprimir na tela os N termos da série. Abrir Projeto

Solução :
#include <iostream>
int main() {
float a0, r;
short N;
cout << "Digite o termo inicial a0: ";

cin >> a0;
cout << "Digite a razão r: ";
cin >> r;
cout << "Digite o número de termos N: ";
cin >> N;
while (N >= 1) {
cout << a0 << endl;
a0 = a0 + r;
N = N - 1;
}
return 0;
}

imprimir na tela a soma dos N termos da série. Não utilize a fórmula da soma dos termos. Abrir Projeto

Solução :
1 #include <iostream> 23 int main() {

2 using namespace std; 24 float a0, r;
3 25 unsigned short N;
4 // Convencional 26 cout << "Digite o termo inicial a0: ";
5 float sum1(float a0, float r, unsigned short N) { 27 cin >> a0;
6 float s = 0; 28 cout << "Digite a razão r: ";
7 for(unsigned short i = 0; i < N; i++) { 29 cin >> r;
8 s += a0; 30 cout << "Digite o número de termos N: ";
9 a0 += r; 31 cin >> N;
10 } 32 cout << "Soma dos termos: " << sum1(a0, r, N) << endl;
11 return s; 33 cout << "Soma dos termos: " << sum2(a0, r, N) << endl;
12 } 34 return 0;
13 35 }
14 // Recursiva
15 float sum2(float a0, float r, unsigned short N) {
16 if(N == 1) {
17 return a0;
18 } else {
19 return a0 + sum2(a0+r, r, N-1);
20 }
21 }

Exercício : Uma progressão geométrica é uma série de números da forma an+1 = an · q , onde o termo inicial a0 e a razão q da série são
conhecidos. Escreva um programa que leia o termo inicial a0 , a razão q e uma quantidade de termos N da série. O programa deve então

Solução :
#include <iostream>
int main() {
float a0, q;
short N;

cin >> a0;
cout << "Digite a razão q: ";
cin >> q;
cin >> N;
while (N >= 1) {
cout << a0 << endl;
a0 = a0 * q;
N = N - 1;
}
return 0;
}


Solução :
#include <iostream>
int main() {
float a0, q, S = 0;
short N;
cin >> a0;
cout << "Digite a razão q: ";
cin >> q;
cin >> N;
while (N >= 1) {
cout << a0 << endl;
S = S + a0;
a0 = a0 * q;
N = N - 1;
}
cout << "Soma dos termos: " << S << endl;
return 0;
}

Ex.: Caramujo no poço Abrir Projeto
// Em quantos dias um caracol sai de um poço de 30 m de profundidade

// se ele sobe 3 m a cada noite, mas dorme durante o dia e escorrega 2 m?
unsigned int h; // Altura atingida pelo caracol no poço
unsigned int d; // Número de dias
d = 0; // Noite do 1o. dia

h = 3; // Subida da 1a. noite
while (h <= 30) { // Enquanto não conseguir sair do poço

h = h - 2; // Descida diurna
d = d + 1; // Depois de uma noite e um dia, mais um dia se foi
h = h + 3; // Subida noturna
}
// Finalmente fora do poço
cout << "Resposta: depois de " << d << " dias." << endl;
}

Ex.: Adivinhe um número entre 1 e 100 Abrir Projeto
// Adivinhe um número gerado aleatoriamente entre 1 e 100

#include <cstdlib> // Biblioteca padrão de funções -> rand()
#include <ctime> // Biblioteca de funções de tempo
unsigned int num, chute; // Número a adivinhar e seu chute
srand(time(NULL)); // Inicializa o gerador aleatório
num = (rand() % 100) + 1; // Sorteia um número entre 1 e 100
cout << "Dê o seu chute para adivinhar um número entre 1 e 100: ";
cin >> chute;
while (chute != num) { // Enquanto não acertar
if (chute > num) { cout << "Errou. O número é menor." << endl; }
if (chute < num) { cout << "Errou. O número é maior." << endl; }
cout << "Dê outro chute: ";

cin >> chute;
}
cout << "Acertou !!! O número era: " << num << endl;
return 0; // Encerra a main e retorna 0
}

Exemplo para estrutura de repetição com pré-teste Abrir Projeto 1 Abrir Projeto 2
Fatorial de N : N ! = N · (N − 1) · (N − 2) · . . . · 2 · 1 1 1
Soma dos termos da série S = 1 + 2
+ ... + N
com N ∈ N
// Biblioteca de E/S #include <iostream>
#include <iostream> using namespace std;
// Ativa o pacote std // Função principal
using namespace std; int main(int argc, char *argv[]) {
// Função principal unsigned int N;
int main(int argc, char *argv[]) { float S = 0.0;
unsigned int N, F; cout << "Entre com N: ";
cout << "Entre c/ N: "; cin >> N;
cin >> N; while ( N > 0 ) {
F = 1; S = S + 1.0 / N;
while( N >= 2 ) { N = N - 1;
F = F * N; }
N = N - 1; if (S > 0) {
} cout << "S = " << S << endl;
cout << "O fatorial é: " << F; } else {
cout << endl; cout << "N = 0 !!!" << endl;
return 0; }
} return 0;
}

Estruturas de repetição com variável de controle
Esta estrutura de repetição utiliza uma variável de controle que:

É inicializada com um valor inicial
É incrementada de um certo passo a cada repetição do laço até ultrapassar um dado valor final
Sintaxe em C/C++
for(contador = vr_inicial; contador < vr_final; contador++) {
comando1;
// ...
comandoN;
}
// ou
for(contador = vr_inicial; contador < vr_final; contador += vr_passo) {
comando1;
// ...
comandoN;
}

Exemplo para estrutura de repetição com variável de controle
Existe uma correspondência direta entre laços do tipo while e for

Inicialização feita antes do while Ü 1a. parte do for
Condição de parada do while Ü 2a. parte do for
Incremento da variável de controle no fim do while Ü 3a. parte do for
Imprimir os números de 1 a 100

#include <iostream> Imprimir os números de 1 a 100
using namespace std; #include <iostream>
unsigned short int i; int main(int argc, char *argv[]) {
unsigned short int i;
i = 1;
while ( i <= 100 ) { for(i = 1; i <= 100; i = i+1) {
cout << i << endl; cout << i << endl;
i = i + 1; }
}
return 0;
return 0; }
}

Quando o problema requer repetição por um número conhecido de vezes, a estrutura com variável
de controle é mais simples e clara de usar
Imprimir os pares de 1 a 100 Imprimir os ímpares de 1 a 100

unsigned short int i; unsigned short int i;
for(i = 2; i <= 100; i = i+2) { for(i = 1; i <= 100; i = i+2) {

cout << i << endl; cout <
Fluxograma
unsigned short int n, N;
cout << "Entre com N: ";
cin >> N; F
cout << "Números pares." << endl; <v> de <v0> até <vF> passo 
for(n = 2*N; n >= 0; n = n-2) {

V
cout << n << " ";
comando1;
} comando2;
cout << endl; ...
cout << "Números ímpares." << endl; comandoN;
for(n = 1; n <= 2*N+1; n = n+2) {

cout << n << " ";
}
cout << endl;
return 0;
}

Estruturas de repetição com variável de controle Abrir Projeto
Dígitos verificadores do CPF Exemplo: Sequência
#include <iostream>

unsigned int CPF, d;
unsigned short int i, D, V1, V2;
cout << "Digite os 09 primeiros digitos do CPF: ";

cin >> CPF;
V1 = 0;
V2 = 0;
d = 1;
for (i = 1; i <= 9; i++) {
D = (CPF / d) % 10;
d = d * 10;
V1 = V1 + D*(10-i);
V2 = V2 + D*(9-i);
}
V1 = V1 % 11;
V2 = V2 + V1*9;
V2 = V2 % 11;
cout << "CPF com dígitos verificadores: " << CPF << "-" << V1 << V2 << endl;
return 0;
}

Estruturas de repetição com variável de controle Abrir Projeto
Série de Fibonacci Ü 0, 1, 1, 2, 3, 5, ... Ü a0 = 0, a1 = 1, an = an−1 + an−2 , 2≤n≤N
#include <iostream>
Fluxograma
unsigned int a0, a1, n, N;
cout << "Entre com N: "; F
cin >> N; <v> de <v0> até <vF> passo 
V
a0 = 0;
comando1;
a1 = 1; comando2;
for(n = 0; n < N; n++) { ...
cout << a0 << " "; comandoN;
a1 = a1 + a0;
a0 = a1 - a0;
}
return 0;
}

Exemplo para estrutura de repetição com variável de controle Abrir Projeto 1 Abrir Projeto 2
Tabuada de multiplicação de um número N Tabuada de multiplicação dos números de 1 a 10

// Biblioteca de E/S // Biblioteca de E/S
// Ativa o pacote std // Ativa o pacote std
// Função principal // Função principal
unsigned short int n, N; unsigned short int n, N;
cout << "Entre com um numero: "; for (N = 1; N <= 10; N++) {
cin >> N; cout << "Tabuada do " << N
for (n = 0; n <= 10; n++) { << endl;
cout << N << " x " << n for (n = 0; n <= 10; n++) {
<< " = " << N*n cout << N << " x " << n
<< endl; << " = " << N*n
} << endl;
return 0; }
} }
return 0;
}

Quantidade de números entre 30 e 90 entre 10 números Quantidade de pessoas com 18 anos ou mais entre 10 pessoas
digitados #include <iostream>
#include <iostream> using namespace std;
int main(int argc, char *argv[]) { const short N=10;
const short N=10; unsigned int i, q, idade;
unsigned int i, Q; q = 0;
float X; for (i = 1; i <= N; i++) {
Q = 0; cout << "Idade da " <> idade;
cout << "Digite um numero: "; if (idade >= 18) {
cin >> X; q = q + 1;
if(X >= 30.0 && X <= 90.0) { }
Q = Q + 1; }
} cout << "Pessoas c/ 18 ou + anos: " << q;
}
cout << "Q = " Q << endl; return 0;
}
return 0;
}

N xn N (−1)n
ex ≈
P P
, com N ≥ 100 π≈4 , com N ≥ 100
n=0 n! n=0 2n + 1
#include <cmath> using namespace std;
using namespace std; int main(int argc, char *argv[]) {
int main(int argc, char *argv[]) { unsigned int n, N;
unsigned int n, N; float SINAL = 1.0, PI = 0.0;
float X, E = 0.0, F = 1.0; cout << "Entre com N >= 100:";
cout << "Entre com x:"; cin >> N;
cin >> X; if (N < 100) {
cout >> "Entre com N >= 100:"; N = 100;
cin >> N; }
if (N < 100) { N = 100; } for (n = 0; n < N; n++) {
for (n = 0; n < N; n++) { PI = PI + SINAL/(2*n+1);
if (n > 0) { F *= n; } SINAL = -SINAL;
E = E + pow(X, n)/F; }
} cout << "PI = " << 4*PI << endl;
cout << "exp(" << x << ")=" << E; return 0;
return 0; }
}

Estruturas de repetição com pós-teste
Semelhante a estrutura de repetição com pré-teste, mas com a diferença de que a condição é
estada após execução dos comandos
Os comandos serão executados ao menos uma vez mesmo que inicialmente a condição já seja falsa
Fluxograma
Sintaxe em C/C++
do
comando1;
{ comando2;
comando1; ...
comandoN;
// ...
comandoN;
V
} while ( condicao ); condição
F

Exemplo para estrutura de repetição com pós-teste
Verificação de dados de entrada Soma de números não-negativos (número negativo encerra a

#include <iostream> entrada de dados)
float N1, N2, M; int main(int argc, char *argv[]) {
float X, S = 0.0;
do {
cout << "Digite a 1a. nota: "; do {
cin >> N1; cout << "Entre um número X:";
} while( (N1 < 0) || (N1 > 10) ); cin >> X;
if(X > 0) {
do { S = S + X;
cout << "Digite a 2a. nota: "; }
cin >> N2; } while (X >= 0.0);
} while( (N2 < 0) || (N2 > 10) ); cout << "S = " << S << endl;
M = (N1 + N2)/2; return 0;

cout << "Média: " << M << endl; }
return 0;
}

Parte V
Introdução a funções

Introdução a funções
Conteúdo
8 Introdução a funções
Conceitos básicos
Exemplos de funções
Passagem de parâmetros por valor e por referência
Recursividade
Fundamentos de bibliotecas de funções

Introdução a funções Conceitos básicos
Conteúdo
Conceitos básicos
Recursividade

Dividir e conquistar
A escrita de um único longo programa linear é, em geral, difícil de seguir

Código de tarefas repetidas é repetido, dificultando a manutenção
Problemas complexos Ü podemos dividir o problema (programa) em subproblemas (funções)
Melhor legibilidade: é mais fácil entender o que o programa faz como um todo e como ele faz cada subtarefa
Melhor manutenibilidade: alterar uma funcionalidade requer alterar apenas uma parte do código
Melhor reuso: como cada função está separada, é mais fácil reusar uma delas em outro programa
Maior confiabilidade: código mais fácil de ser entendido e corrigido
Maior produtividade: cada parte do código pode ser desenvolvida por uma equipe diferente (trabalho paralelo) que só precisa
saber o que fazem as partes das outras equipes, mas não como fazem
Problema Função
principal principal (main)
Subproblema 1 Função 1
Subproblema 2 Função 2
Subproblema N Função N

Dividir e conquistar
A escrita de um único longo programa linear é, em geral, difícil de seguir

Código de tarefas repetidas é repetido, dificultando a manutenção
Problemas complexos Ü podemos dividir o problema (programa) em subproblemas (funções)
Melhor legibilidade: é mais fácil entender o que o programa faz como um todo e como ele faz cada subtarefa
Melhor manutenibilidade: alterar uma funcionalidade requer alterar apenas uma parte do código
Melhor reuso: como cada função está separada, é mais fácil reusar uma delas em outro programa
Maior confiabilidade: código mais fácil de ser entendido e corrigido
Maior produtividade: cada parte do código pode ser desenvolvida por uma equipe diferente (trabalho paralelo) que só precisa
saber o que fazem as partes das outras equipes, mas não como fazem
Chefe
Chefe 1
Funcionário Funcionario 2 Funcionario 3
Funcionario 4 Funcionario 5

Chamadas de funções
Uma função é uma unidade de programa (bloco de instruções) que executa uma tarefa específica, uma parte de um programa
especializada em uma funcionalidade
Funções realizam ações como ler dados, fazer cálculos e devolver resultados
Funções são invocadas por chamada
A chamada é feita pelo nome da função e fornece a informação (valores fornecidos como argumentos) necessária para que a função
cumpra seu objetivo
A função principal Ü controlador Ü chama uma ou mais vezes uma ou mais funções
Ao chamar uma função, a função chamada assume o controle e o função chamadora é interrompida
Ao concluir sua tarefa, a função chamada devolve o controle à função chamadora que continua de onde havia parado
Função 1
Função
Função 2 Função 2.1
principal
Sequência: 1
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 2
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 3
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 4
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 5
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 6
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 7
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 8
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 9
Função 3

cumpra seu objetivo
Função 1
Função
principal
Sequência: 10
Função 3 Fim do Programa

Elementos de uma função: cabeçalho e corpo
Cabeçalho Ü determina o protocolo de uso da função, i.e., para chamada da mesma, onde o
número, ordem, e tipo dos parâmetros deve ser respeitado
Especifica o nome da função Ü “obrigatório”
Especifica os parâmetros da função, bem como determina o número, ordem, tipo de dados, e
funcionalidade de entrada/saída dos mesmos
Especifica o tipo do valor de retorno
Corpo Ü contém os comandos da função

Contém as declarações de variáveis locais da função (existem somente dentro da função)
Contém os comandos que agem sobre os parâmetros e demais dados da função para que a mesma
cumpra sua tarefa
Contém o comando return que retorna o valor da função, se for o caso

Declaração de funções
Sintaxe em C/C++ para declarar uma função

TipoDeRetorno NomeDaFuncao(Tipo1 Parametro1, ..., TipoN ParametroN) {
// Variáveis locais da função
// Comandos da função
return vr_retorno;
}
Valor de Retorno Lista de Parâmetros Exemplo

void void ou () void MyFunction(void) ou
void MyFunction()
void não-void void MyFunction(int x)
(e.g, short, int, float, double)
não-void void ou () int MyFunction(void) ou
(e.g, short, int, float, double) int MyFunction()
não-void não-void int MyFunction(int x)
(e.g, short, int, float, double) (e.g, short, int, float, double)

Ex.: Função sem valor de retorno e sem parâmetros Abrir Projeto
#include <iostream>
void msgDivPorZero() {
cout << "Divisão por zero." << endl;
}
int main() {
float x, y;
cout << "Entre com x: ";
cin >> x;
cout << "Entre com y: ";
cin >> y;
if (y != 0) {
cout << x << "/" << y << " = " << x/y << endl;
} else {
msgDivPorZero();
}
return 0;
}

Ex.: Função sem valor de retorno e com parâmetros Abrir Projeto
#include <iostream>
void msgDivPorZero(float y) {
if (y == 0)
cout << "Dados inválidos." << endl;
}
int main() {
float x, y;
cin >> x;
cin >> y;
msgDivPorZero(y);
if(y != 0) {
cout << x << "/" << y << " = " << x/y << endl;
}
return 0;
}

Ex.: Função com valor de retorno e sem parâmetros Abrir Projeto
#include <iostream> int main() {

using namespace std; float x, y;
do {
char repetir() { cout << "Entre com x: ";
char resp; cin >> x;
do { cout << "Entre com y: ";
cout << "Repetir (s/n)? "; cin >> y;
cin >> resp; if (y != 0) {
if (resp!='s' && resp!='n') { cout << x << "/" << y
cout << "Erro" << endl; << " = " << x/y << endl;
} }
} while (resp!='s' && resp!='n'); } while (repetir() == 's');
return resp; // Retorna resposta return 0;
} }

Ex.: Função com valor de retorno e com parâmetros Abrir Projeto
#include <iostream>
float maior(float a, float b) {

if (a >= b) {
return a; // Funções podem ter mais de um comando return
}
return b; // Funções podem ter mais de um comando return
}
int main() {
float x, y;
cin >> x;
cin >> y;
cout << "maior(" << x << "," << y << ")=" << maior(x, y) << endl;
return 0;
}

Ex.: Situação do aluno usando funções Abrir Projeto
24 int main() {
2 #include <string>
25 float media, freq;
3
26 do {
27 cout << "Entre c/ a média das APs (0 a 10): ";
5
28 cin >> media;
6 string situacaoAluno(float m, float f)
29 if (media < 0 || media > 10) {
7 {
30 cout << "Dado inválido." << endl;
8 if( f < 75) {
31 }
9 return "Reprovado por falta";
32 } while (media < 0 || media > 10);
10 } else {
33 do {
11 if (m >= 7) {
34 cout << "Entre c/ frequência (0 a 100): ";
12 return "Aprovado por média";
35 cin >> freq;
13 } else {
36 if (freq < 0 || freq > 100) {
14 if(m >= 4) {
37 cout << "Dado inválido." << endl;
15 return "Avaliação final";
38 }
16 } else {
39 } while (freq < 0 || freq > 100);
17 return "Reprovado por nota";
40
18 }
41 cout << "Situação do aluno: "
19 }
42 << situacaoAluno(media, freq);
20 }
43 return 0;
21 }
44 }
22

Concepção de funções
Divida o problema em subproblemas

Identifique os parâmetros de entrada e/ou saída e o valor de retorno de cada subproblema
Defina o tipo de dados de cada parâmetro e do valor de retorno
Defina o cabeçalho da função
Construa a função no corpo da mesma, onde vale lembrar que os parâmetros atuam como variáveis e que
variáveis e comandos podem ser usados como em qualquer programa
Lista de
Tipo de Retorno parâmetros
MyFunction
float float a, float b

maximo
float maximo(float a, float b)

Introdução a funções Exemplos de funções
Conteúdo
Conceitos básicos
Recursividade

Exercício : Crie uma função modulo que calcule e retorne o módulo (comprimento) k~
v k2 de um vetor ~v = xî + y ĵ + z k̂ no espaço, onde
p
k~v k2 = x2 + y 2 + z 2 . A função deve receber as coordenadas x, y e z como parâmetros. Na função main, leia as coordenadas de um
v e use a função modulo para calcular o módulo do vetor, e em seguida imprima seu valor na main.
vetor ~ Abrir Projeto

Exercício : Crie uma função modulo que calcule e retorne o módulo (comprimento) k~
v k2 de um vetor ~v = xî + y ĵ + z k̂ no espaço, onde
p
k~v k2 = x2 + y 2 + z 2 . A função deve receber as coordenadas x, y e z como parâmetros. Na função main, leia as coordenadas de um
v e use a função modulo para calcular o módulo do vetor, e em seguida imprima seu valor na main.
vetor ~ Abrir Projeto
Solução :
#include <iostream>
#include <cmath>
double modulo(double x, double y, double z) {

double m;
m = sqrt(x*x + y*y + z*z);
return m;
}
int main() {
double x, y, z, m;
cout << "Entre com as componentes x y z: ";
cin >> x >> y >> z;
m = modulo(x, y, z);
cout << "O módulo é: " << m << endl;
return 0;
}

Exercício : Crie uma função dot que calcule e retorne o produto interno (produto escalar) de dois vetores ~
v = vx î + vy ĵ e
w~ = wx î + wy ĵ no plano, onde ~v · w
~ = vx wx + vy wy . A função deve receber as coordenadas vx , vy , wx e wy como parâmetros. Na
função main, leia as coordenadas dos vetores ~vew~ e use a função dot para calcular o produto interno entre eles. Em seguida imprima seu
valor na main. Abrir Projeto

Exercício : Crie uma função dot que calcule e retorne o produto interno (produto escalar) de dois vetores ~
v = vx î + vy ĵ e
w~ = wx î + wy ĵ no plano, onde ~v · w
~ = vx wx + vy wy . A função deve receber as coordenadas vx , vy , wx e wy como parâmetros. Na
função main, leia as coordenadas dos vetores ~vew~ e use a função dot para calcular o produto interno entre eles. Em seguida imprima seu
valor na main. Abrir Projeto
Solução :
#include <iostream>
double dot(double vx, double vy, double wx, double wy) {

return vx*wx + vy*wy;
}
int main() {
double vx, vy, wx, wy, d;
cout << "Entre com x y do vetor v: ";
cin >> vx >> vy;
cout << "Entre com x y do vetor w: ";
cin >> wx >> wy;
cout << "dot(v, w) = " << dot(vx, vy, wx, wy) << endl;
return 0;
}

Exercício : Crie uma função angulo que calcule e retorne o ângulo θ = ∠~w~
v entre dois vetores ~
v = vx î + vy ĵ e w
~ = wx î + wy ĵ no
plano, onde θ pode ser isolado a partir da relação |~
v · w|
~ = k~v k2 kwk
~ 2 cos(θ). A função deve receber as coordenadas vx , vy , wx e wy
como parâmetros. Na função main, leia as coordenadas dos vetores ~ vew~ e use a função dot para calcular o ângulo entre eles. Em seguida
imprima seu valor na main. Abrir Projeto

Exercício : Crie uma função angulo que calcule e retorne o ângulo θ = ∠~w~
v entre dois vetores ~
v = vx î + vy ĵ e w
~ = wx î + wy ĵ no
plano, onde θ pode ser isolado a partir da relação |~
v · w|
~ = k~v k2 kwk
~ 2 cos(θ). A função deve receber as coordenadas vx , vy , wx e wy
como parâmetros. Na função main, leia as coordenadas dos vetores ~ vew~ e use a função dot para calcular o ângulo entre eles. Em seguida
imprima seu valor na main. Abrir Projeto
Solução :
2 #include <cmath>
14 int main() {
3
15 double vx, vy, wx, wy, ang;
16 cout << "Entre com x y do vetor v: ";
5 double angulo(double vx, double vy, double wx, double wy) {
17 cin >> vx >> vy;
6 double moduloV, moduloW, dotVW, theta;
18 cout << "Entre com x y do vetor w: ";
7 dotVW = vx*wx + vy*wy;
19 cin >> wx >> wy;
8 moduloV = sqrt(vx*vx + vy*vy);
20 ang = angulo(vx, vy, wx, wy)/M_PI*180;
9 moduloW = sqrt(wx*wx + wy*wy);
21 cout << "Ângulo(v, w) = " << ang << endl;
10 theta = acos(dotVW/(moduloV * moduloW));
22 return 0;
11 return theta;
23 }
12 }
13

Exercício : Crie uma função que receba como parâmetro um inteiro não-negativo, calcule e retorne o seu fatorial. Usando essa função,
crie uma segunda função que calcule o número de combinações de n elementos p-a-p, i.e., n n!
. Use essa função na main

p
= p!(n−p)!
para calcular e imprimir o número de combinações de n elementos p-a-p, onde n > 0 e 0 < p ≤ n são lidos via teclado. Abrir Projeto

Exercício : Crie uma função que receba como parâmetro um inteiro não-negativo, calcule e retorne o seu fatorial. Usando essa função,
crie uma segunda função que calcule o número de combinações de n elementos p-a-p, i.e., n n!
. Use essa função na main

p
= p!(n−p)!
para calcular e imprimir o número de combinações de n elementos p-a-p, onde n > 0 e 0 15 }
2 using namespace std; 16
3 17 int main() {
4 unsigned long long fatorial(unsigned short n) { 18 unsigned short n, p;
5 unsigned long long f = 1; 19 cout << "Entre com n e p: ";
6 while (n > 1) { 20 cin >> n >> p;
7 f = f * n; 21 if (p > 0 && n > 0 && n >= p) {
8 n--; 22 cout << "Combinações de " << n << ", " << p
9 } 23 << "-a-" << p << " = " << combinacoes(n, p) << endl;
10 return f; 24 } else {
11 } 25 cout << "Dados inválidos." << endl;
12 26 }
27 return 0;
28 }

Máximo e mínimo entre dois números reais
Máximo entre valores float

float max(float A, float B) {
if(A >= B) {
return A;
}
else {
return B;
}
}
Mínimo entre valores float

float min(float A, float B) {
if(A <= B) {
return A;
}
else {
return B;
}
}

Introdução a funções Passagem de parâmetros por valor e por referência
Conteúdo
Conceitos básicos
Recursividade

Passagem por valor Ü forma padrão

Valores dos argumentos (parâmetro reais) são copiados para os parâmetros da função (parâmetros
formais)
Alterações feitas sobre os parâmetros (formais) dentro da função não alteram os parâmetros (reais) fora
da função
Parâmetros passados por valor Ü agem somente como entradas para a função
Passagem por referência
Valores dos argumentos (parâmetros reais) são ligados aos parâmetros da função (parâmetro formal)
Alterações feitas sobre os parâmetros (formais) dentro da função alteram os parâmetros (reais) fora da
função
Parâmetros passados por referência Ü agem tanto como entradas como saídas para a função
Em C, há apenas passagem de parâmetros por valor e a passagem por referência é simulada
usando ponteiros

Passagem de parâmetros por valor e por referência Abrir Projeto
#include <iostream>
void troca(int A, int B) {

int aux; // Variável auxiliar
aux = A; // Salva valor de A em aux
A = B; // Cópia o valor de B p/ A void troca(int A, int B)
B = aux; // Cópia aux p/ B

int A int B
}

int A, B, C; cópia
cout << "Digite A B C: "; cópia
cin >> A >> B >> C; int main()

while (A > B || B > C) {
if (A > B) troca(A, B); int A int B
if (B > C) troca(B, C);
cout << A << " " <
void troca(int &A, int &B) {

aux = A; // Salva valor de A em aux
A = B; // Copia o valor de B p/ A void troca(int &A, int &B)
B = aux; // Copia aux p/ B

int A int B
}

int A, B, C; ligação
cout << "Digite A B C: "; ligação
cin >> A >> B >> C; int main()

while (A > B || B > C) {
if (A > B) troca(A, B); int A int B
if (B > C) troca(B, C);
cout << A << " " << B
<< " " << C << endl;
}
return 0;
}

Conteúdo
Conceitos básicos
Recursividade

Exemplo de declaração de função
Um exemplo simples para uma função é aquele que calcula o fatorial

n! = n · (n − 1) · (n − 2) · . . . · 2 · 1 de um número não-negativo n
Função para calcular o fatorial
double fatorial(unsigned int n) {
// Variável local
double f;
f = 1.0;
while (n > 1) {
f = f * n;
n--;
}
return f;
}

Tabelas de fatoriais
Crie um programa que imprime uma tabela com n e seu fatorial n! para os Sem o uso de subprogramas o cálculo do fatorial
números entre 0 e 20 caso fosse necessário atualizar um módulo (e.g.,
usar uma forma diferente para o fatorial), a
#include <iostream> mudança não estaria concentrada em um único
using namespace std; ponto
unsigned long long fatorial(unsigned short n) {
unsigned long long f = 1;
while (n > 1) {
f = f * n;
n--;
}
return f;
}

for(unsigned short n = 0; n <= 20; ++n) {
cout << "O fatorial de " << n << " é " << fatorial(n) << '\n';
}
return 0;
}

Introdução a funções Recursividade
Conteúdo
Conceitos básicos
Recursividade

Funções recursivas Abrir Projeto
Funções recursivas são funções que chamam a si mesmas #include <iostream>

(ou seja, que recorrem a si mesmas) using namespace std;
Normalmente, cada função recursiva possui dois elementos
unsigned long long fatorial(unsigned short n) {
Uma cláusula de indução Ü define o processamento if(n <= 1) { // Caso base
recursivo em si return 1;
Um (ou mais) caso(s) base Ü define um caso base ao } else { // Cláusula de indução
qual a recursão pode ser reduzida, sendo portanto usado return n*fatorial(n-1);
normalmente como critério de parada }
Por exemplo, o fatorial pode ser expresso de forma recursiva }
como: int main() {

Cláusula de indução Ü N ! = N · (N − 1)! unsigned short int n;
Caso base Ü 1! = 1 e 0! = 1 cout << "Entre com um número: ";
cin >> n;
cout << n << "! = " << fatorial(n) << endl;
return 0;
}

Exercício : Escreva uma função recursiva que retorne o n-ésimo termo da sequência de Fibonacci. Use essa função na main para imprimir
o n-ésimo da sequência. Sabe-se para essa sequência que a0 = 0, a1 = 1 e an = an−1 + an−2 , ∀n > 2, n ∈ N. Abrir Projeto

Exercício : Escreva uma função recursiva que retorne o n-ésimo termo da sequência de Fibonacci. Use essa função na main para imprimir
o n-ésimo da sequência. Sabe-se para essa sequência que a0 = 0, a1 = 1 e an = an−1 + an−2 , ∀n > 2, n ∈ N. Abrir Projeto
Solução :
#include <iostream>
unsigned int fibonacci(unsigned int n) {

if(n <= 1) { // Caso base
return n;
} else { // Cláusula de indução
return fibonacci(n-1) + fibonacci(n-2);
}
}
int main() {
unsigned short int n;
cout << "Entre com o termo: ";
cin >> n;
cout << "O " << n << "o. termo é = "
<< fibonacci(n) << endl;
return 0;
}

Introdução a funções Fundamentos de bibliotecas de funções
Conteúdo
Conceitos básicos
Recursividade

Introdução a funções Fundamentos de bibliotecas de funções
Fundamentos para criação de bibliotecas de funções Abrir Projeto
Biblioteca de funções Ü forma prática de gerenciar funções Arquivo de declarações Ü contém os protótipos das funções
Listagem 1: myfunctionslib.hpp (cabeçalhos)
Arquivo de implementação Ü inclui o arquivo de declarações e
#ifndef _MYFUNCTIONSLIBH_ implementa as funções
#define _MYFUNCTIONSLIBH_
unsigned long long fatorial(unsigned short n);

// ... Declaração de outras funções Listagem 3: main.cpp
#endif
#include <iostream>
#include "myfunctionslib.hpp"
Listagem 2: myfunctionslib.cpp int main() {

unsigned short n;
for(n = 0; n <= 10; n++) {
#include "myfunctionslib.hpp" // Inclui declarações cout << n << "! \t= "
<< fatorial(n) << endl;
unsigned long long fatorial(unsigned short n) { }
unsigned long long f = 1; return 0;
while(n > 1) { }
f = f * n;
n--;
}
return f;
}
// ... Implementação de outras funções

Parte VI
Estruturas de dados homogêneas

Vetores (arrays unidimensionais)
Conteúdo
9 Vetores (arrays unidimensionais)

Conceitos básicos
Declaração de vetores em C/C++
Leitura/escrita de elementos de um vetor
Exemplos e aplicações
10 Matrizes (arrays bidimensionais)
11 Vetores de caracteres e strings

Vetores (arrays unidimensionais) Conceitos básicos
Conteúdo

Conceitos básicos

Vetores (arrays)
Para atender necessidades de armazenamento e representação de dados, estruturas de dados se

tornam necessárias
Estruturas de dados são coleções de itens de dados correlacionados, sendo derivadas de tipos de
dados básicos como, por exemplo, bool, char, int, float, ou double
Vetores (ou arrays unidimensionais) são estruturas de dados homogêneas

Empregam um único tipo de dados
Possuem um tamanho constante Ü comprimento ou número de elementos
Possuem um conjunto de índices Ü acesso as componentes / posições / elementos do vetor
Assemelham-se conceitualmente aos vetores em matemática
Em C/C++, os elementos de um vetor ocupam posições contíguas na memória

Em C/C++, o primeiro elemento de um vetor possui índice 0 (zero)

Vetores (arrays)
Vetores permitem armazenar conjuntos de dados e simplificam diversas operações
Considere a determinação da interseção entre dois conjuntos de dados A e B

Com variáveis escalares, precisaríamos de uma variável para cada elemento de cada conjunto
A semântica do conjunto como uma única entidade seria perdida, assim como a noção de elemento
O esforço de programação e a dificuldade de generalização seriam proibitivos
Determinados problemas só podem ser solucionados de forma geral e prática utilizando vetores
Precisamos conhecer duas ações básicas envolvendo vetores

Declaração dos vetores
Acesso a um elemento para escrita/leitura
A forma de cada ação é muito similar à usada com escalares

Vetores (arrays unidimensionais) Declaração de vetores em C/C++
Conteúdo

Conceitos básicos

x 0x0000FF10
Sintaxe para declaração de vetores: similar à usada para escalares 16 bits
0x0000FF11
TipoDeDados NomeDoVetor[TamanhoDoVetor]; u[0] 0x0000FF12 16 bits
0x0000FF13
Ex.: Declaração de um escalar e de um vetor u[1] 0x0000FF14 16 bits
short x; // Um escalar inteiro de 16 bits 0x0000FF15
short u[10]; // Um vetor de 10 inteiros u[2] 0x0000FF16 16 bits
0x0000FF17
Comparada à declaração de uma variável escalar, a declaração de um u[3] 0x0000FF18 16 bits
vetor é acrescida de um par de colchetes com o tamanho do vetor 0x0000FF19
entre eles u[4] 0x0000FF1A 16 bits
Na memória, o vetor u assemelha-se a uma coluna (ou linha) de uma 0x0000FF1B
tabela u[5] 0x0000FF1C 16 bits
0x0000FF1D
O tamanho de um vetor tem que ser uma constante, assegurando que
o tamanho será conhecido no momento da compilação ... ...


Declaração de vetores c/ constante literal Declaração de vetores c/ constante escalar
// Vetor de 10 inteiros const short N = 10;
int u[10]; // Vetor de 10 inteiros
// Vetor de 10 números reais int u[N];
float v[10]; // Vetor de 10 números reais
// Vetor de 10 caracteres float v[N];
char w[10]; // Vetor de 10 caracteres
// ... char w[N];
return 0; // ...
} return 0;
}
Constante literal (ou seja, um número) Ü forma

comum de definir o tamanho de um vetor Constante escalar Ü obtida precedendo declaração
de variável com const
Possui o inconveniente de precisar ser alterado em
todos os pontos do programa sempre que o Usado para definir constantes Ü
tamanho do vetor precisar ser redefinido const float PI = 3.14;
Tamanho do vetor deve ser um número inteiro

Vetores (arrays unidimensionais) Leitura/escrita de elementos de um vetor
Conteúdo

Conceitos básicos

Os elementos de um vetor são acessados usando o nome do vetor e um índice

Em C/C++, os índices começam em 0 Ü o 1o elemento tem índice 0, o 2o tem índice 1, o 3o tem índice 2 e assim por
diante até o último elemento com índice N-1, onde N é o tamanho do vetor
Acessar um elemento Ü usa o nome do vetor seguido do índice do elemento entre colchetes
Acesso aos elementos de um vetor Acesso aos elementos de um vetor

int main() { int main() {
const short N = 5; const short N = 5;
int u[N]; // Um vetor de 5 inteiros short i;
u[0] = 0; // 1o. elemento tem índice 0 int u[N]; // Um vetor de 5 inteiros
u[1] = 10; // 2o. elemento tem índice 1 for(i =0; i < N; i++) {
cin >> u[2]; // Suponha 20 é digitado cout << "Digite u[" <> u[i];
u[4] = 40; // Último elemento }
return 0; for(i =0; i < N; i++) {
} cout << "2 x u[" << i << "]="
<< 2*u[i] << endl
}
Modelo de memória do vetor return 0;
}
u Ü 0 10 20 30 40

Inicializando um vetor na declaração
Em geral, os dados em um vetor são acessados elemento a elemento

Um vetor pode também ser inicializado completamente em sua declaração
Os elementos do vetor são listados entre chaves e separados por vírgula
Inicialização de vetor na declaração
const short N = 5;
unsigned int n; // Um contador
int u[N] = {-20, -10, 0, 10, 20}; // Um vetor de 5 inteiros
for(n = 0; n < N; n++) {
cout << u[n] << " ";
}
return 0;
}

Vetores (arrays unidimensionais) Exemplos e aplicações
Conteúdo

Conceitos básicos

Exercício : Faça um programa que leia um vetor com 10 posições para números inteiros e mostre somente os números positivos [Ad12, Q.
6.20]. Abrir Projeto 1 Abrir Projeto 2

Exercício : Faça um programa que leia um vetor com 10 posições para números inteiros e mostre somente os números positivos [Ad12, Q.
6.20]. Abrir Projeto 1 Abrir Projeto 2
Solução :
#include <iostream>
#include <iterator>
#include <iostream>
#include <algorithm>
int main() {
int main() {
const short N = 10; // Tamanho do vetor
short i, v[N];
short i, v[N];
for (i = 0; i < N; i++) {
for (i = 0; i < N; i++) {
cout << "Digite v[" <> v[i];
cin >> v[i];
}
}
cout << "Números positivos: ";
for (auto x : v) { // Range for
cout << "Números positivos: ";
if (x > 0) {
copy_if(v,
cout << x << " ";
v+N,
}
ostream_iterator<short>(cout, " "),
}
[](short x) { return (x > 0); }
cout << endl;
);
cout << endl;
return 0;
}
return 0;
}
Exercício : Faça um programa que preencha um vetor com 7 números inteiros, calcule e mostre: i) os números múltiplos de 2; ii) os
números múltiplos de 3; iii) os números múltiplos de 2 e 3 [Ad12, Q. 6.2]. Abrir Projeto

Solução :
19 cout << "Múltiplos de 3: ";
20 for (auto x : v) {
3
21 if (x % 3 == 0) {
4 int main() {
22 cout << x << " ";
5 // Tamanho do vetor
23 }
6 const short N = 7;
24 }
7 short i, v[N];
25 cout << endl;
8 for (i = 0; i < N; i++) {
26 cout << "Múltiplos de 2 e 3: ";
9 cout << "Digite v[" <> v[i];
28 if ( x % 2 == 0 && x % 3 == 0) {
11 }
29 cout << x << " ";
12 cout << "Múltiplos de 2: ";
30 }
31 }
14 if (x % 2 == 0) {
32 cout << endl;
15 cout << x << " ";
33
16 }
34 return 0;
17 }
35 }
18 cout << endl;


Solução :
2 #include <iterator> 20 cout << "Múltiplos de 3: ";
3 #include <algorithm> 21 copy_if(v,
4 using namespace std; 22 v+N,
5 23 ostream_iterator<short>(cout, " "),
6 int main() { 24 [](short x) { return (x % 3 == 0); }
7 const short N = 7; // Tamanho do vetor 25 );
8 short i, v[N]; 26 cout << endl;
9 for (i = 0; i < N; i++) { 27 cout << "Múltiplos de 2 e 3: ";
10 cout << "Digite v[" <> v[i]; 29 v+N,
12 } 30 ostream_iterator<short>(cout, " "),
13 cout << "Múltiplos de 2: "; 31 [](short x) { return (x % 2 == 0 && x % 3 == 0); }
14 copy_if(v, 32 );
15 v+N, 33 cout << endl;
16 ostream_iterator<short>(cout, " "), 34
17 [](short x) { return (x % 2 == 0); } 35 return 0;
18 ); 36 }
19 cout << endl;

Exercício : Faça um programa que preencha um vetor com 10 números reais, calcule e mostre a quantidade de números negativos e a
soma dos números positivos [Ad12, Q. 6.7]. Abrir Projeto 1 Abrir Projeto 2

Exercício : Faça um programa que preencha um vetor com 10 números reais, calcule e mostre a quantidade de números negativos e a
soma dos números positivos [Ad12, Q. 6.7]. Abrir Projeto 1 Abrir Projeto 2
Solução :
#include <iostream>
#include <iostream>
#include <numeric>
int main() {
int main() {
const short N = 10; // Tamanho dos vetores
const short N = 10; // Tamanho dos vetores
short i, qtNeg = 0;
short i, qtNeg = 0;
float v[N], somaPos = 0;
float v[N], somaPos = 0;
for (i = 0; i < N; i++) {
for (i = 0; i < N; i++) {
cout << "Digite v[" <> v[i];
cin >> v[i];
if (v[i] < 0) {
}
qtNeg++;
qtNeg = count_if(v, v+N, [](float x) { return (x < 0); });
} else {
somaPos = accumulate(v, v+N, somaPos,
somaPos += v[i];
[](float &x, float &y) {
}
if (y > 0) return (x + y);
}
else return x; }
cout << "Qtde. de negativos: " << qtNeg << endl;
);
cout << "Soma dos positivos: " << somaPos << endl;
cout << "Qtde. de negativos: " << qtNeg << endl;
return 0;
cout << "Soma dos positivos: " << somaPos << endl;
}
return 0;
}
Solução : Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 213 / 348
Exercício : Faça um programa que preencha um vetor com quinze números, determine e mostre: o maior número e a posição dele no
vetor; ii) o menor número e a posição dele no vetor [Ad12, Q. 6.18]. Abrir Projeto

Exercício : Faça um programa que preencha um vetor com quinze números, determine e mostre: o maior número e a posição dele no
vetor; ii) o menor número e a posição dele no vetor [Ad12, Q. 6.18]. Abrir Projeto
Solução :
#include <iostream>
int main() {
short i, posMax = 0, posMin = 0;
float v[N];
for (i = 0; i < N; i++) {
cout << "Digite v[" <> v[i];
if (v[i] > v[posMax]) { posMax = i; }
if (v[i] < v[posMin]) { posMin = i; }
}
cout << "Máximo: " << v[posMax] << endl;
cout << "Posição: " << posMax << endl;
cout << "Mínimo: " << v[posMin] << endl;
cout << "Posição: " << posMin << endl;
return 0;
}

Soma de vetores Abrir Projeto Subtração de vetores Abrir Projeto

#include <iostream> // Soma de vetores #include <iostream> // Subtração de vetores
const unsigned int N = 10; const unsigned int N = 10;
unsigned int i; unsigned int i;
float V1[N], V2[N]; float V1[N], V2[N];
cout << "Entre com: " << endl; cout << "Entre com: " << endl;
for(i = 0; i < N; i++) {// Lê V1 for(i = 0; i < N; i++) {// Lê V1
cout << "V1[" <> V1[i]; cin >> V1[i];
} }
cout << "V2[" <> V2[i]; cin >> V2[i];
} }
cout << "V1 + V2 = [ "; cout << "V1 - V2 = [ ";
for(i = 0; i < N; i++) { for(i = 0; i < N; i++) {
cout << V1[i] + V2[i] << " "; cout << V1[i] - V2[i] << " ";
} }
cout << "]" << endl; cout << "]" << endl;
return 0; return 0;
} }

Produto de Hadamard Abrir Projeto Produto Escalar Abrir Projeto

#include <iostream> // Produto de Hadamard #include <iostream> // Produto escalar
const unsigned int N = 10; const unsigned int N = 10;
unsigned int i; unsigned int i;
float V1[N], V2[N]; float V1[N], V2[N], S = 0;
cout << "Entre com: " << endl; cout << "Entre com: " << endl;
cout << "V1[" <> V1[i]; cin >> V1[i];
} }
cout << "V2[" <> V2[i]; cin >> V2[i];
} }
cout << "V1 .* V2 = [ "; for(i = 0; i < N; i++) {
for(i = 0; i < N; i++) { S = S + V1[i]*V2[i];
cout << V1[i] * V2[i] << " "; }
} cout << "<V1,V2>=" << S << endl;
cout << "]" << endl; return 0;
return 0; }
}

Remover Elementos Duplicados Abrir Projeto Complemento entre Conjuntos Abrir Projeto
#include <iostream> // Complemento entre conjuntos
int main(int argc, char *argv[]) { using namespace std;
const int N = 10; int main(int argc, char *argv[]) {
int i, j, k, L = N, V[N]; const int N1 = 3, N2 = 5;
for(i = 0; i < N; i++) { int i, j, A[N1], B[N2];
cout << "Entre V[" <> V[i]; cout << "Entre A[" <> A[i];
for(i = 0; i < L; i++) { }
for(j = i+1; j < L; j++) { for(i = 0; i < N2; i++) {
if(V[i] == V[j]) { cout << "Entre B[" <> B[i];
V[k] = V[k+1]; }
} cout << "C(A, B):" << endl;
L--; j--; for(i = 0; i < N2; i++) {
} for(j = 0; j < N1; j++) {
} if(B[i] == A[j]) { break; }
} }
for(i = 0; i < L; i++) { cout << V[i] << " "; } if(j == N1) { cout << B[i] << " "; }
return 0; }
} return 0;
}

Soma e média dos elementos de um vetor
Soma dos elementos: v ∈ Rn Média dos elementos: v ∈ Rn

float soma(float v[], int n) float media(float v[], int n)
{ {
float S = 0.0; float S = 0.0;
for(int i = 0; i < n; i++) { for(int i = 0; i < n; i++) {
S += v[i]; S += v[i];
} }
return S; S = S/n;
} return S;
}

Norma Euclidiana de um vetor
A norma Euclidiana kvk de um vetor Norma Euclidiana: v ∈ Rn

T
v = v0 v2 . . . vN −1 , v ∈ RN é

float norma(float v[], int n)
definida como {
float S = 0.0;
for(int i = 0; i < n; i++) {
v
uN
S += v[i]*v[i];
uX
kvk = t |vn |2 }
n=1 S = sqrt(S); // cmath
return S;
}

Exercício : Escreva um programa que misture aleatoriamente os números de 1 a 75 usados em um bingo. Os números do bingo devem ser
guardados em um vetor e impressos um por um sempre a uma tecla for pressionada. Imprima também as letras B (de 1 a 15), I(de 16 a 30),
N (de 31 a 45), G (de 46 a 60), ou O (de 61 a 75).

Exercício : Escreva um programa que misture aleatoriamente os números de 1 a 75 usados em um bingo. Os números do bingo devem ser
guardados em um vetor e impressos um por um sempre a uma tecla for pressionada. Imprima também as letras B (de 1 a 15), I(de 16 a 30),
N (de 31 a 45), G (de 46 a 60), ou O (de 61 a 75).
Solução :
16 int main() {
17 const short numBolas = 75;
18 string letras = "BINGO";
1 #include <iostream> 19 short i, bolas[numBolas];
2 #include <cstdlib> 20
3 #include <ctime> 21 srand(time(0));
4 // #include <algorithm> 22
5 using namespace std; 23 for(i = 0; i < numBolas; i++) {
6 24 bolas[i] = i+1;
7 void embaralhar(short *v, short n) { 25 }
8 short i, j, k; 26 // random_shuffle(bolas, bolas + numBolas);
9 for(k = 0; k < 10*n; k++) { 27 embaralhar(bolas, numBolas);
10 i = rand() % n; 28 for(i = 0; i < numBolas; i++) {
11 j = rand() % n; 29 cout << "ENTER para sortear uma bola";
12 swap(v[i], v[j]); 30 cin.ignore();
13 } 31 cout << letras[(bolas[i]-1)/15] << "-"
14 } 32 << bolas[i] << endl;
33 }
34 return 0;
35 }

Matrizes (arrays bidimensionais)
Conteúdo

Conceitos básicos
Declaração de matrizes em C/C++
Leitura e escrita para elementos de uma matriz
Exemplos de aplicações

Matrizes (arrays bidimensionais) Conceitos básicos
Conteúdo

Conceitos básicos

Conceitos básicos
Assim como vetores, matrizes são estruturas de dados homogêneas, ou seja, são derivadas a partir
de um único tipo básico (char, int, float, double)
Matrizes são também chamadas arrays bidimensionais
As principais características de uma matriz estática são
Um tipo de dados (um dos tipos básicos acima)
Dois tamanhos constantes (um tamanho para cada dimensão), ou seja, um número de linhas e um
número de colunas
Dois conjuntos de índices que permitem acessar as componentes/posições/elementos da matriz
Assim como na matemática, um vetor é um caso particular de matriz (com uma única linha ou
coluna)

Ações básicas envolvendo matrizes
Assim como vetores, matrizes são úteis para representação de dados cuja natureza é
essencialmente matricial
Deste modo, o desenvolvimento de algoritmos é simplificado
Considere o caso de uma imagem digital cujos elementos são organizados naturalmente em forma
de matriz, sendo que cada ponto (pixel) contém uma informação de cor
Outros exemplos referem-se a problemas matemáticos de álgebra matricial
Em programação em C/C++, há duas ações básicas envolvendo matrizes
Declaração das matrizes
Acesso a um elemento para escrita/leitura
A forma de cada ação é muito similar àquela usada com vetores

Matrizes (arrays bidimensionais) Declaração de matrizes em C/C++
Conteúdo

Conceitos básicos

As mesmas formas de definir constantes para tamanhos de vetor se aplicam a matrizes

Constante literal Ü 100
Variável com modificador const Ü const int N = 100;
Diretiva #define Ü #define N 100
Diferente dos vetores, as matrizes requerem duas dimensões
Declaração de matrizes
float M[5][4]; // Uma matriz com 5 linhas e 4 colunas
unsigned char img[64][64]; // Uma imagem 64 x 64
Comparado com a declaração de um vetor, a declaração de uma matriz em C/C++ é acrescida de

um par adicional de colchetes
Temos um par de colchetes com o tamanho para cada dimensão

Para a lógica do programa a matriz M deve ser entendida como uma matriz convencional com linhas e
colunas
Colunas 1 2 3 4
Linha 1
Linha 2
Linha 3
Linha 4
Linha 5
Porém, na memória a matriz M assemelha-se a um vetor com 5 × 4 = 20 elementos
Linha 1 Linha 2 Linha 3 Linha 4 Linha 5

Matrizes (arrays bidimensionais) Leitura e escrita para elementos de uma matriz
Conteúdo

Conceitos básicos

Matrizes (arrays bidimensionais) Leitura e escrita para elementos de uma matriz
Acesso a um elemento para escrita e leitura
Os elementos de um matriz são acessados para escrita utilizando um índice para a linha e outro para a coluna
Da mesma forma que com vetores, os índices em cada dimensão têm índice-base 0
A escrita em um elemento de uma matriz se dá escrevendo o nome da variável matriz seguida do índice da linha entre
colchetes e do índice da coluna entre colchetes
Escrita em elementos de uma matriz

const short N = 2, M = 2;
short A[N][M]; // Matriz N x M de inteiros
A[0][0] = 1; // Linha 0, coluna 0, valor 1
cin >> A[1][1]; // Linha 1, coluna 1, suponha que o valor 1 é digitado
for(short i = 0; i < N; i++) {
for(short j = 0; j < M; j++) {
cout << A[i][j] << ' ';
}
cout << '\n';
}
return 0;
}

Matrizes (arrays bidimensionais) Exemplos de aplicações
Conteúdo

Conceitos básicos

Leitura e impressão de matrizes
Leitura e impressão de uma matriz
1 #include <iostream> 17 cout << "Impressão da matriz\n";

2 using namespace std; 18 for(i = 0; i < M; i++) { // Linha i
3
19 for(j = 0; j < N; j++) { // Coluna j
4 int main(int argc, char *argv[]) { 20 // Imprima o elemento
5 // Número de linhas M e colunas N 21 // da linha i e coluna j
6 const short M = 3, N = 4; 22 cout << A[i][j] << ' ';
7 short A[M][N]; // Matriz 23 }
8 short i, j; // Índices 24 // Ao terminar uma linha
9 cout << "Leitura da matriz" << endl; 25 cout << endl;
10 for(i = 0; i < M; i++) { // Linha i 26 }
11 for(j = 0; j < N; j++) { // Coluna j 27 return 0;
12 cout << "Entre A[" <> A[i][j];
15 }
16 }

Contar elementos entre [−10, 10]
1 #include <iostream> 14 for(i = 0; i < M; i++) { // Linha i

2 using namespace std; 15 for(j = 0; j < N; j++) { // Coluna j
3 16 cout << "Entre A[" <> A[i][j];
6 const short M = 3, N = 4; 19 if((A[i][j] >= -10) && (A[i][j] <= 10)) {
7 // Índice da linha i e da coluna j 20 qtde++;
8 short i, j; 21 }
9 float A[M][N]; // Matriz 22 }
10 unsigned int qtde; 23 }
11 24 cout << "Qtde em [-10, 10]:" << qtde << endl;
12 qtde = 0; 25 return 0;
13 cout << "Leitura da matriz" << endl; 26 }

Inicializações usando contadores
Matriz identidade
#include <iostream>
const short N = 5;
short i, j, I[N][N]; // Índices e matriz N x N
for(i = 0; i < N; i++) {
for(j = 0; j < N; j++) {
// 1's somente se i igual a j
I[i][j] = (i == j) ? 1 : 0;
}
}
for(i = 0; i < N; i++) {
for(j = 0; j < N; j++) {
cout << I[i][j] << ' ';
}
cout << '\n';
}
return 0;
}

Inicializações usando contadores
Matriz triangular inferior de 1’s Matriz triangular superior de 1’s

short i, j, L[N][N]; // Índices e matriz N x N short i, j, U[N][N]; // Índices e matriz N x N
for(i = 0; i < N; i++) { for(i = 0; i < N; i++) {
for(j = 0; j < N; j++) { for(j = 0; j < N; j++) {
// Índice da linha >= ao da coluna // Índice da linha <= ao da coluna
L[i][j] = (i >= j) ? 1 : 0; U[i][j] = (i <= j) ? 1 : 0;
} }
} }
for(i = 0; i < N; i++) { for(i = 0; i < N; i++) {
for(j = 0; j < N; j++) { for(j = 0; j < N; j++) {
cout << L[i][j] << ' '; cout << U[i][j] << ' ';
} }
cout << '\n'; cout << '\n';
} }
return 0; return 0;
} }

Operações com matrizes: soma de matrizes
17 for(i = 0; i < 4; i++) {

18 for(j = 0; j < 4; j++) {
1 #include <iostream> 19 cout << "Entre B[" << i+1
2 using namespace std; 20 << "][" << j+1 << "]: ";
3 21 cin >> B[i][j];
4 int main(int argc, char *argv[]) { 22 }
5 // Contadores (índices) 23 }
6 unsigned int i, j; 24 for(i = 0; i < 4; i++) {
7 // Matrizes 25 for(j = 0; j < 4; j++) {
8 unsigned int A[4][4], B[4][4], C[4][4]; 26 // Soma os elementos na posição i,j
9 27 C[i][j] = A[i][j] + B[i][j];
10 for(i = 0; i < 4; i++) { 28 }
11 for(j = 0; j < 4; j++) { 29 }
12 cout << "Entre A[" << i+1 30 for(i = 0; i < 4; i++) {
13 << "][" << j+1 << "]: "; 31 for(j = 0; j < 4; j++) {
14 cin >> A[i][j]; 32 cout << C[i][j] << " ";
15 } 33 }
16 } 34 cout << endl;
35 }
36 return 0; }

Operações com matrizes: subtração de matrizes
17 for(i = 0; i < 4; i++) {

18 for(j = 0; j < 4; j++) {
1 #include <iostream> 19 cout << "Entre B[" << i+1
2 using namespace std; 20 << "][" << j+1 << "]: ";
3 21 cin >> B[i][j];
4 int main(int argc, char *argv[]) { 22 }
5 // Contadores (índices) 23 }
6 unsigned int i, j; 24 for(i = 0; i < 4; i++) {
7 // Matrizes 25 for(j = 0; j < 4; j++) {
8 unsigned int A[4][4], B[4][4], C[4][4]; 26 // Subtrai os elementos na posição i,j
9 27 C[i][j] = A[i][j] - B[i][j];
10 for(i = 0; i < 4; i++) { 28 }
11 for(j = 0; j < 4; j++) { 29 }
12 cout << "Entre A[" << i+1 30 for(i = 0; i < 4; i++) {
13 << "][" << j+1 << "]: "; 31 for(j = 0; j < 4; j++) {
14 cin >> A[i][j]; 32 cout << C[i][j] << " ";
15 } 33 }
16 } 34 cout << endl;
35 }
36 return 0; }

Solução de um sistema triangular inferior de equações lineares
Considere uma aplicação em engenharia que necessite de um subprograma para encontrar a solução de um sistema
triangular inferior de n equações e n incógnitas x1 , x2 , . . . xn da forma
a1,1 · x1
    
= b1
a1,1 0 . . . 0 x1 b1
a2,1 · x1 + a2,2 · x2 = b2
 a2,1 a2,2 . . . 0   x2   b2 
⇒ . .  .  =  . 
    
.. .. .. . .
. .  .. . . ..   ..   .. 
an,1 · x1 + an,2 · x2 + . . . + an,n · xn = bn an,1 an,2 . . . an,n xn bn
| {z } | {z } | {z }
An×n xn×1 bn×1
onde ai,i 6= 0, i = 1, 2, . . . , n. Elabore um procedimento para solucionar o problema.

Para a solução do problema e elaboração do subprograma, identificamos quatro parâmetros
Uma matriz de entrada An×n ∈ Rn×n do tipo float
Um vetor de entrada bn×1 ∈ Rn×1 do tipo float
Uma vetor de saída xn×1 ∈ Rn×1 do tipo float
Um valor de entrada n do tipo const unsigned short
A função deve calcular o vetor solução xn×1 retornando true nesse caso ou false em caso de erro

Assim, podemos definir o cabeçalho do subprograma como

bool solveLowerTriang(float *A, float *b, float *x, const unsigned short n)
Para a implementação do subprograma (corpo), podemos notar que o problema pode ser
facilmente resolvido calculando x1 na 1a equação, substituindo x1 na 2a equação e calculando x2 ,
depois substituindo x1 e x2 na 3a equação e calculando x3 , e assim por diante, até calcular xn , ou
seja,
b1
x1 =
a1,1
 
i−1
1  X
xi = bi − ai,j · xj  , i = 2, 3, . . . , n
ai,i
j=1
Esse modelo de solução pode então ser implemementado como segue:

bool solveLowerTriang(float *A, float *b, float *x, const unsigned short n)
unsigned short i, j;
if (n < 1) {
return false;
}
else {
for(i = 0; i < n; i++) {
x[i] = b[i];
for(j = 0; j < i; j++) {
x[i] = x[i] - A[i*n + j]*x[j];
}
if( A[i*n + i] != 0.0 ) {
x[i] = x[i]/A[i*n + i];
}
else {
return false;
}
}
}
return true;
}

Vetores de caracteres e strings
Conteúdo

O que são strings?
Strings em C
Strings em C++
Exemplos de manipulação de strings

Vetores de caracteres e strings O que são strings?
Conteúdo

O que são strings?
Strings em C
Strings em C++

Vetores de caracteres e strings O que são strings?
O que são strings?
Cedo ou tarde em qualquer linguagem de programação surge a necessidade de armazenar em

uma variável um texto (uma sequência de caracteres)
Chamamos genericamente uma sequência de caracteres de “string”
Em C/C++, pode-se armazenar um texto utilizando vetores de caracteres

C não possui um tipo próprio para armazenar strings, mas possui uma biblioteca que define funções úteis
lidar com vetores de caracteres (vetores de char)
Em C++ podemos usar um vetor de caracteres (e as funções do C), mas a linguagem também possui um
tipo próprio para strings, denominado de “string” (requer #include <string>)

Vetores de caracteres e strings Strings em C
Conteúdo

O que são strings?
Strings em C
Strings em C++

Vetores de caracteres ou strings
Em C, uma string é declarada como um vetor de char

Strings são terminadas pelo caractere terminador especial '\0'
Várias funções são especializadas para lidar com strings (biblioteca string.h em C e cstring em C++)
Declaração, leitura e escrita de strings (Vetor de caracteres)

char texto[100]; // Declara um vetor de 100 caracteres
cin >> texto; // Lê uma palavra para o vetor texto

cout << texto << endl; // Imprime texto do vetor texto
cin.clear(); // Limpa cin
cin.ignore(); // Descarta caracteres extras em cin
cin.getline(texto, 100); // Lê uma frase para o vetor texto

fflush(stdout); // Limpa cout
gets(texto); // Lê uma frase para o vetor texto


Vetores de caracteres ou strings
Considere que o texto “Elisabeth” foi lido para um vetor char nome[10];
Assim, o vetor nome na memória seria E l i s a b e t h \0
Funções que manipulam strings pressupõem a existência do terminador, ou seja, a presença do mesmo no vetor
determina se a string nele é válida ou não
Funções que manipulam strings acrescentam (ou ignoram) automaticamente o '\0'
O programador deve reservar espaço suficiente no vetor para o texto e para o terminador
Para o vetor nome acima, a string admissível mais longa é de 9 caracteres
Nada impede que strings mais curtas sejam armazenadas
Se considerarmos que “Emanuel” foi o nome digitado teríamos E m a n u e l \0

Nada impede que uma string seja manipulada diretamente como um vetor
Uso de string como vetor convencional

nome[0] = 'e'; // Escreve E minúsculo na posição 0 do vetor

Funções para manipulação de strings
Existem várias funções para manipulação de strings disponíveis na biblioteca cstring (em C++ ou string.h
em C)
Principais funções (considerando str1, str2 como strings → vetores de caracteres)

Função Descrição
strlen(str1) Fornece o tamanho da string str1
strcpy(str2, str1) Copia a string str1 (de origem) para a string str2 (de destino)
strcat(str2, str1) Concatena (junta) a string str1 (de origem) no final da string str2 (de destino)
strcmp(str1, str2, n) Compara a string str1 com a str2 até a quantidade n de caracteres
Retorno da função strcmp(str1, str2, n)
0 se str1 == str2 em termos de ordem alfabética

Um número maior que zero se str1 > str2 em termos de ordem alfabética
Um número menor que zero se str1 < str2 em termos de ordem alfabética

Vetores de caracteres e strings Strings em C++
Conteúdo

O que são strings?
Strings em C
Strings em C++

Vetores de caracteres e strings Strings em C++
Strings em C++
Em C++, faz-se manipulação de texto usando objetos string da biblioteca string

C++ strings incorporam em si todas as funcionalidades disponíveis para manipulação de vetores de caracteres em C,
porém de maneira muito mais intuitiva
Use getline(cin, uma_string) para ler uma string (incluindo espaços)
Principais métodos de um objeto string (considere string str = "Texto")

Uso Descrição
str = "Texto" Atribuir um texto em str
str.length() Tamanho da frase em str
str + "Texto 2" Concatenar str com outro texto (ou string)
str == "texto 2" Comparar str com outro texto
str.c_str() Retorna um vetor de caracteres (caso você realmente precise)

Vetores de caracteres e strings Exemplos de manipulação de strings
Conteúdo

O que são strings?
Strings em C
Strings em C++

Exemplo para funções de manipulação de strings

Manipulando nome e sobrenome: gets, strlen, strcpy, strcat
#include <iostream>
#include <cstring>
char nome[20], sobrenome[20], completo[40];
cout << "Digite seu nome:";
cin >> nome;
cout << "Digite seu sobrenome:" ;
cin >> sobrenome;
cout << "Nome tem " << strlen(nome) << " letras." << endl;
cout << "Sobrenome tem " << strlen(sobrenome) << " letras." << endl;
strcpy(completo, nome);
strcat(completo, " ");
strcat(completo, sobrenome);
cout << "Nome completo é " << completo << endl;
return 0;
}

Exemplo de funções e métodos para manipulação de strings

Compare o uso de vetores de caracteres com o de objetos string
1 #include <iostream> 17 // Juntar texto em C

2 #include <cstring> 18 strcpy(txt_c, "Texto 1");
3 #include <string> 19 strcat(txt_c, " Texto 2");
4 using namespace std; 20 // Juntar texto em C ++
5 int main(int argc, char *argv[]) { 21 str = "Texto 1";
6 char txt_c[20]; // Tamanho Máximo 22 str = str + "Texto 2";
7 string str; 23 // Comparar texto
8 // Atribuir texto 24 strcpy(txt_c, "Texto");
9 strcpy(txt_c, "Texto"); // Em C 25 if(strcmp(txt_c, "Texto") == 0) {
10 str = "Texto"; // Em C++ 26 cout << "Iguais." << endl;
11 27 }
12 // Tamanho da frase em C 28 str = "Texto 1";
13 cout << strlen(txt_c) << endl; 29 if(str == "Texto 2") {
14 // Tamanho da frase em C 30 cout << "Iguais." << endl;
15 cout << str.length() << endl; 31 }
16 32 return 0;
33 }

Exemplo de strings: calcular a quantidade de vogais [Ad12, pág. 317]
#include <iostream>
#include <string>
int main(int argc, char *argv[]) { using namespace std;
char frase[128];
short int i, vogais; int main(int argc, char *argv[]) {
cout << "Digite uma frase:" << '\n'; string frase;
cin.getline(frase, 128); size_t pos, vogais;
i = 0; cout << "Digite uma frase:" << '\n';
vogais = 0; getline(cin, frase);
while( frase[i] != '\0') { pos = 0;
if( frase[i] == 'a' || frase[i] == 'e' || vogais = 0;
frase[i] == 'i' || frase[i] == 'o' || do {
frase[i] == 'u' || frase[i] == 'A' || pos = frase.find_first_of("aeiouAEIOU", pos);
frase[i] == 'E' || frase[i] == 'I' || if ( pos != string::npos ) {
frase[i] == 'O' || frase[i] == 'U') { vogais++;
vogais = vogais + 1; pos++;
} }
i = i+1; } while( pos != string::npos );
} cout << "Há " << vogais << " vogais na frase.\n";
cout << "Há " << vogais << " vogais na frase.\n"; return 0;
return 0; }
}

Exemplo de strings: imprimir as palavras de uma frase em linhas separadas [Ad12, pág. 329]
#include <iostream>
#include <iostream>
#include <cstring> // strcpy
#include <algorithm> // replace
#include <string>
int main() {
const int N = 128;
string frase1, frase2; // Frase
char frase1[N], frase2[N];
int pos; // Posição dos espaços
short int i = 0;
// Lê a frase
cout << "Digite uma frase:\n";
cout << "Entre com uma frase:\n";
cin.getline(frase1, N);
getline(cin, frase1);
strcpy(frase2, frase1); // frase1 recebe frase2
// Copia frase1 para frase2
// Método 1
frase2 = frase1;
while( frase1[i] != '\0' ) {
// Separa palavras em linhas distintas
if( frase1[i] == ' ' ) {
do {
frase1[i] = '\n';
pos = frase1.find(" ");
}
if (pos != string::npos) { frase1.replace(pos, 1, "\n"); }
i = i+1;
} while(pos != string::npos);
}
cout << "Método 1\n" << frase1 << '\n';
// Separa palavras em linhas distintas
// Método 2
replace(frase2.begin(), frase2.end(), ' ', '\n');
replace(frase2, frase2+N, ' ', '\n');
return 0;
return 0;
}
}
Parte VII
Estruturas de dados heterogêneas

Registros: struct, class e union
Conteúdo
12 Registros: struct, class e union

Conceitos básicos
Declaração de estruturas usando struct
Acessando os campos de uma estrutura
Declaração de estruturas usando typedef
Vetores de registros
Ponteiros para estruturas

Registros: struct, class e union Conceitos básicos
Conteúdo

Conceitos básicos

Registros: struct, class e union Conceitos básicos
Registros Ü struct
O alcance das estruturas de dados homogêneas termina quando dados de diferentes tipos
precisam ser agregados em uma mesma entidade
É simples encontrar exemplos onde dados de diferentes naturezas precisam ser agregados
Dados de um veículo: marca (string), ano (int), etc.
Dados de uma pessoa: nome (string), altura (float), etc.
Quando dados de diferentes naturezas precisam ser agregados, estruturas de dados heterogêneas
tornam-se necessárias
Registros são estruturas heterogêneas compostas por campos e cada campo pode ser de um tipo
diferente
Uma estrutura ou registro é considerado um novo tipo de dados composto a partir dos tipos de
dados primitivos

Registros: struct, class e union Declaração de estruturas usando struct
Conteúdo

Conceitos básicos

Registros: struct, class e union Declaração de estruturas usando struct
Registros Ü struct
Estruturas em C/C++ são criadas utilizando a palavra-chave struct

Há duas formas de se criar uma estrutura (ou registro)
Utilizando apenas struct
Combinando struct com a palavra-chave typedef
Definição de estrutura usando apenas struct

#include <string>
// Definições feitas acima da main são visíveis nela
struct Carro {
string marca;
unsigned short ano;
};
Carro C; // Cria um novo "carro"
C.marca = "Ford";
C.ano = 2009;
// ... Restante do programa omitido
return 0;
}

Registros: struct, class e union Acessando os campos de uma estrutura
Conteúdo

Conceitos básicos

Registros: struct, class e union Acessando os campos de uma estrutura
Registros usando struct
A estrutura Carro anterior possui dois campos

marca, que é do tipo string
ano, que é do tipo unsigned short
Sendo um novo tipo de dados, uma variável da estrutura é declarada utilizando
“nome_da_estrutura nome_da_variavel;”
No exemplo anterior, “Carro C;” declara uma variável “C” que é do tipo “carro”
Os campos de uma variável do tipo estrutura são acessados utilizando o operador “.”
Em outras palavras, os campos de uma variável do tipo estrutura são acessados utilizando
nome_da_variavel.nome_do_campo
No exemplo anterior, “C.ano = 2009;” define que o ano do carro C é 2009

Registros: struct, class e union Declaração de estruturas usando typedef
Conteúdo

Conceitos básicos

Registros usando struct e typedef
Na declaração de variável anterior, o nome struct precede o nome da estrutura carro

É possível evitar a repetição do uso da palavra-chave struct através de um typedef
Definição de estrutura combinando struct e typedef

#include <string>
// Definições feitas acima da main são visíveis nela
typedef struct { // Declaramos a estrutura anônima
string marca;
unsigned short ano;
} Carro;
Carro C; // Cria um novo "Carro"
C.marca = "Ford";
C.ano = 2009;
return 0;
}

Registros usando struct e typedef
A palavra-chave typedef é usada para definir novos nomes para No exemplo com registro, a estrutura com campos
um dado tipo marca e ano descritos é denominada “Carro”
typedef não cria um novo tipo de dados, apenas um apelido Uma vez definidos, os novos tipos podem ser
para um tipo existente de dados utilizados para declarar variáveis
Forma geral do typedef Exemplos de typedef

typedef tipo_de_origem novo_nome; UINT i, j, k;
LONG m, n;
ULONG u, v;
Exemplos de typedef Carro A, B, C;
typedef unsigned int UINT;
typedef long int LONG;
typedef unsigned long int ULONG;
typedef struct {
string marca;
unsigned short ano;
} Carro; // Typedef para uma estrutura anônima

Registros: struct, class e union Vetores de registros
Conteúdo

Conceitos básicos

Registros: struct, class e union Vetores de registros
#include <iostream>
Vetores de registros Ü solução para #include <string>
#include <iomanip>
coleção de dados using namespace std;
typedef struct {
Considere um programa que gerencia string nome;
unsigned int matricula;
os nomes, matrículas, médias e float media, freq;
} Aluno;
frequências de uma turma de N int main(int argc, char *argv[]) {
const unsigned short N = 60;
alunos Aluno turma[N]; // Vetor de N alunos
for(unsigned short i = 0; i < N; i++) { // Lê os dados dos alunos
cout << "Aluno " << setw(2) << setfill('0') << i+1 << endl;
Uma estrutura poderia ser usada para cout << "Nome: ";
descrever cada aluno e um vetor de N getline(cin, turma[i].nome); // O nome pode ter espaços
cout << "Matricula: ";
posições descreveria uma turma cin >> turma[i].matricula;
cout << "Média: ";
cin >> turma[i].media;
cout << "Frequência: ";
cin >> turma[i].freq;
cin.ignore(); // Ignora nova linha do último cin
}
return 0;
}

Registros: struct, class e union Ponteiros para estruturas
Conteúdo

Conceitos básicos

Combinação de ponteiros e estruturas Ü importante ferramenta em C/C++

Estruturas permitem agregar conjuntos arbitrários de dados
Ponteiros permitem acessar estruturas e ocupam pouca memória
Acesso aos campos da estrutura Ü operador “->” em vez de “.”
Ponteiro para estrutura

#include <iostream>
typedef struct {
unsigned int mat;
float IRA;
} Aluno;
Aluno TurmaA[60], *pAluno = &(Turma[0]);
pAluno->mat = 313309;
pAluno->IRA = 0.8283;
pAluno++; // Vai para o próximo aluno
// ...
return 0;
}

Ordenação de uma turma de acordo com o IRA
#include <iostream>
// Ordenação
pInicio = &(TurmaA[0]);
typedef struct {
pFim = &(TurmaA[N-1]);
unsigned int mat;
while(pFim != pInicio) {
float IRA;
pA1 = pInicio;
} Aluno;
pB = pInicio;
while(pA1 < pFim) {
void troca(Aluno *pA, Aluno *pB) {
pA2 = pA1+1;
Aluno Aux;
if(pA1->IRA < pA2->IRA) {
Aux = *pA;
troca(pA1, pA2);
*pA = *pB;
pB = pA2;
*pB = Aux;
}
}
pA1 = pA1 + 1;
}
pFim = pB;
}
Aluno TurmaA[N];
// Impressão
Aluno *pA1, *pA2, *pB, *pInicio, *pFim;
for(n = 0; n < N; n++) {
unsigned short n;
cout << "Matricula " << n+1 << ":"
// Leitura de dados
<< TurmaA[n].mat << endl;
for(n = 0; n < N; n++) {
cout << "IRA " << n+1 << ":"
cout << "Matricula " << n+1 << ":";
<< TurmaA[n].IRA << endl;
cin >> TurmaA[n].mat;
}
cout << "IRA " << n+1 << ":";
return 0;
cin >> TurmaA[n].IRA;
}
}
// ...

Parte VIII
Ponteiros e alocação de memória

Ponteiros e alocação de memória
Conteúdo
13 Ponteiros e alocação de memória

Ponteiros
Passagem de parâmetros por referência
Passagem de parâmetros para a função main
Alocação de memória estática e dinâmica
Aritmética de ponteiros

Ponteiros e alocação de memória Ponteiros
Conteúdo

Ponteiros

Relembrando o que é uma variável
Uma variável possui um tipo, um endereço de memória, um valor, e um nome

Considere o trecho de programa abaixo
int x = 10; // Declara variável "x" do tipo int com valor 10.
cout << "Valor de x: " << x << endl;
cout << "Endereço de x: " << &x << endl;
Uma possível saída seria
Valor de x: 10
Endereço de x: 0xEF0F
x Tipo: int
10 Valor
0xEF0F Endereço de Memória

Ponteiros
Ponteiros são um tipo especial de variável que não armazenam dados diretamente como as
variáveis convencionais, mas sim o endereço de memória de uma outra variável
Por esse motivo, diz-se que um ponteiro “aponta” para uma variável
Ponteiros são uma parte essencial da programação em C/C++
Entre as maiores aplicações de ponteiros em C/C++ tem-se
Alocação dinâmica de blocos de memória
Passagem de parâmetros por referência para funções
Ações básicas relativas a ponteiros incluem
Declarar um ponteiro
Atribuir um valor a um ponteiro (apontar o ponteiro para uma variável)
Atribuir um valor à variável apontada pelo ponteiro

Declaração de ponteiros
A declaração de um ponteiro é similar à de uma variável convencional, porém o nome da variável é

precedido por um asterisco *
Sintaxe para declaração de ponteiro

TipoDeDados *NomeDoPonteiro;
Exemplos de declaração de ponteiros

// Ponteiro para um inteiro
int *pNum;
// Ponteiro para um float
float *pSalario;
// Ponteiro para um (vetor de) caractere(s)
char *pNome;
É possível declarar ponteiros de ponteiros

int **p2; é, por exemplo, um ponteiro que pode apontar para um ponteiro de inteiros
Pode ser usado para criar ponteiros de ponteiro de ponteiro de ponteiros ...

Atribuição de endereço para ponteiros
Existem dois tipos de atribuição para ponteiros

Atribuir um endereço para um ponteiro Ü apontar o mesmo para uma variável
Atribuir um valor via ponteiro Ü atribuir um valor para a variável apontada pelo ponteiro
Como um ponteiro armazena o endereço de uma outra variável, a atribuição de endereço utiliza o operador
endereço &

Atribuição de endereço para ponteiros
Existem dois tipos de atribuição para ponteiros

Atribuir um endereço para um ponteiro Ü apontar o mesmo para uma variável
Atribuir um valor via ponteiro Ü atribuir um valor para a variável apontada pelo ponteiro
Como um ponteiro armazena o endereço de uma outra variável, a atribuição de endereço utiliza o operador
endereço &
Atribuição de endereço: apontar o ponteiro para uma variável

int Andar; // Uma variável inteira
int *pNum; // Ponteiro para um inteiro
pNum = &Andar; // Armazena o endereço de Andar em pNum
pNum (F00Ah) Andar (EF0Fh)
EF0Fh

Atribuição para ponteiros

Apontar para uma variável
Atribuição de endereço de ponteiro para ponteiro

int A, B = 13; // Duas variáveis inteiras
int *p1, *p2, *p3; // Ponteiros para inteiros
p1 (F001h) A (CF0Ah)
p2 (F005h)
p3 (F009h) B (EF0Eh)
13



p1 = &A; // Armazena o endereço de A em p1
Podemos atribuir um endereço a um ponteiro com o operador &
CF0Ah
p2 (F005h)
13



p2 = p1; // Copia o endereço de A de p1 para p2

A atribuição de endereço pode ainda ser feita de um ponteiro para outro Ü não requer o operador &
É possível ter vários ponteiros apontando para uma mesma posição na memória (uma mesma variável) Ü p1 e p2 apontam para A
CF0Ah
p2 (F005h)
CF0Ah
13



p2 = p1; // Copia o endereço de A de p1 para p2
p3 = &B; // Armazena o endereço de B em p3

A atribuição de endereço pode ainda ser feita de um ponteiro para outro Ü não requer o operador &
É possível ter vários ponteiros apontando para uma mesma posição na memória (uma mesma variável) Ü p1 e p2 apontam para A
CF0Ah
p2 (F005h)
CF0Ah
EF0Eh 13


Alterar o valor da variável apontada
Ponteiros podem ser usados como “apelidos” para as variáveis para as quais apontam
Pode-se alterar indiretamente o valor da variável apontada utilizando o ponteiro
Esse segundo tipo de atribuição usado com ponteiros utiliza o operador conteúdo *
O operador conteúdo não dever ser confundido com:
O operador multiplicação * Ü requer dois fatores, e.g., a = b * c
O * usado apenas na declaração de ponteiros Ü int *p;
Atribuição de conteúdo
int A; // Variável inteira
int *p; // Ponteiro para inteiro
p = &A; // Armazena o endereço de A em p
*p = 10; // Conteúdo de p recebe 10, ou seja, A recebe 10
cout << "A = " << A; // Imprime a mensagem A = 10
p (F00Ah) A (CF0Ah) p (F00Ah) A (CF0Ah)
CF0Ah CF0Ah 10

Ponteiros e alocação de memória Passagem de parâmetros por referência
Conteúdo

Ponteiros

Passagem de parâmetros por valor

Parâmetros servem somente como entrada de dados
Copia de memória para cada parâmetro
Saída de dados unicamente através do valor de retorno
Ponteiros são usados como parâmetros
Cópia apenas dos endereços
Parâmetros servem tanto para entrada como para saída

Passagem de parâmetros por referência Exemplo: referências &
#include <iostream>
void troca(int *pA, int *pB) {
aux = *pA; // Salva conteúdo de pA em aux
*pA = *pB; // Cópia o conteúdo de pB p/ pA void troca(int *pA, int *pB)
*pB = aux; // Cópia aux p/ o conteúdo de pB
} int *pA int *pB
int A, B, C;
cout << "Digite A: ";
cin >> A;
cout << "Digite B: ";
cin >> B; int main()
cout << "Digite C: ";
int A int B
cin >> C;
if (A > B) { troca(&A, &B); }
if (B > C) { troca(&B, &C); }
cout << A << " " << B << " " << C;
return 0;
}

Generalização de funções
Soma dos elementos: v ∈ RN Média dos elementos: v ∈ RN

// Ponteiro p/ o vetor e seu tamanho N // Ponteiro p/ o vetor e seu tamanho N
float soma(float *v, float media(float *v,
unsigned short N) { unsigned short N) {
float S = 0.0; float S = 0.0;
unsigned short n; unsigned short n;
for(n = 0; n < N; n++) { S += v[n]; } for(n = 0; n < N; n++) { S += v[n]; }
return S; return S/N;
} }
Soma dos elementos c/ std::accumulate Média dos elementos c/ std::accumulate

#include <numeric> #include <numeric>
// ... Restante do código omitido // ... Restando do código omitido
float v[N] = {2, 4, 6, 8, 10}; float v[N] = {2, 4, 6, 8, 10};
// ... Restante do código omitido // ... Restante do código omitido
float S = std::accumulate(v, v+N, 0); float S = std::accumulate(v, v+N, 0)/N;
// ... Restante do código omitido // ... Restante do código omitido

Generalização de funções
Máximo: v ∈ RN Mínimo: v ∈ RN
// Ponteiro p/ o vetor e seu tamanho N // Ponteiro p/ o vetor e seu tamanho N
float maximo(float *v, float minimo(float *v,
unsigned short N) unsigned short N)
{ {
float M = 0.0; float M = 0.0;
unsigned short n; unsigned short n;
if (N > 0) { if (N > 0) {
M = v[0]; M = v[0];
for(n = 1; n < N; n++) { for(n = 1; n < N; n++) {
if ( v[n] > M ) { M = v[n]; } if ( v[n] < M ) { M = v[n]; }
} }
} else { } else {
cout << "Tamanho inválido\n"; cout << "Tamanho inválido\n";
} }
return M; return M;
} }

Ponteiros e alocação de memória Passagem de parâmetros para a função main
Conteúdo

Ponteiros

Para chamar um programa pela linha de comando Ü nome do programa, possivelmente seguido de
argumentos
Passagem de parâmetros para comandos do MS DOS

C:\Users\MACIEL>cd \
Programa/comando cd Ü change directory
Argumento/parâmetro \ Ü o diretório para onde ir (no caso o diretório raiz)
C:\Users\MACIEL>del *.txt
Programa/comando del Ü delete file
Argumento/parâmetro *.txt Ü o(s) arquivo(s) a ser(em) apagado (no caso, todos os arquivos com extensão .txt)
A função int main(int argc, char *argv[])

Recebe parâmetros passados pelo SO Ü os argumentos passados ao programa na linha de comando
Retorna um valor para o SO Ü o valor devolvido pelo return no final da main

Parâmetro argc de int main(int argc, char *argv[])

Abreviação de argument count Ü número de argumentos na linha de comando
O nome do programa/comando é contado como 1, o do primeiro argumento como 2, o do segundo
argumento como 3, . . .
Parâmetro “char *argv[]” de “int main(int argc, char *argv[])”
Abreviação de argument values Ü valores argumentos na linha de comando
Vetor de ponteiros de strings contendo os argumentos do programa como texto
argv[0] Ü nome do programa (endereço completo)
argv[1] Ü primeiro argumento do programa
argv[2] Ü segundo argumento do programa
...
argv[argc-1] Ü último argumento do programa
Valores contidos em argv Ü podem ser convertidos com atoi, atol, atof, strtol, strtoul, strtof, ou
strtod

C:\Teste.cpp C:\Fatorial.c
int main(int argc, char *argv[]) { int main(int argc, char *argv[])
int i; {
cout << "# de argumentos:" << argc << endl; int n, N, F = 1;
for(i = 0; i < argc; i++) { N = atoi(argv[1]);
cout << "Argumento " <Teste Valor1 Valor2 Valor3
# de argumentos: 4 Chamada de C:\Fatorial.exe
Argumento 0: C:\Teste.exe C:\>Fatorial 6
Argumento 1: Valor1 6! = 720
Argumento 2: Valor1
Argumento 3: Valor3

Ponteiros e alocação de memória Alocação de memória estática e dinâmica
Conteúdo

Ponteiros

Alocação estática de memória
A memória associada às variáveis de um programa pode se alocada de forma estática ou dinâmica

Na alocação estática de memória
Memória e variável são vinculadas de forma fixa, estática, imutável
A vinculação ocorre normalmente no ponto de declaração da variável
Ao compilar o programa, o compilador realiza a reserva e vinculação da memória correspondente a cada
variável
Ex: int idade;
Nome → idade
idade (EF0Ah)
Vínculo estático
Memória → EF0Fh

Alocação dinâmica de memória
Na alocação dinâmica de memória

Memória e variável são vinculadas de forma flexível (durante execução)
A região de memória associada a uma variável pode ser alterada em um ponto posterior à declaração da
variável
Em C/C++, isto é realizado através do uso de ponteiros com uma região de memória inicialmente
“anônima” sendo vinculada ao ponteiro
Como a região de memória associada a uma variável (ponteiro) pode se alterada, é preciso gerenciar com
cuidado as regiões alocadas
pNum (F00Ah) Vínculo dinâmico: “Anônima” (EF0Fh)

pNum ← EF0Fh

Principais passos para alocação dinâmica de memória
Código em C++ para parte em vermelho
int *p;
1 Declarar um ponteiro do tipo adequado

É boa prática inicializar o ponteiro com o valor NULL
2 Alocar a memória usando um operador adequado
Por exemplo, usando o operador new
O valor de retorno do operador utilizada é atribuído ao ponteiro
3 Verificar se alocação teve sucesso
Se o ponteiro for igual a NULL, a alocação falhou
4 Usar o ponteiro para acessar a memória alocada
Usando, por exemplo, o operador conteúdo *
5 Liberar a memória quando a mesma não for mais necessária
Usando o operador delete
É boa prática definir o ponteiro com o valor NULL

int *p = NULL;


p = new int;


if ( p != NULL ) { /* Deu Certo */ } else { /* Ihhh */}


*p = 10; // Atribui 10 a variável apontada


delete p;


p = NULL;


Exemplo de alocação dinâmica de memória
#include <iostream>
// Ponteiro para inteiro
int *p = NULL;
// Aloca sizeof(int) bytes de memória
// e faz p apontar para essa memória
p = new int;
// Verifica se alocação foi bem sucedida

if ( p != NULL ) {
// Conteúdo de p recebe 10 (utilizando a memória)
*p = 10;
// ... AQUI VIRIA O PROGRAMA DE FATO ...
delete p; // Libera a memória após o uso
p = NULL;
} else {
cout << "Não foi possível alocar memória\n";
}
return 0;
}

Alocando blocos de memória
Leitura de vetor com N elementos

#include <iostream>
Utilizando new e delete é possível alocar grandes blocos de
memória, e.g., vetores // O ponteiro, tamanho do vetor, e índice
unsigned int *v, N, n;
Exceto pela declaração, toda a sintaxe usada com vetores se cout << "Entre c/ N:";
aplica a ponteiros para blocos de memória cin >> N;
if (N > 0) {
Assim, pode-se escrever algoritmos gerais para vetores de // Aloca N*sizeof(unsigned int) bytes de memória
v = new unsigned int[N];
entrada com tamanho arbitrário if ( v != NULL ) {
// Lê dados usando p como vetor
Se você aloca memória com um new e sobrescreve o ponteiro for(n = 0; n < N; n++) {
cout << "Entre v[" << n << "]:";
com outro valor você não terá como usar delete na variável cin >> v[n];
anterior (se não tiver outro ponteiro apontando para ela) }
// ... AQUI VIRIA O PROGRAMA DE FATO ...
“Vazamento de memória” (memory leak) delete [] v; // Libera a memória após o uso
v = NULL;
C++ moderno evita usar new e delete, mas nós vamos usar } else {
por enquanto cout << "Não foi possível alocar memória\n";
}
}
return 0;
}

Ponteiros e alocação de memória Aritmética de ponteiros
Conteúdo

Ponteiros

Ponteiros contém endereços de memória

Operações aritméticas Ü deslocamentos de endereço de memória
O tamanho do deslocamento é igual ao tamanho do tipo apontado
O resultado das operações é um também um ponteiro
pNota = pNota + 1 Aritmética de ponteiro
#include <iostream>

pNota = &(Notas[0]) float Notas[60], *pNota = &(Notas[0]);
unsigned short n;
while(pNota <= &(Notas[59])) {
cout << "Entre nota " << n+1 << ":";
pB pB++ cin >> pNota;
pA + 2
// Desloca uma posição no vetor
pNota++;
n++;
}
return 0;
}
pB - 2
pA

Invertendo a ordem dos elementos de um vetor
#ifndef FUNCOES_HPP_INCLUDED #include <iostream>

#define FUNCOES_HPP_INCLUDED #include <algorithm>
// Habilita função swap e o namespace std #include "funcoes.hpp"
#include <utility> using namespace std;
using namespace std; int main() {
void reverse(float *v, const unsigned short n); float v[N] = {-3, -2, -1, 0, 1, 2, 3};
// Inverte usando a função reverse
#endif // FUNCOES_HPP_INCLUDED reverse(v, N);
// Imprime o vetor modificado
for(auto x : v) { cout << x << " "; }
#include "funcoes.hpp" cout << '\n';
void reverse(float *v, const unsigned short n) { // Inverte usando o algoritmo reverse
float *pBeg = &v[0], *pEnd = &v[n-1]; reverse(v, v+N); // De <algorithm>
while(pBeg < pEnd) { // pBeg à esquerda de pEnd // Imprime o vetor modificado
swap(*pBeg, *pEnd); // Troque os elementos for(auto x : v) { cout << x << " "; }
pBeg++; // Mova o ponteiro pBeg p/ a direita cout << '\n';
pEnd--; // Mova o ponteiro pEnd p/ a esquerda return 0;
} }
}

Parte IX
Manipulação de arquivos

Arquivos
Conteúdo
14 Arquivos
Armazenamento não-persistente × persistente
Modos e ações básicas para manipulação de arquivos
Abertura e fechamento de arquivos
Leitura/escrita em modo texto: operadores de inserção e extração
Outras funções para arquivos
Leitura/escrita em modo binário: write e read

Arquivos Armazenamento não-persistente × persistente
Conteúdo
14 Arquivos

Arquivos Armazenamento não-persistente × persistente
Armazenamento não-persistente
Dados não-persistentes são esquecidos tão logo não sejam mais necessários
Computador Ü quando é desligado
Programa na RAM Ü quando é finalizado
Usado para dados voláteis, intermediários, de interesse momentâneo
Normalmente realizado na RAM do computador
Armazenamento persistente
Dados persistentes são armazenados de modo a serem recuperados num momento futuro
Armazenamento feito pelo SO em um sistema de arquivos com unidades, pastas e arquivos para organização
hierárquica dos dados
Usado para dados de maior interesse que podem ser recuperados do local onde foram armazenados e utilizados
novamente
Memórias de armazenamento persistente Ü discos rígidos, DVDs, pendrives, etc.

Arquivos Modos e ações básicas para manipulação de arquivos
Conteúdo
14 Arquivos

Modos paras arquivos em C/C++
Em C/C++, arquivos podem ser manipulados em modo texto ou em modo binário

Em modo texto
Os dados armazenados em um arquivo são formatados como texto puro (caracteres)
O conteúdo de arquivos de texto pode ser lido diretamente usando um editor
O arquivo ocupa um byte para cada caractere que contém podendo assim ter tamanho diferente na
memória e no disco
Em modo binário
Os dados armazenados em um arquivo são armazenados na forma em que são representados pelo
computador
Portanto, o conteúdo de arquivos binários normalmente não podem ser lido diretamente
O arquivo ocupa o mesmo número de bytes na memória e no disco
Ex: O número 300’000’000 possui 9 caracteres (9 bytes) mas que pode ser armazenado em um int
(4 bytes)

Ações básicas para manipulação de arquivos
Há quatro ações principais para manipulação de arquivos (existem outras)

Abrir o arquivo para ser usado (ou cria um novo se o mesmo não existir)
Fechar o arquivo após o seu uso
Escrever dados no arquivo (que precisa existir e estar aberto)
Ler dados armazenados no arquivo (que precisa existir e estar aberto)
Outras ações referentes a arquivos são:
Mudar o ponto no arquivo onde (a próxima) leitura/escrita será realizada (ir para o início/fim, ou para um
ponto qualquer do arquivo)
Determinar se o fim do arquivo foi atingido

Arquivos Abertura e fechamento de arquivos
Conteúdo
14 Arquivos

Arquivos são representados por variáveis do tipo ofstream (escrita) ou ifstream (leitura) Ü requer
#include <fstream>
Também é possível utilizar o tipo fstream
Arquivos são abertos e fechados usando os métodos open e close
É uma boa prática usar o método is_open() para determinar se o arquivo foi aberto com sucesso
Exemplo de abertura e fechamento de arquivo

#include <iostream>
#include <fstream>
ofstream myfile; // Stream para escrita
myfile.open ("arquivo.txt"); // Abre o arquivo (modo texto)
if (myfile.is_open()) {
myfile << "Esse texto será escrito no arquivo.\n";
myfile.close();
}
return 0;
}

Abertura de arquivos
O método open recebe dois parâmetros de entrada

filename: é o nome do arquivo a ser aberto ou criado
mode: é o modo de abertura do arquivo que combina os códigos abaixo
A função close fecha o arquivo
Tabela: Flags para abertura de arquivo
Cód. Funcionalidade
ios::in Abre o arquivo para leitura (padrão para ifstream)
ios::out Abre o arquivo para escrita (padrão para ofstream)
ios::binary Abrir em modo binário
ios::ate Seta a posição inicial para o final do arquivo (quando não fornecido a posição inicial é
o começo do arquivo)
ios::app Abrir para anexação no final do arquivo (append)
ios::trunc Se o arquivo for aberto para escrita e ele já existe, o conteúdo anterior é substituído
pelo novo (default)

O método open recebe dois parâmetros de entrada

filename: é o nome do arquivo a ser aberto ou criado
mode: é o modo de abertura do arquivo que combina os códigos abaixo
A função close fecha o arquivo
Tabela: Flags para abertura de arquivo
Cód. Funcionalidade
ios::in Abre o arquivo para leitura (padrão para ifstream)
ios::out Abre o arquivo para escrita (padrão para ofstream)
ios::binary Abrir em modo binário
ios::ate Seta a posição inicial para o final do arquivo (quando não fornecido a posição inicial é
o começo do arquivo)
ios::app Abrir para anexação no final do arquivo (append)
ios::trunc Se o arquivo for aberto para escrita e ele já existe, o conteúdo anterior é substituído
pelo novo (default)

Combinando as flags para abertura de arquivo
As flags para abertura de arquivo podem ser combinadas utilizando o operador “|” (Ou Bit-a-Bit).
Ex: myfile.open("arquivo.txt", ios::out | ios::app)
Nem todas as combinações fazem sentido
Combinações úteis das diferentes flags (Modo texto)

binary in out trunc app
+ Abrir para escrita, se não existir cria e se existir esvazia
+ + Abrir para escrita, se não existir cria e se existir esvazia
+ + Abrir para anexação no final do arquivo, precisa existir
+ Abrir para leitura (read), o arquivo precisa existir
+ + Abrir para leitura e escrita, precisa existir
+ + + Abre para leitura e escrita (anexação)

Combinando as flags para abertura de arquivo
As flags para abertura de arquivo podem ser combinadas utilizando o operador “|” (Ou Bit-a-Bit).
Ex: myfile.open("arquivo.txt", ios::out | ios::app)
Nem todas as combinações fazem sentido
Combinações úteis das diferentes flags (Modo binário)

binary in out trunc app
+ + Abrir para escrita, se não existir cria e se existir esvazia
+ + + Abrir para escrita, se não existir cria e se existir esvazia
+ + + Abrir para anexação no final do arquivo, precisa existir
+ + Abrir para leitura (read), o arquivo precisa existir
+ + + Abrir para leitura e escrita, precisa existir
+ + + + Abre para leitura e escrita (anexação)

Arquivos Leitura/escrita em modo texto: operadores de inserção e extração
Conteúdo
14 Arquivos

Escrita em arquivo (texto) usando o operador <<
Para escrever em um arquivo aberto no modo texto usamos o operador de inserção << exatamente
da mesma forma que imprimimos algo na tela
Exemplo de escrita em arquivo texto usando o operador de inserção de stream <<

#include <iostream>
#include <fstream>
#include <string>
ofstream myfile;
myfile.open("alunos.txt", ios::app);
string nome;
unsigned int matricula;
cout << "Qual o nome do aluno?" << endl;
getline(cin, nome); // Usa getline já que o nome pode conter espaços
cout << "Qual a matrícula?" << endl;
cin >> matricula;
cin.ignore();
myfile << "Aluno(a): " << nome << " - Matrícula: " << matricula << endl;
}
return 0;
}

Leitura de arquivo (texto) usando o operador >>
Em modo texto, a leitura de arquivos pode ser feita o operador de extração >> exatamente da
mesma forma que recebemos um valor do teclado
Código para ler o arquivo de texto
Conteúdo de alunos.txt
#include <iostream>
#include <fstream> 433428
#include <string> Sr. Davi Lucas Castro
using namespace std; 683428
int main(int argc, char *argv[]) { Ana Julia Cunha
ifstream myfile; 126507
myfile.open("alunos.txt"); Bárbara Rocha
string nome; 437844
unsigned int matricula; Ana Carolina Santos
if (myfile.is_open()) { 954891
while(!myfile.eof()) { // Repete até o fim do arquivo Luana Barbosa
myfile >> matricula;
myfile.ignore(10000, '\n'); // Ignora até o \n
getline(myfile, nome);
cout << "Matrícula: " << matricula
Saída do programa
<< " - Aluno: " << nome << endl; Matrícula: 433428 - Aluno: Sr. Davi Lucas Castro
} Matrícula: 683428 - Aluno: Ana Julia Cunha
} Matrícula: 126507 - Aluno: Bárbara Rocha
myfile.close(); Matrícula: 437844 - Aluno: Ana Carolina Santos
return 0; Matrícula: 954891 - Aluno: Luana Barbosa
}

Ex: Copia um arquivo de texto para outro
#include <iostream>
#include <fstream>
#include <string>
ifstream myfile_in;
ofstream myfile_out;
myfile_in.open("arquivo.txt"); // Arquivo para leitura
myfile_out.open("arquivo2.txt"); // Arquivo para saída
string linha;
if (myfile_in.is_open() && myfile_out.is_open()) {
while (!myfile_in.eof()) {
getline(myfile_in, linha); // Lemos uma linha por vez com o getline
myfile_out << linha << "\n"; // Acrescentamos o \n que o getline ignorou
}
}
myfile_in.close();
myfile_out.close();
return 0;
}

Ex: Copia um arquivo de texto para outro (versão do Cebolinha)
#include <iostream>
#include <fstream>
ifstream myfile_in;
ofstream myfile_out;
myfile_in.open("arquivo.txt", ios::binary); // Arquivo para leitura
myfile_out.open("arquivo2.txt", ios::binary); // Arquivo para saída
char c;
if (myfile_in.is_open() && myfile_out.is_open()) {
while (!myfile_in.eof()) {
myfile_in.get(c); // Lemos um caractere de cada vez
if (c == 'r') { myfile_out.put('l'); } // Substitui 'r' por 'l'
else if(c == 'R') { myfile_out.put('L'); } // Substitui 'R' por 'L'
else { myfile_out.put(c); } // Não muda demais caracteres
}
}
myfile_in.close();
myfile_out.close();
return 0;
}

Arquivos Outras funções para arquivos
Conteúdo
14 Arquivos

Alguns outros métodos úteis
Método Ação
myfile.is_open() Retorna verdadeiro se o arquivo estiver aberto
myfile.eof() Retorna verdadeiro se atingiu o fim do arquivo
myfile.seekg(n) Muda a posição no arquivo para o n-ésimo byte
myfile.seekg(n, ios::cur) Muda a posição para n bytes para frente
myfile.seekg(-n, ios::end) Muda a posição para n bytes de traz para frente
myfile.seekp(n) Muda a posição no arquivo para o n-ésimo byte
myfile.seekp(n, ios::cur) Muda a posição para n bytes para frente
myfile.seekp(-n, ios::end) Muda a posição para n bytes de traz para frente
myfile.tellg(...) Pega a posição atual no arquivo
myfile.tellp(...) Pega a posição atual no arquivo

Alguns outros métodos úteis
Verificando o tamanho de um arquivo

#include <iostream>
#include <fstream>
ifstream myfile;
myfile.open("arquivo.txt", ios::binary); // Arquivo para leitura
myfile.seekg(0, ios::end);
int length = myfile.tellg();
cout << "O comprimento do arquivo é de " << length << " bytes" << endl;
}
else {
cout << "O arquivo não pôde ser aberto" << endl;
}
myfile.close();
return 0;
}

Arquivos Leitura/escrita em modo binário: write e read
Conteúdo
14 Arquivos

Escrita em modo binário: write
Necessário abrir o arquivo com flag ios::binary
Escrita em um arquivo binário: função myfile.write

myfile.write grava o conteúdo de um vetor de dados no arquivo e tem cabeçalho
myfile.write(const char* buffer, int num_caracteres)
*buffer é um ponteiro (endereço) para a primeira posição do vetor a ser armazenada no disco
num_caracteres é o número de bytes que devem ser escritos no arquivo
Como escrever qualquer tipo de variável

Escrever um vetor de inteiros para um arquivo binário: faz um cast do endereço para char* e diz para escrever o número
de bytes ocupados pelo vetor
int x[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 4 bytes * 10 -> 40 bytes
myfile.write((char*)(&x), sizeof(x));
O operador sizeof retorna quantos bytes uma variável ou um tipo de dados ocupa

Leitura em modo binário: read
Necessário abrir o arquivo com flag ios::binary
Leitura de um arquivo binário

A leitura de um arquivo é feita utilizando o método myfile.read
Esta função lê o número solicitado de bytes do arquivo e guarda em um vetor de caracteres
Ela tem cabeçalho myfile.read(char* s, int num_caracteres)
Como ler qualquer tipo de variável

Declare uma variável ou um ponteiro para o tipo apropriado, como por exemplo int x2[10];
Faça um cast do endereço dessa variável para char* e indique quantos bytes devem ser lidos

Ex: Lendo as informações da tag ID3v1 em uma música mp3
O padrão ID3v1 surgiu em 1996 para permitir gravar algumas informações sobre uma música no
próprio arquivo de música
A tag ID3v1 ocupa os últimos 128 bytes do arquivo de música
Primeiros campos da tag ID3v1

Campo Tamanho (bytes) Descrição
Cabeçalho 3 “TAG”
Título 30 Título da música (máximo de 30 caracteres)
Artista 30 Nome do artista (máximo de 30 caracteres)
Álbum 30 Nome do álbum (máximo de 30 caracteres)
Ano 4 Ano da música (4 caracteres)

Ex: Lendo as informações de uma música
Código
#include <iostream>
#include <fstream>
string le_o_campo(ifstream& arquivo, int tamanho) {
char *buffer = new char[tamanho];
arquivo.read(buffer, tamanho);
string out(buffer); // Cria uma string com o conteúdo do buffer
delete [] buffer; // Deleta o buffer e evitar vazamento de memória
return out; Saída
}
int main(int argc, char *argv[]) { TAG: TAG
const int TAG=3, TITLE=30,ARTIST=30,ALBUM=30,YEAR=4; Título: Bizarre Love Triangle
ifstream myfile;
myfile.open("06 - Bizarre Love Triangle.mp3", ios::binary); Artista: New Order
char buffer[31]; //Buffer para ler o cabeçalho do arquivo Álbum: (The Best of) New Order
if (myfile.is_open()) { Ano: 1995
myfile.seekg(-128, ios::end);
cout << "TAG: " << le_o_campo(myfile, TAG) << endl;
cout << "Título: " << le_o_campo(myfile, TITLE) << endl;
cout << "Artista: " << le_o_campo(myfile, ARTIST) << endl;
cout << "Álbum: " << le_o_campo(myfile, ALBUM) << endl;
cout << "Ano: " << le_o_campo(myfile, YEAR) << endl;
}
myfile.close();
return 0;
}

Parte X
Histórico do computador

Breve histórico da computação
Conteúdo
15 Breve histórico da computação

Primeiros métodos de cálculo
Computadores (eletro)mecânicos
Computadores eletrônicos a válvula
Computadores eletrônicos transistorizados
Microcomputadores
16 Bibliografia

Breve histórico da computação Primeiros métodos de cálculo
Conteúdo

Microcomputadores
16 Bibliografia

Para que computadores?[dSGSC08]
Contar e calcular são atividades que remontam aos primórdios da humanidade

Provavelmente, os dedos foram os primeiros instrumentos utilizados para esses fins
O computador surgiu paralelamente à necessidade humana crescente de realizar cálculos
O verbo computar vem do latim computare, e significa contar, calcular
Os ancestrais dos computadores datam de mais de 5000 anos

Ábaco
Instrumento composto por contas móveis postas em

bastões paralelos distribuídos em uma moldura
Surgiu na Babilônia por volta de 3.000 a.C.
Inicialmente destinado para as operações de soma e
subtração
Exemplo:

Ábaco

subtração
Exemplo: 236

Ábaco

subtração
Exemplo: 236 + 61

Ábaco

subtração
Exemplo: 236 + 61 = 297
Há vários modelos de ábaco: japonês, chinês, romano,
etc.
Atualmente há métodos para realizar outras operações
com o ábaco

Ábaco

subtração
Exemplo: 236 + 61 = 297
Há vários modelos de ábaco: japonês, chinês, romano,
etc.
Atualmente há métodos para realizar outras operações
com o ábaco

Ossos de Napier
Método atual de multiplicação vem do método tabular

árabe
Exemplo: 217 × 14 = 3038

Ossos de Napier

árabe
Exemplo: 217 × 14 = 3038
Dígitos são multiplicados na tabela

Ossos de Napier

árabe
Exemplo: 217 × 14 = 3038
O produto é a soma dos dígitos na diagonal

Ossos de Napier

árabe
Exemplo: 217 × 14 = 3038
Entre 1612-1614, John Napier (inventor dos logaritmos)
generalizou o procedimento em um dispositivo composto
por um bastão de ossos
Exemplo: 137 × 4 = 548

Ossos de Napier

árabe
Exemplo: 217 × 14 = 3038
Entre 1612-1614, John Napier (inventor dos logaritmos)
generalizou o procedimento em um dispositivo composto
por um bastão de ossos
Exemplo: 137 × 4 = 548

Breve histórico da computação Computadores (eletro)mecânicos
Conteúdo

Microcomputadores
16 Bibliografia

Primeiras calculadoras
Pascaline
1623 – Wilhelm Schickard (alemão) criou um “relógio

calculador” baseado em engrenagens e capaz de realizar
as quatro operações
1642-1643 – Blaise Pascal (francês) criou a Pascaline, a
Staffelwalze
primeira máquina de somar e subtrair
1674 – Gottfried Leibniz (alemão) construiu uma
calculadora (Staffelwalze) de engrenagem cilíndrica capaz
de realizar as quatro operações
Até o século XVIII, outras calculadoras mecânicas foram
projetadas e construídas

O primeiro computador
1822-1835 – Charles Babbage (inglês) projeta a máquina diferencial, a qual aperfeiçoou posteriormente para a máquina analítica, a
ancestral dos computadores modernos
A máquina diferencial era composta por discos giratórios operados por manivela
A máquina analítica poderia ser programada utilizando cartões perfurados (utilizados em 1801 por Joseph-Marie Jacquard para tecer
padrões em seu tear), uma ideia desenvolvida por Ada Augusta Byron entre 1842-1843
Máquina diferencial
Máquina analítica

Tabuladora de Hollerith
1889 – Hermann Hollerith inspirou-se nos cartões perfurados de Jacquard para construir sua máquina tabuladora, a qual foi utilizada
para processar os dados do censo dos EUA de 1880 em 6 meses (em vez dos 10 anos previstos)
1896 – Hollerith funda a Tabulating Machine Company, a futura International Business Machines (IBM) de 1924

Z1, Z2 e Z3
1936-1941 – Konrad Zuse (alemão), que não conhecia o trabalho de Babbage, construiu o computador eletromecânico Z1 programado
utilizando cartões perfurados
O Z1 foi inicialmente utilizado para cálculos de aerostática
O Z2 foi construído utilizando relés telefônicos e foi utilizado em projetos aerodinâmicos
O Z3 foi construído empregando álgebra booleana (desenvolvida em 1854 por George Boole), o primeiro computador eletromecânico
digital, funcional e programável
Z1 Z3

Mark I
1937-1944 – Howard Aiken constrói em Harvard o computador Mark I, também chamado IBM Automatic Sequence Controlled Calculator
(ASCC), o qual foi inspirado na máquina analítica de Babbage
Media aproximadamente 16 × 2,5 m2 e pesava cerca de 5 toneladas

Breve histórico da computação Computadores eletrônicos a válvula
Conteúdo

Microcomputadores
16 Bibliografia

Primeiro computador eletrônico: Colossus
1943 – O computador Colossus baseado em válvulas (criadas por John A. Fleming em 1904) é
construído por Alan Turing, Tommy Flowers e Maximilian Hermann Alexander Newman em
Bletchey Park, Inglaterra, sendo considerado o primeiro computador eletrônico
Utilizado durante a 2a Guerra Mundial no auxílio à quebra de mensagens criptografadas pela
Enigma alemã

Electrical Numerical Integrator Analyzer and Calculator (ENIAC)
1943-1946 – Projetado por J. Presper Eckert e John

Mauchly na Universidade da Pensilvânia
Financiado pelo governo dos EUA durante a 2a
Guerra Mundial
Ocupava 150 m2 , pesava cerca de 30 toneladas,
possuía milhares de válvulas, resistências e
capacitores, e era programado usando cerca de
6000 comutadores manuais (fios e pinos)
Limitado em capacidade de armazenamento e de
difícil programação

Manchester Automatic Digital Machine: Manchester Mark I
1948 – Primeiro computador com programa armazenado eletronicamente, um conceito introduzido por John von Neumann
Levou a mais de 30 patentes com ideias aplicadas a futuros computadores
Usava programas armazenados em uma memória de tambor magnético (inventado por Gustav Tauschek em 1932)

Electronic Discrete Variable Automatic Computer (EDVAC)
1945-1952 – Projetado por John Mauchly and J.

Presper Eckert, foi um dos primeiros computadores
a seguir as ideias de John von Neumann
Programas e dados armazenados conjuntamente
Baseado em lógica binária
Arquitetura: memória, Unidade Lógica e
Aritmética (ULA), Unidade Central de
Processamento (UCP), unidades de entrada e
saída de dados
Baseado em válvulas, mas já usava programas
armazenados em fita magnética

Universal Automatic Computer I (UNIVAC I)

1951 – Primeiro computador baseado nas ideias de John von Neumann a ser produzido em escala comercial
Projetado por J. Presper Eckert e John Mauchly
Deu início à Eckert-Mauchly Computer Corporation
Seguido por vários outros computadores similares, e.g., Illiac (Illinois) e Ordvac (US Army)

Série de computadores da IBM
1952 – IBM 701 (Defense Calculator): primeiro computador de grande porte da IBM e que foi usado pela marinha americana
1953 – IBM 650, (Magnetic Drum Calculator): primeiro computador produzido em massa, possuía um tambor de memória
1953 – IBM 704: primeiro computador com hardware para aritmética de ponto flutuante e para o qual a linguagem FORTRAN (FORmula
TRANslator) foi desenvolvida por John Backus em 1957
1958 – IBM 709: o último computador a válvula da IBM
Magnetic Drum
IBM 701 IBM 650

Breve histórico da computação Computadores eletrônicos transistorizados
Conteúdo

Microcomputadores
16 Bibliografia

Primeiros computadores transistorizados
1947 – Transistor é desenvolvido por John Bardeen, Walter

Brattain, e William Schockley na Bell Labs
1951 – O transistor de junção é desenvolvido por Willian Schockley
1953 – O computador transistorizado (protótipo) da Universidade
de Manchester entra em funcionamento
1954 – Transistor de silício é desenvolvido pela Texas Instruments
1956 – Um UNIVAC utilizando transistores é projetado e
introduzido para uso comercial
1958 – É lançado o IBM 7090, a versão transistorizada do IBM 709,
custando US$ milhões

Primeiros computadores transistorizados
1958 – Primeiros protótipos dos Circuitos Integrados (CIs) são produzidos na Texas Instruments,
por Jack Kilby, e na Fairchild Semiconductor, por Robert Noyce
1960 – A Digital Equipment Corp. (DEC), fundada em 1958, introduz o PDP-1, o primeiro
computador comercial com monitor e teclado (periféricos)
1961 – IBM 7030, cerca de 30 vezes mais rápido que o 704, é lançado e torna-se o precussor da
supercomputação
1964 – Control Data Corp. introduz o CDC6600, de 9 Megaflops e projetado por Seymour Cray, e
requer o título de construção do primeiro supercomputador de sucesso

Breve histórico da computação Microcomputadores
Conteúdo

Microcomputadores
16 Bibliografia

Microprocessadores e precursores do computador pessoal
1971 – O time de Ted Hoff, S. Mazor e F. Fagin desenvolvem o

microprocessador Intel 4004 - o computador dentro de um chip
1972 – A Intel apresenta o 8008, o primeiro microprocessador de 8 bits, substituído rapidamente

pelo 8080
1972 – A DEC apresenta o PDP11/45, cujos circuitos são encapsulados em CIs
1972-1973 – Xerox PARC desenvolve um computador pessoal experimental com mouse, rede, e
interface gráfica
1972-1973 – Alan Kay desenvolve um precursor do computador pessoal que utilizava mouse, icons,
e gráficos
1973 – Large Scale Integration (LSI) permite integrar mais de 10.000 componentes por cm2

Computadores pessoais
Altair 8800
1975 – Surge o primeiro computador pessoal, o Altair 8800, equipado com o Intel 8080 Apple I
e programado utilizando a linguagem BASIC (Beginners All-purpose Symbolic
Instruction Code), criada por John Kemeny e Thomas Kurtz em 1964
1976 – Steve Jobs e Steve Wozniak projetam e constroem o Apple I, que era
basicamente uma placa de circuito
Apple II
1977 – Steve Jobs e Steve Wozniak fundam a Apple Computer e o Apple II é anunciado
na primavera do mesmo ano
1981 – O IBM PC de arquitetura aberta é lançado sinalizando o início da “computação
de mesa”

Bibliografia
Conteúdo
16 Bibliografia

Bibliografia
Bibliografia (1)
[Ad07] A. F. G. Ascencio and E. A. V. de Campos, Fundamentos da programação de computadores: algoritmos, Pascal,

C/C++ e Java, 2nd ed. Prentice Hall, 2007.
[Ad12] ——, Fundamentos da programação de computadores: algoritmos, Pascal, C/C++ e Java, 3rd ed. Prentice Hall,
2012.
[AdMGadCL94] Ângelo de Moura Guimarães and N. A. de Castilho Lages, Algoritmos e estruturas de dados, 31st ed. Livros
Técnicos e Científicos, 1994.
[Bre08] B. B. Brey, The Intel microprocessors, 8th ed. Prentice Hall, Jun. 2008.
[DD10] P. Deitel and H. Deitel, C how to program, 6th ed. Prentice Hall, 2010.
[DD12] ——, C++ how to program, 8th ed. Prentice Hall, 2012.
[dSGSC08] M. A. F. de Souza, M. M. Gomes, M. V. Soares, and R. Concilio, Algoritmos e lógica de programação, 1st ed.
Cengage Learning, 2008.
[Eck00] B. Eckel, Thinking in C++: introduction to standard C++, 2nd ed. Prentice Hall, 2000, vol. 1.
[Eck03] ——, Thinking in C++: practical programming, 2nd ed. Prentice Hall, 2003, vol. 2.
[KR88] B. W. Kernighan and D. M. Ritchie, The C programming language, 2nd ed. Prentice Hall, Apr. 1988.
[Sch96] H. Schildt, C completo e total, 3rd ed. Makron Books, 1996.

Bibliografia
Bibliografia (2)
[Str13] B. Stroustrup, The C++ programming language, 4th ed. Addison-Wesley Professional, May 2013.
[TW06] A. S. Tanenbaum and A. S. Woodhull, Operating systems: design and implementation, 3rd ed. Prentice Hall, Jan.
2006.

ProgramacaoComputacional PDF

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

ProgramacaoComputacional PDF

Diunggah oleh

Hak Cipta:

Format Tersedia

Introdução à Programação

Prof. Tarcisio Ferreira Maciel, Dr.-Eng.

Universidade Federal do Ceará

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 1 / 348

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 2 / 348

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 3 / 348

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 4 / 348

Para que computadores?[dSGSC08]

Computador Ü dispositivo que faz cálculos e operações lógicas rapidamente

Seguem hoje arquiteturas de hardware e software consagradas pelo uso

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 6 / 348

Exemplo de computador comercial

Computador com processador i7 de 3,3 GHz

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 7 / 348

Exemplo de computador comercial

Computador com processador i7 de 3,3 GHz

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 7 / 348

Dispositivos Unidade de Unidade Lógica Dispositivos

Unidade Central de Processamento

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 8 / 348

Unidade Central de Processamento (UCP)

Unidade de Controle (UC)

Periféricos Ü vias de comunicação da UCP com o mundo exterior

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 10 / 348

Random Access Memory (RAM) – Memória de Acesso Aleatório

Read-Only Memory (ROM) – Memória Somente para Leitura

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 11 / 348

Caracterizada por dispositivos/unidades de entrada e saída para armazenamento e recuperação

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 12 / 348

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 13 / 348

Exemplo de computador comercial

Computador com processador i7 de 3,3 GHz

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 14 / 348

Note que os conceitos de software e programa de certo modo se confundem

O software do computador é normalmente organizado em camadas [TW06]

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 15 / 348

Basic Input/Output System (BIOS)

Software aplicativo Microarquitetura

Normalmente condicionado pelo SO Dispositivos físicos

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 16 / 348

O BIOS pode ser acessado pressionando-se certas teclas

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 17 / 348

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 18 / 348

Organização de dados em SOs

Os SOs (como Windows e Linux) realizam normalmente a

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 19 / 348

Organização da informação em SOs

Os arquivos são acessados através de um endereço hierárquico especificando unidade → pasta →

No Windows, o arquivo Monografia.doc contido na pasta Documentos da unidade C: possui o

As extensões de 3 caracteres são usadas para identificar o tipo de arquivo

.txt: arquivo texto .wav: arquivo de áudio

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 20 / 348

Organização da informação em SOs

Os arquivos normalmente contém dados organizados segundo algum tipo de estrutura

Nos arquivos de bancos de dados, as informações são organizadas em registros

Os registros são compostos por campos: Nome, Idade, Telefone, etc.

O conteúdo de cada campo é composto por caracteres

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 21 / 348

Organização da informação em SOs

Cada caractere corresponde a um número entre:

A parte estendida da tabela ASCII pode variar (e.g., com o idioma)

Tarcisio F. Maciel (UFC) Introdução à Programação 5 de junho de 2017 22 / 348

Tabela ASCII padrão