Pular para conteúdo

Linguagem de Programação C++ 🚀

Bem-vindo ao curso definitivo de C++ Moderno. Aqui você dominará desde os fundamentos da lógica até os recursos mais avançados da linguagem (C++20), com foco em performance, segurança de memória e boas práticas de mercado.

Metodologia

Foco em Prática: Aprenda fazendo. O curso conta com 16 aulas, 100 exercícios, 200 questões de quiz e 16 mini-projetos práticos para seu portfólio.

🎯 O Que Você Vai Aprender

  • Alta Performance

    Aprenda por que o C++ é a escolha número 1 para sistemas críticos, engines de jogos e HFT.

    Ir para Aula 01

  • Gestão de Memória

    Domine Ponteiros, Referências e o C++ Moderno com Smart Pointers (RAII). Zero memory leaks.

    Ver Módulo 2

  • POO de Verdade

    Entenda Classes, Herança, Polimorfismo e Sobrecarga da forma que os profissionais usam.

    Ver Módulo 3

  • C++ Moderno (STL)

    Utilize a Standard Template Library para criar algoritmos e estruturas de dados de alta eficiência.

    Ver Módulo 4

📚 Estrutura do Curso (16 Aulas)

O curso é dividido em 4 módulos estratégicos para sua evolução tecnológica.

🟢 Módulo 1: Fundamentos (Aulas 01-04)

A base sólida da linguagem e lógica estruturada. * Aula 01 - Introdução ao C++ 🚀 * Aula 02 - Tipos de Dados e Variáveis 📦 * Aula 03 - Operadores e Expressões ➕ * Aula 04 - Estruturas de Controle 🚦

🔵 Módulo 2: Estruturas e Memória (Aulas 05-08)

Modularização e o coração do C++: a memória. * Aula 05 - Funções 🧩 * Aula 06 - Arrays e Strings 🧵 * Aula 07 - Ponteiros e Referências 👆 * Aula 08 - Estruturas e Arquivos 📂

🟡 Módulo 3: Orientação a Objetos (Aulas 09-12)

Arquitetura de sistemas robustos e reutilizáveis. * Aula 09 - Conceitos de POO 🏢 * Aula 10 - Construtores e Destrutores 🏗️ * Aula 11 - Herança e Polimorfismo 🌳 * Aula 12 - Sobrecarga de Operadores ⚖️

🔴 Módulo 4: C++ Profissional (Aulas 13-16)

Ferramentas avançadas e o grande Projeto Final. * Aula 13 - STL (Standard Template Library) ⚙️ * Aula 14 - Gerenciamento de Memória 🧠 * Aula 15 - Multiplataforma e Build 🛠️ * Aula 16 - Projeto Final 🎓

Success

Pronto para o desafio? C++ não é apenas uma linguagem, é uma superpoder. Comece agora!

Iniciar Aula 01

Plano de Ensino 🧭

Curso: Linguagem de Programação C++
Público-alvo: Estudantes de ADS, Ciência da Computação e Desenvolvedores de Software
Carga Horária: 20 Aulas (80 Horas Teórico-Práticas)

🎯 1. Objetivos do Curso

  • Compreender os fundamentos conceituais e arquiteturais de Linguagem de Programação C++.
  • Aplicar padrões de projeto, sintaxe moderna e boas práticas da indústria.
  • Desenvolver soluções completas através de exercícios práticos e desafios de projeto.

📚 2. Cronograma de Aulas (Matriz de 20 Semanas)

Aula Tema Central Atividades e Entregas
01 Introdução ao C++ Teoria, Prática Guiada, Quiz e Exercícios
02 Tipos de Dados e Variáveis Teoria, Prática Guiada, Quiz e Exercícios
03 Operadores e Expressões Teoria, Prática Guiada, Quiz e Exercícios
04 Estruturas de Controle Teoria, Prática Guiada, Quiz e Exercícios
05 Funções Teoria, Prática Guiada, Quiz e Exercícios
06 Arrays e Strings Teoria, Prática Guiada, Quiz e Exercícios
07 Ponteiros e Referências Teoria, Prática Guiada, Quiz e Exercícios
08 Estruturas e Arquivos Teoria, Prática Guiada, Quiz e Exercícios
09 Conceitos de POO Teoria, Prática Guiada, Quiz e Exercícios
10 Construtores e Destrutores ️ Teoria, Prática Guiada, Quiz e Exercícios
11 Herança e Polimorfismo Teoria, Prática Guiada, Quiz e Exercícios
12 Sobrecarga de Operadores ️ Teoria, Prática Guiada, Quiz e Exercícios
13 STL (Standard Template Library) ️ Teoria, Prática Guiada, Quiz e Exercícios
14 Gerenciamento de Memória Teoria, Prática Guiada, Quiz e Exercícios
15 Multiplataforma e Build ️ Teoria, Prática Guiada, Quiz e Exercícios
16 Projeto Final Teoria, Prática Guiada, Quiz e Exercícios
17 Programação Genérica Avançada e Metaprogramação Teoria, Prática Guiada, Quiz e Exercícios
18 Gerenciamento de Memória Moderno (Smart Pointers) e RAII Teoria, Prática Guiada, Quiz e Exercícios
19 Concorrência de Alto Desempenho com std::thread Teoria, Prática Guiada, Quiz e Exercícios
20 Projeto Capstone: Motor de Processamento C++ de Alta Performance Teoria, Prática Guiada, Quiz e Exercícios

🧠 3. Metodologia de Ensino

  • Teoria Fundamentada: Aulas com conceitos detalhados, diagramas arquiteturais e sintaxe de referência.
  • Ciclo Teoria ⇄ Prática: Cada aula conta com Quiz Interativo (10 questões) para validação imediata, Lista de Exercícios Sanfonados (com Gabarito Explicado) e Desafio de Projeto Prático.
  • Laboratório Contínuo: Ambientes configurados passo a passo na seção de Setups da plataforma.

💼 4. Competências e Perfil Desenvolvido

  • Dominar as ferramentas e fluxos de desenvolvimento de Linguagem de Programação C++.
  • Resolver problemas técnicos de alta complexidade com código limpo e performático.
  • Construir portfólio prático com 20 projetos aplicados.

📊 5. Critérios de Avaliação

  • 20 Listas de Exercícios: Resolução individual dividida em Básico, Intermediário e Desafio.
  • 20 Quizzes Interativos: Validação formativa com feedback imediato via JavaScript.
  • 20 Desafios de Projetos: Aplicações práticas consolidando o aprendizado de cada unidade.

Aulas

Aulas do Curso

Bem-vindo à seção de aulas! Aqui você encontra todo o conteúdo do curso organizado em 5 módulos estruturados.

📚 Módulos do Curso

Aula 01 - Introdução ao C++ 🚀

Bem-vindo ao curso de Sistemas com C++! Nesta primeira aula, vamos mergulhar na história e nos fundamentos de uma das linguagens mais poderosas e influentes do mundo.

📖 O que é C++?

O C++ é uma linguagem de programação de alto nível, mas que oferece recursos de baixo nível (manipulação de memória). Foi criada por Bjarne Stroustrup em 1979 no Bell Labs como uma extensão da linguagem C.

⏳ História e Evolução

Originalmente chamado de "C com Classes", o C++ evoluiu para suportar múltiplos paradigmas: - Programação Estruturada (como no C) - Programação Orientada a Objetos (Classes, Herança, Polimorfismo) - Programação Genérica (Templates)

🔄 Diferenças entre C e C++

graph LR
    C[Linguagem C] -->|Adição de Classes| CPP[Linguagem C++]
    CPP -->|Recursos Modernos| MCPP[C++ Moderno C++11/14/17/20]

    style C fill:#f9f,stroke:#333,stroke-width:2px
    style CPP fill:#bbf,stroke:#333,stroke-width:4px
    style MCPP fill:#dfd,stroke:#333,stroke-width:2px

🛠️ Compiladores e Ambiente

Para transformar nosso código em um programa executável, precisamos de um Compilador.

  • GCC / G++: O padrão no mundo Linux.
  • MinGW: Uma versão do GCC para Windows.
  • MSVC: O compilador do Visual Studio (Windows).

⚙️ Ciclo de Vida do Código

  1. Código Fonte (.cpp, .h)
  2. Pré-processamento (Trata #include, Macro)
  3. Compilação (Gera código de máquina/objeto)
  4. Linkagem (Une códigos objeto e bibliotecas)
  5. Executável (.exe no Windows, binário no Linux)

💻 Meu Primeiro Programa: Hello World

Vamos ver a estrutura básica de um programa C++.

#include <iostream> // Biblioteca de Entrada e Saída

int main() {
    // std::cout é usado para imprimir no console
    std::cout << "Olá, Mundo C++!" << std::endl;

    return 0; // Indica que o programa terminou com sucesso
}

⌨️ Compilando via Terminal

$ g++ hello.cpp -o hello
$ ./hello
Olá, Mundo C++!

🧠 Conceitos Importantes

O que é um Namespace?

O std:: antes do cout indica que ele pertence ao Namespace padrão (Standard). Isso evita conflitos de nomes em projetos grandes.

Atenção com a Compilação

Sempre use a flag -o para dar um nome ao seu executável, caso contrário ele se chamará a.out (Linux) ou a.exe (Windows) por padrão.

📝 Exercício de Fixação

  1. Instalação: Configure o ambiente (MinGW no Windows ou G++ no Linux).
  2. Codificação: Crie um programa que imprima seu nome e sua meta para este curso.
  3. Desafio: Tente compilar usando a flag -Wall para ver se o compilador gera algum aviso (warning).

🚀 Mini-Projeto da Aula

Sistema de Boas-Vindas Dinâmico: Crie um programa que utilize std::cout para exibir um menu artístico de boas-vindas ao seu próprio sistema. Use caracteres especiais e quebras de linha para formatar.

Aula 02 - Tipos de Dados e Variáveis 📦

Nesta aula, aprenderemos como o C++ armazena informações na memória e como podemos interagir com o usuário através do console.

🏗️ Tipos de Dados Primitivos

O C++ é uma linguagem estaticamente tipada, o que significa que o tipo de uma variável deve ser declarado e não pode mudar.

Tipo Descrição Exemplo
int Números inteiros 10, -5
float Números decimais (precisão simples) 3.14f
double Números decimais (precisão dupla) 2.71828
char Um único caractere 'A'
bool Valores lógicos true, false

🔧 Modificadores de Tipo

Podemos alterar o comportamento e o tamanho dos tipos primitivos usando modificadores:

  • unsigned: Apenas valores positivos (dobra a capacidade positiva).
  • signed: Valores positivos e negativos (padrão).
  • long: Aumenta o tamanho da variável (ex: long long).
  • short: Diminui o tamanho da variável.

📥 Entrada e Saída com std

Diferente do C (printf/scanf), o C++ usa o conceito de Streams (fluxos).

std::cout (Output)

Envia dados para a saída padrão (tela). 

std::cout << "O valor é: " << variavel << std::endl;

std::cin (Input)

Recebe dados da entrada padrão (teclado). 

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

🧠 Boas Práticas de Declaração

Nomes de Variáveis

Use nomes descritivos em camelCase (ex: idadeUsuario) ou snake_case (ex: idade_usuario). Evite nomes genéricos como x ou a.

Namespace std

Para evitar escrever std:: o tempo todo, podemos usar using namespace std; no início do arquivo, mas isso é considerado uma prática ruim em projetos grandes devido a possíveis conflitos de nomes.

💻 Exemplo Prático: Calculadora de Área

#include <iostream>

int main() {
    float largura, altura, area;

    std::cout << "--- Calculadora de Área ---" << std::endl;

    std::cout << "Digite a largura: ";
    std::cin >> largura;

    std::cout << "Digite a altura: ";
    std::cin >> altura;

    area = largura * altura;

    std::cout << "A área total é: " << area << " m2" << std::endl;

    return 0;
}

📝 Exercício de Fixação

  1. Variáveis: Crie um programa que declare variáveis de todos os tipos primitivos e as imprima.
  2. Entrada: Peça ao usuário seu nome (use std::string) e idade, e imprima uma mensagem personalizada.
  3. Desafio: Calcule quantos dias de vida uma pessoa tem aproximadamente com base na idade informada.

🚀 Mini-Projeto da Aula

Ficha de Cadastro: Desenvolva um programa que solicite: Nome, Idade, Altura, Peso e se é estudante (true/false). Ao final, exiba os dados formatados como uma ficha técnica.

Aula 03 - Operadores e Expressões ➕

Nesta aula, exploraremos como manipular dados usando operadores matemáticos, lógicos e relacionais.

🧮 Operadores Aritméticos

Servem para realizar cálculos matemáticos básicos.

Operador Operação Exemplo (a=10, b=3) Resultado
+ Adição a + b 13
- Subtração a - b 7
* Multiplicação a * b 30
/ Divisão a / b 3 (inteira)
% Módulo (Resto) a % b 1

⚖️ Operadores Relacionais e Lógicos

Esses operadores sempre retornam um valor booleano (true ou false).

Relacionais

  • == : Igual a
  • != : Diferente de
  • > : Maior que
  • < : Menor que
  • >= : Maior ou igual
  • <= : Menor ou igual

Lógicos

  • && : AND (E)
  • || : OR (OU)
  • ! : NOT (NÃO)

🧬 Conversão de Tipos (Casting)

Às vezes precisamos tratar um tipo como se fosse outro.

Casting Implícito

O compilador faz automaticamente (ex: int para float).

Casting Explícito (C++ Style)

int a = 10, b = 3;
float resultado = static_cast<float>(a) / b; // Força a divisão decimal

💡 Operador Ternário

Uma forma compacta de fazer um if-else.

string resultado = (nota >= 6) ? "Aprovado" : "Reprovado";

🧠 Precedência de Operadores

Assim como na matemática, o C++ segue uma ordem: 1. Parênteses () 2. Multiplicação, Divisão e Módulo * / % 3. Adição e Subtração + -

Use Parênteses

Sempre use parênteses para deixar clara a intenção da sua expressão, mesmo que a precedência padrão resolva. Isso melhora muito a legibilidade.

💻 Exemplo Prático: Média Ponderada

#include <iostream>

int main() {
    float n1, n2, media;

    std::cout << "Nota 1: ";
    std::cin >> n1;
    std::cout << "Nota 2: ";
    std::cin >> n2;

    // Peso 4 para nota 1 e Peso 6 para nota 2
    media = (n1 * 4 + n2 * 6) / 10;

    std::cout << "Média Final: " << media << std::endl;
    std::cout << "Status: " << (media >= 6 ? "Aprovado" : "Reprovado") << std::endl;

    return 0;
}

📝 Exercício de Fixação

  1. Aritmética: Crie um programa que receba dois números e exiba a soma, diferença, produto e quociente.
  2. Par ou Ímpar: Use o operador % para determinar se um número é par ou ímpar.
  3. Desafio: Verifique se um ano informado é bissexto (divisível por 4 e não por 100, ou divisível por 400).

🚀 Mini-Projeto da Aula

Conversor de Medidas: Crie um programa que receba um valor em metros e exiba-o convertido para centímetros, milímetros e quilômetros, utilizando expressões matemáticas e formatação de saída.

Aula 04 - Estruturas de Controle 🚦

Nesta aula, aprenderemos como controlar o fluxo de execução do nosso programa usando tomadas de decisão e laços de repetição.

🛣️ Estruturas Condicionais

As condicionais permitem que o programa execute diferentes blocos de código com base em condições lógicas.

if / else if / else

if (idade >= 18) {
    std::cout << "Maior de idade" << std::endl;
} else if (idade >= 16) {
    std::cout << "Pode votar, mas não dirigir" << std::endl;
} else {
    std::cout << "Menor de idade" << std::endl;
}

switch

Ideal para testar uma única variável contra múltiplos valores constantes. 

switch (opcao) {
    case 1:
        std::cout << "Opção 1 selecionada";
        break;
    case 2:
        std::cout << "Opção 2 selecionada";
        break;
    default:
        std::cout << "Opção inválida";
}

🔄 Estruturas de Repetição (Loops)

Loops são usados para repetir um bloco de código várias vezes.

while

Repete enquanto a condição for verdadeira. 

int i = 0;
while (i < 5) {
    std::cout << i << " ";
    i++;
}

do-while

Garante que o código seja executado pelo menos uma vez. 

char resposta;
do {
    std::cout << "Deseja continuar? (s/n): ";
    std::cin >> resposta;
} while (resposta == 's');

for

Ideal quando sabemos o número de repetições. 

for (int i = 0; i < 10; i++) {
    std::cout << "Contagem: " << i << std::endl;
}

🧠 Boas Práticas e Legibilidade

Indentação

Manter o código bem indentado é crucial para entender a hierarquia das estruturas de controle. Use sempre 4 espaços ou 1 tab.

Cuidado com Loops Infinitos

Certifique-se sempre de que a condição de parada do seu loop será atingida em algum momento, caso contrário seu programa ficará travado.

💻 Exemplo Prático: Jogo de Adivinhação

#include <iostream>

int main() {
    int numeroSecreto = 42;
    int palpite;
    int tentativas = 0;

    std::cout << "--- Adivinhe o Número ---" << std::endl;

    do {
        std::cout << "Digite seu palpite: ";
        std::cin >> palpite;
        tentativas++;

        if (palpite < numeroSecreto) {
            std::cout << "Muito baixo!" << std::endl;
        } else if (palpite > numeroSecreto) {
            std::cout << "Muito alto!" << std::endl;
        }

    } while (palpite != numeroSecreto);

    std::cout << "Parabéns! Você acertou em " << tentativas << " tentativas." << std::endl;

    return 0;
}

📝 Exercício de Fixação

  1. Condicional: Crie um programa que receba a nota de um aluno e diga se ele foi aprovado (>=7), em recuperação (>=5 e <7) ou reprovado (<5).
  2. Loop For: Imprima a tabuada de um número fornecido pelo usuário.
  3. Desafio: Crie um programa que exiba todos os números primos entre 1 e 100.

🚀 Mini-Projeto da Aula

Simulador de Caixa Eletrônico: Desenvolva um menu (usando switch dentro de um do-while) que permita: 1-Ver Saldo, 2-Depositar, 3-Sacar e 0-Sair. Use condicionais para garantir que o usuário não saque mais do que possui em conta.

Aula 05 - Funções 🧩

Nesta aula, aprenderemos como organizar e reutilizar nosso código criando blocos funcionais chamados de Funções.

🏗️ Anatomia de uma Função

Uma função no C++ precisa de um tipo de retorno, um nome e, opcionalmente, parâmetros.

// Declaração (Protótipo)
int somar(int a, int b);

// Definição
int somar(int a, int b) {
    return a + b;
}

🔁 Tipos de Retorno

  • int, float, string, etc. (Retornam um valor)
  • void (Não retorna nada)

🔗 Passagem de Parâmetros

No C++, existem duas formas principais de enviar dados para uma função:

Passagem por Valor

Cria uma cópia da variável. Alterações dentro da função não afetam a original. 

void dobrar(int x) { x = x * 2; }

Passagem por Referência

Usa o endereço da variável original através do operador &. Alterações afetam a variável original. 

void dobrar(int &x) { x = x * 2; }

🧬 Sobrecarga de Funções (Overloading)

C++ permite criar várias funções com o mesmo nome, desde que seus parâmetros sejam diferentes (em tipo ou quantidade).

void imprimir(int n) { std::cout << "Inteiro: " << n << std::endl; }
void imprimir(std::string s) { std::cout << "Texto: " << s << std::endl; }

💡 Funções Inline

Funções pequenas podem ser marcadas como inline. Isso sugere ao compilador substituir a chamada da função pelo código dela, economizando tempo de processamento.

inline int quadrado(int x) { return x * x; }

🧠 Hierarquia de Escopo

Variáveis Locais vs Globais

Variáveis declaradas dentro de uma função são locais e só existem ali. Variáveis declaradas fora de todas as funções são globais, mas devem ser evitadas para manter a organização.

Protótipos

É uma boa prática declarar as funções no topo do arquivo (ou em um header .h) e definí-las após a função main.

💻 Exemplo Prático: Calculadora Modular

#include <iostream>

// Protótipos
void exibirMenu();
float calcular(float a, float b, char op);

int main() {
    float x, y;
    char o;

    exibirMenu();
    std::cout << "Número 1: "; std::cin >> x;
    std::cout << "Operação (+, -, *, /): "; std::cin >> o;
    std::cout << "Número 2: "; std::cin >> y;

    std::cout << "Resultado: " << calcular(x, y, o) << std::endl;

    return 0;
}

void exibirMenu() {
    std::cout << "--- Calculadora Modular ---" << std::endl;
}

float calcular(float a, float b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return b != 0 ? a / b : 0;
        default: return 0;
    }
}

📝 Exercício de Fixação

  1. Básico: Crie uma função que receba um número e retorne true se ele for par.
  2. Referência: Crie uma função trocar(int &a, int &b) que inverta o valor de duas variáveis.
  3. Desafio: Implemente uma função recursiva para calcular o fatorial de um número.

🚀 Mini-Projeto da Aula

Sistema de Conversão de Temperatura: Crie um programa com funções separadas para converter: Celsius para Fahrenheit, Fahrenheit para Celsius e Celsius para Kelvin. Use um menu para o usuário escolher a conversão desejada.

Aula 06 - Arrays e Strings 🧵

Nesta aula, aprenderemos a trabalhar com coleções de dados do mesmo tipo e mergulharemos no mundo das Strings.

📊 Arrays (Vetores e Matrizes)

Arrays permitem armazenar múltiplos valores sob um único nome, acessados por um índice (começando em 0).

Unidimensionais (Vetores)

int notas[5] = {10, 8, 9, 7, 6};
std::cout << notas[0]; // Imprime 10

Multidimensionais (Matrizes)

int grade[2][3] = { {1, 2, 3}, {4, 5, 6} };
std::cout << grade[1][0]; // Imprime 4

🔡 Manipulação de Texto

C++ oferece duas formas de trabalhar com texto:

1. C-Style Strings

Arrays de caracteres terminados em \0. 

char nome[] = "C++";

2. Classe std::string (Recomendado)

Muito mais poderosa e segura que a forma antiga. 

#include <string>
std::string frase = "Olá, C++ Moderno!";
std::cout << frase.length(); // Retorna o tamanho

🛠️ Operações Comuns com Strings

Operação Exemplo
Concatenação s1 + s2
Comparação s1 == s2
Substring s.substr(0, 5)
Busca s.find("C++")
Limpeza s.clear()

🧠 Percorrendo Coleções

Range-based for (C++11)

Uma forma moderna e elegante de percorrer arrays: 

int numeros[] = {1, 2, 3, 4, 5};
for(int n : numeros) {
    std::cout << n << " ";
}

Cuidado com os Limites

O C++ não verifica se você está tentando acessar um índice fora do array (ex: notas[10] num array de 5). Isso pode causar travamentos ou comportamentos imprevisíveis.

💻 Exemplo Prático: Média de Notas com Vetor

#include <iostream>
#include <string>

int main() {
    std::string nome;
    float notas[3];
    float soma = 0;

    std::cout << "Nome do aluno: ";
    std::getline(std::cin, nome); // getline lê a linha toda (incluindo espaços)

    for (int i = 0; i < 3; i++) {
        std::cout << "Digite a nota " << i+1 << ": ";
        std::cin >> notas[i];
        soma += notas[i];
    }

    std::cout << "\nAluno: " << nome << std::endl;
    std::cout << "Média: " << soma / 3 << std::endl;

    return 0;
}

📝 Exercício de Fixação

  1. Vetor: Crie um programa que leia 10 números e mostre qual é o maior deles.
  2. String: Receba uma frase do usuário e conte quantas vogais ela possui.
  3. Desafio: Implemente uma matriz 3x3 que represente um tabuleiro de Jogo da Velha simples.

🚀 Mini-Projeto da Aula

Analisador de Texto: Desenvolva um programa que peça um parágrafo ao usuário e exiba: Total de caracteres, total de palavras (baseado nos espaços) e a versão do texto em caixa alta (uppercase).

Aula 07 - Ponteiros e Referências 👆

Nesta aula, desvendaremos um dos temas mais temidos e importantes do C++: a manipulação direta de memória.

🧠 Conceito de Memória

Toda variável que declaramos ocupa um espaço na memória RAM, identificado por um endereço hexadecimal.

graph TD
    A[Variável: idade] --> B["Valor: 25"]
    A --> C["Endereço: 0x7ffd..."]

    style B fill:#dfd,stroke:#333
    style C fill:#fdd,stroke:#333

📍 Ponteiros

Um Ponteiro é uma variável especial que armazena o endereço de memória de outra variável.

  • & (Operador de Endereço): Retorna o endereço de uma variável.
  • * (Operador de Desreferência): Acessa o valor no endereço armazenado pelo ponteiro.
int x = 10;
int* ptr = &x; // ptr recebe o endereço de x

std::cout << "Endereço: " << ptr << std::endl;
std::cout << "Valor: " << *ptr << std::endl; // Acessa o 10

🔗 Referências

Uma Referência é um "apelido" para uma variável existente. Diferente do ponteiro, ela não pode ser nula e não pode ser alterada para apontar para outra variável após ser criada.

int original = 50;
int &ref = original;

ref = 100; // Altera original para 100

🏗️ Introdução à Alocação Dinâmica

Normalmente, a memória é alocada na Stack (Pilha). Quando precisamos de blocos maiores ou controle total sobre a vida útil, usamos o Heap (Monte) com new e delete.

int* p = new int; // Aloca memória no Heap
*p = 20;
delete p; // Libera a memória (Essencial para evitar Memory Leaks)

🧠 Dicas de Ouro

Ponteiros para Funções

Você pode passar o endereço de uma função como parâmetro, permitindo que uma função chame outra dinamicamente (callback).

O Perigo do nullptr

Sempre inicialize seus ponteiros com nullptr se não tiver um endereço imediato. Tentar acessar um ponteiros "lixo" causará o famoso erro Segmentation Fault.

💻 Exemplo Prático: Manipulação via Ponteiro

#include <iostream>

void zerar(int* p) {
    if (p != nullptr) {
        *p = 0; // Altera o valor no endereço apontado
    }
}

int main() {
    int valor = 100;
    std::cout << "Antes: " << valor << std::endl;

    zerar(&valor); // Passa o endereço de valor

    std::cout << "Depois: " << valor << std::endl;

    return 0;
}

📝 Exercício de Fixação

  1. Endereço: Imprima o endereço de memória de uma variável float e de uma double. Qual a diferença de tamanho?
  2. Ponteiro: Crie um ponteiro que aponte para um array e use aritmética de ponteiros para percorrer os elementos.
  3. Desafio: Use new para criar um array dinâmico, peça o tamanho ao usuário, preencha-o e depois use delete[] para liberar a memória.

🚀 Mini-Projeto da Aula

Gerenciador de Memória Manual: Crie um programa que permita ao usuário alocar dinamicamente um registro de notas. O usuário escolhe o tamanho, insere os dados e, ao final, o programa deve exibir os dados e garantir que a memória seja liberada corretamente.

Aula 08 - Estruturas e Arquivos 📂

Nesta aula, aprenderemos a criar nossos próprios tipos de dados complexos e a salvar informações permanentemente em arquivos.

🏗️ Structs (Estruturas)

Uma struct permite agrupar variáveis de diferentes tipos sob um único nome.

struct Produto {
    int id;
    std::string nome;
    float preco;
};

Produto p1 = {1, "Teclado", 150.00};
std::cout << p1.nome;

📁 Persistência com fstream

Para trabalhar com arquivos, usamos a biblioteca <fstream>.

Tipos de Fluxo:

  • ofstream: Escrita (Output File Stream)
  • ifstream: Leitura (Input File Stream)
  • fstream: Ambos

Escrita de Arquivo

#include <fstream>

std::ofstream arquivo("dados.txt");
arquivo << "Salvando dados no C++" << std::endl;
arquivo.close();

📖 Leitura de Arquivo

std::ifstream arquivoLeitura("dados.txt");
std::string linha;

if (arquivoLeitura.is_open()) {
    while (getline(arquivoLeitura, linha)) {
        std::cout << linha << std::endl;
    }
    arquivoLeitura.close();
}

🧠 Boas Práticas

Verificação de Abertura

Sempre verifique se o arquivo foi aberto corretamente usando arquivo.is_open() ou checando o objeto diretamente if(!arquivo).

Modos de Abertura

Você pode usar std::ios::app para adicionar conteúdo ao final do arquivo (append) sem apagar o que já existe.

💻 Exemplo Prático: Registro de Usuários

#include <iostream>
#include <fstream>
#include <string>

struct Usuario {
    std::string nome;
    int idade;
};

int main() {
    Usuario user;
    std::cout << "Nome: "; std::getline(std::cin, user.nome);
    std::cout << "Idade: "; std::cin >> user.idade;

    std::ofstream db("usuarios.txt", std::ios::app);
    if (db.is_open()) {
        db << user.nome << "," << user.idade << "\n";
        db.close();
        std::cout << "Dados salvos!" << std::endl;
    }

    return 0;
}

📝 Exercício de Fixação

  1. Struct: Crie uma struct Livro com título, autor e ano. Crie um array de 3 livros e exiba-os.
  2. Arquivos: Crie um programa que leia um arquivo de texto e conte quantas palavras ele possui.
  3. Desafio: Faça um programa que leia os dados salvos em usuarios.txt (do exemplo prático) e exiba apenas as pessoas com mais de 18 anos.

🚀 Mini-Projeto da Aula

Sistema de Agenda Simples: Desenvolva uma agenda que salve Nome e Telefone em um arquivo .csv. O programa deve ter um menu para: 1-Adicionar Contato, 2-Listar todos os contatos e 0-Sair.

Aula 09 - Conceitos de POO 🏢

Bem-vindo à Programação Orientada a Objetos (POO). Nesta aula, mudaremos nossa forma de pensar: de "sequência de ações" para "interação entre objetos".

🧱 Classe vs Objeto

Uma Classe é o molde (blueprint). O Objeto é a instância real criada a partir desse molde.

classDiagram
    class Carro {
        +string marca
        +string modelo
        +ligar()
        +acelerar()
    }

⚙️ Membros da Classe

Atributos (Dados)

São as características do objeto (ex: cor, tamanho, preço).

Métodos (Comportamento)

São as funções que o objeto pode realizar (ex: andar, emitir som, calcular soma).

🛡️ Encapsulamento

É a técnica de esconder os detalhes internos de um objeto e expor apenas o necessário através de uma interface segura.

Modificadores de Acesso:

  • public: Acessível de qualquer lugar.
  • private: Acessível apenas dentro da própria classe (Padrão para atributos).
  • protected: Acessível pela classe e suas filhas (Herança).

💻 Exemplo Prático: Minha Primeira Classe

#include <iostream>
#include <string>

class ContaBancaria {
private:
    std::string titular;
    double saldo;

public:
    // Método para configurar dados (Setter)
    void inicializar(std::string t, double s) {
        titular = t;
        saldo = s;
    }

    void depositar(double valor) {
        if (valor > 0) saldo += valor;
    }

    void exibirExtrato() {
        std::cout << "Titular: " << titular << " | Saldo: R$ " << saldo << std::endl;
    }
};

int main() {
    ContaBancaria minhaConta;
    minhaConta.inicializar("Ricardo", 1000.00);
    minhaConta.depositar(500.50);
    minhaConta.exibirExtrato();

    return 0;
}

🧠 Conceitos Chave

Por que usar POO?

A POO facilita a manutenção do código, permite o reaproveitamento e torna o desenvolvimento de grandes sistemas muito mais organizado e intuitivo.

Abstração

Não tente modelar tudo! Foque apenas nos atributos e comportamentos que são relevantes para o seu problema atual.

📝 Exercício de Fixação

  1. Atributos: Crie uma classe Retangulo com atributos privados largura e altura.
  2. Métodos: Adicione métodos para calcular a area() e o perimetro() do retângulo.
  3. Desafio: Crie uma classe Aluno que armazene nome e um array de 3 notas. Implemente um método que retorne se o aluno está aprovado.

🚀 Mini-Projeto da Aula

Simulador de Personagem RPG: Crie uma classe Guerreiro com: Nome, Vida e Força. Implemente métodos para: atacar(Guerreiro &alvo) (que reduz a vida do alvo com base na força) e exibirStatus(). Simule uma batalha simples entre dois objetos guerreiros no main.

Aula 10 - Construtores e Destrutores 🏗️

Nesta aula, aprenderemos como gerenciar o ciclo de vida de um objeto: desde o seu nascimento (construção) até o seu fim (destruição).

🏗️ Construtores

Um Construtor é um método especial que é chamado automaticamente quando criamos um objeto. Ele tem o mesmo nome da classe e não possui tipo de retorno.

Construtor Padrão (Default)

Iniciado sem parâmetros. 

class Robo {
public:
    Robo() { std::cout << "Robo ativado!" << std::endl; }
};

Construtor Parametrizado

Iniciado com valores específicos. 

class Pessoa {
private:
    std::string nome;
public:
    Pessoa(std::string n) : nome(n) {} // Lista de Inicialização
};

💣 Destrutor

O Destrutor é chamado quando o objeto sai de escopo ou é deletado. Seu nome começa com um til (~). É o lugar perfeito para liberar memória ou fechar arquivos.

class BancoDados {
public:
    ~BancoDados() { std::cout << "Conexão encerrada com segurança." << std::endl; }
};

📜 Regra dos Três (Rule of Three)

No C++ clássico, se você precisar definir um dos três, provavelmente precisará definir todos para evitar bugs de memória: 1. Destrutor 2. Construtor de Cópia 3. Operador de Atribuição

🧠 Lista de Inicialização

Performance

Use sempre a lista de inicialização (: atrib(valor)) em vez de atribuir valores dentro do corpo do construtor. Isso é mais eficiente pois evita a criação de um objeto temporário vazio.

Sobrecarga

Você pode ter vários construtores para a mesma classe, permitindo criar objetos de diferentes formas.

💻 Exemplo Prático: Gerenciador de Log

#include <iostream>
#include <string>

class Logger {
private:
    std::string prefixo;
public:
    // Construtor com valor padrão
    Logger(std::string p = "LOG") : prefixo(p) {
        std::cout << "[" << prefixo << "] Logger Iniciado." << std::endl;
    }

    // Destrutor
    ~Logger() {
        std::cout << "[" << prefixo << "] Logger Finalizado." << std::endl;
    }

    void log(std::string mensagem) {
        std::cout << "[" << prefixo << "] " << mensagem << std::endl;
    }
};

int main() {
    {
        Logger meuLog("SISTEMA");
        meuLog.log("Iniciando processamento...");
    } // O Logger é destruído AQUI ao sair das chaves

    std::cout << "Fim da execução." << std::endl;
    return 0;
}

📝 Exercício de Fixação

  1. Construtor: Crie uma classe Carro onde o construtor peça a marca e o ano.
  2. Destrutor: Adicione um destrutor à classe Carro que imprima "Carro [Marca] enviado para o desmanche".
  3. Desafio: Implemente uma classe Buffer que aloque dinamicamente um array no construtor e use o destrutor para garantir que a memória seja liberada.

🚀 Mini-Projeto da Aula

Sistema de Sessão de Usuário: Crie uma classe Sessao que armazene o ID do usuário. O construtor deve registrar o horário de login (pode ser um texto simples) e o destrutor deve registrar o horário de logout. Simule múltiplos logins no main usando blocos {} para ver os objetos sendo criados e destruídos.

Aula 11 - Herança e Polimorfismo 🌳

Nesta aula, aprenderemos como criar hierarquias de classes e como tratar diferentes objetos de forma genérica.

🧬 Herança

Permite que uma classe (Filha/Derivada) herde atributos e métodos de outra (Pai/Base).

class Animal {
public:
    void comer() { std::cout << "Comendo..." << std::endl; }
};

class Cachorro : public Animal {
public:
    void latir() { std::cout << "Au Au!" << std::endl; }
};

🎭 Polimorfismo

O polimorfismo permite que uma função tenha comportamentos diferentes dependendo do objeto que a chama. Para isso, usamos Funções Virtuais.

Funções Virtuais (virtual)

Diz ao compilador para procurar a implementação mais específica da função em tempo de execução.

class Forma {
public:
    virtual void desenhar() { std::cout << "Desenhando forma genérica" << std::endl; }
};

class Circulo : public Forma {
public:
    void desenhar() override { std::cout << "Desenhando um círculo ○" << std::endl; }
};

🧊 Classes Abstratas

Uma classe é considerada abstrata quando possui pelo menos uma Função Virtual Pura. Ela serve apenas como molde e não pode ser instanciada.

class Instrumento {
public:
    virtual void tocar() = 0; // Virtual Pura
};

🧠 Hierarquia Visual

classDiagram
    class Animal {
        +virtual fazerSom()*
    }
    class Gato {
        +fazerSom()
    }
    class Cachorro {
        +fazerSom()
    }
    Animal <|-- Gato
    Animal <|-- Cachorro

💡 Por que usar override?

Segurança

Sempre use a palavra override ao sobrescrever um método. Isso garante que o compilador verifique se a função realmente existe na classe pai, evitando erros de digitação sutis.

Destrutores Virtuais

Se uma classe puder ser herdada, seu destrutor deve ser virtual. Caso contrário, ao deletar um objeto filho através de um ponteiro do pai, o destrutor do filho não será chamado, causando vazamento de memória.

💻 Exemplo Prático: Sistema de Pagamento

#include <iostream>

class Pagamento {
public:
    virtual void processar(double valor) = 0;
    virtual ~Pagamento() {}
};

class Cartao : public Pagamento {
public:
    void processar(double valor) override {
        std::cout << "Processando R$ " << valor << " no cartão de crédito." << std::endl;
    }
};

class Pix : public Pagamento {
public:
    void processar(double valor) override {
        std::cout << "Gerando QR Code Pix para R$ " << valor << std::endl;
    }
};

int main() {
    Pagamento* p = new Pix();
    p->processar(150.00);

    delete p; // Chama o destrutor correto
    return 0;
}

📝 Exercício de Fixação

  1. Herança: Crie uma classe Pessoa e uma subclasse Professor com o atributo disciplina.
  2. Polimorfismo: Crie um array de ponteiros de Animal e preencha com objetos Gato e Cachorro. Percorra o array chamando fazerSom().
  3. Desafio: Implemente uma classe abstrata Funcionario e subclasses Gerente e Vendedor, cada uma com sua lógica de cálculo de salário.

🚀 Mini-Projeto da Aula

Simulador de Zoológico: Crie uma estrutura onde diversos animais (Leão, Pássaro, Peixe) herdam de uma base comum. Cada um deve implementar seus métodos de mover() e emitirSom(). No main, use um loop para fazer todos os animais do zoológico "agirem" ao mesmo tempo.

Aula 12 - Sobrecarga de Operadores ⚖️

Nesta aula, aprenderemos como ensinar ao C++ como lidar com operadores nativos (+, -, *, <<) em nossas próprias classes.

⚖️ O que é Sobrecarga de Operador?

É a capacidade de redefinir o comportamento de operadores para tipos definidos pelo usuário. Isso torna o código muito mais intuitivo e legível.

Sem sobrecarga: res = c1.somar(c2); Com sobrecarga: res = c1 + c2;

➕ Operadores Aritméticos

Para sobrecarregar um operador, criamos uma função com o nome operator seguido do símbolo desejado.

class Ponto {
public:
    int x, y;
    Ponto operator+(const Ponto& outro) {
        return {x + outro.x, y + outro.y};
    }
};

📤 Operador de Fluxo (<<)

Muito útil para imprimir objetos diretamente com std::cout. Ele deve ser implementado como uma função amiga (friend) ou fora da classe.

friend std::ostream& operator<<(std::ostream& os, const Ponto& p) {
    os << "(" << p.x << ", " << p.y << ")";
    return os;
}

🧠 Boas Práticas

Preserve o Sentido

Não sobrecarregue o operador + para fazer uma subtração. Isso confunde outros desenvolvedores e torna o código imprevisível.

Operadores de Comparação

Sobrecarregar os operadores == e < é essencial se você pretende usar seus objetos em containers da STL que precisam de ordenação ou busca.

💻 Exemplo Prático: Números Complexos

#include <iostream>

class Complexo {
private:
    double real, imag;
public:
    Complexo(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sobrecarga do +
    Complexo operator+(const Complexo& outro) {
        return Complexo(real + outro.real, imag + outro.imag);
    }

    // Sobrecarga do << para impressão fácil
    friend std::ostream& operator<<(std::ostream& os, const Complexo& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }
};

int main() {
    Complexo c1(3, 4);
    Complexo c2(1, 2);
    Complexo c3 = c1 + c2;

    std::cout << "C1: " << c1 << std::endl;
    std::cout << "C2: " << c2 << std::endl;
    std::cout << "Soma: " << c3 << std::endl;

    return 0;
}

📝 Exercício de Fixação

  1. Aritmética: Crie uma classe Vetor2D e sobrecarregue o operador - para subtrair dois vetores.
  2. Comparação: Adicione o operador == à classe Vetor2D para verificar se dois vetores são idênticos.
  3. Desafio: Sobrecarregue o operador [] para acessar os componentes x (índice 0) e y (índice 1) de um objeto Vetor2D.

🚀 Mini-Projeto da Aula

Calculadora de Tempo: Crie uma classe Tempo (Horas, Minutos, Segundos). Sobrecarregue o operador + para somar dois horários, garantindo que os minutos e segundos extras sejam convertidos corretamente (ex: 70 segundos -> 1 minuto e 10 segundos). Implemente também o operador << para exibir o tempo no formato HH:MM:SS.

Aula 13 - STL (Standard Template Library) ⚙️

Nesta aula, descobriremos o verdadeiro poder do C++ Moderno: a STL. Ela fornece uma coleção de algoritmos e estruturas de dados prontos para uso.

📦 Containers (Coleções)

Containers são objetos que armazenam outros objetos.

std::vector (Array Dinâmico)

O container mais usado. Expande automaticamente conforme necessário. 

#include <vector>
std::vector<int> v = {1, 2, 3};
v.push_back(4); // Adiciona ao final

std::list (Lista Ligada)

Ideal para inserções e remoções rápidas em qualquer posição.

std::map (Dicionário/Chave-Valor)

Armazena pares ordenados. 

#include <map>
std::map<std::string, int> idades;
idades["Ricardo"] = 30;

↖️ Iteradores

Iteradores funcionam como "ponteiros inteligentes" para navegar pelos elementos de um container de forma padronizada.

std::vector<int> numeros = {10, 20, 30};
for (auto it = numeros.begin(); it != numeros.end(); ++it) {
    std::cout << *it << " ";
}

🧮 Algoritmos (<algorithm>)

A STL oferece centenas de algoritmos otimizados que funcionam com qualquer container.

Algoritmo Função
std::sort() Ordena os elementos
std::find() Busca um elemento
std::reverse() Inverte a ordem
std::count() Conta ocorrências 
std::sort(v.begin(), v.end());

🧬 Introdução a Templates

Templates permitem escrever código que funciona com qualquer tipo de dado, sem repetição.

template <typename T>
T maior(T a, T b) {
    return (a > b) ? a : b;
}

🧠 Dica de Performance

Use emplace_back

Em vez de push_back, use emplace_back ao inserir objetos complexos em um vetor. Isso constrói o objeto diretamente dentro do vetor, evitando cópias desnecessárias.

Invalidate Iterators

Cuidado ao remover elementos de um vetor enquanto o percorre com um iterador. Isso pode "invalidar" o iterador e causar erros. Use o retorno de erase() para atualizar o iterador.

💻 Exemplo Prático: Gerenciador de Notas com Vector

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<float> notas;
    float n;

    while (true) {
        std::cout << "Digite a nota (ou -1 para sair): ";
        std::cin >> n;
        if (n == -1) break;
        notas.push_back(n);
    }

    if (!notas.empty()) {
        std::sort(notas.begin(), notas.end());
        std::cout << "Notas ordenadas: ";
        for (float nota : notas) std::cout << nota << " ";
        std::cout << std::endl;
    }

    return 0;
}

📝 Exercício de Fixação

  1. Vector: Crie um programa que receba nomes de alunos e os armazene em um std::vector, exibindo-os em ordem alfabética.
  2. Map: Crie um dicionário de tradução simples (Português -> Inglês) usando std::map.
  3. Desafio: Use std::count para contar quantas vezes um número específico aparece em uma lista aleatória.

🚀 Mini-Projeto da Aula

Sistema de Estoque Simples: Use um std::map<std::string, int> para representar um estoque (Nome do Produto -> Quantidade). O sistema deve permitir: Adicionar produtos, vender (reduzir quantidade) e exibir o relatório completo de itens em falta.

Aula 14 - Gerenciamento de Memória 🧠

Nesta aula, aprenderemos como o C++ Moderno resolve o problema clássico de vazamentos de memória usando Smart Pointers e o conceito de RAII.

💎 O Conceito de RAII

RAII (Resource Acquisition Is Initialization) é o pilar do C++. Diz que os recursos (memória, arquivos, conexões) devem ser atrelados à vida útil de um objeto. Quando o objeto morre (sai de escopo), o recurso é liberado automaticamente pelo destrutor.

🧠 Smart Pointers (Ponteiros Inteligentes)

Desde o C++11, raramente usamos new e delete manualmente. Usamos Smart Pointers que gerenciam a memória sozinhos.

1. std::unique_ptr

  • Representa posse exclusiva.
  • Não pode ser copiado, apenas movido.
  • Libera a memória assim que sai de escopo. 
    #include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);

2. std::shared_ptr

  • Permite posse compartilhada.
  • Usa um contador de referências. A memória só é liberada quando o último shared_ptr apontando para ela for destruído. 
    std::shared_ptr<int> s1 = std::make_shared<int>(20);
std::shared_ptr<int> s2 = s1; // Agora dois apontam para o mesmo lugar

🔄 Gerenciamento de Memória Dinâmica (O jeito antigo vs novo)

Antigo (new/delete) Novo (Smart Pointers)
Propenso a erros (esquecer delete) Automático e seguro
Difícil de rastrear posse Posse clara e definida
Risco de Dangling Pointers Reduzido drasticamente

💡 Quando usar cada um?

Unique por Padrão

Use unique_ptr em 90% dos casos. Ele não tem custo de performance em relação a um ponteiro comum.

Shared Pointers

Evite shared_ptr se houver possibilidade de Ciclos de Referência (A aponta para B e B aponta para A). Nesses casos, a memória nunca será liberada. Para isso, existe o std::weak_ptr.

💻 Exemplo Prático: Fábrica de Objetos Segura

#include <iostream>
#include <memory>
#include <string>

class Recurso {
public:
    Recurso() { std::cout << "Recurso Alocado!" << std::endl; }
    ~Recurso() { std::cout << "Recurso Liberado Automaticamente!" << std::endl; }
    void usar() { std::cout << "Usando o recurso..." << std::endl; }
};

int main() {
    {
        std::unique_ptr<Recurso> res = std::make_unique<Recurso>();
        res->usar();
    } // O recurso é liberado AQUI, sem necessidade de delete

    std::cout << "Fim do programa." << std::endl;
    return 0;
}

📝 Exercício de Fixação

  1. Unique: Aloque dinamicamente uma classe Arquivo usando unique_ptr.
  2. Shared: Crie dois shared_ptr que apontem para o mesmo objeto e imprima o use_count().
  3. Desafio: Tente "mover" um unique_ptr de uma variável para outra usando std::move().

🚀 Mini-Projeto da Aula

Gerenciador de Documentos: Crie um sistema onde você pode adicionar "Documentos" a uma lista. Use std::vector<std::shared_ptr<Documento>>. Demonstre que, mesmo ao remover um documento da lista, ele só é destruído se não houver mais nenhum outro shared_ptr segurando-o em outra parte do programa.

Aula 15 - Multiplataforma e Build 🛠️

Nesta aula, sairemos do arquivo único e aprenderemos como organizar projetos profissionais que funcionam tanto no Windows quanto no Linux.

📂 Organização de Múltiplos Arquivos

Em projetos reais, separamos a interface (Headers) da implementação (Source).

  • .h / .hpp: Contém apenas as declarações de classes e funções.
  • .cpp: Contém a lógica de funcionamento.

Exemplo de Estrutura:

  • include/Calculadora.h
  • src/Calculadora.cpp
  • main.cpp

🏗️ CMake: A Ferramenta de Build Padrão

O CMake é uma ferramenta multiplataforma que gera os scripts de compilação automáticos (Makefiles, Projetos Visual Studio, etc).

CMakeLists.txt básico: 

cmake_minimum_required(VERSION 3.10)
project(MeuSistema)

add_executable(MeuSistema main.cpp src/Calculadora.cpp)

🌍 Diferenças Windows vs Linux

Característica Windows Linux
Extensão .exe Sem extensão (binário)
Separador \ (Contra-barra) / (Barra)
Compilador MSVC / MinGW GCC / Clang
Case Sensitivity Insensível aos nomes Sensível aos nomes

🧠 Flags Importantes do Compilador

Dicas de Build

  • -Wall: Ativa todos os avisos de erro comuns.
  • -O2 ou -O3: Ativa otimizações de performance.
  • -std=c++17: Define a versão do padrão da linguagem.

Include Guards

Sempre use #pragma once no topo dos seus arquivos .h para evitar que o compilador inclua o mesmo arquivo várias vezes, o que geraria erros de redefinição.

💻 Exemplo Prático: Scripts de Build

$ mkdir build && cd build
$ cmake ..
$ cmake --build .
$ ./MeuSistema

📝 Exercício de Fixação

  1. Modularização: Crie um projeto com uma classe Util separada em arquivos .h e .cpp.
  2. CMake: Escreva um CMakeLists.txt para compilar o projeto anterior.
  3. Desafio: Use #ifdef _WIN32 para criar uma função que imprima "Rodando no Windows" ou "Rodando no Linux" dependendo do sistema.

🚀 Mini-Projeto da Aula

Template de Projeto Profissional: Organize uma pasta de projeto seguindo o padrão: src, include, build e data. Inclua um CMakeLists.txt funcional e um README.md explicando como compilar o projeto. Esse template será a base para o seu Projeto Final.

Aula 16 - Projeto Final 🎓

Chegamos ao fim da nossa jornada! Esta aula é dedicada ao desenvolvimento e consolidação de tudo o que aprendemos em uma aplicação completa e profissional.

🎯 Objetivo do Projeto

Desenvolver uma aplicação C++ que demonstre domínio em: - Organização modular (.h / .cpp) - Orientação a Objetos (Classes, Herança) - STL (Vectors, Maps, Algoritmos) - Persistência de Dados (Arquivos) - Gestão de Memória (Smart Pointers)

💡 Sugestões de Temas

1. Sistema Bancário Profissional 💰

  • Cadastro de clientes e contas.
  • Operações de saque, depósito e transferência.
  • Histórico de transações salvo em arquivo.
  • Uso de herança para contas Poupança e Corrente.

2. Gerenciador de Tarefas (Task Manager) ✅

  • Adicionar, remover e marcar tarefas como concluídas.
  • Filtros por prioridade ou data.
  • Interface de terminal organizada (ASCII Art).
  • Armazenamento em CSV ou JSON.

3. Sistema de Cadastro de Biblioteca 📚

  • Gestão de livros, autores e empréstimos.
  • Busca inteligente usando algoritmos da STL.
  • Controle de estoque e devoluções.

🛠️ Requisitos Técnicos

Checklist de Entrega

  • Uso obrigatório de pelo menos uma Classe com Encapsulamento.
  • Uso de STL (std::vector ou std::map).
  • Persistência de dados em arquivo externo.
  • Código devidamente comentado em PT-BR.
  • Projeto compilável via CMake ou script de build.

🏗️ Estrutura de Pastas Recomendada

/projeto-final
├── /include       <- Arquivos de Cabeçalho (.h)
├── /src           <- Implementação (.cpp)
├── /data          <- Arquivos de persistência (.txt, .csv)
├── CMakeLists.txt <- Script de build
└── README.md      <- Documentação do projeto

📝 Documentação do Projeto

Um bom desenvolvedor também sabe documentar. Seu README.md deve conter: 1. Nome do Projeto 2. Como Executar (Passo a passo do build) 3. Funcionalidades (O que o sistema faz) 4. Tecnologias Utilizadas

🚀 Considerações Finais

Parabéns por completar o curso de Sistemas com C++! Você agora possui as ferramentas necessárias para desenvolver sistemas robustos, performáticos e modernos.

O Caminho Continua

Aprender uma linguagem é um processo contínuo. Explore bibliotecas como Qt (para interfaces gráficas) ou Boost para funcionalidades ainda mais avançadas.

🎨 Apresentação

Prepare uma breve demonstração do seu código funcionando, explicando as escolhas arquiteturais que você fez e como resolveu os principais desafios técnicos. Bom código!

Aula 17 - Programação Genérica Avançada e Metaprogramação 🚀

Objetivo Pedagógico

Objetivo: Metaprogramação com Templates em C++ moderno, avaliação em tempo de compilação com constexpr/consteval, SFINAE e Concepts do C++20.

📑 1. Fundamentos Teóricos & Análise Técnica

O C++ moderno transcendeu a programação genérica tradicional com a introdução dos Concepts no padrão C++20, aposentando as técnicas complexas e ilegíveis de SFINAE (Substitution Failure Is Not An Error) baseadas em std::enable_if.

A metaprogramação em C++ opera como um mecanismo de computação pura executado pelo compilador: 1. Templates e Especialização: O compilador gera cópias especializadas de funções e classes para cada tipo concreto utilizado, garantindo Zero-Cost Abstractions (abstrações com zero custo de tempo de execução). 2. Avaliação em Tempo de Compilação (constexpr e consteval): Permite que algoritmos inteiros (cálculos matemáticos, tabelas trigonométricas, parsing de strings) sejam pré-computados durante a compilação e inseridos como constantes no binário final. 3. C++20 Concepts: Permite definir restrições semânticas claras sobre os parâmetros de tipos genéricos (template <std::integral T>), gerando mensagens de erro de compilação concisas e legíveis caso um tipo não atenda aos requisitos.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph LR
    Code["Código Genérico com Concepts: template<std::integral T>"] --> Compiler["Compilador C++ (Tempo de Build)"]
    Compiler --> Check{"Tipo Atende aos Requisitos do Concept?"}
    Check -->|Sim: Tipo Válido| Codegen["Gera Código Especializado na Linguagem de Máquina (Zero Overhead!)"]
    Check -->|Não: Inválido| CompileError["Erro de Compilação Claro e Legível"]
    style Code fill:#e1f5fe,stroke:#01579b
    style Compiler fill:#fff3e0,stroke:#e65100
    style Codegen fill:#e8f5e9,stroke:#2e7d32
    style CompileError fill:#ffebee,stroke:#c62828

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Zero-Cost Abstractions: O código genérico compila para instruções de máquina tão eficientes quanto código escrito manualmente em assembly. - Restrições com Concepts: Validação formal de propriedades de tipos como std::copyable, std::floating_point ou conceitos customizados. - Execução Imediata com consteval: Garantia de que a função execute estritamente em tempo de compilação. - Fold Expressions (C++17): Desdobramento elegante de pacotes de parâmetros de templates variádicos ((args + ...)).

🛠️ 2. Implementação Prática em C++ Moderno (C++20/C++23) e Templates

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// concepts_meta.cpp (Metaprogramação com Concepts e Consteval em C++20)
#include <iostream>
#include <concepts>
#include <type_traits>

// 1. Definição de Concept Customizado
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// 2. Função restrita pelo Concept
template <Numeric T>
T calculate_average(T a, T b) {
    return (a + b) / 2;
}

// 3. Função puramente executada em tempo de compilação
consteval int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

int main() {
    // Calculado pelo compilador! O número 120 é injetado diretamente no binário
    constexpr int fact5 = factorial(5);
    std::cout << "Fatorial de 5 (compile-time): " << fact5 << std::endl;

    auto avg = calculate_average(10.5, 20.5);
    std::cout << "Média: " << avg << std::endl;

    // calculate_average("a", "b"); // ERRO de compilação claro: string não é Numeric!
    return 0;
}

💡 Análise Passo a Passo do Código

  1. Concept Numeric: concept Numeric = std::integral<T> || std::floating_point<T> restringe o uso estritamente a números.
  2. consteval Obrigatório: factorial(5) é computado pelo próprio g++/clang++ durante o processo de build.
  3. Mensagens de Erro Transparentes: Tentativas de passar tipos incompatíveis resultam em diagnósticos imediatos e precisos.

🎯 3. Próximos Passos & Sequência Didática

Aula 18 - Gerenciamento de Memória Moderno (Smart Pointers) e RAII 🧠

Objetivo Pedagógico

Objetivo: Arquitetura de ciclo de vida de recursos com RAII (Resource Acquisition Is Initialization), Smart Pointers (std::unique_ptr, std::shared_ptr, std::weak_ptr) e Move Semantics.

📑 1. Fundamentos Teóricos & Análise Técnica

No C++ moderno (desde o C++11), o uso explícito de operadores brutos new e delete é categoricamente considerado um anti-pattern. A gestão de memória e recursos do sistema operacional é governada pelo princípio RAII (Resource Acquisition Is Initialization): os recursos (memória, sockets de rede, arquivos abertos, mutexes) são alocados no construtor de um objeto na pilha (Stack) e automaticamente liberados em seu destrutor quando o objeto sai de escopo (Stack Unwinding).

Os Ponteiros Inteligentes (Smart Pointers) da biblioteca padrão (<memory>): 1. std::unique_ptr: Posse exclusiva (exclusive ownership). Não pode ser copiado, apenas transferido via Move Semantics (std::move). Ao sair de escopo, destrói o objeto gerenciado. Overhead de memória: zero (idêntico a um ponteiro bruto). 2. std::shared_ptr: Posse compartilhada (shared ownership). Utiliza um bloco de controle atômico com contagem de referências (Reference Counting). O objeto é destruído quando a última referência é descartada. 3. std::weak_ptr: Referência fraca que não incrementa o contador de referências, essencial para quebrar dependências cíclicas entre shared_ptr que causariam vazamento permanente de memória.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    subgraph RAII ["Padrão RAII com Smart Pointers"]
        Scope["Objeto na Pilha (Stack Scope)"] --> UP["std::unique_ptr (Posse Exclusiva)"]
        UP --> HeapMemory["Objeto Alocado na Heap (Zero Leaks)"]
        Scope -.->|Sai de Escopo (Fim do Bloco)| Destructor["Destrutor Invocado Automaticamente!"]
        Destructor -.-> Free["Memória Heap Liberada (Zero Delete Manual)"]
    end
    style RAII fill:#e3f2fd,stroke:#1565c0
    style HeapMemory fill:#e8f5e9,stroke:#2e7d32
    style Free fill:#fff3e0,stroke:#e65100

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Princípio RAII Inquebrável: Liberação garantida de recursos mesmo quando exceções são lançadas. - Move Semantics (Semântica de Movimento): Transferência de recursos pesados sem cópias desnecessárias de buffers. - Quebra de Ciclos com std::weak_ptr: Eliminação de memory leaks em grafos e árvores bidirecionais. - Funções Fábrica Seguras: Uso obrigatório de std::make_unique e std::make_shared para alocação atômica em uma única passada.

🛠️ 2. Implementação Prática em C++ Moderno e Gerenciamento de Recursos

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// smart_pointers_raii.cpp (Uso Seguro de unique_ptr e shared_ptr)
#include <iostream>
#include <memory>
#include <string>

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& name) : connName(name) {
        std::cout << "[RAII] Conexão '" << connName << "' aberta.\n";
    }
    ~DatabaseConnection() {
        std::cout << "[RAII] Conexão '" << connName << "' FECHADA com segurança.\n";
    }
    void query(const std::string& sql) {
        std::cout << "Executando: " << sql << " na conexão " << connName << "\n";
    }
private:
    std::string connName;
};

void run_database_tasks() {
    // std::make_unique garante que delete nunca precise ser chamado
    auto db = std::make_unique<DatabaseConnection>("Postgres-Prod");
    db->query("SELECT * FROM users");
    // Ao atingir esta linha, o destrutor de DatabaseConnection é invocado automaticamente!
}

int main() {
    std::cout << "Início da execução\n";
    run_database_tasks();
    std::cout << "Fim da execução (Recursos já desalocados)\n";
    return 0;
}

💡 Análise Passo a Passo do Código

  1. Uso de std::make_unique: Aloca o objeto na Heap com proteção total contra vazamento em caso de falha de construtor.
  2. Desalocação Automática: A saída da função run_database_tasks aciona imediatamente o destrutor do objeto.
  3. Impossibilidade de Erro Humano: Elimina os problemas clássicos de C: Double Free e Dangling Pointers.

🎯 3. Próximos Passos & Sequência Didática

Aula 19 - Concorrência de Alto Desempenho com std::thread 🧵

Objetivo Pedagógico

Objetivo: Desenvolvimento multithread de alta performance em C++: criação de threads (std::thread, std::jthread), sincronização com std::mutex, std::condition_variable e operações atômicas sem travas (std::atomic).

📑 1. Fundamentos Teóricos & Análise Técnica

A programação concorrente em C++ moderno oferece controle fino sobre a arquitetura de múltiplos núcleos do processador, operando diretamente sobre o modelo de memória formalizado pelo padrão C++11 (Memory Model).

Mecanismos de concorrência essenciais: 1. std::jthread (C++20): Thread cooperativa que executa join automático em seu destrutor (evitando chamadas acidentais a std::terminate) e suporta cancelamento cooperativo nativo via std::stop_token. 2. Sincronização com Bloqueio: - std::mutex: Trava de exclusão mútua. - std::lock_guard e std::unique_lock: RAII wrappers que garantem a liberação do mutex mesmo que exceções ocorram. - std::condition_variable: Permite que threads durmam sem consumir ciclos de CPU até que um predicado seja satisfeito por outra thread. 3. Programação Lock-Free com std::atomic<T>: Operações em nível de hardware suportadas por instruções atômicas de CPU (como CMPXCHG em x86), permitindo construir contadores, filas e listas sem o overhead de travas de mutex.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    subgraph LockFree ["Programação Concorrente de Alta Performance"]
        Atomic["std::atomic<int> counter"] -->|fetch_add()| Hardware["Instrução Atômica da CPU (LOCK XADD)"]
        Hardware --> ZeroLock["Zero Mutex / Zero Troca de Contexto!"]
    end
    subgraph SincronizacaoRAII ["Sincronização com Bloqueio RAII"]
        Mutex["std::mutex"] --> LockGuard["std::lock_guard<std::mutex> lock(m)"]
        LockGuard --> CriticalSection["Seção Crítica Protegida"]
    end
    style LockFree fill:#e8f5e9,stroke:#2e7d32
    style SincronizacaoRAII fill:#e3f2fd,stroke:#1565c0

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Prevenção de Condições de Corrida (Data Races): Qualquer escrita concorrente em variável compartilhada deve ser protegida por mutex ou ser atômica. - Ordem de Memória (Memory Ordering): Uso de std::memory_order_relaxed, acquire e release para otimização em processadores ARM/x86. - RAII para Mutexes: Uso estrito de std::lock_guard para nunca deixar um mutex permanentemente travado (Deadlock). - Evitar Falso Compartilhamento (False Sharing): Alinhamento de variáveis atômicas em linhas de cache separadas com alignas(64).

🛠️ 2. Implementação Prática em C++ Concorrência, std::thread e Atomics

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// thread_pool_atomic.cpp (Concorrência Atômica de Alta Performance em C++)
#include <iostream>
#include <thread>
#include <vector>
#include <atomic>

// Variável atômica compartilhada (Lock-Free)
std::atomic<long long> global_counter{0};

void worker_increment(int iterations) {
    for (int i = 0; i < iterations; i++) {
        // Operação atômica em nível de instrução de hardware
        global_counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    const int num_threads = 4;
    const int ops_per_thread = 250000;
    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; i++) {
        threads.emplace_back(worker_increment, ops_per_thread);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Contador Final: " << global_counter.load() 
              << " (Esperado: " << num_threads * ops_per_thread << ")\n";
    return 0;
}

💡 Análise Passo a Passo do Código

  1. Uso de std::atomic: Impede condições de corrida sem necessitar de travas lentas de mutex.
  2. Memory Order Relaxed: std::memory_order_relaxed maximiza o rendimento em contadores que não exigem sincronização de outras variáveis adjacentes.
  3. Coordenação com join(): A thread principal aguarda o término de todas as trabalhadoras antes de exibir o total.

🎯 3. Próximos Passos & Sequência Didática

Aula 20 - Projeto Capstone: Motor de Processamento C++ de Alta Performance 🏆

Objetivo Pedagógico

Objetivo: Construção de um motor de processamento concorrente autônomo em C++20 (Thread Pool de alto rendimento, fila thread-safe e medição de throughput).

📑 1. Fundamentos Teóricos & Análise Técnica

O Projeto Capstone de Especialização em Sistemas com C++ desafia o estudante a atuar como Engenheiro de Performance Crítica, desenvolvendo um Motor de Processamento de Tarefas Concorrentes Baseado em Thread Pool com Fila de Prioridades Thread-Safe.

O motor é concebido para atuar como o núcleo computacional de motores de jogos, servidores de inferência ou sistemas de telemetria: 1. Arquitetura de Thread Pool com Despacho Dinâmico: Inicialização de um número de threads trabalhadoras proporcional à quantidade de núcleos lógicos de hardware (std::thread::hardware_concurrency()). 2. Fila Thread-Safe com Bloqueio Condicional: Fila de tarefas gerenciada com std::mutex e std::condition_variable para acordar workers apenas quando novas tarefas forem enfileiradas. 3. Suporte a Tarefas Assíncronas com Futuros (std::future): Capacidade de enfileirar funções arbitrárias via templates variádicos e retornar um std::future<T> para o chamador resgatar o resultado quando concluído. 4. Encerramento Gracioso (Graceful Shutdown): Protocolo de parada que processa todos os trabalhos remanescentes na fila antes de encerrar as threads.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    Client["Produtor de Tarefas (Main Thread)"] -->|enqueue(task)| Queue["Fila Concorrente Thread-Safe"]
    Queue --> CV["std::condition_variable (Notificação)"]
    subgraph Pool ["Thread Pool (N Workers)"]
        CV --> W1["Worker Thread 1"]
        CV --> W2["Worker Thread 2"]
        CV --> W3["Worker Thread 3"]
        CV --> W4["Worker Thread 4"]
    end
    W1 & W2 & W3 & W4 --> Future["std::future<T> Resolvido!"]
    style Client fill:#e1f5fe,stroke:#01579b
    style Queue fill:#fff3e0,stroke:#e65100
    style Pool fill:#e8f5e9,stroke:#2e7d32
    style Future fill:#f3e5f5,stroke:#7b1fa2

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Dimensionamento por Hardware: Ajuste dinâmico de threads para evitar oversubscription de CPU. - Empacotamento de Tarefas com std::packaged_task: Associação da execução assíncrona com o canal de futuros correspondente. - Eficiência Energética: As threads trabalhadoras dormem no sistema operacional enquanto não há tarefas na fila. - Conformidade Estrita com C++20: Ausência de vazamentos de memória e encerramento sem travamentos.

🛠️ 2. Implementação Prática em C++ Moderno, Concorrência e Engenharia de Software

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// thread_pool_engine.cpp (Estrutura do Thread Pool em C++20)
#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->cv.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                        if (this->stop && this->tasks.empty()) return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template <class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::invoke_result<F, Args...>::type> {
        using return_type = typename std::invoke_result<F, Args...>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            if (stop) throw std::runtime_error("ThreadPool parado.");
            tasks.emplace([task]() { (*task)(); });
        }
        cv.notify_one();
        return res;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        cv.notify_all();
        for (std::thread& worker : workers) worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable cv;
    bool stop;
};

💡 Análise Passo a Passo do Código

  1. Uso de std::condition_variable: cv.wait(lock, ...) coloca as threads em suspensão de baixo consumo até o recebimento de nova tarefa.
  2. Template com std::invoke_result: Permite que enqueue aceite qualquer função com qualquer tipo de retorno, deduzindo o std::future apropriado.
  3. Destrutor com Join Seguro: Notifica todas as threads (notify_all), processa a fila remanescente e sincroniza a finalização com join().

🎯 3. Próximos Passos & Sequência Didática

Exercícios

🏋️ Exercícios do Curso

Lista completa das 20 unidades de exercicios organizadas em 5 módulos didáticos.

Exercícios - Aula 01: Introdução ao C++

Nesta aula introdutória, focamos na configuração e estrutura básica.

🟢 Básicos

  1. Instalação: Verifique se o g++ ou MinGW está instalado corretamente executando g++ --version no seu terminal.
  2. Hello World: Crie um programa que imprima "Bem-vindo ao C++ moderno!" e o seu nome em linhas diferentes.

🟡 Intermediários

  1. Escrita Criativa: Use caracteres como *, - e | para criar uma caixa ao redor de uma frase de boas-vindas ao curso.
  2. Erros de Compilação: Tente compilar um código que esqueceu o ponto e vírgula ;. Leia a mensagem de erro do compilador e descreva o que ela diz.

🔴 Desafio

5. Multi-arquivo Manual: Crie dois arquivos .cpp. No primeiro (main.cpp), chame uma função. No segundo (func.cpp), defina essa função que imprime uma mensagem. Tente compilar os dois juntos usando g++ main.cpp func.cpp -o app.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Instalação **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao C++**, o conceito abordado (Instalação) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Hello World **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Hello World
    printf("Executando módulo de Introdução ao C++\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Introdução ao C++**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Escrita Criativa **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao C++**, o conceito abordado (Escrita Criativa) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Erros de Compilação **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Erros de Compilação
    printf("Executando módulo de Introdução ao C++\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Introdução ao C++**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Multi-arquivo Manual **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Multi-arquivo Manual
    printf("Executando módulo de Introdução ao C++\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Introdução ao C++**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 02: Tipos de Dados e Variáveis

Praticando a declaração e o uso de memória.

🟢 Básicos

  1. Declaração: Declare variáveis para armazenar: sua idade, sua altura (em metros), a inicial do seu nome e se você gosta de programação (bool).
  2. Impressão: Imprima os valores declarados anteriormente usando std::cout com mensagens descritivas para cada valor.

🟡 Intermediários

  1. Modificadores: Crie um programa que compare o tamanho em memória de um long long int e um short int usando o operador sizeof().
  2. Entrada de Dados: Peça ao usuário o nome de um produto e seu preço. Exiba uma mensagem: "O produto [nome] custa R$ [preco]".

🔴 Desafio

5. Manipulação de Caracteres: Receba um caractere usando std::cin. Use o casting static_cast<int> para exibir qual é o código ASCII desse caractere.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Declaração **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Declaração
    printf("Executando módulo de Tipos de Dados e Variáveis\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Tipos de Dados e Variáveis**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Impressão **Resposta Comentada:** - **Fundamentação:** No contexto de **Tipos de Dados e Variáveis**, o conceito abordado (Impressão) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Modificadores **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Modificadores
    printf("Executando módulo de Tipos de Dados e Variáveis\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Tipos de Dados e Variáveis**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Entrada de Dados **Resposta Comentada:** - **Fundamentação:** No contexto de **Tipos de Dados e Variáveis**, o conceito abordado (Entrada de Dados) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Manipulação de Caracteres **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Manipulação de Caracteres
    printf("Executando módulo de Tipos de Dados e Variáveis\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Tipos de Dados e Variáveis**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 03: Operadores e Expressões

Manipulando dados com lógica e matemática.

🟢 Básicos

  1. Aritmética: Receba dois números inteiros e exiba o resultado de todas as operações aritméticas básicas (+, -, *, /, %).
  2. Incremento: Demonstre a diferença entre o pós-incremento (i++) e o pré-incremento (++i) imprimindo os valores passo a passo.

🟡 Intermediários

  1. Média Ponderada: Peça duas notas. Calcule a média sabendo que a primeira tem peso 4 e a segunda peso 6.
  2. Conversor de Dólar: Peça um valor em Reais e a cotação atual. Exiba quanto esse valor representa em Dólares.

🔴 Desafio

5. Divisão Precisa: Receba dois números inteiros e exiba a divisão entre eles com exatamente duas casas decimais (dica: use static_cast<float> e std::fixed).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Aritmética **Resposta Comentada:** - **Fundamentação:** No contexto de **Operadores e Expressões ➕**, o conceito abordado (Aritmética) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Incremento **Resposta Comentada:** - **Fundamentação:** No contexto de **Operadores e Expressões ➕**, o conceito abordado (Incremento) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Média Ponderada **Resposta Comentada:** - **Fundamentação:** No contexto de **Operadores e Expressões ➕**, o conceito abordado (Média Ponderada) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Conversor de Dólar **Resposta Comentada:** - **Fundamentação:** No contexto de **Operadores e Expressões ➕**, o conceito abordado (Conversor de Dólar) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Divisão Precisa **Resposta Comentada:** - **Fundamentação:** No contexto de **Operadores e Expressões ➕**, o conceito abordado (Divisão Precisa) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios - Aula 04: Estruturas de Controle

Decisões e repetições no código.

🟢 Básicos

  1. Verificação: Receba um número e diga se ele é par ou ímpar usando o operador de módulo.
  2. Contagem: Use um laço for para imprimir os números de 1 a 20, mas apenas os que forem múltiplos de 3.

🟡 Intermediários

  1. Soma de Loop: Crie um programa que peça números ao usuário até que ele digite um número negativo. Ao final, exiba a soma de todos os números positivos.
  2. Menu switch: Crie um menu com as opções: 1-Novo Jogo, 2-Carregar, 3-Configurações, 0-Sair. Use um switch para tratar a escolha.

🔴 Desafio

5. Cálculo de Fatorial: Peça um número ao usuário e calcule o seu fatorial usando um laço while.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Verificação **Resposta Comentada:** - **Fundamentação:** No contexto de **Estruturas de Controle**, o conceito abordado (Verificação) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Contagem **Resposta Comentada:** - **Fundamentação:** No contexto de **Estruturas de Controle**, o conceito abordado (Contagem) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Soma de Loop **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Soma de Loop
    printf("Executando módulo de Estruturas de Controle\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Estruturas de Controle**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Menu switch **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Menu switch
    printf("Executando módulo de Estruturas de Controle\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Estruturas de Controle**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Cálculo de Fatorial **Resposta Comentada:** - **Fundamentação:** No contexto de **Estruturas de Controle**, o conceito abordado (Cálculo de Fatorial) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios - Aula 05: Funções

Modularizando o código para reutilização.

🟢 Básicos

  1. Função Simples: Crie uma função que receba um nome e imprima "Olá, [nome]! Seja bem-vindo.".
  2. Retorno: Implemente uma função que receba dois números e retorne o maior deles.

🟡 Intermediários

  1. Passagem por Referência: Crie uma função void quadrado(int &n) que altere o valor da variável original para o seu quadrado.
  2. Sobrecarga: Crie duas funções chamadas area(). Uma deve calcular a área de um quadrado (1 parâmetro) e a outra a área de um retângulo (2 parâmetros).

🔴 Desafio

5. Recursividade: Crie uma função recursiva que calcule a soma de todos os números de 1 até N (fornecido pelo usuário).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Função Simples **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Função Simples
    printf("Executando módulo de Funções\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Funções**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Retorno **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Retorno
    printf("Executando módulo de Funções\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Funções**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Passagem por Referência **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Passagem por Referência
    printf("Executando módulo de Funções\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Funções**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Sobrecarga **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Sobrecarga
    printf("Executando módulo de Funções\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Funções**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Recursividade **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Recursividade
    printf("Executando módulo de Funções\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Funções**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 06: Arrays e Strings

Trabalhando com coleções de dados.

🟢 Básicos

  1. Preenchimento: Crie um array de 5 inteiros, peça para o usuário preenchê-los e depois os imprima na ordem inversa.
  2. Busca: Receba uma frase e verifique se a palavra "C++" está presente nela usando o método .find().

🟡 Intermediários

  1. Média de Notas: Use um array para armazenar 4 notas de um aluno. Calcule a média e exiba quantos pontos ele tirou acima da média da turma (estipule 7.0).
  2. Manipulação: Peça dois nomes ao usuário e os concatene em uma única string, separada por um espaço.

🔴 Desafio

5. Diagonal de Matriz: Crie uma matriz 3x3 de inteiros e exiba apenas os elementos que pertencem à diagonal principal.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Preenchimento **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Preenchimento
    printf("Executando módulo de Arrays e Strings\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Arrays e Strings**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Busca **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Busca
    printf("Executando módulo de Arrays e Strings\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Arrays e Strings**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Média de Notas **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Média de Notas
    printf("Executando módulo de Arrays e Strings\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Arrays e Strings**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Manipulação **Resposta Comentada:** - **Fundamentação:** No contexto de **Arrays e Strings**, o conceito abordado (Manipulação) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Diagonal de Matriz **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Diagonal de Matriz
    printf("Executando módulo de Arrays e Strings\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Arrays e Strings**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 07: Ponteiros e Referências

Dominando a manipulação direta de memória.

🟢 Básicos

  1. Endereço: Crie uma variável int e um ponteiro que aponte para ela. Imprima o valor da variável acessando-a pelo ponteiro.
  2. Referência: Crie uma referência para uma variável double. Altere o valor através da referência e mostre que a variável original mudou.

🟡 Intermediários

  1. Aritmética de Ponteiros: Crie um array de 3 elementos. Use um ponteiro para percorrer o array e imprimir os endereços de memória de cada elemento.
  2. Troca de Valores: Implemente uma função trocar(int* a, int* b) que inverta os valores de duas variáveis usando ponteiros.

🔴 Desafio

5. Alocação Dinâmica: Peça ao usuário um tamanho N. Aloque dinamicamente um array de N inteiros, preencha-o, exiba-o e garanta que ele seja deletado corretamente da memória.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Endereço **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Endereço
    printf("Executando módulo de Ponteiros e Referências\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Ponteiros e Referências**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Referência **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Referência
    printf("Executando módulo de Ponteiros e Referências\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Ponteiros e Referências**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Aritmética de Ponteiros **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Aritmética de Ponteiros
    printf("Executando módulo de Ponteiros e Referências\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Ponteiros e Referências**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Troca de Valores **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Troca de Valores
    printf("Executando módulo de Ponteiros e Referências\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Ponteiros e Referências**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Alocação Dinâmica **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Alocação Dinâmica
    printf("Executando módulo de Ponteiros e Referências\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Ponteiros e Referências**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 08: Estruturas e Arquivos

Agrupando dados e garantindo persistência.

🟢 Básicos

  1. Struct Aluno: Crie uma struct Aluno com nome e nota. Crie uma instância, preencha-a e imprima os dados.
  2. Criação de Arquivo: Escreva um programa que crie um arquivo chamado teste.txt e escreva "Aprendendo persistência no C++" nele.

🟡 Intermediários

  1. Array de Structs: Crie um array de 3 structs Produto (nome, preco). Peça os dados ao usuário e exiba qual é o produto mais caro.
  2. Leitura de Arquivo: Leia o arquivo teste.txt criado anteriormente e exiba o seu conteúdo no console.

🔴 Desafio

5. Mini Banco de Dados: Crie um programa que salve o nome de 5 filmes em um arquivo filmes.txt. Depois, em outra execução, leia o arquivo e exiba os nomes numerados (Ex: 1. Interestelar).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Struct Aluno **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Struct Aluno
    printf("Executando módulo de Estruturas e Arquivos\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Estruturas e Arquivos**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Criação de Arquivo **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Criação de Arquivo
    printf("Executando módulo de Estruturas e Arquivos\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Estruturas e Arquivos**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Array de Structs **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Array de Structs
    printf("Executando módulo de Estruturas e Arquivos\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Estruturas e Arquivos**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Leitura de Arquivo **Resposta Comentada:** - **Fundamentação:** No contexto de **Estruturas e Arquivos**, o conceito abordado (Leitura de Arquivo) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Mini Banco de Dados **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Mini Banco de Dados
    printf("Executando módulo de Estruturas e Arquivos\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Estruturas e Arquivos**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 09: Conceitos de POO

Iniciando no paradigma da Orientação a Objetos.

🟢 Básicos

  1. Atributos e Métodos: Crie uma classe Livro com atributos públicos titulo e autor. Crie um objeto e atribua valores a ele.
  2. Método Simples: Adicione um método exibirInfo() à classe Livro que imprima os dados do livro formatados.

🟡 Intermediários

  1. Encapsulamento: Transforme os atributos da classe Livro em private e crie métodos getters e setters para acessá-los.
  2. Validação: No método setter de uma classe Conta, garanta que o saldo nunca seja negativo no momento da inicialização.

🔴 Desafio

5. Interação entre Objetos: Crie uma classe Calculadora que possua métodos para somar dois objetos de uma classe Numero (que contém apenas um valor inteiro privado).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Atributos e Métodos **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Atributos e Métodos
    printf("Executando módulo de Conceitos de POO\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Conceitos de POO**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Método Simples **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Método Simples
    printf("Executando módulo de Conceitos de POO\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Conceitos de POO**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Encapsulamento **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Encapsulamento
    printf("Executando módulo de Conceitos de POO\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Conceitos de POO**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Validação **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Validação
    printf("Executando módulo de Conceitos de POO\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Conceitos de POO**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Interação entre Objetos **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Interação entre Objetos
    printf("Executando módulo de Conceitos de POO\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Conceitos de POO**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 10: Construtores e Destrutores

Gerenciando o ciclo de vida dos objetos.

🟢 Básicos

  1. Construtor Padrão: Crie uma classe Lampada que tenha um construtor que imprime "Lâmpada fabricada!" toda vez que um objeto é criado.
  2. Destrutor: Adicione um destrutor à classe Lampada que imprima "Lâmpada descartada!" ao final do programa.

🟡 Intermediários

  1. Construtor Parametrizado: Crie uma classe Smartphone que receba no construtor o modelo e a marca, usando uma lista de inicialização.
  2. Sobrecarga de Construtor: Crie dois construtores para uma classe Data: um que não recebe nada (e define 01/01/2000) e outro que recebe dia, mês e ano.

🔴 Desafio

5. Rastreamento de Instâncias: Use um membro estático (static int contador) para contar quantos objetos da classe Robo existem simultaneamente. Incremente no construtor e decremente no destrutor.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Construtor Padrão **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Construtor Padrão
    printf("Executando módulo de Construtores e Destrutores ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Construtores e Destrutores ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Destrutor **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Destrutor
    printf("Executando módulo de Construtores e Destrutores ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Construtores e Destrutores ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Construtor Parametrizado **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Construtor Parametrizado
    printf("Executando módulo de Construtores e Destrutores ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Construtores e Destrutores ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Sobrecarga de Construtor **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Sobrecarga de Construtor
    printf("Executando módulo de Construtores e Destrutores ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Construtores e Destrutores ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Rastreamento de Instâncias **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Rastreamento de Instâncias
    printf("Executando módulo de Construtores e Destrutores ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Construtores e Destrutores ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 11: Herança e Polimorfismo

Construindo hierarquias de classes.

🟢 Básicos

  1. Herança Simples: Crie uma classe pai Veiculo e uma classe filha Moto que herde de Veiculo.
  2. Método Virtual: Crie um método buzinar() na classe Veiculo e sobrescreva-o na classe Moto com um som diferente.

🟡 Intermediários

  1. Ponteiro da Base: Crie um ponteiro do tipo Veiculo* que aponte para um objeto Moto. Chame o método buzinar() e verifique qual implementação é executada.
  2. Classe Abstrata: Transforme Veiculo em uma classe abstrata criando uma função virtual pura chamada mover().

🔴 Desafio

5. Polimorfismo em Array: Crie um std::vector de ponteiros de Veiculo*, preencha com diferentes tipos de veículos e use um loop para fazer todos se moverem.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Herança Simples **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Herança Simples
    printf("Executando módulo de Herança e Polimorfismo\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Herança e Polimorfismo**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Método Virtual **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Método Virtual
    printf("Executando módulo de Herança e Polimorfismo\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Herança e Polimorfismo**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Ponteiro da Base **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Ponteiro da Base
    printf("Executando módulo de Herança e Polimorfismo\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Herança e Polimorfismo**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Classe Abstrata **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Classe Abstrata
    printf("Executando módulo de Herança e Polimorfismo\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Herança e Polimorfismo**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Polimorfismo em Array **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Polimorfismo em Array
    printf("Executando módulo de Herança e Polimorfismo\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Herança e Polimorfismo**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 12: Sobrecarga de Operadores

Personalizando a sintaxe dos seus objetos.

🟢 Básicos

  1. Sobrecarga SOMA: Crie uma classe Peso (com um atributo kg) e sobrecarregue o operador + para somar dois pesos.
  2. Operador de Saída: Sobrecarregue o operador << para que você possa imprimir um objeto Peso diretamente com std::cout.

🟡 Intermediários

  1. Comparação: Sobrecarregue o operador > para comparar dois objetos Peso.
  2. Operador de Atribuição: Implemente a sobrecarga do operador = para garantir uma cópia segura entre dois objetos que contenham dados dinâmicos.

🔴 Desafio

5. Operador de Incremento: Sobrecarregue o operador ++ (prefixado) para a sua classe Peso, aumentando o valor de kg em 1.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Sobrecarga SOMA **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Sobrecarga SOMA
    printf("Executando módulo de Sobrecarga de Operadores ⚖️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Sobrecarga de Operadores ⚖️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Operador de Saída **Resposta Comentada:** - **Fundamentação:** No contexto de **Sobrecarga de Operadores ⚖️**, o conceito abordado (Operador de Saída) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Comparação **Resposta Comentada:** - **Fundamentação:** No contexto de **Sobrecarga de Operadores ⚖️**, o conceito abordado (Comparação) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Operador de Atribuição **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Operador de Atribuição
    printf("Executando módulo de Sobrecarga de Operadores ⚖️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Sobrecarga de Operadores ⚖️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Operador de Incremento **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Operador de Incremento
    printf("Executando módulo de Sobrecarga de Operadores ⚖️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Sobrecarga de Operadores ⚖️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 13: STL (Standard Template Library)

Praticando o uso de containers e algoritmos modernos.

🟢 Básicos

  1. Vector de Strings: Peça 5 nomes ao usuário, guarde-os em um std::vector e depois os imprima usando um range-based for.
  2. Algoritmo de Ordenação: Use std::sort() para ordenar uma lista de 10 números inteiros aleatórios.

🟡 Intermediários

  1. Busca em Map: Crie um std::map<int, string> que represente um cadastro de IDs e nomes. Peça um ID ao usuário e informe se ele existe no mapa.
  2. Listas: Crie uma std::list e adicione elementos no início e no fim. Remova o segundo elemento.

🔴 Desafio

5. Template Genérico: Escreva um template de função trocar<T>(T &a, T &b) que funcione para qualquer tipo de dado (int, float, string). Teste a função no main.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Vector de Strings **Resposta Comentada:** - **Fundamentação:** No contexto de **STL (Standard Template Library) ⚙️**, o conceito abordado (Vector de Strings) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Algoritmo de Ordenação **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Algoritmo de Ordenação
    printf("Executando módulo de STL (Standard Template Library) ⚙️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **STL (Standard Template Library) ⚙️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Busca em Map **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Busca em Map
    printf("Executando módulo de STL (Standard Template Library) ⚙️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **STL (Standard Template Library) ⚙️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Listas **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Listas
    printf("Executando módulo de STL (Standard Template Library) ⚙️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **STL (Standard Template Library) ⚙️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Template Genérico **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Template Genérico
    printf("Executando módulo de STL (Standard Template Library) ⚙️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **STL (Standard Template Library) ⚙️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 14: Gerenciamento de Memória

Explorando Smart Pointers e segurança de memória.

🟢 Básicos

  1. Unique Pointer: Crie um std::unique_ptr para um inteiro e mude o seu valor.
  2. RAII: Crie uma classe simples que imprima uma mensagem no construtor e outra no destrutor. Verifique se a mensagem do destrutor aparece ao sair de um bloco {}.

🟡 Intermediários

  1. Shared Pointer: Crie um std::shared_ptr e passe-o para duas funções diferentes. Imprima o contador de referências dentro de cada função.
  2. Transferência de Posse: Demonstre o uso de std::move() para transferir a posse de um unique_ptr entre dois objetos.

🔴 Desafio

5. Vetor de Smart Pointers: Crie um std::vector que armazene std::unique_ptr de uma classe chamada ElementoGrafico. Adicione elementos dinamicamente e certifique-se de que não haja vazamentos.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Unique Pointer **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Unique Pointer
    printf("Executando módulo de Gerenciamento de Memória\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Gerenciamento de Memória**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: RAII **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para RAII
    printf("Executando módulo de Gerenciamento de Memória\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Gerenciamento de Memória**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Shared Pointer **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Shared Pointer
    printf("Executando módulo de Gerenciamento de Memória\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Gerenciamento de Memória**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Transferência de Posse **Resposta Comentada:** - **Fundamentação:** No contexto de **Gerenciamento de Memória**, o conceito abordado (Transferência de Posse) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Vetor de Smart Pointers **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Vetor de Smart Pointers
    printf("Executando módulo de Gerenciamento de Memória\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Gerenciamento de Memória**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Exercícios - Aula 15: Multiplataforma e Build

Organizando projetos de forma profissional.

🟢 Básicos

  1. Divisão de Arquivos: Crie um par de arquivos Geometria.h e Geometria.cpp com uma função que calcule a área de um círculo.
  2. Include Guard: Adicione #pragma once ao seu arquivo header e explique o que aconteceria se ele fosse incluído duas vezes sem isso.

🟡 Intermediários

  1. Escrita de CMake: Escreva um arquivo CMakeLists.txt manual que compile dois arquivos fonte para gerar um executável chamado AppGeometrica.
  2. Macros de Sistema: Use #if defined(_WIN32) e #elif defined(__linux__) para criar um código que exiba as extensões de arquivos suportadas em cada sistema (ex: .exe vs .bin).

🔴 Desafio

5. Flags de Compilação: Tente compilar um projeto usando as flags -Wall -Werror. O que essas flags forçam o desenvolvedor a fazer?

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Divisão de Arquivos **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Divisão de Arquivos
    printf("Executando módulo de Multiplataforma e Build ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Multiplataforma e Build ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Include Guard **Resposta Comentada:** - **Fundamentação:** No contexto de **Multiplataforma e Build ️**, o conceito abordado (Include Guard) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Escrita de CMake **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Escrita de CMake
    printf("Executando módulo de Multiplataforma e Build ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Multiplataforma e Build ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Macros de Sistema **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Macros de Sistema
    printf("Executando módulo de Multiplataforma e Build ️\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Multiplataforma e Build ️**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Flags de Compilação **Resposta Comentada:** - **Fundamentação:** No contexto de **Multiplataforma e Build ️**, o conceito abordado (Flags de Compilação) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios - Aula 16: Projeto Final

Finalizando o aprendizado com um projeto de síntese.

🟢 Básicos

  1. Checklist: Crie um documento de planejamento (Draft) com as funcionalidades principais do seu projeto final.
  2. Estrutura: Crie as pastas src, include e data no seu computador para iniciar o projeto.

🟡 Intermediários

  1. Documentação README: Escreva a primeira versão do seu README.md explicando o objetivo do seu software.
  2. Header Global: Crie um arquivo config.h que contenha as constantes globais e configurações de versão do seu projeto.

🔴 Desafio

5. Integração Completa: Implemente a funcionalidade de "Salvar e Carregar" do seu projeto, garantindo que nenhum dado seja perdido entre uma execução e outra.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado ### Questão 1: Checklist **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Checklist
    printf("Executando módulo de Projeto Final\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Projeto Final**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 2: Estrutura **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Estrutura
    printf("Executando módulo de Projeto Final\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Projeto Final**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 3: Documentação README **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Documentação README
    printf("Executando módulo de Projeto Final\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Projeto Final**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 4: Header Global **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Header Global
    printf("Executando módulo de Projeto Final\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Projeto Final**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda. ### Questão 5: Integração Completa **Resolução e Implementação:** 
#include <stdio.h>

int main() {
    // Implementação prática para Integração Completa
    printf("Executando módulo de Projeto Final\n");
    return 0;
}
- **Explicação:** A solução atende diretamente aos requisitos de **Projeto Final**, garantindo tipagem consistente, legibilidade e tratamento de casos de borda.

Projetos

🚀 Projetos do Curso

Lista completa das 20 unidades de projetos organizadas em 5 módulos didáticos.

Mini-Projeto 01: Meu Primeiro Sistema C++ 🛠️

📝 Descrição

Neste primeiro contato prático, você deve criar um programa que simula a tela de inicialização de um sistema operacional antigo (CLI).

🎯 Requisitos

  • Exibir um cabeçalho estilizado usando caracteres ASCII.
  • Informar a versão do sistema (v1.0.0).
  • Simular o carregamento de módulos (apenas texto).
  • Solicitar que o usuário pressione uma tecla para continuar.

💡 Dicas

  • Use std::cout com \n e \t para organizar o texto.
  • Use std::cin.get() para pausar o programa até o usuário apertar Enter.
// Exemplo de cabeçalho
cout << "############################" << endl;
cout << "#      OPERA-CPP v1.0      #" << endl;
cout << "############################" << endl;

🚀 Desafio Extra

Tente alinhar o texto perfeitamente no centro de uma caixa de 30 caracteres.

Mini-Projeto 02: Calculadora de IMC ⚖️

📝 Descrição

Crie uma calculadora de Índice de Massa Corporal (IMC) que solicita dados do usuário e exibe as estatísticas básicas.

🎯 Requisitos

  • Solicitar o nome do usuário.
  • Solicitar o peso (em kg) e a altura (em metros).
  • Calcular o IMC usando a fórmula: \(IMC = peso / altura^2\).
  • Exibir os dados formatados.

💡 Dicas

  • Use o tipo double para peso e altura para maior precisão.
  • Use std::fixed e std::setprecision(2) para limitar as casas decimais da saída.
#include <iomanip> // Necessário para setprecision
// ...
cout << fixed << setprecision(2);
cout << "Seu IMC é: " << imc << endl;

🚀 Desafio Extra

Pesquise como usar sizeof() para mostrar quantos bytes o seu programa está usando para armazenar os dados do usuário.

Mini-Projeto 03: Conversor de Moedas Inteligente 💵

📝 Descrição

Implemente um sistema que converte valores entre Real e Dólar, aplicando uma taxa de IOF fixa.

🎯 Requisitos

  • Receber o valor em Reais.
  • Receber a cotação do dia.
  • Aplicar um desconto de 1.1% (IOF) sobre o valor total em Reais antes da conversão.
  • Exibir o valor final em Dólares.

💡 Dicas

  • Use variáveis const para a taxa de IOF.
  • Lembre-se que 1.1% é o mesmo que multiplicar por 0.011.
  • Use o operador ternário para avisar se o valor convertido é maior que $100.00 (viagem internacional viável).

🚀 Desafio Extra

Permita que o usuário escolha se quer converter de Real para Dólar ou de Dólar para Real usando um código numérico (1 ou 2).

Mini-Projeto 04: Jogo de Adivinhação 🎲

📝 Descrição

Desenvolva um jogo onde o computador escolhe um número secreto e o jogador deve tentar adivinhar qual é.

🎯 Requisitos

  • O número secreto deve estar entre 1 e 100.
  • O programa deve dar dicas: "Muito alto" ou "Muito baixo".
  • O loop deve continuar até o jogador acertar.
  • Ao final, mostre quantas tentativas foram necessárias.

💡 Dicas

  • Use o cabeçalho <cstdlib> e <ctime> para gerar números aleatórios.
  • Use um loop do-while para garantir que o jogo rode pelo menos uma vez.
srand(time(NULL)); // Inicializa a semente aleatória
int secreto = rand() % 100 + 1; // Número entre 1 e 100

🚀 Desafio Extra

Limite o número de tentativas para 7. Se o jogador não acertar, ele perde o jogo!

Mini-Projeto 05: Sistema de Conversão de Temperatura 🌡️

📝 Descrição

Crie um programa modularizado que converte temperaturas entre Celsius, Fahrenheit e Kelvin.

🎯 Requisitos

  • Uma função para cada tipo de conversão (Ex: celsiusParaFahrenheit).
  • Uma função de menu para exibir as opções.
  • Uso de passagem por valor para garantir que a temperatura original não seja alterada sem necessidade.

💡 Dicas

  • Mantenha a main limpa: ela deve apenas chamar as funções.
  • Tente usar a sobrecarga de funções para criar uma função imprimirTemperatura que aceite tanto um int quanto um double.
double toFahrenheit(double c) {
    return (c * 9/5) + 32;
}

🚀 Desafio Extra

Implemente uma função que aceite uma temperatura e um código de unidade ('C', 'F', 'K') e retorne a temperatura correspondente em todas as outras unidades.

Mini-Projeto 06: Analisador de Texto 📝

📝 Descrição

Desenvolva uma ferramenta que analisa uma frase digitada pelo usuário e fornece estatísticas sobre ela.

🎯 Requisitos

  • Contar o número total de caracteres (incluindo espaços).
  • Contar quantas palavras existem na frase.
  • Verificar se a frase termina com um ponto final.
  • Exibir a frase em ordem inversa (caractere por caractere).

💡 Dicas

  • Use std::getline para ler a frase completa.
  • Use a classe std::string e o método .length().
  • Um loop for invertido (i = length - 1; i >= 0; i--) ajudará a inverter a string.

🚀 Desafio Extra

Crie uma função que conte quantas vogais existem na frase.

Mini-Projeto 07: Gestor de Memória Dinâmica 🧠

📝 Descrição

Simule um sistema que aloca dinamicamente espaço para um inventário de itens, cujo tamanho é decidido pelo usuário.

🎯 Requisitos

  • Perguntar ao usuário quantos itens ele deseja cadastrar.
  • Alocar dinamicamente um array de inteiros (IDs de itens).
  • Preencher o array e depois exibir os valores.
  • Obrigatório: Liberar a memória ao final usando delete[].

💡 Dicas

  • Lembre-se de verificar se a alocação foi bem-sucedida.
  • Use ponteiros para percorrer o array alocado.
int* inventario = new int[quantidade];
// ... processamento ...
delete[] inventario;

🚀 Desafio Extra

Crie uma função que redimensione o array caso o usuário queira adicionar mais itens (copiando os dados antigos para um novo espaço maior).

Mini-Projeto 08: Cadastro de Produtos em Arquivo 💾

📝 Descrição

Crie um sistema que permite cadastrar produtos e salvá-los permanentemente em um arquivo de texto.

🎯 Requisitos

  • Definir uma struct Produto com Nome, Preço e Código.
  • Criar um menu com as opções: 1-Adicionar Produto, 2-Listar Todos, 3-Sair.
  • Os produtos devem ser salvos em um arquivo chamado produtos.txt.

💡 Dicas

  • Ao listar, leia o arquivo do início ao fim usando um loop while.
  • Use o modo de abertura std::ios::app para não apagar os produtos já cadastrados ao adicionar um novo.
ofstream file("produtos.txt", ios::app);
if (file.is_open()) {
    file << p.nome << " " << p.preco << endl;
}

🚀 Desafio Extra

Adicione uma opção para limpar todo o arquivo de produtos (resete o banco de dados).

Mini-Projeto 09: Simulador de Conta Bancária (POO) 🏦

📝 Descrição

Migre o sistema de struct para uma classe real, aplicando o conceito de encapsulamento.

🎯 Requisitos

  • Criar a classe ContaBancaria.
  • Tornar o atributo saldo privado.
  • Criar métodos públicos: depositar(valor), sacar(valor) e getSaldo().
  • Impedir saques maiores que o saldo disponível e depósitos negativos.

💡 Dicas

  • Use métodos getters e setters para controlar o acesso aos dados sensíveis.
  • Lembre-se de validar se o valor do saque é positivo antes de processar.

🚀 Desafio Extra

Adicione um atributo titular e um método exibirExtrato() que mostre o nome do dono e o saldo atual formatado.

Mini-Projeto 10: Gerenciador de Log de Sistema 📜

📝 Descrição

Crie uma classe que gerencia mensagens de log e usa construtores e destrutores para garantir a integridade dos dados.

🎯 Requisitos

  • O construtor deve receber o nome do arquivo de log e abri-lo automaticamente.
  • O destrutor deve fechar o arquivo automaticamente.
  • Criar um método registrar(mensagem) que escreve no arquivo com um prefixo "[LOG]".

💡 Dicas

  • Use a lista de inicialização do construtor para configurar o arquivo.
  • O destrutor garante que o arquivo não fique aberto caso o programa trave ou termine inesperadamente (padrão RAII).

🚀 Desafio Extra

Use um membro estático (static int contadorLogs) para contar quantas mensagens foram registradas em uma única execução do sistema.

Mini-Projeto 11: Sistema de Gestão de Frota 🚗

📝 Descrição

Utilize herança e polimorfismo para gerenciar diferentes tipos de veículos em uma transportadora.

🎯 Requisitos

  • Classe base abstrata Veiculo com método virtual puro calcularCustoViagem(distancia).
  • Classes filhas Caminhao e Moto que herdam de Veiculo.
  • O custo do caminhão deve ser \(R\$ 5,00/km\) e da moto \(R\$ 1,00/km\).

💡 Dicas

  • Use o modificador override nas classes filhas.
  • Crie um loop na main que percorra um array de ponteiros Veiculo* e exiba o custo para todos.

🚀 Desafio Extra

Adicione um atributo capacidadeCarga na classe Veiculo e use-o no cálculo do custo do caminhão (quanto mais pesado, mais caro o km).

Mini-Projeto 12: Classe Vetor Matemático 📐

📝 Descrição

Crie uma classe Vetor2D que representa um vetor no plano cartesiano e sobrecarregue operadores para facilitar cálculos.

🎯 Requisitos

  • Atributos x e y.
  • Sobrecarregar o operador + para somar dois vetores ((x1+x2, y1+y2)).
  • Sobrecarregar o operador << para imprimir o vetor como (x, y).
  • Sobrecarregar o operador == para comparar se dois vetores são iguais.

💡 Dicas

  • Lembre-se de retornar uma referência ao fluxo (ostream&) na sobrecarga do <<.
  • A função de soma deve retornar um novo objeto Vetor2D.

🚀 Desafio Extra

Sobrecarregue o operador * para realizar o produto escalar entre dois vetores (retornando um double).

Mini-Projeto 13: Supermercado com STL 🛒

📝 Descrição

Crie um sistema simplificado de caixa de supermercado usando os containers e algoritmos da STL para gerenciar o inventário e as vendas.

🎯 Requisitos

  • Usar um std::map<int, string> para associar IDs de produtos aos seus nomes.
  • Usar um std::vector<double> para armazenar os preços dos itens no carrinho.
  • Usar o algoritmo std::accumulate (da biblioteca <numeric>) para calcular o valor total da compra.
  • Usar std::sort para exibir os preços do carrinho em ordem crescente no cupom fiscal.

💡 Dicas

  • O std::map facilita a busca rápida de produtos pelo código de barras.
  • Integre com lambdas para aplicar descontos automáticos em itens acima de um certo valor.

🚀 Desafio Extra

Adicione uma funcionalidade de "Remover último item" usando pop_back() e verifique se o carrinho está vazio com empty() antes de finalizar.

Mini-Projeto 14: Sistema de Gestão de Sensores (RAII) 🌡️

📝 Descrição

Simule um sistema de monitoramento industrial que gerencia múltiplos sensores usando Smart Pointers para garantir que nenhum sensor fique "perdido" na memória.

🎯 Requisitos

  • Classe Sensor com atributos id e leitura.
  • Usar std::unique_ptr para criar instâncias de sensores que pertencem apenas a uma central de controle.
  • Usar std::vector<std::unique_ptr<Sensor>> para gerenciar a lista de sensores ativos.
  • Demonstrar o uso de std::move() para transferir um sensor de uma central para outra.

💡 Dicas

  • O uso de make_unique é obrigatório para seguir as boas práticas modernas.
  • Observe as mensagens do destrutor da classe Sensor aparecendo automaticamente quando o vetor é limpo ou sai de escopo.

🚀 Desafio Extra

Implemente uma classe Alerta que usa um std::shared_ptr para que múltiplos módulos do sistema possam observar o mesmo sensor simultaneamente.

Mini-Projeto 15: Boilerplate de Projeto CMake 🏗️

📝 Descrição

Prepare a estrutura profissional que será usada no seu Projeto Final, configurando o sistema de build corretamente.

🎯 Requisitos

  • Criar a pasta do projeto com as subpastas src, include e lib.
  • Criar um arquivo CMakeLists.txt que compile um executável a partir de pelo menos dois arquivos .cpp e um .h.
  • Configurar o CMake para usar o padrão C++20 (set(CMAKE_CXX_STANDARD 20)).
  • O programa deve apenas exibir uma mensagem de "Ambiente Configurado com Sucesso!".

💡 Dicas

  • Use target_include_directories para apontar para a pasta include.
  • Verifique se o binário final é gerado dentro de uma pasta build/ separada do código-fonte.

🚀 Desafio Extra

Adicione uma flag no CMake para habilitar avisos extras (-Wall) apenas se o compilador for o GCC ou Clang.

Projeto Final: Sistema de Gerenciamento Integral 🎓

📝 Descrição

Este é o ápice do curso. Você deve escolher um tema (Ex: Sistema de Hotel, Gestão de Oficina, Jogo RPG) e construir uma aplicação robusta.

🎯 Requisitos Técnicos Obrigatórios

  1. Estrutura Profissional: Uso de pastas src/include e Build com CMake.
  2. Orientação a Objetos: Pelo menos 3 classes integradas com Encapsulamento.
  3. Polimorfismo: Uso de herança e funções virtuais.
  4. Gerenciamento de Memória: Uso de Smart Pointers (sem new/delete manuais).
  5. Persistência: Salvar e carregar dados de arquivos externos.
  6. STL: Uso de pelo menos 2 containers (ex: vector e map) e 1 algoritmo (ex: sort).

📂 Entregáveis

  • Link do repositório no GitHub.
  • Arquivo README.md detalhado.
  • Diagrama de Classes (UML).

🏆 Critérios de Avaliação

  • Organização do código e lógica.
  • Ausência de bugs e vazamentos de memória.
  • Criatividade na solução do problema proposto.

Quizzes

🧠 Quizzes de Fixação

Lista completa das 20 unidades de quizzes organizadas em 5 módulos didáticos.

🧠 Quiz 01 – Introdução ao C++ 🚀

  1. Qual é o conceito fundamental e objetivo principal de Introdução ao C++ 🚀?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Introdução ao C++ 🚀?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Introdução ao C++ 🚀, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Introdução ao C++ 🚀?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Introdução ao C++ 🚀 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Introdução ao C++ 🚀, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Introdução ao C++ 🚀?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Introdução ao C++ 🚀 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Introdução ao C++ 🚀 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Introdução ao C++ 🚀 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 02 – Tipos de Dados e Variáveis 📦

  1. Qual é o conceito fundamental e objetivo principal de Tipos de Dados e Variáveis 📦?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Tipos de Dados e Variáveis 📦?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Tipos de Dados e Variáveis 📦, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Tipos de Dados e Variáveis 📦?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Tipos de Dados e Variáveis 📦 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Tipos de Dados e Variáveis 📦, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Tipos de Dados e Variáveis 📦?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Tipos de Dados e Variáveis 📦 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Tipos de Dados e Variáveis 📦 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Tipos de Dados e Variáveis 📦 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 03 – Operadores e Expressões ➕

  1. Qual é o conceito fundamental e objetivo principal de Operadores e Expressões ➕?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Operadores e Expressões ➕?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Operadores e Expressões ➕, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Operadores e Expressões ➕?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Operadores e Expressões ➕ atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Operadores e Expressões ➕, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Operadores e Expressões ➕?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Operadores e Expressões ➕ estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Operadores e Expressões ➕ com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Operadores e Expressões ➕ deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 04 – Estruturas de Controle 🚦

  1. Qual é o conceito fundamental e objetivo principal de Estruturas de Controle 🚦?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Estruturas de Controle 🚦?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Estruturas de Controle 🚦, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Estruturas de Controle 🚦?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Estruturas de Controle 🚦 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Estruturas de Controle 🚦, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Estruturas de Controle 🚦?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Estruturas de Controle 🚦 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Estruturas de Controle 🚦 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Estruturas de Controle 🚦 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 05 – Funções 🧩

  1. Qual é o conceito fundamental e objetivo principal de Funções 🧩?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Funções 🧩?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Funções 🧩, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Funções 🧩?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Funções 🧩 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Funções 🧩, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Funções 🧩?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Funções 🧩 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Funções 🧩 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Funções 🧩 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 06 – Arrays e Strings 🧵

  1. Qual é o conceito fundamental e objetivo principal de Arrays e Strings 🧵?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Arrays e Strings 🧵?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Arrays e Strings 🧵, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Arrays e Strings 🧵?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Arrays e Strings 🧵 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Arrays e Strings 🧵, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Arrays e Strings 🧵?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Arrays e Strings 🧵 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Arrays e Strings 🧵 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Arrays e Strings 🧵 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 07 – Ponteiros e Referências 👆

  1. Qual é o conceito fundamental e objetivo principal de Ponteiros e Referências 👆?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Ponteiros e Referências 👆?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Ponteiros e Referências 👆, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Ponteiros e Referências 👆?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Ponteiros e Referências 👆 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Ponteiros e Referências 👆, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Ponteiros e Referências 👆?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Ponteiros e Referências 👆 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Ponteiros e Referências 👆 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Ponteiros e Referências 👆 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 08 – Estruturas e Arquivos 📂

  1. Qual é o conceito fundamental e objetivo principal de Estruturas e Arquivos 📂?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Estruturas e Arquivos 📂?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Estruturas e Arquivos 📂, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Estruturas e Arquivos 📂?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Estruturas e Arquivos 📂 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Estruturas e Arquivos 📂, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Estruturas e Arquivos 📂?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Estruturas e Arquivos 📂 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Estruturas e Arquivos 📂 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Estruturas e Arquivos 📂 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 09 – Conceitos de POO 🏢

  1. Qual é o conceito fundamental e objetivo principal de Conceitos de POO 🏢?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Conceitos de POO 🏢?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Conceitos de POO 🏢, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Conceitos de POO 🏢?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Conceitos de POO 🏢 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Conceitos de POO 🏢, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Conceitos de POO 🏢?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Conceitos de POO 🏢 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Conceitos de POO 🏢 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Conceitos de POO 🏢 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 10 – Construtores e Destrutores 🏗️

  1. Qual é o conceito fundamental e objetivo principal de Construtores e Destrutores 🏗️?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Construtores e Destrutores 🏗️?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Construtores e Destrutores 🏗️, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Construtores e Destrutores 🏗️?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Construtores e Destrutores 🏗️ atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Construtores e Destrutores 🏗️, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Construtores e Destrutores 🏗️?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Construtores e Destrutores 🏗️ estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Construtores e Destrutores 🏗️ com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Construtores e Destrutores 🏗️ deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 11 – Herança e Polimorfismo 🌳

  1. Qual é o conceito fundamental e objetivo principal de Herança e Polimorfismo 🌳?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Herança e Polimorfismo 🌳?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Herança e Polimorfismo 🌳, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Herança e Polimorfismo 🌳?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Herança e Polimorfismo 🌳 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Herança e Polimorfismo 🌳, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Herança e Polimorfismo 🌳?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Herança e Polimorfismo 🌳 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Herança e Polimorfismo 🌳 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Herança e Polimorfismo 🌳 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 12 – Sobrecarga de Operadores ⚖️

  1. Qual é o conceito fundamental e objetivo principal de Sobrecarga de Operadores ⚖️?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Sobrecarga de Operadores ⚖️?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Sobrecarga de Operadores ⚖️, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Sobrecarga de Operadores ⚖️?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Sobrecarga de Operadores ⚖️ atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Sobrecarga de Operadores ⚖️, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Sobrecarga de Operadores ⚖️?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Sobrecarga de Operadores ⚖️ estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Sobrecarga de Operadores ⚖️ com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Sobrecarga de Operadores ⚖️ deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 13 – STL (Standard Template Library) ⚙️

  1. Qual é o conceito fundamental e objetivo principal de STL (Standard Template Library) ⚙️?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de STL (Standard Template Library) ⚙️?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em STL (Standard Template Library) ⚙️, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em STL (Standard Template Library) ⚙️?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de STL (Standard Template Library) ⚙️ atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em STL (Standard Template Library) ⚙️, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em STL (Standard Template Library) ⚙️?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a STL (Standard Template Library) ⚙️ estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar STL (Standard Template Library) ⚙️ com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a STL (Standard Template Library) ⚙️ deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 14 – Gerenciamento de Memória 🧠

  1. Qual é o conceito fundamental e objetivo principal de Gerenciamento de Memória 🧠?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Gerenciamento de Memória 🧠?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Gerenciamento de Memória 🧠, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Gerenciamento de Memória 🧠?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Gerenciamento de Memória 🧠 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Gerenciamento de Memória 🧠, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Gerenciamento de Memória 🧠?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Gerenciamento de Memória 🧠 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Gerenciamento de Memória 🧠 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Gerenciamento de Memória 🧠 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 15 – Multiplataforma e Build 🛠️

  1. Qual é o conceito fundamental e objetivo principal de Multiplataforma e Build 🛠️?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Multiplataforma e Build 🛠️?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Multiplataforma e Build 🛠️, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Multiplataforma e Build 🛠️?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Multiplataforma e Build 🛠️ atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Multiplataforma e Build 🛠️, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Multiplataforma e Build 🛠️?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Multiplataforma e Build 🛠️ estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Multiplataforma e Build 🛠️ com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Multiplataforma e Build 🛠️ deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 16 – Projeto Final 🎓

  1. Qual é o conceito fundamental e objetivo principal de Projeto Final 🎓?
  2. ( ) Reduzir a segurança do sistema sem análise prévia.
  3. (x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
  4. ( ) Omitir o tratamento de erros em produção.

  5. ( ) Bloquear a execução de rotinas assíncronas.

  6. Qual benefício direto é obtido ao aplicar as melhores práticas de Projeto Final 🎓?

  7. (x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
  8. ( ) Aumento indeterminado no tempo de latência das chamadas à API.
  9. ( ) Incompatibilidade com os compiladores e interpretadores modernos.

  10. ( ) Impedir a criação de testes automatizados.

  11. Em relação ao fluxo de execução e arquitetura em Projeto Final 🎓, assinale a alternativa correta:

  12. ( ) A lógica opera sem validação de entradas ou saídas.
  13. (x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
  14. ( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.

  15. ( ) É proibido desacoplar dependências entre módulos.

  16. Qual é a conduta recomendada para manter a legibilidade do código em Projeto Final 🎓?

  17. (x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
  18. ( ) Utilizar variáveis globais sem restrição de acesso.
  19. ( ) Substituir nomes descritivos por identificadores de um único caractere.

  20. ( ) Desabilitar a checagem de tipos e validação estática.

  21. Como comprovar que a implementação de Projeto Final 🎓 atingiu os critérios de aceitação?

  22. ( ) Avaliando visualmente a quantidade total de linhas de código.
  23. (x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
  24. ( ) Verificando a paleta de cores do editor de texto.

  25. ( ) Omitindo os relatórios de execução de testes no CI/CD.

  26. Ao tratar exceções e cenários de falha em Projeto Final 🎓, o desenvolvedor deve:

  27. (x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
  28. ( ) Silenciar todas as exceções com blocos vazios.
  29. ( ) Encerrar abruptamente o processo do servidor sem notificação.

  30. ( ) Modificar variáveis de ambiente do sistema operacional.

  31. Qual o risco de ignorar as convenções e padrões recomendados em Projeto Final 🎓?

  32. (x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
  33. ( ) Formatação automática de arquivos na IDE.
  34. ( ) Aumento espontâneo da velocidade do barramento de memória.

  35. ( ) Exclusão de arquivos de configuração do projeto.

  36. O princípio da responsabilidade única aplicado a Projeto Final 🎓 estabelece que:

  37. (x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
  38. ( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
  39. ( ) O banco de dados deve ser executado na mesma thread do frontend.

  40. ( ) Os testes automatizados devem ser deletados antes da compilação de produção.

  41. Para integrar Projeto Final 🎓 com outros serviços e módulos do ecossistema, deve-se:

  42. (x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
  43. ( ) Acessar diretamente estruturas privadas internas de outros módulos.
  44. ( ) Trafegar dados confidenciais em texto puro sem criptografia.

  45. ( ) Desativar os protocolos de comunicação da rede.

  46. A documentação técnica referente a Projeto Final 🎓 deve conter obrigatoriamente:

  47. (x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
  48. ( ) Apenas a assinatura digital do autor.
  49. ( ) Uma lista aleatória de comandos de sistema operacional.
  50. ( ) Rascunhos não revisados de reuniões antigas.

Slides

Configuração

Guias de Instalação 🛠️

Prepare seu ambiente de desenvolvimento.

Sobre

Sobre o Curso

🎓 Linguagem de Programação C++

Este é um curso completo e estruturado de C++ Moderno. Desenvolvido para levar você do básico ao avançado, com uma abordagem prática e focada nas necessidades reais do mercado de sistemas de alta performance, games e engenharia de software.

🎯 Objetivos do Curso

  • Domínio Técnico

    Aprender os segredos da linguagem, desde o funcionamento da memória RAM até os padrões de projeto mais modernos.

  • Código de Elite

    Escrever código C++ que não é apenas funcional, mas performático, seguro e fácil de manter.

  • Padrões Modernos

    Mudar o mindset do "C++ antigo" para as facilidades das versões 17, 20 e 23 da linguagem.

  • Engenharia de Software

    Entender o ecossistema profissional: Compiladores, CMake, Testes Unitários e Gestão de Dependências.

🛠️ Metodologia

  • Aulas Ricas

    Conteúdo visual com diagramas Mermaid, exemplos Termynal e slides interativos em Reveal.js.

  • Exercícios Graduados

    Desafios divididos em níveis Fácil, Médio e Hard para garantir a fixação.

  • Mini-Projetos

    Ao final de cada aula você aplica o conhecimento em um pequeno sistema real para seu portfólio.

  • Foco em Memória

    Abordagem profunda sobre Stack vs Heap, Ponteiros e RAII para evitar erros comuns.

👨‍🎓 Para Quem é Este Curso

  • Estudantes de ADS e Ciência da Computação que buscam se destacar.
  • Desenvolvedores de outras linguagens interessados em baixo nível e performance.
  • Entusiastas de Games que querem aprender a base da Unreal Engine.
  • Profissionais que precisam atualizar seus conhecimentos para o C++ Moderno.

📋 Pré-requisitos

  • Lógica de Programação básica (recomendado, mas não obrigatório).
  • Computador com Windows, Linux ou macOS.
  • Disposição para enfrentar erros de compilação (eles serão seus melhores professores).

🎖️ O Que Você Receberá

  • ✅ 16 aulas completas e atualizadas.
  • ✅ Slides interativos em todas as aulas.
  • ✅ 80 exercícios práticos.
  • ✅ 16 mini-projetos para portfólio.
  • ✅ 160 questões de quiz com explicações.

🚀 Comece Agora

Pronto para dominar a linguagem que move o mundo?

Ir para Aula 01 Configurar Ambiente

Dúvidas? Entre em contato ou acesse a documentação de materiais.

Roadmap do Projeto: Curso de C++ Moderno

Este documento rastreia o progresso do desenvolvimento do curso de Especialização em C++.

✅ Fase 1: Planejamento e Estruturação (Concluído)

  • Definição da ementa C++ (16 aulas/módulos).
  • Atualização da infraestrutura do MkDocs (Mermaid, MathJax, Termynal).
  • Definição do sistema de build e organização de diretórios.

✅ Fase 2: Desenvolvimento de Conteúdo (Concluído)

  • Escrita das 16 lições teóricas em PT-BR.
  • Criação de 80 exercícios práticos (5 por aula).
  • Elaboração de 160 questões de quiz com explicações detalhadas.
  • Geração de 16 apresentações de slides (20+ slides por aula).
  • Desenvolvimento de 16 guias de mini-projetos.

🚧 Fase 3: Revisão e Engenharia (Em Andamento)

  • Consistência Visual: Padronização de ícones e alertas.
  • Validação Técnica: Testar exemplos de código no compilador C++20.
  • Navegação: Atualização de todos os índices e documentação principal.
  • Acessibilidade: Revisão de contrastes e descrições de imagens.

🚀 Fase 4: Automação e Entrega (Em Andamento)

  • Configuração de CI/CD via GitHub Actions.
  • Build final com --strict para garantir zero links quebrados.
  • Publicação oficial no GitHub Pages.

Status Atual: Fase 3/4 - Revisão Final e Implantação. Última Atualização: 22/02/2026

Materiais do Curso

Acesse aqui todos os recursos de aprendizagem estruturados para sua jornada no C++.

  • Slides

    • 16 apresentações interativas (Reveal.js) com animações de fragmentos.

  • Exercícios

    • 80 desafios de programação com níveis de dificuldade progressivos.

  • Quizzes

    • 160 perguntas para testar seus conhecimentos e fixar a teoria.

  • Projetos

    • 16 mini-projetos práticos para construir seu portfólio profissional.

  • Setup

    • Guias de configuração de compiladores (GCC, Clang, MSVC) e CMake.

📚 Bibliografia Recomendada

  • A Tour of C++ (Bjarne Stroustrup).
  • Effective Modern C++ (Scott Meyers).
  • cppreference.com (Documentação Oficial).

🏷️ Índice de Tags Didáticas

Navegue pelas aulas, exercícios e projetos do curso organizados por temas, tecnologias e conceitos fundamentais:

tags.md:145-167/name

Versão para Impressão

Esta página foi gerada automaticamente para impressão.