TÉCNICAS DE PROGRAMAÇÃO – FAESA

Lista: Unidade 2
Professor: Daniel Luis Cosmo

ENGENHARIA DA COMPUTAÇÃO
CÓDIGO: D009053
Aluno: Roberli Schuina Silva
RA: 23110406
Período: 2023/2
Turma: CI-1030-231-A

1. Cite e descreva duas variáveis definidas na biblioteca iostream que são utilizadas para
entrada e saída de dados do programa.

Na biblioteca <iostream>, duas variáveis fundamentais são comumente utilizadas para entrada
e saída de dados em um programa C++: cin e cout.

a) ‘cin’: É a variável usada para entrada padrão, normalmente associada à leitura de dados
do teclado. Ela é usada em conjunto com o operador ‘>>’ para receber dados digitados
pelo usuário.

Exemplo de uso:
int idade;
std::cout << "Digite sua idade: ";
std::cin >> idade;

b) ‘cout’: É a variável usada para saída padrão, normalmente associada à exibição de dados
no console. Ela é usada em conjunto com o operador << para imprimir informações na
tela.

Exemplo de uso: std::cout << "Olá, mundo!" << std::endl;

Essas variáveis são essenciais para interagir com o usuário e exibir informações relevantes no
programa.

2. Por padrão, as variáveis definidas na biblioteca iostream vinculam suas entradas e

saídas a que Software do sistema operacional?

Por padrão, as variáveis definidas na biblioteca <iostream> do C++ estão vinculadas às

entradas e saídas do console ou terminal do sistema operacional. Isso significa que cin está
associada à entrada padrão, geralmente representada pelo teclado, e cout está associada à
saída padrão, que normalmente é a tela do console.

Portanto, ao utilizar cin para entrada de dados, o programa espera que o usuário forneça
esses dados através do teclado. Da mesma forma, ao usar cout para a saída de dados, o
programa exibirá as informações na tela do console.

Essa configuração padrão permite a interação básica com o usuário por meio do terminal,
sendo um meio comum para entrada e saída de dados em muitos programas.

PÚBLICA
 3. Qual comando deve ser usado para incluir o uso de uma biblioteca no programa que
está sendo desenvolvido?

Para incluir o uso de uma biblioteca em um programa C++, deve-se usar a diretiva #include.
A #include é usada para incorporar o conteúdo de um arquivo de cabeçalho (header file) na
sua fonte, o que torna as definições e funcionalidades da biblioteca disponíveis para o seu
programa. Aqui está a sintaxe básica da diretiva #include: #include <nome_da_biblioteca>

Onde nome_da_biblioteca é o nome da biblioteca que você deseja incluir. Se a biblioteca

estiver localizada no diretório padrão de bibliotecas do sistema, deve-se utilizar < >. Se
estiver em um diretório específico ou no mesmo diretório do seu código-fonte, utiliza-se
aspas duplas "". Por exemplo, para incluir a biblioteca <iostream>: #include <iostream>

E para incluir uma biblioteca de um arquivo no mesmo diretório ou em um diretório

específico: #include "minha_biblioteca.h"

4. Os operadores » e « operando sobre quais tipos de dados na esquerda e na direita?

Os operadores >> e << são chamados de operadores de extração e inserção,

respectivamente, e são usados em C++ para operações de entrada e saída de dados.

a) Operador de Extração (>>):

▪ Na esquerda: É usado com um objeto do tipo istream (como std::cin);
▪ Na direita: Geralmente é usado com uma variável ou objeto no qual os dados
serão lidos. O tipo da variável ou objeto deve ser compatível com o tipo de
dados sendo lido. Exemplo: int idade; std::cin >> idade; // Lê um valor do
teclado e o armazena na variável 'idade'.

b) Operador de Inserção (<<):

▪ Na esquerda: É usado com um objeto do tipo ostream (como std::cout);
▪ Na direita: Geralmente é usado com valores, variáveis ou expressões que você
deseja exibir. Exemplo: std::cout << "Idade: " << idade; // Exibe a mensagem
e o valor da variável 'idade'.

Esses operadores são vitais para a entrada e saída de dados em C++. O operador >> lê dados
de uma fonte (como o teclado) e os armazena em uma variável, enquanto o operador << exibe
dados na saída padrão (como a tela).

5. Qual a função do manipulador endl, definido na biblioteca iostream?

O manipulador std::endl é usado para inserir uma quebra de linha e "limpar" o buffer de
saída. Ele é definido na biblioteca <iostream> em C++ e tem a seguinte função:

a) Quebra de Linha: std::endl é usado para adicionar uma nova linha (ou quebra de linha)
à saída. Exemplo de uso: std::cout << "Olá, mundo!" << std::endl; Isso resultará na
impressão de "Olá, mundo!" seguido de uma nova linha;

b) Limpar o Buffer de Saída: Além de adicionar uma nova linha, std::endl também força
a limpeza do buffer de saída. Isso significa que quaisquer dados pendentes no buffer

PÚBLICA
 serão imediatamente escritos no dispositivo de saída. Exemplo de uso combinado:
std::cout << "Olá, mundo!" << std::endl;

Para o exemplo, não apenas uma nova linha é adicionada após "Olá, mundo!", mas o buffer é
limpo, garantindo que a saída seja exibida imediatamente.

O uso de std::endl é semelhante a usar '\n' para inserir uma nova linha. No entanto, std::endl é
mais flexível e portátil, pois leva em consideração as configurações de novas linhas específicas
do sistema operacional, enquanto '\n' pode não se comportar da mesma forma em todos os
sistemas.

6. O que a palavra std significa?

A palavra "std" em C++ é um prefixo usado para indicar que você está usando um elemento
(como uma função, classe, variável) do namespace padrão da biblioteca padrão do C++,
chamada de "Standard Template Library" (STL).

"std": É uma abreviação de "standard", que denota o padrão estabelecido pela linguagem
C++ para suas bibliotecas e funcionalidades básicas.

Namespace "std": O namespace "std" é usado para organizar todas as classes, funções e
objetos relacionados à biblioteca padrão do C++. Ao usar o prefixo "std::" antes de um
elemento (por exemplo, std::cout), você está especificando que deseja usar esse elemento
do namespace padrão.

Por exemplo, ao usar std::cout, você está acessando a função cout que faz parte do
namespace std e é usada para imprimir dados na saída padrão. Este é um mecanismo que
ajuda a evitar conflitos de nome entre diferentes bibliotecas e partes do código.

7. Quais são os dois tipos de comentários na linguagem c++?

Na linguagem C++, existem dois tipos principais de comentários:

a) Comentários de Linha Única:

▪ Comentários que se aplicam apenas a uma linha de código;
▪ São iniciados com // e continuam até o final da linha. Exemplo: int idade = 25; //
Esta é uma variável de idade.

b) Comentários de Múltiplas Linhas:

▪ Comentários que podem abranger várias linhas de código;
▪ São iniciados com /* e terminam com */. Exemplo: /* Este é um comentário que
se estende por várias linhas. */ int salario = 5000.

Os comentários são usados para documentar o código, explicar funcionalidades, fornece

informações sobre variáveis ou qualquer outra informação relevante para os programadores
que estão lendo o código. Eles são ignorados pelo compilador e não afetam o funcionamento
do programa.

8. Qual é o tamanho em Bytes dos tipos primitivos bool, char, int e double?

PÚBLICA
 O tamanho em bytes dos tipos primitivos em C++ pode variar dependendo da
implementação, do compilador e da arquitetura do sistema. No entanto, algumas
informações típicas sobre o tamanho desses tipos de dados com base em convenções
comuns são:

a) bool: O tamanho do tipo bool pode variar, mas geralmente é implementado como 1
byte (8 bits). Em alguns casos, pode ser armazenado como um bit apenas, mas isso
depende da implementação;

b) char: O tamanho do tipo char é sempre 1 byte. Em C++, por definição, um char é
composto por pelo menos 8 bits;

c) int: O tamanho do tipo int pode variar dependendo do compilador e da arquitetura,

mas geralmente é de 4 bytes (32 bits) em sistemas de 32 bits e 4 ou 8 bytes (32 ou
64 bits) em sistemas de 64 bits;

d) double: O tamanho do tipo double é geralmente de 8 bytes (64 bits) em praticamente

todas as implementações e arquiteturas comuns.

Lembrando que, esses tamanhos podem variar em algumas situações específicas ou em

sistemas menos comuns. Podendo utilizar-se do operador sizeof em C++ para determinar o
tamanho real desses tipos em sua plataforma específica.

Exemplo:

#include <iostream>

int main() {
std::cout << "Tamanho de bool: " << sizeof(bool) << " bytes\n";
std::cout << "Tamanho de char: " << sizeof(char) << " bytes\n";
std::cout << "Tamanho de int: " << sizeof(int) << " bytes\n";
std::cout << "Tamanho de double: " << sizeof(double) << " bytes\n";

return 0;
}

9. Como uma variável qualquer é definida?

Uma variável em C++ é definida especificando o tipo de dados da variável, seguido pelo
nome da variável. Aqui está a sintaxe geral para definir uma variável em C++: tipo_de_dados
nome_da_variavel;

Onde:

▪ tipo_de_dados é o tipo de dados da variável, como int, double, char, bool etc.
▪ nome_da_variavel é o nome que você escolhe para a variável.

Exemplo de definição de variáveis para diferentes tipos de dados:

a) Inteiro (‘int’):int idade; // Define uma variável chamada "idade" do tipo inteiro

PÚBLICA
 b) Ponto flutuante (‘double’): double salario; // Define uma variável chamada "salario" do
tipo double

c) Caractere (’char’): char letra; // Define uma variável chamada "letra" do tipo char

d) Booleano (‘bool’): bool estaChovendo; // Define uma variável chamada

"estaChovendo" do tipo bool

Após a definição, é possível atribuir um valor à variável usando o operador de atribuição =.

Por exemplo: idade = 30; // Atribui o valor 30 à variável "idade".

Em C++ moderno, é uma boa prática inicializar as variáveis no momento da definição. Por
exemplo: int idade = 30; // Define e inicializa a variável "idade" com o valor 30. Assim, a
variável está pronta para ser usada com o valor inicial especificado.

10. Variáveis do tipo unsigned int e signed int conseguem representar a mesma
quantidade de valores?

Não, as variáveis do tipo unsigned int e signed int não conseguem representar a mesma
quantidade de valores. Detalhamos abaixo a diferença entre elas e como isso afeta a faixa
de valores que cada tipo pode representar:

a) ‘signed int’:
▪ É um tipo de dados que pode representar valores inteiros, positivos e negativos;
▪ Dedica um bit para representar o sinal (positivo ou negativo) e os outros bits para o
valor absoluto;
▪ A faixa de valores que um signed int pode representar varia dependendo da
implementação, mas é comumente de -2,147,483,648 a 2,147,483,647 para uma
arquitetura de 32 bits.

b) ‘unsigned int’:
▪ É um tipo de dados que representa apenas valores inteiros não negativos;
▪ Todos os bits são usados para representar o valor absoluto;
▪ Como não precisa representar o sinal, a faixa de valores que um unsigned int pode
representar é de 0 a 4,294,967,295 para uma arquitetura de 32 bits.

Portanto, enquanto um signed int pode representar valores positivos e negativos, um

unsigned int pode representar apenas valores não negativos, resultando em uma faixa de
valores diferente. A faixa para unsigned int é maior, mas ela não inclui números negativos. É
importante escolher o tipo de dados com base nos requisitos específicos do programa e na
faixa de valores que você precisa representar.

11. Descreva a diferença fundamental entre uma variável do tipo int e uma variável do tipo
const int.

A diferença fundamental está na capacidade de modificar seu valor após a declaração. Uma
variável do tipo int é uma variável inteira que pode ser modificada após sua inicialização,
sendo possível atribuir novos valores a uma variável int.

PÚBLICA
 Uma variável do tipo const int é uma constante inteira, ou seja, seu valor não pode ser
alterado após sua inicialização. Tentativas de modificar o valor de uma variável const int
resultarão em erros de compilação.

Portanto, a principal diferença é que uma variável do tipo int pode ter seu valor alterado após
a inicialização, enquanto uma variável do tipo const int é uma constante e seu valor não pode
ser modificado uma vez que é atribuído. O uso de const é útil quando se deseja garantir que
o valor de uma variável não seja modificado inadvertidamente durante a execução do
programa.

12. Como é possível escrever uma literal do tipo int na notação binária e hexadecimal?

Na linguagem C++ e em muitas linguagens de programação, você pode escrever literais no

formato binário, octal e hexadecimal para representar números inteiros. Abordaremos como
se pode fazer isso para inteiros nas notações binária e hexadecimal:

a) Notação Binária: Para escrever um literal de int na notação binária, se pode usar o prefixo
0b (ou 0B) seguido da sequência de dígitos binários (0s e 1s). Exemplo: int binario =
0b101010; // Representa o número binário 101010 em decimal;

b) Notação Hexadecimal: Para escrever um literal de int na notação hexadecimal, se pode

usar o prefixo 0x (ou 0X) seguido da sequência de dígitos hexadecimais (0-9 e A-F ou a-
f). Exemplo: int hexadecimal = 0x2A; // Representa o número hexadecimal 2A em
decimal.

Independentemente da notação utilizada, o valor é armazenado internamente em decimal

(base 10) e pode ser manipulado da mesma forma que um número inteiro comum. As
notações binária e hexadecimal são úteis para facilitar a leitura e a compreensão dos
números, especialmente quando se trabalha com valores específicos em sistemas de
numeração diferentes do decimal.

13. Explique como uma referência funciona.

Uma referência em C++ é uma forma de criar um "alias" (um apelido) para uma variável
existente. É uma maneira de associar um nome adicional a uma variável já existente, o que
permite manipular a variável por meio desse novo nome.

Aqui estão os pontos-chave sobre como as referências funcionam em C++:

a) Declaração de uma Referência:

▪ Uma referência é declarada usando o operador & (ampersand) após o tipo de dados;
▪ A sintaxe é: tipo_de_dados &nome_referencia = variavel.

b) Associação a uma Variável Existente:

▪ Uma referência deve ser associada a uma variável existente durante a sua
declaração;
▪ Depois de associada, a referência se torna um alias para essa variável.

c) Comportamento de Alias:

PÚBLICA
 ▪ A referência é um alias para a variável associada; modificar a referência é o mesmo
que modificar a variável original;
▪ Qualquer operação ou modificação feita através da referência é refletida diretamente
na variável original.

d) Sempre Inicializada:
▪ Uma referência deve ser inicializada no momento da sua declaração;
▪ Após a inicialização, ela não pode ser referente a outra variável.

As referências são frequentemente usadas para passar argumentos para funções por
referência, permitindo que a função modifique diretamente a variável original. Além disso,
são úteis para criar "atalhos" para variáveis e evitar a cópia de dados, especialmente ao
trabalhar com grandes objetos ou estruturas.

14. Explique como um ponteiro funciona.

Um ponteiro em C++ é uma variável que armazena o endereço de memória de outra variável.
Em outras palavras, um ponteiro "aponta" para uma posição na memória onde um valor está
armazenado. Entenderemos como os ponteiros funcionam em detalhes abaixo:

a) Declaração de um Ponteiro:
▪ Um ponteiro é declarado usando o operador * (asterisco) antes do nome do ponteiro;
▪ A sintaxe é: tipo_de_dados *nome_ponteiro.

Exemplo: int *ponteiro; // Declaração de um ponteiro para um inteiro

b) Associação a um Endereço de Memória:

▪ Um ponteiro deve ser associado a um endereço de memória de uma variável

existente.
▪ Isso é feito atribuindo o endereço de memória da variável ao ponteiro usando o
operador & (ampersand).

Exemplo:
int numero = 42; // Declaração de uma variável
int *ponteiro = &numero; / Associa o endereço de 'numero' ao ponteiro

c) Acesso ao Valor Apontado:

▪ Para acessar o valor armazenado no endereço apontado pelo ponteiro, usamos o

operador * (asterisco), chamado operador de desreferência.

Exemplo: int valor = *ponteiro; // Valor conterá o valor de 'numero'

d) Modificação da Variável Original através do Ponteiro:

▪ Modificar o valor através do ponteiro altera diretamente a variável original.

Exemplo: *ponteiro = 100; // Isso modifica 'numero' diretamente para 100.

PÚBLICA
 e) Ponteiro Nulo:

▪ Um ponteiro pode apontar para nenhum lugar específico, representado pelo valor
nulo (nullptr em C++11 em diante ou NULL em versões mais antigas).

Exemplo: int *ponteiro_nulo = nullptr; // Ponteiro aponta para lugar nenhum

Os ponteiros são frequentemente usados para passar endereços de variáveis para funções,
para alocar memória dinamicamente, para trabalhar com estruturas de dados complexas e
para otimizar o desempenho de certas operações. No entanto, é importante usar ponteiros
com cuidado para evitar erros de acesso indevido à memória e vazamentos de memória.

15. Os símbolos & e * podem significar tipos compostos ou operadores. Explique o

funcionamento dos símbolos nos dois modos de operação e como diferenciar o
significado deles.

Os símbolos & e * têm significados distintos dependendo do contexto em que são usados.
Como operadores e como parte de tipos compostos (ponteiros e referências).

a) Operadores & e *:

➢ ‘&’ (Operador de Endereço):

▪ Usado para obter o endereço de uma variável na memória.
▪ Sintaxe: &variavel.

Exemplo:
int numero = 42;
int *ponteiro = &numero; // & é usado para obter o endereço de 'numero'

➢ (Operador de Desreferência):
▪ Usado para acessar o valor armazenado em um endereço de memória apontado por
um ponteiro.
▪ Sintaxe: *ponteiro.

Exemplo:
int numero = 42;
int *ponteiro = &numero;
int valor = *ponteiro; // * é usado para acessar o valor apontado por 'ponteiro'

b) Tipos Compostos (Ponteiros e Referências):

➢ & (Parte de um Tipo - Referência):
▪ Usado para declarar uma referência.
▪ Sintaxe: tipo_de_dados &nome_referencia = variavel;.

Exemplo:
int numero = 42;
int &referencia = numero; // & é usado para declarar uma referência

➢ (Parte de um Tipo - Ponteiro):

PÚBLICA
 ▪ Usado para declarar um ponteiro.
▪ Sintaxe: tipo_de_dados *nome_ponteiro;.

Exemplo:
int numero = 42;
int *ponteiro = &numero; // * é usado para declarar um ponteiro

Para diferenciar o significado de & e * em um código, é importante analisar o contexto em

que são usados. Se estão associados a uma variável e usados para obter o endereço ou
acessar o valor, são operadores. Se estão na declaração de uma referência ou de um
ponteiro, fazem parte do tipo composto.

Em resumo, a interpretação correta depende do contexto: se estão sendo usados em

operações (obter endereço ou desreferenciar), são operadores; se fazem parte de uma
declaração de tipo (referência ou ponteiro), são parte do tipo composto.

16. Qual a ordem de precedência dos operadores aritméticos de soma (+), subtração (-),
multiplicação (*), divisão (/) e resto (%)?

A ordem de precedência dos operadores aritméticos em C++ (e na maioria das linguagens

de programação) segue as regras matemáticas convencionais. A lista a seguir apresenta a
ordem de precedência dos operadores aritméticos, do mais alto para o mais baixo:

a) Multiplicação (*), Divisão (/), Resto (%)

▪ Esses operadores têm a mais alta precedência e são avaliados antes de adição e
subtração.
▪ Eles são avaliados da esquerda para a direita.

b) Soma (+), Subtração (-)

▪ A adição e subtração têm uma precedência menor do que multiplicação, divisão e
resto.
▪ São avaliados da esquerda para a direita.

A ordem de avaliação pode ser alterada usando parênteses para controlar a sequência das
operações.

Exemplo de expressão com a ordem de precedência:

int resultado = 10 + 5 * 2; // Multiplicação é avaliada antes da adição // O resultado
será 20, não 30

Se deseja que a adição seja avaliada antes da multiplicação, é possível utilizar parênteses
para forçar essa ordem:

int resultado_corrigido = (10 + 5) * 2; // Agora, a adição é avaliada primeiro // O

resultado será 30

É sempre uma boa prática usar parênteses para tornar a ordem de avaliação explícita e
evitar ambiguidades, especialmente em expressões complexas.

17. Qual é o tipo dos dados de saída das operações relacionais?

PÚBLICA
 O tipo de dados de saída das operações relacionais em C++ é o tipo bool. As operações
relacionais, como igualdade (==), desigualdade (!=), maior que (>), menor que (<), maior ou
igual a (>=) e menor ou igual a (<=), comparam dois valores e retornam um valor booleano
(true ou false) indicando o resultado da comparação.

Por exemplo:
int a = 10;
int b = 5;

bool igual = (a == b); // false, a não é igual a b

bool maior = (a > b); // true, a é maior que b
bool menor_ou_igual = (a <= b); // false, a não é menor ou igual a b

Essas operações relacionais são amplamente utilizadas em estruturas de controle de fluxo

condicional, como instruções if, else if, while, do-while, e outros lugares onde a lógica de
decisão é necessária. O resultado booleano é fundamental para determinar o fluxo de
execução do programa com base nas condições especificadas.

18. Escreva a tabela verdade das operações lógicas AND e OR.

A tabela verdade para as operações lógicas AND (E) e OR (OU) é uma tabela que mostra
todas as combinações possíveis de valores de entrada e os resultados correspondentes da
operação.

Operação Lógica AND (E):

A B A AND B
0 0 0
0 1 0
1 0 0
1 1 1

Operação Lógica OR (OU):

A B A OR B
0 0 0
0 1 1
1 0 1
1 1 1

Na tabela acima:
▪ A e B representam os valores de entrada (0 para falso, 1 para verdadeiro).
▪ A AND B representa o resultado da operação AND entre A e B.
▪ A OR B representa o resultado da operação OR entre A e B.

PÚBLICA
 As operações lógicas AND e OR são usadas em lógica booleana para determinar o resultado
baseado nas condições de verdade (1) ou falsidade (0) das proposições envolvidas. O AND
é verdadeiro apenas quando ambas as proposições são verdadeiras, enquanto o OR é
verdadeiro quando pelo menos uma das proposições é verdadeira.

19. Cite três casos em que o valor do lado esquerdo do operador de atribuição não é
compatível.

O lado esquerdo do operador de atribuição em C++ deve ser uma expressão que resulta em
uma localização de memória modificável, ou seja, deve ser uma variável, um elemento de
array ou um objeto que pode ser modificado. Casos em que o lado esquerdo não é
compatível incluem:

a) Constantes Literais:
▪ Não é possível atribuir um valor a uma constante literal.

Exemplo: 10 = 5; // Inválido: não é possível atribuir um valor a uma constante literal

b) Expressões sem Lado Esquerdo Modificável:

▪ Expressões complexas, como operações aritméticas ou chamadas de função, não

possuem um lado esquerdo que possa ser modificado.

Exemplo: (a + b) = 10; // Inválido: (a + b) não é uma localização de memória modificável

c) Valores de Retorno de Funções:

O valor de retorno de uma função não pode ser usado no lado esquerdo de uma atribuição.

Exemplo:
int funcao() {
return 5;
}

funcao() = 10; // Inválido: não é possível atribuir um valor ao retorno da função

Em todos esses casos, a tentativa de atribuir um valor ao lado esquerdo resultará em um

erro de compilação, pois o lado esquerdo não é compatível ou não é uma localização de
memória modificável. A atribuição só é válida quando o lado esquerdo é uma variável ou
uma localização de memória que pode ser modificada.

20. Qual a diferença no operador de incremento quando aparece antes ou depois da

variável incrementada?

O operador de incremento em C++ é usado para aumentar o valor de uma variável por 1. A
diferença entre o operador de incremento quando aparece antes (++variavel) ou depois
(variavel++) da variável incrementada está relacionada ao momento em que a variável é
incrementada e o valor retornado na expressão.

PÚBLICA
 a) Operador de Incremento Pré-fixo (++variavel):
▪ Incrementa a variável antes de usar seu valor na expressão.
▪ Retorna o valor incrementado.
Exemplo:
int a= 5;
int b= ++a; // 'a' é incrementado antes de atribuir seu valor a 'b' // Agora, a= 6 e b= 6

b) Operador de Incremento Pós-fixo (variavel++):

▪ Usa o valor atual da variável na expressão e, em seguida, incrementa a variável.

▪ Retorna o valor antes do incremento.

Exemplo:
int x= 5;
int y= x++; // 'x' é usado em 'y' antes de ser incrementado // Agora, x= 6 e y= 5

Em resumo, a diferença está quando a variável é incrementada. Com ++variável, a variável

é incrementada antes de ser usada na expressão, resultando no valor incrementado. Com
variável++, a variável é usada na expressão antes de ser incrementada, resultando no valor
antes do incremento.

É importante entender essa diferença, pois pode afetar o comportamento do programa,

especialmente em situações em que a ordem de avaliação dos operadores é crucial.

21. Escreva um programa que:

▪ Receba dois valores inteiros do usuário;

▪ Calcule a divisão e o resto entre os dois valores;
▪ Apresente os resultados de volta para o usuário.

Instruções a seguir:

#include <iostream>

int main() {
int numero1, numero2;

// Passo 1: Recebendo os dois valores inteiros do usuário

std::cout << "Digite o primeiro valor inteiro: ";
std::cin >> numero1;

std::cout << "Digite o segundo valor inteiro: ";

std::cin >> numero2;

// Passo 2: Calculando a divisão e o resto entre os dois valores

int resultadoDivisao = numero1 / numero2;
int resultadoResto = numero1 % numero2;

// Passo 3: Apresentando os resultados de volta para o usuário

std::cout << "O resultado da divisão é: " << resultadoDivisao << std::endl;

PÚBLICA
 std::cout << "O resto da divisão é: " << resultadoResto << std::endl;

return 0;
}

22. Escreva um programa que:

▪ Crie duas variáveis do tipo double v1 e v2;

▪ Receba um valor do usuário e atribua a v1;
▪ Crie um ponteiro que aponte para v1;
▪ Através do ponteiro, atribua o dobro de v1 à v2;
▪ Imprima as variáveis v1 e v2.

Instruções a seguir:

#include <iostream>

int main() {
double v1, v2;

// Passo 1: Criar duas variáveis do tipo double v1 e v2

double *ponteiro;

// Passo 2: Recebendo um valor do usuário e atribuindo a v1

std::cout << "Digite um valor para v1: ";
std::cin >> v1;

// Passo 3: Criando um ponteiro que aponte para v1

ponteiro = &v1;

// Passo 4: Através do ponteiro, atribuindo o dobro de v1 à v2

v2 = (*ponteiro) * 2;

// Passo 5: Imprimindo as variáveis v1 e v2

std::cout << "v1: " << v1 << std::endl;
std::cout << "v2: " << v2 << std::endl;

return 0;
}

23. Escreva um programa que:

▪ Receba um valor inteiro do usuário;

▪ Usando os operadores de resto (%) e igualdade (==), imprima 1 caso o número
seja par ou 0 caso seja ímpar.

Instruções a seguir:

#include <iostream>

PÚBLICA
 int main() {
int numero;

// Passo 1: Recebendo um valor inteiro do usuário

std::cout << "Digite um valor inteiro: ";
std::cin >> numero;

// Passo 2: Usando os operadores de resto (%) e igualdade (==), imprimindo 1 caso o

número seja par ou 0 caso seja ímpar
if (numero % 2 == 0) {
std::cout << "1" << std::endl; // Número é par
} else {
std::cout << "0" << std::endl; // Número é ímpar
}

return 0;
}

PÚBLICA