Aula 1 – Introdução

Algoritmo é comumente definido como uma sequência finita de etapas lógicas e sequenciais
que visam atingir um objetivo definido.
A linguagem de programação C++ foi desenvolvida em meados de 1983 (originalmente com o
nome C with classes) por Bjarne Stroustrup. É uma linguagem orientada a objetos e
considerada como de médio nível, pois oferece mecanismos encontrados em linguagens de
baixo e alto nível. A estrutura de um programa em C++ pode ser definida como uma coleção de
objetos que se comunicam via chamadas de seus métodos.
Cabeçalhos contém informações ou recursos que são necessários ou úteis ao programa. No
programa anterior, o cabeçalho iostream é necessário;
• A linha using namescape std; informa ao compilador que a área de nomes chamada std será
utilizada. Através dela é possível acessar o objeto cout;
• int main() denota o método principal. A partir dele que a aplicação inicia sua execução;
• A última linha return 0; concluirá o método main() retornando um código de status.

Tipos de dados
Bool - Tipo booleano, que assume apenas os valores true ou false. char Caractere
representado por um octeto de bits (1 byte) ASCII. É um tipo de int.
Int - Número inteiro, cujo tamanho pode variar conforme a arquitetura do processador.
Float - Número em ponto flutuante de precisão simples.
Double - Igualmente ao float, porém com precisão dupla.
Void - Representa a absência de tipo (não é utilizado para declarar variáveis).
Wchar_t - Armazena caracteres mais amplos para suportar internacionalização.

Existem quatro modificadores que podem ser combinados com os tipos primitivos char,
int e double, são eles:
• short: indica uma variável com range menor (aplicável a int);
• long: indica uma variável com range maior (aplicável a int e double);
• signed: indica um número que pode ser negativo ou positivo (aplicável a int e char);
• unsigned: indica que um número só pode ser positivo (aplicável a int e char).
Exemplo:
unsigned short int var1; //Aceita valores entre 0 a 65.535.
long double var2; //Possui 10 dígitos de precisão, contra 8 do double convencional.
signed char var3; //Varia entre -127 a 127, igualmente ao char convencional.
long int var4; //Aceita valores entre -2.147.483.648 a 2.147.483.647.
Se o fluxo de bytes tem origem em um teclado, um disco rígido ou uma conexão de rede e
tem destino para a memória principal do computador, é uma operação de entrada.
Se os bytes estão alocados na memória principal e têm como destino um monitor de
vídeo, uma impressora ou uma conexão de rede, é uma operação de saída.
As operações de entrada e saída realizadas através de cout e cin, que são instâncias das
classes ostream e istream. Para utilizá-las, é necessário incluir o arquivo header iostream
e explicitar o uso da área de nomes chamada std.

Blocos condicionais: São estruturas que envolvem o teste condicional de uma expressão,
de tal forma que se a condição for satisfeita, uma determinada tarefa será executada,
caso contrário, uma outra tarefa poderá ser realizada.
 IF: Executa um bloco de código caso a condição booleana a ser testada retornar true,
exemplo:
int main() { int n = 10;
if (n < 20) {
cout << "n e menor que 20" << endl; }
cout << "Valor de n: " << n << endl;
return 0; }
IF...ELSE: Executa um bloco de código caso a condição booleana a ser testada retornar true. Se
for falsa, executa outro bloco de código, exemplo:
int main() { int n = 10;
if (n < 20) {
cout << "n e menor que 20" << endl; }
else {
cout << "n nao e menor que 20" << endl; }
cout << "Valor de n: " << n << endl;
return 0; }
IF TERNÁRIO: O comando IF...ELSE pode ser escrito como um IF ternário em condições onde
haja uma atribuição de variável, exemplo:
int main() { int n;
char c = 'A';
//Atribui à variável n o valor 10 se c for igual a A
//Caso contrário, o valor de n será igual a 20
n = (c == 'A' ? 10 : 20);
return 0; }

IF...ELSE IF...ELSE: Executa um bloco de código caso a sua condição correspondente retornar
true. O uso de else nesta estrutura é opcional.
int main() { int n = 10;
if (n < 20) {
 cout << "n e menor que 20" << endl; }
else if (n < 30) {
cout << "n e menor que 30" << endl; }
else {
cout << "n nao e menor que 20 e nem 30" << endl; }
cout << "Valor de n: " << n << endl;
return 0; }

SWITCH: Esta estrutura testa uma variável a partir de uma lista de valores, sendo que
cada valor é conhecido como case. Se a variável for igual a algum valor, o comando switch
irá executar o bloco de código correspondente ao case. Exemplo:
int main() { int n = 10;
switch (n) {
case 10:
cout << "O valor e 10" << endl;
break;
case 20:
cout << "O valor e 20" << endl;
break;
default: cout << "Valor nao e 10 e nem 20" << endl; }
return 0; }
O comando switch pode ser comparado com uma estrutura IF...ELSEIF...ELSE, porém é
importante frisar os seus pontos peculiares:
• A variável a ser testada deve ser um tipo inteiro ou enumerado;
• É possível inserir quantos casos forem necessários, onde a sintaxe deve conter a palavra
case e dois pontos;
• O deve ser do mesmo tipo da variável. Além disso deve ser necessariamente uma
constante ou um literal;
• O uso de break é opcional. Seu propósito é de interromper o fluxo de código, forçando-o
a executar a próxima linha de código depois do bloco switch;
• Um bloco switch pode ter um caso default, que é o equivalente ao else de uma
estrutura if, ou seja, é executado apenas quando todos os casos anteriores falharem. Por
ser o último caso, não há necessidade do comando break.

Blocos de repetição: Um bloco de repetição processará uma ou várias linhas de código

enquanto a condição booleana que a mantém retornar true. O diagrama ilustra a ideia de
um bloco de repetição:
WHILE :Processa um bloco de código repetidamente até que a sua condição retorne true.
int main() { int n = 1;
while (n <= 10) {
cout << "O valor de n e " << n << endl; n++; }
return 0; }

A saída será a seguinte:

O valor de n e 1
O valor de n e 2
O valor de n e 3
O valor de n e 4
O valor de n e 5
O valor de n e 6
O valor de n e 7
O valor de n e 8
O valor de n e 9
O valor de n e 10
*a rotina irá incrementar o valor de n até que este chegue a 11. Quando isso acontecer, a
condição no laço while retornará false (pois 11 não é menor e nem igual a 10) e,
consequentemente, o bloco de repetição se encerrará.
FOR : Permite controlar de forma mais eficiente a quantidade de iterações a ser realizada,
int main() { for (int n = 1; n <= 10; n++) {
cout << "O valor de n e " << n << endl; }
return 0; }

Este programa imprimirá o mesmo resultado do código do exemplo anterior. A diferença está
em relação ao controle da quantidade de iterações, que fica implícita no próprio comando for.
DO...WHILE:Diferentemente dos casos anteriores, onde o teste da condição é realizado
primeiro, neste tipo de bloco de repetição a condição é verificada somente ao fim do bloco. A
diferença principal é que o código será executado pelo menos uma vez, conforme exemplo
abaixo (cuja saída será igual aos dois códigos anteriores).
int main() { int n = 1;
do {
cout << "O valor de n e " << n << endl; n++; }
while (n <= 10);
return 0; }

setlocale(LC_CTYPE, "portuguese_brazil"); - Informa ao programa as regras do idioma do

brasil

Exercícios:
1.Crie um programa que solicite ao usuário os três coeficientes de uma equação do segundo
grau e informe os valores de x’ e x’’.
{ int a,b,c;
float d, x1,x2;
cout<<"Digite 3 valores \n";
cin>>a>>b>>c;
d = (b*b) - (4*a*c);
if(d>0){
x1=-b + sqrt(d) / (2*a);
x2=-b - sqrt(d) / (2*a);
cout<< "As saidas sao x1= "<<x1<<" e x2= "<<x2<<"\n"; }
else if(d==0){
x1=-b/(2*a);
cout<<"A raiz "<<x1<<"\n"; }
else{
cout<<"Nao existe raiz\n"; }
system("PAUSE");
return EXIT_SUCCESS; }

2.Crie um programa que solicite ao usuário os lados de um retângulo e informe a sua área.
{ float b, h;
//Lendo os atributos do retângulo (base e altura)
cout << "Informe a base do retangulo: ";
cin >> b;
if (b < 0) {
cout << endl << "Valor invalido para a base do retangulo!" << endl;
return 0; }
cout << endl << "Informe a altura do retangulo: ";
cin >> h;
if (h < 0) {
cout << endl << "Valor invalido para a altura do retangulo!" << endl;
return 0; }
//Calculando a área do retângulo (base x altura)
float area = b * h;
cout << endl << "Area do retangulo: " << area << endl;
return 0; }

3.Crie um programa que solicite ao usuário os lados de um triângulo e informe a sua área.
 { float b, h;
//Lendo os atributos do triângulo (base e altura)
cout << "Informe a base do triangulo: ";
cin >> b;
if (b < 0) {
cout << endl << "Valor invalido para a base do triangulo!" << endl;
return 0; }
cout << endl << "Informe a altura do triangulo: ";
cin >> h;
if (h < 0) {
cout << endl << "Valor invalido para a altura do triangulo!" << endl;
return 0; }
//Calculando a área do triângulo (base x altura)
float area = (b * h) / 2;
cout << endl << "Area do triangulo: " << area << endl;
return 0; }

4.Crie um programa que solicite ao usuário os lados de um trapézio e informe a sua área.
{ float b, B, h;
//Lendo os atributos do trapézio (base menor, base maior e altura)
cout << "Informe a base menor do trapezio: ";
cin >> b;
if (b < 0) {
cout << endl << "Valor invalido para a base menor do trapezio!" << endl;
return 0; }
cout << endl << "Informe a base maior do trapezio: ";
cin >> B;
if (B < 0) {
cout << endl << "Valor invalido para a base maior do trapezio!" << endl;
return 0; }
else if (B < b) {
cout << endl << "A base maior e menor do que a base menor!" << endl;
return 0; }
cout << endl << "Informe a altura do trapezio: ";
cin >> h;
if (h < 0) {
cout << endl << "Valor invalido para a altura do trapezio!" << endl;
return 0; }
//Calculando a área do trapézio (((base maior + base menor) x altura) / 2)
float area = ((b + B) * h) / 2;
cout << endl << "Area do trapezio: " << area << endl;
return 0; }
5.Escreva um programa que solicite ao usuário um valor inteiro e informe se esse número é
par ou ímpar.
{ int numero;
cout << "Digite um numero: ";
cin >> numero;
cout << endl;
if (numero % 2 == 0) {
cout << "Numero " << numero << " e par" << endl;
} else {
 cout << "Numero " << numero << " e impar" << endl; }
return 0; }
6.Escreva m programa que solicite ao usuário a idade de uma pessoa e informe se essa pessoa
é criança (0 a 11 anos), adolescente (12 a 17 anos), adulta (18 a 49 anos) ou idosa (a partir de
50 anos).
{ int idade;
//Lendo a idade da pessoa
cout << "Digite a idade de uma pessoa: ";
cin >> idade;
//Idade negativa não é válida
if (idade < 0) {
cout << endl << "Idade invalida!" << endl;
return 0; }
cout << endl;
//Verificando o intervalo de idade da pessoa
if (idade <= 11) {
cout << "A pessoa e uma crianca";
} else if (idade <= 17) {
cout << "A pessoa e adolescente";
} else if (idade <= 49) {
cout << "A pessoa e adulta";
} else {
cout << "A pessoa e idosa"; }
cout << endl;
return 0; }

11.Escreva um programa que solicite ao usuário um ano qualquer e informe se esse ano é
bissexto. Um ano é considerado bissexto se ele for divisível por quatro, mas não por 100. Ou
então se ele for divisível por 400.
{ int ano;
//Lendo o ano informado pelo usuário
cout << "Informe um ano: ";
cin >> ano;
//Validando o ano (não pode ser negativo)
if (ano < 0) {
cout << endl << "Ano invalido!" << endl;
return 0; }
cout << endl;
//Verifica se o ano é divisível por 400
bool divisivelPor400 = (ano % 400 == 0);
//Verifica se o ano é divisível por 4 e não por 100
bool divisivelPor4 = (ano % 4 == 0 && ano % 100 != 0);
//Um ano é considerado bissexto se uma das duas condições acima for verdadeira
if (divisivelPor400 || divisivelPor4) {
cout << "Ano " << ano << " e bissexto!";
} else {
cout << "Ano " << ano << " nao e bissexto!"; }
cout << endl;
return 0; }
12.Crie um programa que solicite ao usuário os três ângulos de um triângulo e informe se este
é um triângulo equilátero, isósceles ou escaleno.
 { int angulo1, angulo2, angulo3;
cout << "Digite o primeiro angulo de um triangulo: ";
cin >> angulo1;
if (angulo1 <= 0) {
cout << endl << "Angulo invalido!";
return 0; }
cout << endl << "Digite o segundo angulo de um triangulo: ";
cin >> angulo2;
if (angulo2 <= 0) {
cout << endl << "Angulo invalido!";
return 0; }
cout << endl << "Digite o terceiro angulo de um triangulo: ";
cin >> angulo3;
if (angulo3 <= 0) {
cout << endl << "Angulo invalido!";
return 0; }
//Verificando se a soma dos ângulos do triângulo equivale a 180º. Se não for, então a
figura geométrica não é um triângulo
if ((angulo1 + angulo2 + angulo3) != 180) {
cout << endl << "A soma dos angulos internos de um triangulo deve ser igual a 180!" <<
endl;
return 0; }
cout << endl;
//Verificando os ângulos
if (angulo1 == angulo2 && angulo2 == angulo3) { //Todos os ângulos iguais, então ele é
equilátero
cout << "Este e um triangulo equilatero";
} else if (angulo1 == angulo2 || angulo2 == angulo3 || angulo1 == angulo3) { //Um par
de ângulos igual, então é isósceles
cout << "Este e um triangulo isosceles";
} else { //Todos os ângulos são diferentes, então ele é escaleno
cout << "Este e um triangulo escaleno"; }
cout << endl;
return 0; }
13.Escreva um programa que solicite ao usuário quatro números e mostre na tela o maior, o
menor e a média aritmética dos números digitados.
{ int angulo1, angulo2, angulo3;
cout << "Digite o primeiro angulo de um triangulo: ";
cin >> angulo1;
if (angulo1 <= 0) {
cout << endl << "Angulo invalido!";
return 0; }
cout << endl << "Digite o segundo angulo de um triangulo: ";
cin >> angulo2;
if (angulo2 <= 0) {
cout << endl << "Angulo invalido!";
return 0; }
cout << endl << "Digite o terceiro angulo de um triangulo: ";
cin >> angulo3;
if (angulo3 <= 0) {
cout << endl << "Angulo invalido!";
return 0; }
 //Verificando se a soma dos ângulos do triângulo equivale a 180º. Se não for, então a
figura geométrica não é um triângulo
if ((angulo1 + angulo2 + angulo3) != 180) {
cout << endl << "A soma dos angulos internos de um triangulo deve ser igual a 180!" <<
endl;
return 0; }
cout << endl;
//Verificando os ângulos
if (angulo1 == angulo2 && angulo2 == angulo3) { //Todos os ângulos iguais, então ele é
equilátero
cout << "Este e um triangulo equilatero";
} else if (angulo1 == angulo2 || angulo2 == angulo3 || angulo1 == angulo3) { //Um par
de ângulos igual, então é isósceles
cout << "Este e um triangulo isosceles";
} else { //Todos os ângulos são diferentes, então ele é escaleno
cout << "Este e um triangulo escaleno"; }
cout << endl;
return 0; }
*Todos os exercícios estão dentro do main.

Vetor: É uma variável composta homogênea unidimensional formada por uma sequência de
variáveis, todas do mesmo tipo, com o mesmo identificador (mesmo nome) e alocadas
sequencialmente na memória.
Tipo Nome [tamanho];
Para atribuir: salario[0] = 240.00
Strcpy (nome, “Maria”) – Deixa cada letra em um índice, se sobrar ficara 0/ nos demais

Exemplo de código:
#include<stdio.h>
Using namespace std;
Int main () {
Int I;
Float notas[5];
For (i=0; i<=4; i++){
Cout<<”Digite um número\n\n”;
Cin>> notas[i]; }
Return 0; }

Exercícios:
1. Fazer um programa que leia vários números inteiros e positivos. A leitura se encerra quando
encontrar um número negativo ou quando o vetor ficar completo. Sabe-se que o vetor possui,
no máximo, 10 elementos. Gerar e imprimir um vetor onde cada elemento é o inverso do
correspondente do vetor original
{ int i,vet[10], x;
i=0;
do{
cout<<"Digite um número \n";
cin>>x;
if(x>0){
vet[i]=x;
i++; } }
while(i<10 && x>0);
for(int y=0; y<i; y++)
cout<<vet[y]*(-1)<<"\n";
 system("PAUSE");
return EXIT_SUCCESS; }
2.Fazer um programa que digite vários números no vetor de tamanho máximo de 100
elementos, até digitar o número “0”. Imprimir quantos números iguais ao último número
foram lidos. O limite de números é 100. Sem considerar o “0” como último número.
{ int v[100], x, i, aux, c;
x=1;i=0; c=0;
while(x!=0 && i<100){
cout<<"Digite um número \n";
cin>>x;
if(x!=0){
v[i]=x;
i++ } }
for(int y=0; y<i-1; y++){
if(v[y]== v[i-1])
c++; }
cout<<c<<"\n";
system("PAUSE");
return EXIT_SUCCESS; }
3.Criar um programa que crie um vetor com 10 posições e carregue com uma palavra, depois
imprima o vetor de uma maneira que exiba a palavra ao contrário (ex. Casa...asac)
{ char v[10];
int tam;
cout<<"Digite o tamanho da palavra \n";
cin>>tam;
for(int i=0; i<tam; i++){
cout<<"Digite as letras da palavra \n";
cin>>v[i];
}
cout<<"\n";
for(int i=tam-1; i>=0; i--){
cout<<v[i]; }
cout<<"\n";

system("PAUSE");
return EXIT_SUCCESS; }

Matriz: É uma variável composta homogênea bidimensional formada por uma

sequência de variáveis, todas do mesmo tipo, com o mesmo identificador (mesmo
nome) e alocadas sequencialmente na memória.
Tipo Nome [linha] [coluna];
Exemplo de código:

{ int i, j;
Float notas[2][2] = {7,8,9.5,9.9}; // atribuição direta
//declarando e inicializando o vetor notas
Cout<<”Exibindo os Valores do Vetor\n\n”;
For(i = 0; i <2; i++) {
For(j = 0; j <2; j++) {
Cout<<notas[i][j]
}}
Return 0; }
Exercícios:
1. Criar uma matriz de ordem 4 e exibir a soma da diagonal principal.
{ int matrizA[4][4];
int somaA=0;
int total;

for(int i= 0; i<4; i++){

for(int j= 0; j<4; j++){
cout << "Insira um valor na matriz " << i << " " << j << ": ";
cin>> matrizA[i][j];
if(i==j){
somaA += matrizA[i][j]; } } }
cout<< "Diagonal Principal: " << somaA<<endl;
return 0; }
2. Ler valores inteiros para a matriz A[3][5]. Gerar e imprimir o vetor Soma_Linha, onde cada
elemento é a soma dos elementos de uma linha da matriz A. Faça o trecho que gera a matriz
separadamente da entrada e saída.
{ int A[3][5];
int soma_Linha[3]={0,0,0};
for(int i= 0; i<3; i++){
for(int j= 0; j<5; j++){
cout << "Insira um valor na matriz " << i << " " << j << ": ";
cin>> A[i][j]; } }
for(int i= 0; i<3; i++){
for(int j= 0; j<5; j++){
soma_Linha[i] += A[i][j]; } }
for(int i= 0; i<3;i++){
cout << "Soma da linha "<< i<< ": " << soma_Linha[i] << "\n"; }
return 0; }
3.Criar uma matriz 2x3. Gerar e imprimir a transposta dessa matriz. A matriz transposta é
gerada trocando linha por coluna.
{ int matrizA[2][3] = {{0}};
int matrizB[3][2] = {{0}};
cout<<"Popule a matriz 2x3 \n";
for(int i=0; i<2; i++){
for(int j=0; j<3; j++){
cin>>matrizA[i][j];
}
}
for(int i=0; i<2; i++){
for(int j=0; j<3; j++){
matrizB[j][i]= matrizA[i][j];
}
}
cout<<"\n";
for(int i=0; i<3; i++){
for(int j=0; j<2; j++){
cout<<matrizB[i][j]<<"\t";
}
cout<<"\n"; }
return 0; }

Métodos (Orientação a Objeto): Um método é uma sub-rotina que é executada por

um objeto ao receber uma mensagem. Os métodos determinam o comportamento dos
objetos de uma classe e são análogos a funções ou procedimentos da programação
estrutura. Então método é a ação de uma classe
TIPO NOME_DO_MÉTODO (PARÂMETROS) {
INSTRUÇÕES;
RETORNO }
TIPO DO MÉTODO – SERIA UM TIPO DE DADO (PODE SER OS TIPOS CLÁSSICOS
COMO INT, LONG, FLOAT ...) PORÉM PODEMOS TER UM TIPO DIFERENTES DESSES, TIPO DE
UMA CLASSE.
NOME_DO_MÉTODO – NOME DADO AO MÉTODO, SEGUE AS MESMA REGRA PARA A
CRIAÇÃO DAS VARIÁVEIS.
PARÂMETROS – SÃO DADOS QUE SERVEM PARA ENTRADA DA AÇÃO DO MÉTODO.
{ - ABERTURA DO ESCOPO DO MÉTODO
RETORNO – É USADO O COMANDO RETURN PARA RETORNAR A AÇÃO DOS MÉTODOS, OU
SEJA A SAÍDA/RESPOSTA DO MÉTODO, TEMOS CASOS QUE NÃO USAMOS QUANDO O TIPO
FOR VOID.
} – FECHANDO O ESPOCO DO MÉTODO. (EM ORDEM COM O MODELO A CIMA)

Exemplo:
INT SOMA (FLOAT A, FLOAT B){
INT S = A+B;
RETURN S; }
VOID IMPRIMI (STRING NOME){
COUT<<NOME; }

Exemplo (Chamando o método no main):

#inlude <iostream>
Using namespace std;
Int soma (float a, float b) {
Int s = a + b;
Return s; }
Int main (int argc, char** argv) {
Float x,y;
Count << “Digite 2 valores” << “\n”;
Cin >> x >> y;
Cout<<soma(x,y) << “\n”;
Return 0; }

Exercícios:
1.Desenvolva um programa que tenha dois métodos fahrenheit e celsius, onde você entra com
um valor em fahrenheit e transforma em celsius e vice e versa.
- Fórmula Celsius: (fahrenheit – 32) * 5/9; - Fahrenheit = (Celsius * 9/5) + 32;
#include <cstdlib>
#include <iostream>
using namespace std;

float calcCel (float f);

float calcFah (float c);

int main(int argc, char *argv[]) {

float Fahrenheit, Celsius;

int valor;
 cout << "*** Converte Celsius para Fahrenheit e vice-versa ***\n";

cin >> valor;

if (valor == 1) {

cout << "\nDigite os graus Fahrenheit: ";

cin >> Fahrenheit;

Celsius = calcCel (Fahrenheit);

cout << "\nGraus Celsius: "<< Celsius <<"\n"; }

else {

cout << "\nDigite os graus Celsius: ";

cin >> Celsius;

Fahrenheit = calcFah (Celsius);

cout << "Graus Fahrenheit: "<< Fahrenheit<<"\n"; }

system("PAUSE");

return EXIT_SUCCESS; }

float calcCel (float f) {

return (f - 32)/1.8; }

float calcFah (float c) {

return (c / 5 * 9 )+ 32; }

2. Um número primo é qualquer inteiro divisível por si próprio e por 1. Escreva um método que
receba um inteiro positivo e, se este número for primo retorne 1, caso contrário retorne
#include <cstdlib>
#include <iostream>
using namespace std;

bool primo(int x);

int main(int argc, char *argv[]) {

int x;
cin>>x;
cout<<primo(x)<<"\n";
system("PAUSE");
return EXIT_SUCCESS; }
bool primo(int x){

int c=0;
 for(int i=1; i<=x; i++){
if(x % i == 0){
c++; } }
if(c==2){
return 1; }
else{
return 0;} }
3. Escreva um método que receba o ano e retorne 1 se for bissexto e 0 se não for. Um ano é
bissexto quando divisível por 4, mas não por 100. Um ano também é bissexto quando divisível
por 400.
#include <cstdlib>
#include <iostream>
using namespace std;

bool ano (int a){

if(a%4==0 && a%100!=0 || a%400==0){
return 1; }
else {
return 0; } }

int main(int argc, char *argv[]) {

int a;
cin>>a;
cout<<ano(a)<<"\n";
system("PAUSE");
return EXIT_SUCCESS; }
4. Desenvolver um programa onde você entre via teclado com dois valores e após a digitação o
usuário escolha um seletor de opção (menu) com as seguintes opções:
- Multiplicação; - Adição; - Divisão; - Subtração; - Fim do processo;
Obs. Criar um método para cada opção e dentro do case chamar as funções respectivamente.
#include <cstdlib>
#include <iostream>
using namespace std;

int adicao(int n1, int n2){

return n1 + n2; }
int subtracao(int n1,int n2){
return n1 + n2; }
int multiplicacao(int n1,int n2){
return n1 * n2; }
int divisao(int n1,int n2){
return n1 / n2; }

int main(int argc, char *argv[]) {

int i, n, op;
cout<<"Digite dois valores" << endl;
cin >> i >> n;
cout << "Digite a operacao desejada"<< endl;
cout << "1-Adicao"<< endl;
cout << "2-Subtracao"<< endl;
 cout << "3-Multiplicacao"<< endl;
cout << "4-Divisao"<< endl;
cin >> op;

switch (op){
case 1:
cout << (adicao(i,n);
break;
case 2:
cout << subtracao(i,n);
break;
case 3:
cout << multiplicacao(i,n);
break;

case 4:
cout << divisao(i,n);
break;

default :
break; }

system("PAUSE");
return EXIT_SUCCESS; }
6- Fazer um método que ordene um vetor, tenha como parâmetro um vetor de inteiro e
seu tamanho.
Exemplo método:
void nome ( float vet[], int tam) {
for(int i=0; i<tam; i++){

int main()
{
int vet[10], aux;
for(int i=0; i<10; i++){
cout<<"Digite um numero \n";
cin>>vet[i];
}
for(int i=0; i<10; i++){
for(int j=i+1; j<10; j++){
if(vet[i]>vet[j]){
aux=vet[i];
vet[i]=vet[j];
vet[j]=aux; } } }
for(int i=0; i<10; i++){
cout<<vet[i]<<"\t"; }

cout<<"Hello World";
return 0; }
Recursividade: é a definição de uma sub-rotina (função ou método) que pode invocar a si
mesma. Um exemplo de aplicação de recursividade, pode ser encontrado nos analisadores
sintáticos recursivos para linguagens de programação.
A grande vantagem da recursão está na possibilidade de usar um programa de computador
finito para definir. Analisar ou produzir um estoque potencialmente infinito de sentenças,
designs ou outros dados.

• Um método comum de simplificação consiste em dividir um problema em

subproblemas do mesmo tipo. Como técnica de programação, isto se denomina divisão e
conquista, e constitui a chave para o desenvolvimento de muitos algoritmos importantes,
bem como um elemento fundamental do paradigma de programação dinâmica.
• Praticamente todas as linguagens de programação usadas hoje em dia permitem a
especificação direta de funções e procedimentos recursivos. Quando uma função é
invocada, o computador (na maioria das linguagens sobre a maior parte das arquiteturas
baseadas em pilhas) ou a implementação da linguagem registra as várias instâncias de uma
função (em muitas arquiteturas, usa-se uma pilha de chamada, embora outros métodos
possam ser usados). Reciprocamente, toda função recursiva pode ser transformada em uma
função iterativa usando uma pilha.

Programação Recursiva
• Em geral, uma definição recursiva é definida por casos: um número limitado de casos
base e um caso recursivo. Os casos base são geralmente situações triviais e não
envolvem recursão.
• Um exemplo comum usando recursão é a função para calcular o fatorial de
um natural N. Nesse caso, no caso base o valor de 0! é 1. No caso recursivo, dado um N > 0,
o valor de N! é calculado multiplicando por N o valor de (N-1)!, e assim por diante, de tal
forma que N! tem como valor N * (N-1) * (N-2) * ... * (N-N)!, onde (N-N)! representa
obviamente o caso base. Em termos recursivos:

Exemplo do processo do fatorial: 5!

5 x (5-1) = 20
20 x (4 -1) = 60
60 x (3 -1) = 120
120 x (2-1) = 120
Int fatorial (int n) {
If ((n==0) II (n==1))
Return 1;
Return n * fatorial(n-1); }
Int main (int argc, char** argv){
Int fat;
Cont<<”Deseja calcular o fatorial de quanto? ” << endl;
Cin >> fat;
Cout << fat << “! é” << fatorial(fat); }

Exercício: Faça um metódo de Fibonacci usando recursividade

using namespace std;
long fatorial(int n);
int main(int argc, char** argv) {
int x;
cin>>x;
cout<<fatorial(x)<<endl;
return 0; }
long fatorial(int n) {
long vfat;
 if ( n <= 1 )
//Caso base: fatorial de n <= 1 retorna 1
return (1);
else {
//Chamada recursiva
vfat = n * fatorial(n - 1);
return (vfat); } }

Exemplo:
using namespace std;
long fatorial(int n);
int main(int argc, char** argv) {
int x;
cin>>x;
cout<<fatorial(x)<<endl;
return 0; }
long fatorial(int n) {
long vfat;
if ( n <= 1 )
//Caso base: fatorial de n <= 1 retorna 1
return (1);
else {
//Chamada recursiva
vfat = n * fatorial(n - 1);
return (vfat); } }
Busca Binária: é um algoritmo de busca em vetores que segue o paradigma de divisão
e conquisa. Ela parte do pressuposto de que o vetor está ordenado e realiza sucessivas
divisões do espaço de busca comparando o elemento buscado com o elemento no
meio do vetor.
Regras:
• Vetor deve estar ordenado, para isso use qualquer algoritmo de ordenação;
• Depois divida o vetor ao meio e compare o valor a ser buscado com o valor do meio;
se for menor ignore toda a metade do vetor que vai do meio até o final; caso o valor
seja maior que o meio; ignore todos os valores do meio até o início.
• Faça isso repetidamente, pode usar a recursividade.
Exercicio: Criar um método de ordenação com 2 parâmetros (um vetor de inteiro e uma
variável inteira para o tamanho do vetor), esse método pode ser “void” ele serve apenas para
ordenar o vetor que está no parâmetro.
Criar um segundo método que faça a busca binária no vetor, esse vetor também deve estar no
parâmetro do método.
Depois criar um vetor e popular no “main”, chamar os métodos criados acima, primeiro
chamar o de ordenação e depois o “busca binária”.
Bubble sort: Um algoritmo de ordenação simples e intuitivo. Esse algoritmo percorre uma lista
que basicamente compara elementos adjacentes e aS troca se estiverem na ordem errada.
Se o objetivo é ordenar os valores em forma decrescente ou crescente, então, a posição atual
é comparada com a próxima posição e, se a posição atual for maior que a posição posterior, é
realizada a troca dos valores nessa posição. Embora seja útil para fins educacionais e para
ilustrar os conceitos básicos de ordenação, ele não é a escolha ideal em cenários práticos
devido à sua ineficiência.

Insertion sort: John von Neumann criou o algoritmo insertion sort em 1951, é
um método de ordenação simples. Ele compara a troca elementos adjacentes para organizar a
lista. Funciona bem em listas pequenas ou quase ordenas mas é ineficiente em listas grandes e
desordenadas
Melhor caso: Lista quase ou completamente ordenada; Eficiente, requer poucas comparações
e movimentos; Complexidade de tempo: O(N.)
Pior caso: Lista ordenada de forma inversa; Menos eficiente, muitas comparações e
movimentos; Complexidade de tempo: O(n^2).
Algoritmo útil em situações de pequenas quantidades de dados ou quando a lista já está
quase ordenada. É frequente empregado em sistemas embarcados devido as restrições de
recursos e pode ser usado em conjunto com outros algoritmos de ordenação para aprimorar o
desempenho de cenários específicos

Shell sort: Uma técnica sofisticada de ordenação que se baseia no princípio do algoritmo de
inserção (Insertion Sort), o Shell Sort adota uma abordagem diferente, tornando-o mais
eficiente.
Começa por dividir o array em subgrupos menores, criando um espaço maior entre os
elementos que serão comparados.
O Shell Sort realiza uma série de interações através da lista principal, a cada passo diminuindo
o tamanho do espaço entre os elementos. Esses espaços maiores permitem que o algoritmo
mova elementos distantes uns dos outros, acelerando o processo de ordenação. Durante cada
iteração, ele compara elementos adjacentes em subgrupos e, se encontrar um elemento fora
de ordem, efetua a troca.
O algoritmo então prossegue com uma nova iteração, continuando a diminuir o espaço entre
os elementos até que, em sua última varredura, o espaço seja igual a 1, tornando-se
essencialmente um algoritmo de inserção padrão. No entanto, devido às otimizações
realizadas nas iterações anteriores, o número de elementos fora de ordem será
significativamente menor, resultando em menos trocas e, portanto, uma ordenação mais
rápida.
Vantagens: ele é capaz de reduzir substancialmente o número de trocas necessárias para
ordenar um conjunto de dados em comparação com o Insertion Sort. Isso se traduz em uma
melhoria notável na performance do algoritmo, especialmente quando se trata de listas
maiores ou parcialmente ordenadas.
Melhor caso: quando a coleção de entrada está parcialmente ordenada.
Pior caso: quando a coleção de entrada está ordenada de forma inversa.
Aplicabilidade: Conjuntos pré-Ordenados; Sistemas embarcados. Desempenho variado

Heap sort: A origem do Heapsort começa em 1964, por Robert. W Floyd e J. W J Williams,
sendo demonstrado como uma árvore binária e hierárquica, onde os nós (posição do número
na árvore) estão organizados em níveis (pais e filhos), o que fica no topo é o NÓ RAIZ.
Nó filhos são as ramificações da arvore, cada nó pai pode ter até 2 nós filho.
HEAP MIN - o valor armazenado em cada nó é menor ou igual ao valor de seus filhos (PAI <=
FILHO);
HEAP MAX - o valor armazenado em cada nó é maior ou igual ao valor de seus filhos (PAI >=
FILHO);
É uma boa escolha quando você precisa ordenar grandes conjuntos de dados
com restrições de memória, deseja uma ordenação em tempo
real ou está trabalhando com elementos que têm chaves de prioridade.
O heapsort, embora eficiente em termos de
tempo, tem limitações que o tornam menos recomendado em certos cenários, como,
complexa implementação, falta de estabilidade, exigência de espaço adicional
Aplicabilidade: depende de suas características em diversos cenários, como: Tempo de
execução previsível, estabilidade e bom desempenho em situação de dados desordenados

QUICK SORT: Desenvolvido em 1960 por Charles Antony Richard Hoare.

Encontra, a cada passo, a posição de um determinado elemento dentro de um vetor (pivô). E a
partir da definição dele, o Quick Sort busca garantir que todos os elementos a esquerda do
pivô sejam menores que ele e os da direita maiores. Basicamente, essa técnica de
particionamento ocorre por meio da troca de posições entre as duas variáveis de começo e
fim, que serão as responsáveis por analisar todas as informações armazenadas no array.
Melhor cenário - ocorre quando o número escolhido para ser o pivô se encontra no meio do
vetor ou próximo a ele, originando, assim, a divisão de sub-vetores ideal: duas sub-listas
proporcionais, facilitando a finalização do código e, automaticamente, aumentando a
velocidade de ordenação do vetor.
Pior cenário - quando o pivô escolhido é na extrema direita ou na extrema esquerda, fazendo
com que perca a eficiência e velocidade.
Usado em Sistemas de gerenciamento de banco de dados, Algoritmos de busca,pesquisa e
otimização e etc

Merge Sort: Divide e conquista para ordenar uma lista de elementos em ordem crescente. Ele
é conhecido por sua eficiência e estabilidade. Usado para grandes conjuntos de dados
Primeiro divide a lista original em dois subconjuntos aproximadamente iguais. Esse processo
de divisão continua até que cada subconjunto contenha apenas um elemento. Após envolve
a ordenação recursiva dos subconjuntos individuais e depois mescla os subconjuntos
ordenados em uma única lista ordenada. Aplicabilidade: Ordenação de grandes conjuntos de
dados, manter a ordem de classificação estável e processamento externo. Ruim: precisa de
espaço adicional e é complexo para implementar. Bom: é eficiente e estável.