comparativo entre linguagens python c++ java.pdf

Elementos Iniciais Linhas de Execução
Programação Orientada a Objetos
Tutorial Básico Multi Linguagens
Parte 1
Ronaldo F. Ramos
IFCE
2 de novembro de 2024
1 / 183

Conteúdo
1 Elementos Iniciais
2 Linhas de Execução
3 Gestão de Memória
4 Gestão de E/S - Fluxos (Streams)
2 / 183

Elementos de C++, Java e Python
/* Este é um exemplo de comentário de múltiplas linhas em C,
C++ e java */
// Este é um comentário de uma linha em C, C++, Java
# Isto é um comentário de uma linha em python
“““Isto é um comentário de múltiplas linhas em Python “““
3 / 183

Olá Mundo em C
1 #include <stdio.h>
2 int main () {
3 printf("ola mundon"); // Imprime "ola mundo" na tela
4 return 0; // Retorna 0 para indicar que o programa
terminou corretamente
5 }
para compilar usar: gcc 001_olamundo.c -o olamundo
para executar digitar: ./olamundo
4 / 183

Olá Mundo em C++
1 #include <iostream >
2 using namespace std;
3 int main () {
4 cout << "Olá Mundo Cruel!" << endl;
5 return 0;
6 }
para compilar: g++ 002_olamundo.cpp -o olamundo
para executar: ./olamundo
5 / 183

Introdução aos Namespaces
• Em C++, namespaces são uma forma de organizar o código e evitar conflitos de
nomes entre funções, variáveis, classes e outros identificadores.
• Namespaces ajudam a resolver problemas de ambiguidade, especialmente em
programas grandes ou bibliotecas que utilizam muitos componentes.
• A palavra-chave namespace permite agrupar identificadores sob um nome
específico.
6 / 183

Problema de Conflito de Nomes
• À medida que o código cresce, múltiplas bibliotecas ou módulos podem usar os
mesmos nomes para diferentes variáveis ou funções.
• Sem namespaces, esses conflitos poderiam causar erros e dificultar a manutenção
do código.
• Namespaces resolvem esse problema permitindo que cada biblioteca ou módulo
tenha seu próprio "espaço de nomes".
7 / 183

Olá Mundo em JAVA
1 public class olamundo{
2 public static void main(String [] args) {
3 System.out.println("olá mundo"); // Imprime "olá mundo" na
tela
4 }
5 }
para compilar: javac olamundo.java
para executar: java olamundo
8 / 183

Olá Mundo em Python
1 print("Olá Mundo")
para executar: python 004_olamundo.py
9 / 183

Literais e Tipos Primitivos em C++
3 int main (){
4 const int x = 043; // constante octal
5 const int z = 0x2f; // constante hexadecimal
6 const int w = 12; // constante decimal
7 const char * k = "Const string ";// constante string
8 cout << "x = " << oct << x << " z = " << showbase << hex << z <<
" w = " << w << " k = " << k << endl;
9 return 0;
10 }
para compilar: g++ 005_literais.cpp -o literais
para executar: ./literais
10 / 183

Explicação do Código
A saída em C++ acima funciona da seguinte forma:
1. cout « "x = ": Imprime a string "x = "diretamente no console.
2. oct « x: Define que o valor de x será exibido em base octal (base 8). Se x for, por
exemplo, 10, ele será impresso como 12 (a representação octal de 10 em decimal).
3. "z = ": Imprime a string "z = "no console.
4. showbase « hex « z:
• hex: Define que o valor de z será exibido em formato hexadecimal (base 16).
• showbase: Exibe o prefixo da base numérica na frente do valor hexadecimal,
ou seja, 0x antes do número. Se z for, por exemplo, 31, ele será impresso
como 0x1F (a representação hexadecimal de 31 em decimal).
5. "w = ": Imprime a string "w = "no console.
11 / 183

Continuando
6. w: Exibe o valor da variável w no formato padrão (decimal, se não tiver outra
formatação).
7. "k = ": Imprime a string "k = "no console.
8. k: Exibe o valor da variável k no formato padrão (decimal).
9. endl: Insere uma nova linha e força a saída de todos os dados que estão no buffer
de cout.
12 / 183

Saída
Os literais podem ser seguidos pelos sufixos u, l, f. Significando os tipos unsigned, long
e float respectivamente. Observe que 2.0 é por default do tipo double enquanto 2.0f é
um float, e2.0l é um long double.
Resultado da execução do programa acima.
x = 43 z = 0x2f w = 0xc k = Const string
13 / 183

Literais e Tipos Primitivos em JAVA
1 public class literais {
3 final int x = 043; // constante octal
4 final int z = 0x2f; // constante hexadecimal
5 final int w = 12; // constante decimal
6 final String k = "Const string "; // constante string
7 System.out.printf("x = %o z = %#x w = %d k = %s%n", x, z, w,
k);
8 }
9 }
printf está disponível em java a partir da versão 5
14 / 183

Literais e Tipos Primitivos em Python
1 # Constantes
2 x = 0o43 # constante octal
3 z = 0x2f # constante hexadecimal
4 w = 12 # constante decimal
5 k = "Const string" # constante string
6 # Imprimindo as variáveis for matadas
7 print(f"x = {x:o} z = {z:#x} w = {w} k = {k}")
15 / 183

Matrizes/Listas/Arrays
• Arrays são estruturas que armazenam múltiplos elementos do mesmo tipo.
• C++, Java e Python oferecem suporte a arrays, mas com diferenças significativas
em criação e manipulação.
16 / 183

Arrays em C++
• Em C++, arrays podem ser declarados com tamanho fixo e armazenam elementos
de tipo específico.
• Há suporte para arrays nativos e para a classe ‘std::vector‘ da STL, que permite
arrays dinâmicos.
17 / 183

Exemplo de Array Estático em C++
3 int main () {
4 int arr [5] = {1, 2, 3, 4, 5};
5 cout << "Primeiro elemento: " << arr [0] << endl;
6 return 0;
7 }
18 / 183

Exemplo de Array Dinâmico em C++
2 #include <vector >
4 int main () {
5 vector <int > arr = {1, 2, 3, 4, 5};
6 cout << "Primeiro elemento: " << arr [0] << endl;
7 return 0;
8 }
19 / 183

Arrays em Java
• Em Java, arrays são objetos com tamanho fixo, definidos pelo tipo e pelo número
de elementos.
• Arrays são indexados a partir de zero e possuem uma propriedade length que
armazena o tamanho.
20 / 183

Exemplos em JAVA
1 public class ExemploArray {
3 int[] arr = {1, 2, 3, 4, 5};
4 System.out.println("Primeiro elemento: " + arr [0]);
5 }
6 }
21 / 183

Inicialização Posterior
1 int[] arr = new int [5]; // Array com tamanho fixo
2 arr [0] = 1;
22 / 183

Arrays em Python
• Python não possui uma estrutura de array nativa fixa; geralmente, listas são
usadas como substitutos de arrays.
• Listas são dinâmicas, podendo armazenar elementos de diferentes tipos, e são
indexadas a partir de zero.
• Python também oferece a biblioteca array para arrays de tipos específicos, e
numpy para arrays multidimensionais.
23 / 183

Exemplos em Python
1 arr = [1, 2, 3, 4, 5]
2 print("Primeiro elemento:", arr [0])
Exemplo com array:
1 import array as arr
2 arr = arr.array(’i’, [1, 2, 3, 4, 5])
3 print("Primeiro elemento:", arr [0])
24 / 183

Strings
• Strings são estruturas essenciais para manipulação de texto nas linguagens de
programação.
• C++, Java e Python fornecem suporte para strings, mas com diferentes APIs e
características.
25 / 183

Strings em C++
• Em C++, há duas principais maneiras de representar strings: char[] (array de
caracteres) e a classe std::string da biblioteca padrão.
• A classe std::string oferece uma interface mais moderna e funcional para
manipulação de texto.
26 / 183

Exemplos em C++
2 #include <string >
4 int main () {
5 string texto = "Olá, C++!";
6 cout << "Texto: " << texto << endl;
7 cout << "Tamanho: " << texto.size () << endl;
8 // usando arrays de char
9 char texto [] = "Olá, C++!";
10 cout << "Texto: " << texto << endl;
11 return 0;
12 }
27 / 183

Strings em Java
• Em Java, strings são objetos imutáveis da classe String.
• A classe String possui métodos para manipulação e processamento de texto.
28 / 183

Exemplos
1 public class ExemploString {
3 String texto = "Olá, Java!";
4 System.out.println("Texto: " + texto);
5 System.out.println("Tamanho: " + texto.length ());
6 }
7 }
Java possui uma biblioteca chamada StringBuilder para processamento de strings
29 / 183

Strings em Python
• Em Python, strings são objetos imutáveis e podem ser definidas usando aspas
simples ou duplas.
• Python oferece muitos métodos embutidos para manipulação de strings.
30 / 183

Exemplo
1 texto = "Olá, Python!"
2 print("Texto:", texto)
3 print("Tamanho:", len(texto))
4 // uso de f-strings
5 nome = "Python"
6 print(f"Olá, {nome }!")
31 / 183

Operadores Aritméticos Básicos
• Adição (+): Soma dois valores ou variáveis.
• Subtração (-): Subtrai o segundo valor do primeiro.
• Multiplicação (*): Multiplica dois valores ou variáveis.
• Divisão (/): Divide o primeiro valor pelo segundo. Em divisões entre inteiros, o
resultado é arredondado para baixo.
32 / 183

Operadores Específicos
• Incremento (++): Aumenta o valor de uma variável em 1. Pode ser usado em
duas formas:
• ++var: Incremento prefixado, onde a variável é incrementada antes de ser
usada na expressão.
• var++: Incremento postfixado, onde a variável é usada na expressão antes de
ser incrementada.
• Decremento (--): Diminui o valor de uma variável em 1, com formas prefixada e
postfixada.
33 / 183

Algumas Diferenças Em relação às Linguagens
Operador C++ Java Python
Divisão Inteira / (inteiros) / (inteiros) //
Divisão com Ponto
Flutuante
/ (um operando
float/double)
/ (um operando
float)
/ (sempre retorna
float)
Exponenciação pow(x, y) Math.pow(x, y) **
Incremento ++ ++ +=1
Decremento – – +=1
Tabela: Diferenças entre operadores aritméticos em C++, Java e Python
34 / 183

Definição de Variáveis em C++
Em C++, o tipo de dado precisa ser especificado explicitamente, e as variáveis podem
ser inicializadas ao mesmo tempo em que são declaradas.
• C++ é uma linguagem de tipagem estática, o que significa que o tipo da variável
deve ser declarado e não pode mudar.
• Exemplo de declaração e inicialização de variáveis em C++:
1 int idade = 25;
2 double salario = 5500.75;
3 char inicial = ’J’;
4 std:: string nome = "João";
35 / 183

Definição de Variáveis em Java
Em Java, assim como em C++, o tipo de dado deve ser especificado, e a linguagem
também é de tipagem estática.
• As variáveis precisam ser declaradas com um tipo e inicializadas antes do uso.
• Exemplo de declaração e inicialização de variáveis em Java:
1 int idade = 25;
2 double salario = 5500.75;
3 char inicial = ’J’;
4 String nome = "João";
36 / 183

Definição de Variáveis em Python
Em Python, a definição de variáveis é dinâmica e não exige a declaração explícita de
tipo.
• Python é uma linguagem de tipagem dinâmica e inferida, então o tipo da variável
é determinado pelo valor atribuído.
• Exemplo de declaração e inicialização de variáveis em Python:
1 idade = 25
2 salario = 5500.75
3 inicial = ’J’
4 nome = "João"
37 / 183

Comparação entre as Linguagens
• C++ e Java: Ambos exigem que o tipo de dado seja explicitamente declarado e
são linguagens de tipagem estática.
• Python: Não exige declaração de tipo e utiliza tipagem dinâmica, o que permite
maior flexibilidade.
• As variáveis em C++ e Java têm tipos fixos após a declaração, enquanto em
Python o tipo pode mudar com a atribuição de novos valores.1
1
Na verdade o que ocorre é que o nome da variável pode ser reutilizado
38 / 183

Conversão de Tipos
A conversão de tipos é o processo de transformar o tipo de um valor em outro tipo, o
que pode ser necessário para realizar operações matemáticas, manipulação de dados e
compatibilidade de tipos. Existem dois tipos principais de conversão:
• Conversão implícita: Feita automaticamente pela linguagem quando não há
perda de dados.
• Conversão explícita: Necessária quando há risco de perda de dados ou para
transformar tipos incompatíveis.
39 / 183

Conversão de Tipos em C++
Em C++, a conversão de tipos pode ser implícita ou explícita. A conversão explícita é
feita principalmente usando casting.
• Conversão implícita: C++ converte automaticamente tipos menores para tipos
maiores em expressões. Exemplo: int para float.
• Conversão explícita: Feita através de castings tradicionais ou específicos de
C++.
1 int a = 10;
2 double b = a; // Conversão implícita de int para double
3
4 double c = 9.7;
5 int d = (int)c; // Conversão explícita usando C-style casting
6 int e = static_cast <int >(c); // Conversão explícita com C++ casting
40 / 183

Conversão de Tipos em Java
Em Java, a conversão de tipos segue regras semelhantes, mas utiliza um sistema de
casting específico.
• Conversão implícita: Java faz conversões automáticas de tipos menores para
tipos maiores. Exemplo: int para double.
• Conversão explícita: Feita usando o operador de cast (tipo) antes do valor.
1 int a = 10;
2 double b = a; // Conversão implícita de int para double
3
4 double c = 9.7;
5 int d = (int)c; // Conversão explícita de double para int
41 / 183

Conversão de Tipos em Python
Em Python, a conversão de tipos é realizada principalmente de forma explícita, já que
a linguagem é de tipagem dinâmica e não realiza conversão implícita em expressões.
• Conversão implícita: Python realiza conversão automática em poucas situações,
como em operações aritméticas com números inteiros e de ponto flutuante.
• Conversão explícita: Feita com funções de conversão, como int(), float(), e
str().
1 a = 10
2 b = float(a) # Conversão explícita de int para float
3
4 c = 9.7
5 d = int(c) # Conversão explícita de float para int
6 e = str(a) # Conversão explícita de int para string
42 / 183

Resumo das Conversões de Tipos
• C++: Conversão implícita de tipos menores para tipos maiores; para outros
tipos, utiliza castings tradicionais ou static_cast.
• Java: Conversão implícita entre tipos numéricos compatíveis e casting explícito
para tipos incompatíveis.
• Python: Conversão explícita é mais comum, usando funções como int(),
float(), str().
43 / 183

Escopo das variáveis
O escopo de variáveis define a parte do código em que uma variável está acessível.
• Diferentes linguagens de programação possuem regras específicas para o escopo
de variáveis.
• Tipos comuns de escopo incluem:
• Escopo Local: Dentro de funções ou blocos específicos.
• Escopo Global: Disponível em todo o código, fora de qualquer função ou
classe.
• Escopo de Classe: Definido em classes, acessível apenas pelos métodos da
classe.
44 / 183

Escopo de Variáveis em C++
Em C++, o escopo é bem definido com base nos blocos de código, funções e classes.
• Escopo Global: Variáveis definidas fora de qualquer função, acessíveis em todo o
código.
• Escopo Local: Variáveis definidas dentro de funções ou blocos ‘‘, acessíveis
apenas dentro desses blocos.
• Escopo de Classe: Variáveis definidas em classes (também chamadas de
membros), acessíveis apenas pelos métodos da classe.
1 int globalVar = 10; // Escopo Global
2
3 void funcao () {
4 int localVar = 5; // Escopo Local
5 if (true) {
6 int blocoVar = 7; // Escopo do Bloco
7 }
8 }
45 / 183

Escopo de Variáveis em Java
Em Java, o escopo segue um modelo similar ao C++, mas com o conceito adicional de
escopo de classe para variáveis de instância e estáticas.
• Escopo de Classe (Instância): Variáveis definidas em uma classe, acessíveis por
instâncias da classe.
• Escopo de Classe (Estático): Variáveis ‘static‘ acessíveis sem instanciar a classe.
• Escopo Local e de Bloco: Variáveis definidas em métodos ou blocos ‘{ }‘,
acessíveis apenas dentro desses blocos.
46 / 183

Exemplo de Escopo em Java
1 public class Exemplo {
2 static int varEstatica = 10; // Escopo de Classe Estático
3 int varInstancia = 5; // Escopo de Classe (instância)
4
5 void metodo () {
6 int varLocal = 7; // Escopo Local
7 }
8 }
47 / 183

Escopo de Variáveis em Python
Em Python, o escopo é gerido principalmente pelos conceitos de escopo local, global e
de função.
• Escopo Local: Variáveis definidas dentro de funções, acessíveis apenas dentro
dessas funções.
• Escopo Global: Variáveis definidas fora de funções, acessíveis em todo o código.
Para alterar variáveis globais dentro de uma função, usa-se a palavra-chave
‘global‘.
• Escopo de Função e Classe: Variáveis definidas em classes (atributos) e funções
seguem o escopo da instância ou função.
48 / 183

Exemplo de uso de escopo em Python
1 global_var = 10 # Escopo Global
2 def funcao ():
3 local_var = 5 # Escopo Local
4 global global_var
5 global_var = 15 # Modificando escopo global
49 / 183

Resumo do Escopo em C++, Java e Python
• C++: Escopo local, global e de classe. Blocos ‘{}‘ também definem escopos.
• Java: Escopo local, global (no contexto de classe) e de classe (variáveis de
instância e ‘static‘).
• Python: Escopo global, local e de função. Usa a palavra-chave ‘global‘ para
manipular variáveis globais dentro de funções.
50 / 183

Classes de Armazenamento
As classes de armazenamento (storage classes) são uma forma de especificar as
características de armazenamento e o tempo de vida de variáveis em linguagens de
programação. Cada linguagem lida com o conceito de armazenamento de forma
distinta:
• Em C++, as classes de armazenamento determinam o tempo de vida e a
visibilidade das variáveis.
• Em Java, as classes de armazenamento não são explicitamente definidas, mas as
palavras-chave como static e final influenciam o comportamento de
armazenamento.
• Em Python, o conceito de classes de armazenamento é simplificado, com o
gerenciamento automático de memória.
51 / 183

Classes de Armazenamento em C++
Em C++, as classes de armazenamento definem o escopo, tempo de vida e visibilidade
de variáveis. As principais classes de armazenamento em C++ são:
• auto: Define variáveis locais com tempo de vida limitado ao bloco onde foram
declaradas. Hoje em dia, o auto é mais usado para inferir automaticamente o
tipo de variáveis.
• register: Sugerido para variáveis de acesso rápido, armazenadas em registradores
da CPU (pode ser ignorado pelo compilador).
• static: Faz com que a variável mantenha seu valor entre chamadas de função, ou
seja, tem um tempo de vida persistente dentro de seu escopo.
• extern: Declara uma variável que é definida em outro arquivo ou escopo. Usada
para compartilhar variáveis globais entre arquivos.
• mutable: Usada em classes, permite que variáveis sejam modificadas mesmo em
métodos const.
52 / 183

Exemplo de Uso de Classes de Armazenamento em C++
2 void exemplo () {
3 static int contador = 0; // ’static ’ mantém o valor entre chamadas
4 contador ++;
5 std:: cout << contador << std:: endl;
6 }
53 / 183

Classes de Armazenamento em JAVA
Em Java, não há classes de armazenamento no sentido tradicional, mas algumas
palavras-chave desempenham funções similares:
• static: Variáveis static pertencem à classe e não às instâncias, ou seja, são
compartilhadas entre todos os objetos daquela classe.
• final: Define variáveis constantes que não podem ser modificadas após a
inicialização. Usado principalmente para valores imutáveis.
• transient: Utilizado em variáveis de instância, impede que uma variável seja
serializada.
• volatile: Indica que uma variável pode ser modificada por múltiplas threads,
garantindo que as threads leiam sempre o valor atualizado.
54 / 183

Exemplos de Classes de Armazenament em JAVA
2 static int contador = 0; // variável compartilhada por todas as
instâncias
3 final int constante = 10; // variável constante
4
6 contador ++;
7 System.out.println(contador);
8 }
9 }
55 / 183

Clases de Armazenamento em Python
Em Python, o gerenciamento de memória e o escopo das variáveis são automáticos, e
o conceito de classes de armazenamento é simplificado. Ainda assim, algumas
palavras-chave e práticas controlam o comportamento de variáveis:
• global: Declara uma variável global dentro de uma função, permitindo que seja
acessada e modificada fora do escopo local.
• nonlocal: Usada para modificar variáveis que estão em um escopo intermediário
(por exemplo, dentro de funções aninhadas).
56 / 183

Exemplos de Classes de Armazenamento em Python
Python utiliza o coletor de lixo (garbage collector) para gerenciar o tempo de vida das
variáveis automaticamente, liberando memória quando uma variável não é mais
referenciada.
1 contador = 0 # Variável global
2 def exemplo ():
3 global contador
4 contador += 1
5 print(contador)
6 contador_externo = 10 # Variável no escopo externo
7 def interno ():
8 nonlocal contador_externo
9 contador_externo += 5 # Modifica a variável do escopo externo
10 print("Valor interno:", contador_externo )
11 interno ()
12 print("Valor externo:", contador_externo )
57 / 183

Resumo das Classes de Armazenamento
• C++: Oferece classes de armazenamento explícitas, como auto, static,
register, extern, e mutable.
• Java: Utiliza modificadores como static, final, transient e volatile para
controlar o comportamento das variáveis.
• Python: Gerencia automaticamente o tempo de vida das variáveis, com global e
nonlocal para controle de escopo.
58 / 183

Desvios Condicionais - IFs
• O controle de fluxo condicional é uma parte essencial de qualquer linguagem de
programação.
• As estruturas if, else if e else permitem que o programa tome decisões
baseadas em condições.
• Vamos explorar a sintaxe e funcionamento dos desvios condicionais em C++,
Java e Python.
59 / 183

Desvios Condicionais em C++
• if: testa uma condição.
• else if: permite testar condições adicionais.
• else: executa caso nenhuma condição anterior seja atendida.
60 / 183

Exemplo em C++
3
4 int main () {
5 int x = 10;
6
7 if (x > 15) {
8 cout << "x é maior que 15" << endl;
9 } else if (x == 10) {
10 cout << "x é igual a 10" << endl;
11 } else {
12 cout << "x é menor que 15" << endl;
13 }
14 return 0;
15 }
61 / 183

Desvios Condicionais em Java
• Estrutura similar à de C++: if, else if e else.
• Cada bloco condicional é delimitado por chaves { }.
62 / 183

Exemplos em JAVA
3 int x = 10;
4
5 if (x > 15) {
6 System.out.println("x é maior que 15");
7 } else if (x == 10) {
8 System.out.println("x é igual a 10");
9 } else {
10 System.out.println("x é menor que 15");
11 }
12 }
13 }
63 / 183

Desvios Condicionais em Python
• elif: usado em vez de else if.
• Indentação é obrigatória para definir blocos.
• Dispensa o uso de chaves.
64 / 183

Exemplos em Python
1 x = 10
2 if x > 15:
3 print("x é maior que 15")
4 elif x == 10:
5 print("x é igual a 10")
6 else:
7 print("x é menor que 15")
65 / 183

Resumo das Diferenças
• C++: Utiliza if, else if e else com blocos entre chaves.
• Java: Similar a C++, com if, else if e else.
• Python: Usa if, elif e else, com indentação para blocos.
66 / 183

Switch
• O switch é uma estrutura de controle que permite comparar o valor de uma
variável com múltiplos casos.
• C++ e Java possuem uma estrutura switch-case nativa, que evita múltiplas
comparações if-else.
• Python possui o comando match a partir da versão 3.10.
67 / 183

Uso do Swicth em C++
• O switch compara uma expressão com diferentes case e executa o código do
caso correspondente.
• O comando break encerra o switch após a execução de um caso.
• default é executado se nenhum caso for correspondido.
68 / 183

Exemplos C++
3 int main () {
4 int opcao = 2;
5 switch (opcao) {
6 case 1:
7 cout << "Opção 1 selecionada." << endl;
8 break;
9 case 2:
10 cout << "Opção 2 selecionada." << endl;
11 break;
12 def ault:
13 cout << "Opção inválida." << endl;
14 }
15 return 0;
16 }
69 / 183

Uso do Switch em Java
• A estrutura switch-case em Java é semelhante à de C++, permitindo múltiplos
casos e o uso de break.
• A partir do Java 14, o switch pode retornar valores e usar expressões case.
70 / 183

Exemplo JAVA
3 int opcao = 2;
4 switch (opcao) {
5 case 1:
6 System.out.println("Opção 1 selecionada.");
7 break;
8 case 2:
9 System.out.println("Opção 2 selecionada.");
10 break;
11 def ault:
12 System.out.println("Opção inválida.");
13 }
14 }
15 }
71 / 183

Uso do match-case em Python (3.10+)
• No Python 3.10, foi introduzida a estrutura match-case, uma alternativa ao
switch.
• O match permite comparar uma variável com múltiplos casos, semelhante ao
switch-case.
72 / 183

Exemplos em Python
1 opcao = 2
2 match opcao:
3 case 1:
4 print("Opção 1 selecionada.")
5 case 2:
7 case 3:
9 case _:
10 print("Opção inválida.")
73 / 183

• C++ e Java: Possuem estrutura switch-case nativa, com break para sair dos
casos.
• Python (3.10+): Adota match-case, que oferece funcionalidade similar ao
switch-case sem a necessidade de break.
74 / 183

Laços - While
• O laço while permite repetir um bloco de código enquanto uma condição for
verdadeira.
• É utilizado quando o número de iterações não é conhecido previamente.
• Vamos ver como implementar o while em C++, Java e Python.
75 / 183

Uso do while em C++
• O laço while em C++ é estruturado com uma condição de entrada.
• O código dentro do laço é executado repetidamente enquanto a condição for
verdadeira.
• Geralmente utilizado com uma variável de controle que é atualizada dentro do
laço.
76 / 183

Exemplo em C++
3 int main () {
4 int count = 1;
5 while (count <= 5) {
6 cout << "Contagem: " << count << endl;
7 count ++; // Atualiza a variável de controle
8 }
9 return 0;
10 }
77 / 183

Uso do while em Java
• O while em Java é semelhante ao C++.
• Avalia uma condição booleana antes de cada iteração.
• Utilizado para laços onde o número de repetições depende de uma condição que
pode mudar durante a execução.
78 / 183

Exemplo em JAVA
1 public class ExemploWhile {
3 int count = 1;
4
5 while (count <= 5) {
6 System.out.println("Contagem: " + count);
8 }
9 }
10 }
79 / 183

Uso do while em Python
• Em Python, o while também depende de uma condição de entrada.
• O bloco do laço é delimitado pela indentação, seguindo a sintaxe da linguagem.
• Atualização da variável de controle dentro do laço é necessária para evitar loops
infinitos.
80 / 183

Exemplo em Python
1 count = 1
2
3 while count <= 5:
4 print("Contagem:", count)
5 count += 1 # Atualiza a variável de controle
81 / 183

• C++ e Java: Sintaxe similar, usando chaves { } para delimitar o bloco do
while.
• Python: Usa indentação para delimitar o bloco, dispensando chaves.
• Em todas as linguagens, a variável de controle deve ser atualizada para evitar
loops infinitos.
82 / 183

Laço do ... while
• O laço do-while executa o bloco de código pelo menos uma vez antes de
verificar a condição.
• É útil quando queremos garantir que o código execute ao menos uma vez,
independentemente da condição.
• Disponível em C++ e Java, mas Python não possui uma estrutura do-while
nativa.
83 / 183

Uso do do-while em C++
• O do-while executa o bloco de código primeiro e verifica a condição após a
execução.
• Se a condição for verdadeira, o laço continua executando.
84 / 183

Exemplos em C++
3
4 int main () {
5 int count = 1;
6
7 do {
8 cout << "Contagem: " << count << endl;
10 } while (count <= 5);
11
12 return 0;
13 }
85 / 183

Uso do do-while em Java
• A estrutura do-while em Java é semelhante à de C++.
• O bloco de código é executado ao menos uma vez antes da verificação da
condição.
86 / 183

Exemplo em Java
1 public class ExemploDoWhile {
3 int count = 1;
4
5 do {
6 System.out.println("Contagem: " + count);
8 } while (count <= 5);
9 }
10 }
87 / 183

Alternativa ao do-while em Python
• Python não possui um laço do-while nativo.
• Podemos simular o do-while usando um while True e break para sair do laço.
88 / 183

Laço FOR
• O laço for é amplamente utilizado para iteração em coleções e sequências.
• Em C++, Java e Python, o laço for tem sintaxes e usos diferentes, adaptados ao
estilo de cada linguagem.
• Vamos explorar as características e exemplos do for em cada uma dessas
linguagens.
89 / 183

Uso do for em C++
• Em C++, o laço for possui uma estrutura tradicional com inicialização, condição
e incremento.
• Também suporta o laço de tipo for-each (disponível a partir do C++11) para
iterar sobre coleções.
90 / 183

Exemplo
2 #include <vector >
4 int main () {
5 // Laço tradicional
6 for (int i = 0; i < 5; i++) {
7 cout << "Contagem: " << i << endl;
8 }
9
10 // Laço for-each em um vetor
11 vector <int > numeros = {1, 2, 3, 4, 5};
12 for (int num : numeros) {
13 cout << "Número: " << num << endl;
14 }
15 return 0;
16 }
91 / 183

Uso do for em Java
• Em Java, o laço for é semelhante ao de C++, com inicialização, condição e
incremento.
• Java também oferece um laço for-each para iteração em coleções e arrays.
92 / 183

Exemplo
1 public class ExemploFor {
3 // Laço tradicional
4 for (int i = 0; i < 5; i++) {
5 System.out.println("Contagem: " + i);
6 }
7
8 // Laço for-each em um array
9 int[] numeros = {1, 2, 3, 4, 5};
10 for (int num : numeros) {
11 System.out.println("Número: " + num);
12 }
13 }
14 }
93 / 183

Uso do for em Python
• Em Python, o laço for é usado para iterar diretamente sobre listas, strings e
outros iteráveis.
• Python não possui o laço tradicional com inicialização, condição e incremento; ele
é baseado em coleções.
94 / 183

Exemplo
1 # Laço for em uma sequência com range
2 for i in range (5):
3 print("Contagem:", i)
4
5 # Laço for-each em uma lista
6 numeros = [1, 2, 3, 4, 5]
7 for num in numeros:
8 print("Número:", num)
95 / 183

• C++ e Java: Suportam o laço for tradicional e o laço for-each (C++ a partir
do C++11).
• Python: Usa um for simplificado, baseado em coleções, sem suporte para a
estrutura tradicional com inicialização, condição e incremento.
• Todos os três permitem a iteração em listas, arrays e outras coleções.
96 / 183

Break e Continue
• A palavra break interrompe o laço não executando os comandos deste que
estiverem abaixo da mesma
• A palavra continue faz o processador saltar os comandos e retornar a expressão
que controla o laço.
• São usadas nestas três linguagens.
97 / 183

Exemplo em C++
3 int main () {
4 for (int i = 1; i <= 10; i++) {
5 if (i == 5) {
6 break; // Interrompe o laço quando i == 5
7 }
8 if (i % 2 == 0) {
9 continue; // Pula a iteração quando i é par
10 }
11 cout << i << " ";
12 }
13 return 0;
14 }
98 / 183

Exemplo em JAVA
3 for (int i = 1; i <= 10; i++) {
4 if (i == 5) {
5 break; // Interrompe o laço quando i == 5
6 }
7 if (i % 2 == 0) {
8 continue; // Pula a iteração quando i é par
9 }
10 System.out.print(i + " ");
11 }
12 }
13 }
99 / 183

Exemplo em Python
1 for i in range (1, 11):
2 if i == 5:
3 break # Interrompe o laço quando i == 5
4 if i % 2 == 0:
5 continue # Pula a iteração quando i é par
6 print(i, end=" ")
100 / 183

• Em todas as três linguagens, break e continue controlam o fluxo de laços de
maneira semelhante.
• Java: Possui break com rótulos para sair de laços aninhados, o que não está
presente em C++ e Python.
• Python: Sintaxe é simplificada e usa indentação em vez de chaves.
101 / 183

Protótipos de Funções
...
• Em programação, um protótipo de função declara a assinatura de uma função
antes de sua implementação completa.
• Ele especifica o nome da função, seus parâmetros e o tipo de retorno.
• O uso de protótipos varia entre as linguagens C++, Java e Python.
102 / 183

Protótipos de Função em C++
• Em C++, o protótipo é declarado antes da função principal (main).
• Um protótipo é necessário para informar ao compilador a existência da função e os
tipos de seus parâmetros.
103 / 183

Exemplo
2 int soma(int a, int b); // Protótipo de função
3 int main () {
4 int resultado = soma (5, 10);
5 std:: cout << "Resultado: " << resultado;
6 return 0;
7 }
8 int soma(int a, int b) { // Implementação
9 return a + b;
10 }
104 / 183

Usando Recursos C++ - Exemplo
1 // Exemplo de Programa em C++
4 // Função para calcular multa
5 double multa ();
6 // Estrutura de dados para pagamento
7 struct Pagamento {
8 std:: string nome;
9 double valor;
10 };
11 // Variáveis globais
12 int dia = 10; // dia do pagamento
13 const double taxa_dia = 1.01;
105 / 183

Usando Recursos C++ - Exemplo - Continuação
14 int main () {
15 Pagamento cliente;
16 double taxa;
17 // Leitura dos dados do cliente
18 std:: cout << "Nome do Cliente : ";
19 std:: getline(std::cin, cliente.nome);
20 std:: cout << "Valor da Prestacao : ";
21 std::cin >> cliente.valor;
22 taxa = multa (); // Calcula taxa
23 cliente.valor *= taxa; // calcula multa
24 // Exibe o resultado
25 std:: cout << "nntNome do Cliente : " << cliente.nome;
26 std:: cout << "nntValor a Ser Pago : Cr$ " << cliente.valor <<
"nn";
27 return 0;
28 }
106 / 183

Usando Recursos C++ - Exemplo - Continuação
29 // Função para calcular a taxa de multa com base na diferença de dias
30 double multa () {
31 int dia_atual; // dia de hoje
32 double taxa = 1;
33 std:: cout << "nDia de Hoje : ";
34 std::cin >> dia_atual;
35 for (int i = 0; i < dia_atual - ::dia; i++) { // Uso de
resolução de escopo
36 taxa *= taxa_dia;
37 }
38 return taxa;
39 }
107 / 183

Versão Java
1 // progrmama em java
2 import java.util.Scanner;
3 class Pagamento {
4 String nome;
5 double valor;
6 }
7 public class melhoras{
8 static int dia = 10; // dia do pagamento
9 static final double taxaDia = 1.01;
11 Scanner scanner = new Scanner(System.in);
12 Pagamento cliente = new Pagamento ();
13 // Leitura dos dados do cliente
14 System.out.print("Nome do Cliente : ");
15 cliente.nome = scanner.nextLine ();
16 System.out.print("Valor da Prestacao : ");
108 / 183

Versão Java - Continuação
17 cliente.valor = scanner.nextDouble ();
18 // Calcula a taxa de multa
19 double taxa = multa(scanner);
20 cliente.valor *= taxa;
21 // Exibe o resultado
22 System.out.printf("nntNome do Cliente : %s",
cliente.nome);
23 System.out.printf("nntValor a Ser Pago : Cr$ %.2fnn",
cliente.valor);
24 }
25 // Função para calcular a taxa de multa com base na diferença de
dias
26 public static double multa(Scanner scanner) {
27 System.out.print("nDia de Hoje : ");
28 int diaAtual = scanner.nextInt ();
29 double taxa = 1;
109 / 183

Versão Java - Continuação
30 for (int i = 0; i < diaAtual - dia; i++) {
31 taxa *= taxaDia;
32 }
33 return taxa;
34 }
35 }
110 / 183

Versão Python
1 # versão python
2 class Pagamento:
3 pass
4 def multa(dia_atual):
5 dia = 10 # dia do pagamento
6 taxa_dia = 1.01
7 taxa = 1.0
8 for _ in range(dia_atual - dia):
9 taxa *= taxa_dia
10 return taxa
11 # Leitura dos dados do cliente
12 cliente = Pagamento ()
13 cliente.nome = input("Nome do Cliente : ")
14 cliente.valor = float(input("Valor da Prestacao : "))
15 dia_atual = int(input("Dia de Hoje : "))
16 cliente.valor *= multa(dia_atual)
111 / 183

Versão Python - Continuação
17 print(f"nNome do Cliente : {cliente.nome}")
18 print(f"nValor a Ser Pago : Cr$ {cliente.valor:.2f}")
112 / 183

Parâmetros Padrão (default)
• Em muitas linguagens de programação, os parâmetros padrão permitem atribuir
valores padrão aos argumentos de uma função.
• Caso o argumento não seja passado na chamada da função, o valor padrão é
utilizado.
• C++, Java e Python lidam com parâmetros padrão de maneiras distintas.
113 / 183

Parâmetros Padrão em C++
• Em C++, parâmetros padrão podem ser definidos diretamente na declaração da
função.
• Valores padrão são atribuídos no protótipo da função e não precisam ser
especificados na definição.
114 / 183

Exemplo em C++
2 void saudacao(std:: string nome = "Visitante") {
3 std:: cout << "Olá, " << nome << "!" << std:: endl;
4 }
5 int main () {
6 saudacao (); // Usa o valor padrão "Visitante"
7 saudacao("Alice"); // Usa o valor "Alice"
8 return 0;
9 }
115 / 183

Parâmetros Padrão em Java
• Java não suporta parâmetros padrão diretamente.
• Em vez disso, sobrecarga de métodos é usada para definir versões alternativas de
uma função com diferentes números de argumentos.
• Cada versão sobrecarregada do método fornece um conjunto alternativo de
parâmetros.
116 / 183

Parâmetros Padrão em Python
• Em Python, parâmetros padrão são definidos diretamente na função, e valores
padrão podem ser especificados facilmente.
• Caso o argumento não seja passado, o valor padrão especificado será utilizado.
117 / 183

Exemplo em Python
1 def saudacao(nome="Visitante"):
2 print(f"Olá, {nome }!")
3 # Chamadas da função
4 saudacao () # Usa o valor padrão "Visitante"
5 saudacao("Alice") # Usa o valor "Alice"
118 / 183

Funções Inlines e Anônimas
• Funções *inline* são funções que o compilador tenta expandir diretamente no
local onde são chamadas, em vez de realizar uma chamada tradicional.
• Elas são usadas para otimizar o desempenho ao evitar a sobrecarga de chamadas
de função, especialmente em funções pequenas.
• O suporte e o comportamento das funções *inline* variam entre as linguagens
C++, Java e Python.
119 / 183

Funções Inline em C++
• Em C++, as funções *inline* são declaradas com a palavra-chave inline.
• O compilador tenta substituir a chamada da função pelo código da função,
embora isso seja uma sugestão e não uma garantia.
• As funções *inline* são ideais para funções curtas, como getters e setters.
120 / 183

Exemplo em C++
2 inline int quadrado(int x) {
3 return x * x;
4 }
5 int main () {
6 std:: cout << "Quadrado de 5: " << quadrado (5) << std:: endl;
7 return 0;
8 }
121 / 183

Funções Inline em Java
• Em Java, não existe a palavra-chave inline.
• O compilador Java e a Máquina Virtual Java (JVM) realizam a otimização
*inline* automaticamente, conforme necessário.
• O método final pode ser utilizado para sugerir que a função é pequena e final,
podendo ser expandida inline, mas essa decisão é interna ao compilador.
122 / 183

Funções Inline em Python
• Python não possui uma funcionalidade específica para funções *inline*.
• Funções curtas podem ser definidas como expressões lambda, que podem ser
usadas de forma compacta em expressões.
• Não há otimização *inline* no sentido de compilação em Python, devido ao seu
comportamento interpretado.
123 / 183

Exemplo de Funções Lambda em Python
1 # Função lambda para def inir uma função inline
2 quadrado = lambda x: x * x
3 print("Quadrado de 5:", quadrado (5))
124 / 183

Estruturas (*Structs*)
• Estruturas (*structs*) são tipos de dados que permitem agrupar variáveis de
diferentes tipos em uma única unidade.
• Em C++, as *structs* são amplamente usadas para agrupar dados.
• Em Java e Python, as *structs* não existem da mesma forma, mas podem ser
simuladas por meio de classes ou outras estruturas.
125 / 183

Structs em C++
• Em C++, uma *struct* é uma forma de agrupar variáveis sob uma mesma
estrutura.
• Por padrão, os membros de uma *struct* são públicos.
• As *structs* em C++ podem ter métodos, semelhante às classes.
Exemplo em C++:
126 / 183

Exemplo de Uso de Structs
2 struct Pessoa {
3 std:: string nome;
4 int idade;
5 };
6 int main () {
7 Pessoa p = {"Alice", 30};
8 std:: cout << p.nome << " tem " << p.idade << " anos." <<
std:: endl;
9 return 0;
10 }
127 / 183

Estruturas Similares em Java
• Java não possui *structs*. No entanto, classes podem ser usadas para criar
estruturas semelhantes.
• Em Java, todos os campos e métodos de uma classe devem ter especificadores de
acesso (por exemplo, public ou private).
128 / 183

Exemplo Java
1 public class Pessoa{
2 public String nome;
3 public int idade;
5 Pessoa p = new Pessoa ();
6 p.nome = "Alice";
7 p.idade = 30;
8 System.out.println("" + p.nome + " tem " + p.idade + "
anos.");
9 }
10 }
129 / 183

Estruturas Similares em Python
• Python não possui *structs*, mas classes e dataclasses (Python 3.7+) podem
ser usadas para simular estruturas de dados.
• As dataclasses permitem a definição de classes com menos código e incluem
recursos adicionais como comparação e ordenação.
130 / 183

Exemplo Python
1 from data class es import data class
2 @data class
3 class Pessoa:
4 nome: str
5 idade: int
6 # Uso da data class
7 p = Pessoa(nome="Alice", idade =30)
8 print(p.nome," tem ", p.idade," anos")
131 / 183

Ponteiros
• Ponteiros são variáveis que armazenam o endereço de memória de outras variáveis.
• Eles são usados para manipulação direta da memória, permitindo operações de
baixo nível e maior controle sobre o uso de recursos.
• O uso de ponteiros é diferente nas linguagens C++, Java e Python devido às suas
diferentes arquiteturas e modelos de gerenciamento de memória.
132 / 183

Ponteiros em C++
• Em C++, ponteiros são amplamente utilizados para manipulação direta de
memória.
• São definidos com o operador *, e seu endereço é obtido com o operador &.
• Os ponteiros em C++ são fundamentais para alocação dinâmica de memória,
gerenciamento de recursos e criação de estruturas de dados como listas
encadeadas.
133 / 183

Exemplo em C++
3 int main () {
4 int x = 10;
5 int* ptr = &x; // Ponteiro para x
6 cout << "Valor de x: " << x << endl;
7 cout << "Endereço de x: " << ptr << endl;
8 cout << "Valor através do ponteiro: " << *ptr << endl;
9 return 0;
10 }
134 / 183

Ponteiro void em C++
Na linguagem C o conceito de ponteiro void estava implícito no retorno da função
malloc(). Este conceito de "ponteiro sem tipo especificado a apontar"foi formalizado
em C++ na declaração void. Com ponteiros void pode-se especificar funções com
propósito geral cujo parâmetro é um ponteiro a formatar.
135 / 183

Exemplo Ponteiro Void
3 void imprime(void* ptr, char flag) {
4 switch (flag) {
5 case ’s’:
6 std:: cout << "nMensagem = " <<
*( static_cast <std:: string *>(ptr)) << std:: endl;
7 break;
8 case ’i’:
9 std:: cout << "nNúmero Inteiro = " <<
*( static_cast <int*>(ptr)) << std:: endl;
10 break;
11 case ’r’:
12 std:: cout << "nNúmero Real = " <<
*( static_cast <float*>(ptr)) << std:: endl;
13 break;
14 } 136 / 183

Exemplo Ponteiro Void - Continuação
15 }
16 int main () {
17 float real = 0.0;
18 int inteiro = 0;
19 std:: string msg = "Você não digitou uma Mensagem";
20 std:: string inbuf;
21 std:: cout << "Digite um número real: ";
22 std::cin >> real;
23 std:: cout << "Digite um número inteiro: ";
24 std::cin >> inteiro;
25 std::cin.get(); // Limpa o buffer
26 std:: cout << "Digite uma mensagem: ";
27 std:: getline(std::cin, msg); // Lê a linha inteira
28 imprime (& inteiro, ’i’);
29 imprime (& real, ’r’);
30 imprime (&msg, ’s’);
137 / 183

Exemplo Ponteiro Void - Continuação
31 std:: cout << "Pressione Enter para continuar...";
32 std::cin.get();
33 return 0;
34 }
138 / 183

Ponteiro para uma constante
O conteúdo é imutável, mas o ponteiro pode apontar para outro endereço.
const tipo * nome_ponteiro;
1 const char * string = "eu sou constante";
139 / 183

Ponteiro Constante
O conteúdo pode ser alterado mas o ponteiro é imutável.
tipo * const nome_ponteiro;
1 char * const msg = "meu ponteiro constante";
140 / 183

Ponteiro Costante para uma constante
O ponteiro e conteúdo são imutáveis: const tipo * const nome;
1 const char * const msg = "Todos constantes";
141 / 183

Exemplos
1 int i; // i é um inteiro
2 int * ptr_i; // ponteiro para int
3 int * const c_ptr = &i; // c_ptr é um ponteiro constante para int
4 const int ci=7; // ci é int constante
5 const int * p_cte; // p_cte é um ponteiro para constante int
6 const int * const gelo; // gelo é um ponteiro constante para uma
constante
142 / 183

Operações Válidas
1 i = ci; // a variável i recebe o valor ci
2 *c_ptr = ci; // coloca um valor constante int em uma variável
apontada p/ um ponteiro constante
3 p_cte = &ci; // inicializa -se o ponteiro para constante
4 ++ p_cte; // incrementa um pont. p/ const
5 p_cte=gelo; // atribui um pointer const. para const. a um ponteiro
constante.
143 / 183

Operações Ilegais
1 ci = 0; ci --; // não se pode mudar um valor constante
2 *p_cte = 9; // não se pode mudar o conteúdo de um pointer para
const
3 c_ptr = &ci; // não se pode modificar um ponteiro constante mesmo
que seja para apontar p/ uma constante.
4 gelo ++; // não se pode modificar um ponteiro constante
5 ptr_i=p_cte; // tenta -se apontar um ponteiro normal para um
constante. Como
6 // não se pode modificar o valor de *ptr_i, a
operação não é válida
144 / 183

Referências em C++
Tanto em C como C++ pode-se declarar funções com parâmetros por referência, ou
seja, funções que recebem endereços de variáveis.
C
1 void zera(int * valor){
2 *valor = 0;
3 }
4 int x;
5 zera (&x)
C++
1 void zera(int &valor){
2 valor = 0;
3 }
4 int x;
5 zera(x);
145 / 183

Restrições a Referências em C++
A exceção de argumentos de funções, todas as referências devem ser inicializadas
quando declaradas.Referências não podem ser atualizadas( apontadas para outras
variáveis).Não se pode criar uma referência de uma referência nem ponteiro de uma
referência. Referências de ponteiros, no entanto são permitidas.
146 / 183

Exemplos
1 int i = 1, j = 2;
2 int &ref = i; // declara e inicia ref.
3 ref = &j; // erro: não se atualiza
4 ref = j; // correto faz i = j
5 int & * ptr = &ref; // erro:não se cria ponteiro de referência
6 float & arrayf [3]; // erro: arrayf é um ponteiro de referência;
7 int &&ptr = ref; // erro: não se cria referência de referência
8 int * ptr; // cria um ponteiro para inteiro
9 int *& ref2 = ptr; // correto cria uma referência de um ponteiro.
147 / 183

Tipos de Referências
Pode-se criar referências: constantes, de constantes, de funções, de estruturas e de
classes. ex.
1 struct ponto{
2 int x,y;
3 };
4 Ponto Centro = {0,0}; // declara ponto
5 Ponto *ptr = &Centro; // ponteiro de ponto
6 Ponto &ref = Centro; // ref. de centro
7 ptr ->x = 10; ref.y = 10; // Acesso a membros via pont. e ref.
148 / 183

Java e Referências
• Em Java, não há suporte para ponteiros como em C++.
• Em vez disso, Java utiliza referências, que permitem o acesso a objetos, mas sem
manipulação direta de endereços de memória.
• A gestão de memória é realizada pelo Garbage Collector, que gerencia
automaticamente a alocação e liberação de memória.
149 / 183

Referências em Python
• Assim como em Java, Python não possui ponteiros, mas usa referências para
acessar objetos.
• Todos os tipos de dados em Python são tratados como objetos, e variáveis são
referências para esses objetos.
• Python também conta com um sistema de coleta de lixo (Garbage Collector) que
lida com o gerenciamento de memória automaticamente.
150 / 183

Gerenciamento de Memória
O gerenciamento dinâmico de memória refere-se a alocação e liberação de memória na
área de heap do sistema. Em C, o gerenciamento de memória é feito com as funções
malloc() e free(), nas bibliotecas stdlib.h ou alloc.h. Em C++ utilizam-se os
operadores new e delete, já incorporados à linguagem. Os operadores C++ são mais
confiáveis e mais fáceis de usar.
151 / 183

Diferenças de Gerenciamento de Memória entre C e C++
Operador NEW
C
1 double * ptr; ptr = (double *) malloc(sizeof(double));
C++
1 double * ptr; ptr = new double;
C++ dispensa a formatação do ponteiro e o tamanho do tipo a alocar. Como em
malloc(), memória insufuciente provoca retorno nulo em new.
152 / 183

Operador Delete
Este operador libera memória na área do heap não for mais necessária. O parâmetro de
delete é o ponteiro que identifica a região do heap (valorado por new).
Sintaxe:
delete ptr_tipo; delete [tam_mat] ptr_tipo;
1 // Alocação // deleção
2 int * ptr1 = new int; delete ptr1;
3 int * ptr2 = new(int); delete ptr2;
4 int *ptr2 =new int [10] delete [10] ptr3;
5 int ** ptr4 = new int [10]; delete [10] ptr4;
Utilizar delete com ponteiros não identificados na área de heap provoca erro de
execução.(Maior crítica ao uso do C e C++)
153 / 183

Gestão de Memória em Python
• Em linguagens como C e C++, a gestão de memória é manual.
• O programador é responsável por alocar e liberar memória usando funções
como malloc e free (em C) ou new e delete (em C++).
• Esse controle direto oferece flexibilidade, mas aumenta o risco de erros como
vazamentos de memória ou uso de ponteiros inválidos.
• Em Java e Python, a gestão de memória é feita automaticamente pelo Garbage
Collector (coletor de lixo).
• O compilador e o runtime monitoram automaticamente os objetos sem
referências, liberando a memória ocupada por eles.
• Esse gerenciamento automático torna o código menos propenso a erros e
mais fácil de escrever e manter, ao custo de menos controle sobre o uso da
memória.
154 / 183

Vantagens e Desvantagens
• C/C++: Oferecem controle total, ideal para sistemas que demandam alto
desempenho, mas exigem cuidado extra com a gestão de memória.
• Java e Python: Simplificam a programação, especialmente para aplicações de
alto nível, embora possam ter um desempenho ligeiramente menor devido ao
Garbage Collector.
155 / 183

E/S - Streams
Em C, o tratamento de dados requer a inclusão das bibliotecas de funções de
manipulação de entrada e saída. A linguagem C++ aceita o padrão C, mas acrescenta
a chamada biblioteca stream. O termo stream significa “fluxo de caracteres”. A
biblioteca stream é definida em termos de classes. Nela, estão os três objetos cin, cout
e cerr destinados à entrada e saída de dados via terminal ou via arquivos. A biblioteca
stream é baseada nas seguintes classes: Streambuf : contém as funções de
manipulação de buffer de dados. Istream e Ostream. Contém as funções de
manipulação de entrada e saída.
156 / 183

Exemplos de uso do cin
1 int x;
2 float f,g;
3 double dob;
4 char ch;
5 C++ C
6 cin >>x; scanf("%d",&x);
7 cin >>f>>g; scanf("%f%f",&f,&g);
8 cin >>dob >>ch; scanf("%Lf%c", &dob,&ch);
157 / 183

Exemplos de Uso do cout
1 Variável C++
2
3 int x=2; cout <<"x="<<x;
4 float f=1,g=3; cout <<f<<" "<<g;
5 double dob =3; cout <<"dob="<<dob;
6 char sex=’F’; cout <<"nsex="<<sex;
7
8 Result.: x = 2 1.00 3.00 dob =3 sex = F
158 / 183

Função de Entrada cin.get
O objeto cin é encerrado com o <RETURN>, mas não guarda o char n. Por isso
cada pergunta ocorre em linha separada. cin lê o conjunto de chars até o espaço.
strings maiores são passados para os próximos cin. Pode-se alterar o default de cin (
saídas formatadas) ou adotar as funções cin.get.
159 / 183

Função de Entrada cin.get
Presentes na stream istream, servem para realizar entradas de caracteres ou sequência
de caracteres(strings) em C++ e possui as seguintes formas (Sintaxe):
cin.get(char * string, int tamanho, char terminador);
cin.get(streambuf& buffer, char terminador);
cin.get(char& ch);
onde:
string é um ponteiro para char, que guarda uma cadeia de carateres. tamanho
é o comprimento máximo da cadeia de caracteres. terminador indica o caracter
que encerrará a operação de leitura do string. Seu default é n. buffer é um
objeto da classe streambuf e ch é uma referência a uma variável caracter.
160 / 183

Exemplos CINGET
1 // CIN_GET.CPP - Ilustra Prolemas com a Stream Cin do C++
4 struct Pessoa {
5 char nome [30];
6 char ende [30];
7 };
8 int main (){
9 Pessoa funcionario, cliente;
10 char newline;
11 cout << "nEntre com o nome do Cliente t: ";
12 cin.get(cliente.nome,30,’n’);
13 cin.get(newline); // experimentar depois com comentário nesta linha
14 cout << "Entre com o endereco do Cliente t: ";
15 cin.get(cliente.ende,30,’n’); // trocar ’A’ por ’n’
16 cin.get(newline);
161 / 183

Exemplos CINGET
17 cout << "Entre com o nome do Funcionario t: ";
18 cin.get(funcionario.nome,30,’n’);
20 cout << "Entre com o endereco do Funcionario t: ";
21 cin.get(funcionario.ende,30,’n’);
23 cout << "nnNome do Cliente t: " << cliente.nome << "n";
24 cout << "Endereco do Cliente t: " << cliente.ende << "n";
25 cout << "Nome do Funcionario t: " << funcionario.nome << "n";
26 cout << "Endereco do Funcionario : " << funcionario.ende << "n";
27 return 0;
28 }
162 / 183

Seria mais fácil em java com comportamento padrão não é? Segue o mesmo código
em Java.
163 / 183

Exemplo convertido para JAVA
1 // CinGetExample.java - Ilustra problemas similares aos da stream
‘cin ‘ em C++
2 import java.util.Scanner;
3 class Pessoa {
4 String nome;
5 String ende;
6 }
7 public class CinGetExample {
9 Scanner scanner = new Scanner(System.in);
10 Pessoa funcionario = new Pessoa ();
11 Pessoa cliente = new Pessoa ();
12
13 System.out.print("nEntre com o nome do Cliente t: ");
14 cliente.nome = scanner.nextLine (); // lê o nome do cliente
15
16 System.out.print("Entre com o endereco do Cliente t: "); 163 / 183

17 cliente.ende = scanner.nextLine (); // lê o endereço do
cliente
18
19 System.out.print("Entre com o nome do Funcionario t: ");
20 funcionario.nome = scanner.nextLine (); // lê o nome do
funcionário
21
22 System.out.print("Entre com o endereco do Funcionario t: ");
23 funcionario.ende = scanner.nextLine (); // lê o endereço do
funcionário
24
25 // Exibe os dados do cliente e do funcionário
26 System.out.println("nnNome do Cliente t: " + cliente.nome);
27 System.out.println("Endereco do Cliente t: " + cliente.ende);
164 / 183

28 System.out.println("Nome do Funcionario t: " +
funcionario.nome);
29 System.out.println("Endereco do Funcionario t: " +
funcionario.ende);
30
31 scanner.close ();
32 }
33 }
165 / 183

Exemplo convertido para PYTHON
1 # CinGetExample.py - Exemplo de entrada de dados usando data class
2 from data class es import data class
3
4 @data class
5 class Pessoa:
6 nome: str = ""
7 ende: str = ""
8
9 cliente = Pessoa ()
10 funcionario = Pessoa ()
11
12 # Entrada de dados do cliente
13 cliente.nome = input("Entre com o nome do Cliente t: ")
14 cliente.ende = input("Entre com o endereco do Cliente t: ")
166 / 183

Exemplo convertido para PYTHON
16 # Entrada de dados do funcionário
17 funcionario.nome = input("Entre com o nome do Funcionario t: ")
18 funcionario.ende = input("Entre com o endereco do Funcionario t: ")
19
20 # Exibe os dados do cliente e do funcionário
21 print("nnNome do Cliente t:", cliente.nome)
22 print("Endereco do Cliente t:", cliente.ende)
23 print("Nome do Funcionario t:", funcionario.nome)
24 print("Endereco do Funcionario t:", funcionario.ende)
167 / 183

Saídas Formatadas em C++
Para formatação de dados em saídas no c++ usam-se sinalizadores e manipuladores.
Nos Sinalizadores o estado de formato é alterado através da utilização das funções
setf() e unsetf().
Sinalizador Significado
skipws Tira espaço em branco da saída.
left Saída ajustada a esquerda.
right Saída ajustada à direita.
internal Preenchimento após indicador de sinal ou base.
dec Conversão para decimal.
oct Conversão para octal.
hex Conversão para hexa.
showbase Mostra indicador de base na saída.
Tabela: Sinalizadores e seus significados
168 / 183

Saídas Formatadas em C++
Sinalizador Significado
showpoint Mostra ponto decimal (saída em ponto flutuante).
uppercase Saída hex maiúscula.
showpos Mostra ’+’ em inteiros positivos.
scientific Usa notação de ponto flutuante 1.23E2 e saída exponencial.
fixed Usa notação de ponto flutuante.
unitbuf Libera (flush) todas as streams depois de inserção.
stdio Libera (flush) todas as streams depois de inserção.
Tabela: Sinalizadores e seus significados
169 / 183

Sintaxe e Exemplos
Sintaxe:
Para ligar
cout.setf(ios::sinalizador);
Para desligar
cout.unsetf(ios:sinalizador);
Exemplos.
cout.setf(ios::scientific);
cout« ....
cout.unsetf(ios::scientific);
cout.setf(ios::fixed);
170 / 183

Manipuladores
Trata-se da segunda forma de se formatar saídas em C++.Alguns manipuladores são
homônimos aos sinalizadores. A diferença está na forma mais compacta e na inclusão
de outra biblioteca de classes (iomaninp.h)
171 / 183

Manipuladores em C++
Manipulador Significado
dec Conversão para decimal
hex Conversão para hexa
oct Conversão para octal
ws Extrai caracteres de espaço em branco
endl Insere nova linha e libera stream
ends Insere término nulo em string
flush Libera uma ostream
Tabela: Manipuladores e seus significados
172 / 183

Manipuladores em C++
Manipulador Significado
setbase(int n) Ajusta o formato de conversão para a base n
resetIosflags(long) Limpa os bits de formato em Ins ou Outs especificadas
setIosflags(long) Ajusta os bits de formato em Ins ou Outs especificadas
setfill(int n) Ajusta o caractere de preenchimento para n
setPrecision(int n) Ajusta a precisão do ponto flutuante para n
setw(int n) Ajusta o tamanho do campo para n
Tabela: Manipuladores e seus significados
173 / 183

Exemplo
1 // FORM_MAN.CPP - Exemplo de Saidas Formatadas em C++ com
Manipuladores
3 #include <iomanip >
5 int main () {
6 char letra = ’A’;
7 int inteiro = 128;
8 float real = 4555.57877889898 ;
9 cout.setf(ios:: fixed);
10 cout << setprecision (2) ;
11 // Imprime uma Letra
12 cout << "nChar como caracter : " << letra;
13 // Imprime Codigo ASCII da Letra
14 cout << "nCodigo ASCII da Letra : " << (int) letra;
15 // Imprime A Letra cujo ASCII e’ 90
16 cout << "nASCII 90 como uma Letra : " << (char) 90; 174 / 183

Exemplo
17 // Imprime Um Inteiro de Varias Formas
18 cout << "nnnComo Decimal : "<< inteiro;
19 cout << "nComo Char : "<< (char) inteiro;
20 cout << "nComo Hexadecimal : "<< hex << inteiro;
21 cout << "nComo Octal : "<< oct << inteiro;
22 cout << "nComo Float : "<< (float) inteiro;
23 // Imprime Um Float de Varias Formas
24 cout << "nnnFloat como Decimal : "<< real;
25 cout.unsetf(ios:: fixed);
26 cout << "nFloat como Cientifico : " << real;
27 cout.setf(ios:: fixed);
28 // tamanho minimo 20, ajuste a direita
29 cout << "nnn" << setw (20) << real << "n";
30 // ajuste a direita com zeros anteriores
31 cout << setw (20) << setfill(’0’) << real << setfill(’ ’);
175 / 183

Exemplo
31 cout << setw (20) << setfill(’0’) << real << setfill(’ ’);
32 // tamanho minimo 20, ajuste a esquerda
33 cout.setf(ios:: left);
34 cout << "n" << setw (20) << real << "n";
35 // ajuste a esquerda, com zeros anteriores
36 cout << setw (20) << setfill(’*’) << real << setfill(’ ’);
37 cout.unsetf(ios:: left);
38 cout <<’n’;
39 return 0;
40 }
176 / 183

Formatação de Saídas em Java
A formatação de saídas em Java permite personalizar a apresentação dos dados ao
usuário. Em Java, as principais maneiras de formatar saídas são:
• Uso da classe System.out.printf() para formatar strings de maneira
semelhante à linguagem C.
• Uso da classe String.format() para criar strings formatadas sem imprimir
diretamente.
177 / 183

Sintaxe Básica do printf() em Java
O método printf() segue uma sintaxe semelhante ao C para especificar formatos:
• %d para inteiros.
• %f para números de ponto flutuante.
• %s para strings.
• %x para inteiros em hexadecimal.
Exemplo:
1 int valor = 42;
2 System.out.printf("Valor: %d", valor); // Saída: Valor: 42
178 / 183

Formatos Avançados
O printf() permite ajustes mais avançados:
• Especificadores de largura e precisão: %10.2f (10 caracteres de largura e 2 casas
decimais).
• Alinhamento: - para alinhar à esquerda.
• Indicador de sinal: + para mostrar sempre o sinal.
Exemplo:
1 double pi = 3.14159;
2 System.out.printf("PI for matado: %+10.2f", pi); // Saída: PI
for matado: +3.14
179 / 183

Exemplo Completo
1 int idade = 25;
2 double altura = 1.75;
3 String nome = "João";
4 System.out.printf("Nome: %s, Idade: %d anos, Altura: %.2f
metros",nome, idade, altura);
5 // Saída: Nome: João, Idade: 25 anos, Altura: 1.75 metros
Este exemplo mostra como combinar diferentes tipos de variáveis em uma única saída
formatada.
180 / 183

Formatação de Saídas em Python
A formatação de saídas em Python permite exibir dados ao usuário de forma
personalizada. As principais abordagens de formatação em Python incluem:
• Uso do operador de formatação %.
• Métodos str.format().
• Strings formatadas (f-strings), disponíveis a partir do Python 3.6.
181 / 183

Uso do Operador %
O operador % permite especificar o tipo de dado diretamente na string:
• %d para inteiros.
• %f para números de ponto flutuante.
• %s para strings.
Exemplo:
1 idade = 25
2 print("Idade: %d anos" % idade) # Saída: Idade: 25 anos
182 / 183

Método str.format()
O método str.format() permite substituir placeholders {} dentro de strings:
nome = "João"
idade = 25
print("Nome: {}, Idade: {}".format(nome, idade))
Saída: Nome: João, Idade: 25
• Pode-se especificar a posição ou nome dos argumentos dentro das chaves.
183 / 183

Strings Formatadas (f-strings)
As f-strings, introduzidas no Python 3.6, oferecem uma forma direta e intuitiva de
formatar strings:
nome = "João"
idade = 25
print(f"Nome: {nome}, Idade: {idade}")
Saída: Nome: João, Idade: 25
• Permite a inclusão de expressões dentro das chaves, facilitando a formatação de
forma dinâmica.
184 / 183

Especificação de Formatos com f-strings e str.format()
É possível ajustar a precisão e a largura de campos:
• :.2f para 2 casas decimais.
• :>10 para alinhar à direita com largura de 10.
Exemplo:
pi = 3.14159
print(f"PI com 2 casas: {pi:.2f}") # Saída: PI com 2 casas: 3.14
185 / 183

Exemplo Completo
nome = "João"
idade = 25
altura = 1.75
print(f"Nome: {nome}, Idade: {idade}, Altura: {altura:.2f} m")
# Saída: Nome: João, Idade: 25, Altura: 1.75 m
Este exemplo mostra como formatar diferentes tipos de dados em uma única string.
186 / 183

FIM DA PRIMEIRA PARTE
187 / 183

comparativo entre linguagens python c++ java.pdf

Mais conteúdo relacionado

Semelhante a comparativo entre linguagens python c++ java.pdf

Mais de ronaldo ramos

Último

comparativo entre linguagens python c++ java.pdf