Comparativo de Plugins

1. Comparativo de Plugins

Comparação direta dos principais formatos e plugins para criar diagramas UML e outros diagramas direto em Markdown, levando em conta suporte no GitHub, facilidade de edição e capacidade de gerar diagramas como código.

Ferramenta	Tipo	Suporte direto no GitHub Markdown	Sintaxe/Modo de edição	Prós	Contras
Mermaid	Diagrama como código	Sim (renderiza direto no GitHub)	Texto (blocos ```mermaid)	✅ Renderiza no GitHub sem extensões ✅ Fácil versionamento ✅ Ideal para UML simples (classes, seq., ER, etc.)	❌ Menos opções visuais que Draw.io/Excalidraw ❌ Layout automático nem sempre perfeito
PlantUML	Diagrama como código	Não nativo (precisa converter para PNG/SVG antes ou usar GitHub Pages)	Texto (blocos ```plantuml)	✅ Extremamente poderoso (todos os tipos UML, temas, integração com código) ✅ Suporte avançado a estilos	❌ Não renderiza direto no GitHub ❌ Requer Java ou servidor PlantUML
Draw.io (diagrams.net)	Editor visual	Não direto (precisa exportar para imagem/SVG e inserir no README)	Arrastar e soltar	✅ Interface visual completa ✅ Extensa biblioteca de formas ✅ Integração com VS Code/Obsidian	❌ Não é “diagram-as-code” (difícil versionar) ❌ Dependência de exportar arquivo
Excalidraw	Editor visual estilo “whiteboard”	Não direto (mesmo caso do Draw.io)	Arrastar e soltar (foco em estilo à mão livre)	✅ Visual bonito, mais “orgânico” ✅ Bom para brainstorms e apresentações	❌ Não é código, exige exportar ❌ Layout menos preciso para UML formal
Graphviz / DOT	Diagrama como código	Não direto (precisa exportar)	Texto (blocos ```dot)	✅ Excelente para grafos complexos ✅ Integração com CI/CD	❌ Sintaxe pouco intuitiva ❌ Não renderiza no GitHub sem conversão
Kroki.io	Serviço web para diagramas como código	Parcial (via imagens SVG linkadas)	Suporta Mermaid, PlantUML, Graphviz, BPMN, etc.	✅ Suporta vários formatos num só lugar ✅ Não precisa instalar nada localmente	❌ Depende de servidor externo
Markmap	Mapas mentais como código	Não nativo (precisa GitHub Pages ou plugin)	Markdown estruturado	✅ Transformar Markdown em mapa mental direto	❌ Pouco suporte no GitHub direto

2. Foco no GitHub Markdown

No GitHub especificamente:

✅ Melhor suporte nativo: Mermaid → basta criar um bloco de código:

#````

classDiagram
    class Usuario {
    -nome: String
    +login(): void
    }
    class Admin
    Usuario <|-- Admin

#````

❌ PlantUML → só funciona direto se você converter para imagem (PNG/SVG) antes de subir, ou usar GitHub Pages + pipeline para renderizar.

3. Sugestões de uso prático

Cenário	Melhor Ferramenta
UML em Markdown no GitHub com visualização imediata	Mermaid
UML completo com todos recursos gráficos, mas render offline	PlantUML
Diagrama visual editável e colaborativo	Draw.io
Diagrama com estilo descontraído ou brainstorming	Excalidraw
Vários formatos de diagrama com código e centralização online	Kroki.io
Mapas mentais rápidos no Markdown	Markmap

4. Minha recomendação para Markdown + GitHub

Para documentação técnica diretamente no repositório → Mermaid (suporte nativo + versionamento fácil).
Para modelos UML avançados → PlantUML + export para SVG (inserir no Markdown).
Para diagrama visual mais polido → Draw.io (integrado ao VS Code ou Obsidian).
Para brainstorms ou fluxos não formais → Excalidraw.

Montar um exemplo do mesmo diagrama UML de classes escrito em Mermaid e em PlantUML, para você ver lado a lado como ficaria no GitHub. Isso ajudaria a decidir qual usar no seu fluxo.

👍 Montar o mesmo diagrama UML de classes em Mermaid (renderiza direto no GitHub) e PlantUML (mais avançado, mas precisa exportar para imagem antes).

O diagrama será este:

Classe Usuario (atributos: nome, email; métodos: login(), logout())
Classe Admin (herda de Usuario; método: gerenciarUsuarios())
Classe Cliente (herda de Usuario; método: comprar())

1️⃣ Mermaid (suporte nativo no GitHub)

Basta colar no seu README.md.

#````markdown

classDiagram
    class Usuario {
    -nome: String
    -email: String
    +login(): boolean
    +logout(): void
    }
    class Admin {
    +gerenciarUsuarios(): void
    }
    class Cliente {
    +comprar(): void
    }
    Usuario <|-- Admin
    Usuario <|-- Cliente

#````

2️⃣ PlantUML (mais completo, mas não renderiza direto no GitHub)

Para usar no GitHub, exporte para PNG/SVG antes, ou use Kroki.io ou GitHub Pages para renderizar.

#````markdown

@startuml
skinparam backgroundColor #F9F9F9
skinparam classAttributeIconSize 0
skinparam classFontSize 14
skinparam classAttributeFontSize 12
skinparam arrowColor #3366CC

class Usuario {
    -nome: String
    -email: String
    +login(): boolean
    +logout(): void
}

class Admin {
    +gerenciarUsuarios(): void
}

class Cliente {
    +comprar(): void
}

Usuario <|-- Admin
Usuario <|-- Cliente
@enduml

#````

Comparação rápida

Critério	Mermaid	PlantUML
Renderiza direto no GitHub	✅ Sim	❌ Não (precisa exportar)
Sintaxe	Mais simples	Mais detalhada e poderosa
Customização visual	Limitada	Avançada (cores, estilos, temas)
Tipos UML suportados	Básicos (classe, sequência, ERD, estado, etc.)	Quase todos (incluindo diagramas de componentes, atividades, pacotes, deploy)
Integração com código	Média	Alta (pode gerar diagramas a partir de código-fonte e anotações)

Vamos separar em dois blocos:

Mermaid → todos exemplos com suporte direto no GitHub Markdown, basta colar no README.
PlantUML → exemplos mais completos, mas precisam ser exportados para imagem antes de inserir no GitHub (ou via GitHub Pages).

1️⃣ Mermaid – exemplos com suporte direto no GitHub

Basta usar blocos ```mermaid no Markdown e o GitHub renderiza automaticamente.

UML de Classes

#````markdown

classDiagram
    class Usuario {
    -nome: String
    -email: String
    +login(): boolean
    +logout(): void
    }
    class Admin {
    +gerenciarUsuarios(): void
    }
    class Cliente {
    +comprar(): void
    }
    Usuario <|-- Admin
    Usuario <|-- Cliente

#````

Diagrama de Sequência

#````markdown

sequenceDiagram
    participant Cliente
    participant Sistema
    participant Banco
    Cliente->>Sistema: Solicita Login
    Sistema->>Banco: Verifica credenciais
    Banco-->>Sistema: Resposta
    Sistema-->>Cliente: Acesso concedido

#````

Diagrama Entidade-Relacionamento (ERD)

#````markdown

erDiagram
    CLIENTE {
    int id
    string nome
    string email
    }
    PEDIDO {
    int id
    date data
    float valor
    }
    CLIENTE ||--o{ PEDIDO : realiza

#````

2️⃣ PlantUML – exemplos mais completos (não renderiza direto no GitHub)

Você precisa exportar para .png ou .svg e inserir no Markdown. Ferramentas para converter: PlantUML Server, Kroki.io, VS Code plugin.

UML de Classes com Tema

#````markdown

@startuml
skinparam backgroundColor #F9F9F9
skinparam classAttributeIconSize 0

class Usuario {
    -nome: String
    -email: String
    +login(): boolean
    +logout(): void
}

class Admin {
    +gerenciarUsuarios(): void
}

class Cliente {
    +comprar(): void
}

Usuario <|-- Admin
Usuario <|-- Cliente
@enduml

#````

Diagrama de Sequência com Estilo

#````markdown

@startuml
skinparam sequenceArrowColor #3366CC
skinparam participantBackgroundColor #E6F2FF
skinparam sequenceLifeLineBorderColor #999999

actor Cliente
participant Sistema
database Banco

Cliente -> Sistema: Solicita Login
Sistema -> Banco: Verifica credenciais
Banco --> Sistema: Resposta
Sistema --> Cliente: Acesso concedido
@enduml

#````

Diagrama de Casos de Uso

#````markdown

@startuml
actor Cliente
actor Admin

usecase "Realizar Pedido" as UC1
usecase "Gerenciar Sistema" as UC2

Cliente --> UC1
Admin --> UC2
@enduml

#````

📌 Resumo

Mermaid → perfeito para diagramas rápidos direto no GitHub.
PlantUML → ideal para diagramas UML complexos e customizados, mas precisa converter antes.

O erro de “Parse error” acontece porque o Mermaid usa caracteres como parênteses ( ), pontos . e vírgulas , para definir a sua própria sintaxe. Quando você os usa diretamente no texto de um nó, ele não consegue interpretar o código corretamente.

Para resolver isso, basta colocar o texto que contém esses caracteres especiais entre aspas duplas (").

Objeto Aluno


    flowchart TD
    A["'Start"] --> B[""""Criar objeto Aluno"""""]
    B --> C["Capturar nome, idade, matrícula"]
    C --> D["'Chamar aluno.cadastrarDados(")"]
    D --> E["Capturar média"]
    E --> F["'Chamar aluno.cadastrarMediaNotas(")"]
    F --> G["'Chamar aluno.exibirInformacoes(")"]
    G --> H["End"]

Código Corrigido

Aqui estão os dois exemplos de fluxograma com a sintaxe corrigida.

Correção 1: Passando Dados como Argumentos

flowchart TD
    A["'Início"] --> B[""""Capturar nome, idade, matrícula"""""]
    B --> C["Criar objeto Aluno"]
    C --> D["'Chamar aluno.cadastrarDados(nome, idade, matrícula")"]
    D --> E["Capturar média"]
    E --> F["'Chamar aluno.cadastrarMediaNotas(media")"]
    F --> G["'Chamar aluno.exibirInformacoes(")"]
    G --> H["Fim"]

Correção 2: Usando um Construtor

flowchart TD
    A["'Início"] --> B[""""Capturar nome, idade, matrícula"""""]
    B --> C["'Criar objeto Aluno(nome, idade, matrícula")"]
    C --> D["Capturar média"]
    D --> E["'Chamar aluno.cadastrarMediaNotas(media")"]
    E --> F["'Chamar aluno.exibirInformacoes(")"]
    F --> G["Fim"]

A simples adição de aspas duplas nos nós que continham () e . resolve o problema de interpretação do código.

Quais dessas ferramentas para diagramas (Mermaid, PlantUML, etc.) funcionam diretamente no GitHub Pages com HTML gerado pelo Jekyll, e quais precisam de conversão prévia.

O funcionamento muda porque o GitHub Pages com Jekyll não processa todos os tipos de código da mesma forma que o renderizador nativo do README.

1️⃣ Suporte no README do GitHub x GitHub Pages (Jekyll)

Ferramenta	Suporte direto no README do repositório	Suporte direto no GitHub Pages / Jekyll	Observações
Mermaid	✅ Sim (renderização nativa desde 2022)	❌ Não direto (o Jekyll padrão não renderiza Mermaid)	Precisa incluir JS do Mermaid no layout HTML (`mermaid.min.js`) e inicializar com `<script>mermaid.initialize(...)</script>`
PlantUML	❌ Não nativo	❌ Não direto	Precisa gerar PNG/SVG antes ou usar Kroki.io / servidor PlantUML e embutir imagem
Draw.io	❌ Não nativo	❌ Não direto	Sempre precisa exportar para imagem/SVG
Excalidraw	❌ Não nativo	❌ Não direto	Mesmo caso do Draw.io
Graphviz / DOT	❌ Não nativo	❌ Não direto	Precisa gerar imagem antes ou usar Kroki
Kroki.io	❌ Não nativo	✅ Sim (com HTML `<img>` apontando para URL Kroki)	Funciona sem build local, gera diagrama dinamicamente
Markmap	❌ Não nativo	✅ Sim (precisa incluir `markmap.min.js` no tema Jekyll)	Permite mapas mentais no browser

2️⃣ Como usar no GitHub Pages / Jekyll

Mermaid no Jekyll

Você precisa injetar o script JS no seu tema _layouts/default.html ou equivalente:

<script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
<script>
  mermaid.initialize({ startOnLoad: true });
</script>

E no Markdown/HTML do Jekyll:

```mermaid
classDiagram
    A <|-- B
```

PlantUML no Jekyll

Opções:

Pré-renderizar com plantuml.jar → exporta PNG/SVG para a pasta do site.
Usar Kroki.io:

![Diagrama UML](https://kroki.io/plantuml/svg/eNp...)

Kroki.io no Jekyll

Permite incluir Mermaid, PlantUML, Graphviz, BPMN e outros via URL de imagem. Exemplo:

![Mermaid via Kroki](https://kroki.io/mermaid/svg/eNq...)

3️⃣ Resumo prático

Se quer usar GitHub Pages sem conversão manual → Kroki.io é a opção mais universal (funciona para Mermaid, PlantUML, Graphviz, etc.).
Se quer manter tudo local no HTML do Jekyll → usar Mermaid com script JS.
PlantUML direto só se usar Kroki ou pré-gerar as imagens.

Montar um template Jekyll pronto para GitHub Pages que suporta:

Mermaid.js → renderização de diagramas direto no navegador.
Kroki.io → renderização de PlantUML, Graphviz, ERD e vários outros sem precisar instalar nada localmente.

📂 Estrutura do Template

📦 meu-site-jekyll
 ┣ 📂 _layouts
 ┃ ┗ 📜 default.html
 ┣ 📂 assets
 ┃ ┗ 📜 style.css
 ┣ 📜 _config.yml
 ┣ 📜 index.md
 ┗ 📜 README.md

1️⃣ Arquivo `_layouts/default.html`

<!DOCTYPE html>
<html lang="pt-BR">
<head>
  <meta charset="UTF-8">
  <title>1. Comparativo de Plugins</title>
  <link rel="stylesheet" href="/portal_jekyll/assets/style.css">
</head>
<body>
  <main>
    <h1 id="linguagem-c-">Linguagem C++ 💻</h1>

<p>Bem-vindo ao guia de C++, uma evolução da linguagem C com recursos poderosos como orientação a objetos, strings nativas e um sistema de entrada e saída mais robusto. Este material é ideal para quem já tem noções de lógica e busca dominar os fundamentos do C++.</p>

<h2 id="️-instalação-e-configuração-do-ambiente-vs-code">🛠️ Instalação e Configuração do Ambiente (VS Code)</h2>

<p>Assim como em C, para programar em C++ você precisa de um <strong>compilador</strong> e de um <strong>IDE</strong>. O compilador para C++ que usaremos é o <strong>g++</strong>, que também faz parte do pacote <strong>MinGW</strong>.</p>

<p>O processo de instalação é o mesmo do guia de C:</p>

<ol>
  <li><strong>Instale o Compilador (MinGW-w64)</strong>: Siga as instruções para instalar o MinGW e adicionar sua pasta <code class="language-plaintext highlighter-rouge">bin</code> à variável de ambiente <code class="language-plaintext highlighter-rouge">Path</code> do Windows. Isso dará ao sistema acesso tanto ao <code class="language-plaintext highlighter-rouge">gcc</code> (para C) quanto ao <code class="language-plaintext highlighter-rouge">g++</code> (para C++).</li>
  <li><strong>Instale o VS Code</strong>: Baixe e instale o <a href="https://code.visualstudio.com/">Visual Studio Code</a>.</li>
  <li><strong>Instale a Extensão C/C++</strong>: No VS Code, instale a extensão “C/C++” da Microsoft para habilitar o suporte completo à linguagem.</li>
</ol>

<h3 id="-seu-primeiro-programa-em-c">🚀 Seu Primeiro Programa em C++</h3>

<p>Vamos criar o programa “Olá, Mundo!” na versão C++.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Ola, Universo C++!"</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p><strong>Saída Esperada:</strong></p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Ola, Universo C++!
</code></pre></div></div>

<p><strong>Análise do Código:</strong></p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">#include &lt;iostream&gt;</code>: Importa a biblioteca de <em>stream</em> (fluxo) de entrada e saída, essencial para usar <code class="language-plaintext highlighter-rouge">cout</code> e <code class="language-plaintext highlighter-rouge">cin</code>.</li>
  <li><code class="language-plaintext highlighter-rouge">using namespace std;</code>: Indica que usaremos elementos do <em>namespace</em> (espaço de nomes) <code class="language-plaintext highlighter-rouge">std</code> (standard/padrão). Isso nos permite escrever <code class="language-plaintext highlighter-rouge">cout</code> em vez de <code class="language-plaintext highlighter-rouge">std::cout</code>.</li>
  <li><code class="language-plaintext highlighter-rouge">int main()</code>: A função principal onde a execução do programa começa.</li>
  <li><code class="language-plaintext highlighter-rouge">cout &lt;&lt; "..." &lt;&lt; endl;</code>: <code class="language-plaintext highlighter-rouge">cout</code> é o objeto de saída padrão (o console). O operador <code class="language-plaintext highlighter-rouge">&lt;&lt;</code> “insere” dados no fluxo de saída. <code class="language-plaintext highlighter-rouge">endl</code> insere uma nova linha e limpa o buffer.</li>
  <li><code class="language-plaintext highlighter-rouge">return 0;</code>: Informa ao sistema operacional que o programa terminou com sucesso.</li>
</ul>

<h2 id="-tipos-de-dados-e-variáveis">📊 Tipos de Dados e Variáveis</h2>

<p>C++ herda os tipos de dados de C, mas adiciona tipos nativos que facilitam muito a programação, como <code class="language-plaintext highlighter-rouge">string</code> e <code class="language-plaintext highlighter-rouge">bool</code>.</p>

<table>
  <thead>
    <tr>
      <th style="text-align: left">Significado</th>
      <th style="text-align: left">Tipo em C++</th>
      <th style="text-align: left">Exemplo de Declaração</th>
      <th style="text-align: left">Observações</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: left">Número Inteiro</td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">int</code></td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">int quantidade;</code></td>
      <td style="text-align: left">Armazena números inteiros. Use <code class="language-plaintext highlighter-rouge">long long</code> para números muito grandes.</td>
    </tr>
    <tr>
      <td style="text-align: left">Número com Ponto Flutuante</td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">double</code></td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">double preco;</code></td>
      <td style="text-align: left">Armazena números reais com alta precisão. <code class="language-plaintext highlighter-rouge">float</code> pode ser usado para precisão simples.</td>
    </tr>
    <tr>
      <td style="text-align: left">Um Único Caractere</td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">char</code></td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">char categoria;</code></td>
      <td style="text-align: left">Armazena um caractere entre <strong>aspas simples</strong>. Ex: <code class="language-plaintext highlighter-rouge">'A'</code>.</td>
    </tr>
    <tr>
      <td style="text-align: left">Texto (String)</td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">string</code></td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">string nomeProduto;</code></td>
      <td style="text-align: left">Um tipo nativo poderoso e flexível para textos. Requer a biblioteca <code class="language-plaintext highlighter-rouge">&lt;string&gt;</code> e usa <strong>aspas duplas</strong>.</td>
    </tr>
    <tr>
      <td style="text-align: left">Valor Lógico (Booleano)</td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">bool</code></td>
      <td style="text-align: left"><code class="language-plaintext highlighter-rouge">bool emEstoque;</code></td>
      <td style="text-align: left">Armazena os valores <code class="language-plaintext highlighter-rouge">true</code> (verdadeiro) ou <code class="language-plaintext highlighter-rouge">false</code> (falso).</td>
    </tr>
  </tbody>
</table>

<h2 id="-declaração-e-atribuição-de-variáveis">📝 Declaração e Atribuição de Variáveis</h2>

<p>A declaração e atribuição em C++ são diretas e intuitivas, especialmente com o tipo <code class="language-plaintext highlighter-rouge">string</code>.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;string&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;iomanip&gt;</span><span class="c1"> // Para formatar a saída de dados</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="c1">// Declaração e inicialização de variáveis</span>
    <span class="kt">int</span> <span class="n">idade</span> <span class="o">=</span> <span class="mi">35</span><span class="p">;</span>
    <span class="kt">double</span> <span class="n">salario</span> <span class="o">=</span> <span class="mf">7500.90</span><span class="p">;</span>
    <span class="kt">double</span> <span class="n">altura</span> <span class="o">=</span> <span class="mf">1.82</span><span class="p">;</span>
    <span class="kt">char</span> <span class="n">genero</span> <span class="o">=</span> <span class="sc">'M'</span><span class="p">;</span>
    <span class="n">string</span> <span class="n">nome</span> <span class="o">=</span> <span class="s">"Carlos Pereira"</span><span class="p">;</span> <span class="c1">// Atribuição direta e simples</span>

    <span class="c1">// Configura a saída para exibir 2 casas decimais em números double</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">fixed</span> <span class="o">&lt;&lt;</span> <span class="n">setprecision</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>

    <span class="c1">// Saída de dados</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"NOME = "</span> <span class="o">&lt;&lt;</span> <span class="n">nome</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"IDADE = "</span> <span class="o">&lt;&lt;</span> <span class="n">idade</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"GENERO = "</span> <span class="o">&lt;&lt;</span> <span class="n">genero</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"ALTURA = "</span> <span class="o">&lt;&lt;</span> <span class="n">altura</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"SALARIO = R$ "</span> <span class="o">&lt;&lt;</span> <span class="n">salario</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p><strong>Saída Esperada:</strong></p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>NOME = Carlos Pereira
IDADE = 35
GENERO = M
ALTURA = 1.82
SALARIO = R$ 7500.90
</code></pre></div></div>

<h2 id="-operadores">🔢 Operadores</h2>

<p>Os operadores em C++ são, em sua maioria, idênticos aos da linguagem C.</p>

<h3 id="aritméticos">Aritméticos</h3>

<table>
  <thead>
    <tr>
      <th style="text-align: center">Operador</th>
      <th style="text-align: left">Significado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">+</code></td>
      <td style="text-align: left">Adição</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">-</code></td>
      <td style="text-align: left">Subtração</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">*</code></td>
      <td style="text-align: left">Multiplicação</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">/</code></td>
      <td style="text-align: left">Divisão</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">%</code></td>
      <td style="text-align: left">Resto da divisão (módulo)</td>
    </tr>
  </tbody>
</table>

<h3 id="comparativos">Comparativos</h3>

<table>
  <thead>
    <tr>
      <th style="text-align: center">Operador</th>
      <th style="text-align: left">Significado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">&lt;</code></td>
      <td style="text-align: left">Menor que</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">&gt;</code></td>
      <td style="text-align: left">Maior que</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">&lt;=</code></td>
      <td style="text-align: left">Menor ou igual a</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">&gt;=</code></td>
      <td style="text-align: left">Maior ou igual a</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">==</code></td>
      <td style="text-align: left">Igual a</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">!=</code></td>
      <td style="text-align: left">Diferente de</td>
    </tr>
  </tbody>
</table>

<h3 id="lógicos">Lógicos</h3>

<table>
  <thead>
    <tr>
      <th style="text-align: center">Operador</th>
      <th style="text-align: left">Significado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">&amp;&amp;</code></td>
      <td style="text-align: left">E (AND)</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">||</code></td>
      <td style="text-align: left">OU (OR)</td>
    </tr>
    <tr>
      <td style="text-align: center"><code class="language-plaintext highlighter-rouge">!</code></td>
      <td style="text-align: left">NÃO (NOT)</td>
    </tr>
  </tbody>
</table>

<h2 id="-saída-de-dados-com-cout">📤 Saída de Dados com <code class="language-plaintext highlighter-rouge">cout</code></h2>

<p>O <code class="language-plaintext highlighter-rouge">cout</code> é o principal meio de exibir informações no console em C++. Para formatar números, usamos manipuladores da biblioteca <code class="language-plaintext highlighter-rouge">&lt;iomanip&gt;</code>.</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">cout &lt;&lt; fixed &lt;&lt; setprecision(N);</code>: Define que a saída de números de ponto flutuante terá um número fixo de <code class="language-plaintext highlighter-rouge">N</code> casas decimais.</li>
</ul>

<p><strong>Nota sobre <code class="language-plaintext highlighter-rouge">#include &lt;bits/stdc++.h&gt;</code></strong>:
Você pode encontrar este comando em alguns códigos. Ele é um atalho (não padrão do C++) que inclui todas as bibliotecas padrão de uma vez. Embora seja prático para competições de programação, <strong>não é recomendado</strong> em projetos profissionais, pois aumenta o tempo de compilação e pode não ser compatível com todos os compiladores.</p>

<h2 id="-processamento-de-dados-e-casting">🔄 Processamento de Dados e Casting</h2>

<p>O <em>casting</em> (conversão de tipo) em C++ funciona de forma similar ao C e é crucial para operações matemáticas precisas.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;iomanip&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">a</span> <span class="o">=</span> <span class="mi">11</span><span class="p">;</span>
    <span class="kt">int</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">4</span><span class="p">;</span>
    <span class="kt">double</span> <span class="n">resultado</span><span class="p">;</span>

    <span class="c1">// A divisão de dois inteiros resulta em um inteiro (a parte decimal é truncada)</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Divisao de inteiros: "</span> <span class="o">&lt;&lt;</span> <span class="n">a</span> <span class="o">/</span> <span class="n">b</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span> <span class="c1">// Saída: 2</span>

    <span class="c1">// Fazendo o casting de 'a' para double para obter um resultado preciso</span>
    <span class="n">resultado</span> <span class="o">=</span> <span class="p">(</span><span class="kt">double</span><span class="p">)</span> <span class="n">a</span> <span class="o">/</span> <span class="n">b</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">fixed</span> <span class="o">&lt;&lt;</span> <span class="n">setprecision</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Divisao com casting: "</span> <span class="o">&lt;&lt;</span> <span class="n">resultado</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span> <span class="c1">// Saída: 2.75</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="-entrada-de-dados-com-cin">📥 Entrada de Dados com <code class="language-plaintext highlighter-rouge">cin</code></h2>

<p>Para receber dados do usuário, usamos o objeto <code class="language-plaintext highlighter-rouge">cin</code> com o operador de extração <code class="language-plaintext highlighter-rouge">&gt;&gt;</code>.</p>

<p><strong>Lendo Textos com Espaços (<code class="language-plaintext highlighter-rouge">getline</code>)</strong>
O <code class="language-plaintext highlighter-rouge">cin &gt;&gt;</code> lê a entrada até encontrar um espaço em branco. Para ler uma linha inteira de texto (com espaços), usamos a função <code class="language-plaintext highlighter-rouge">getline(cin, variavel_string);</code>.</p>

<p><strong>Limpando o Buffer de Entrada</strong>
Assim como em C, ler um número com <code class="language-plaintext highlighter-rouge">cin &gt;&gt;</code> deixa uma quebra de linha (<code class="language-plaintext highlighter-rouge">
</code>) no buffer. Isso pode atrapalhar uma chamada subsequente a <code class="language-plaintext highlighter-rouge">getline</code>. Para resolver isso, limpamos o buffer.</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">cin.ignore(INT_MAX, '
');</code>: Ignora todos os caracteres no buffer até encontrar e descartar a próxima quebra de linha.</li>
</ul>

<!-- end list -->

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;string&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;iomanip&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;climits&gt;</span><span class="c1"> // Para usar INT_MAX</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">idade</span><span class="p">;</span>
    <span class="kt">double</span> <span class="n">salario</span><span class="p">;</span>
    <span class="n">string</span> <span class="n">nome</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite sua idade: "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">idade</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite seu nome completo: "</span><span class="p">;</span>
    <span class="n">cin</span><span class="p">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">INT_MAX</span><span class="p">,</span> <span class="err">'</span>
<span class="err">'</span><span class="p">);</span> <span class="c1">// Limpeza de buffer obrigatória aqui!</span>
    <span class="n">getline</span><span class="p">(</span><span class="n">cin</span><span class="p">,</span> <span class="n">nome</span><span class="p">);</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite seu salario: "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">salario</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">fixed</span> <span class="o">&lt;&lt;</span> <span class="n">setprecision</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="err">
</span><span class="s">--- DADOS DIGITADOS ---</span><span class="err">
</span><span class="s">"</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Nome: "</span> <span class="o">&lt;&lt;</span> <span class="n">nome</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Idade: "</span> <span class="o">&lt;&lt;</span> <span class="n">idade</span> <span class="o">&lt;&lt;</span> <span class="s">" anos"</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Salario: R$ "</span> <span class="o">&lt;&lt;</span> <span class="n">salario</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="-estrutura-condicional-if-else">🔀 Estrutura Condicional (<code class="language-plaintext highlighter-rouge">if-else</code>)</h2>

<p>Permite executar blocos de código diferentes com base em uma condição.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">hora</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite uma hora do dia (0-23): "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">hora</span><span class="p">;</span>

    <span class="k">if</span> <span class="p">(</span><span class="n">hora</span> <span class="o">&lt;</span> <span class="mi">12</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Bom dia!"</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="p">}</span>
    <span class="k">else</span> <span class="nf">if</span> <span class="p">(</span><span class="n">hora</span> <span class="o">&lt;</span> <span class="mi">18</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Boa tarde!"</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="p">}</span>
    <span class="k">else</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Boa noite!"</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="-estruturas-de-repetição">🔁 Estruturas de Repetição</h2>

<h3 id="while-enquanto"><code class="language-plaintext highlighter-rouge">while</code> (Enquanto)</h3>

<p>Executa um bloco de código repetidamente enquanto uma condição for verdadeira. A condição é verificada <strong>antes</strong> de cada iteração.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">numero</span><span class="p">,</span> <span class="n">soma</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite um numero (0 para parar): "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">numero</span><span class="p">;</span>

    <span class="k">while</span> <span class="p">(</span><span class="n">numero</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">soma</span> <span class="o">+=</span> <span class="n">numero</span><span class="p">;</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite outro numero (0 para parar): "</span><span class="p">;</span>
        <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">numero</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"SOMA FINAL = "</span> <span class="o">&lt;&lt;</span> <span class="n">soma</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h3 id="for-para"><code class="language-plaintext highlighter-rouge">for</code> (Para)</h3>

<p>É a estrutura ideal para laços com um número conhecido de repetições.</p>

<p>Sintaxe: <code class="language-plaintext highlighter-rouge">for (inicialização; condição; incremento) { ... }</code></p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">N</span><span class="p">,</span> <span class="n">valor</span><span class="p">,</span> <span class="n">soma</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Quantos numeros voce quer somar? "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">N</span><span class="p">;</span>

    <span class="n">soma</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">N</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite o valor #"</span> <span class="o">&lt;&lt;</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">&lt;&lt;</span> <span class="s">": "</span><span class="p">;</span>
        <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">valor</span><span class="p">;</span>
        <span class="n">soma</span> <span class="o">+=</span> <span class="n">valor</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"SOMA = "</span> <span class="o">&lt;&lt;</span> <span class="n">soma</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h3 id="do-while-faça-enquanto"><code class="language-plaintext highlighter-rouge">do-while</code> (Faça-Enquanto)</h3>

<p>Garante que o bloco de código seja executado <strong>pelo menos uma vez</strong>, pois a condição é verificada <strong>ao final</strong> da iteração.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">double</span> <span class="n">C</span><span class="p">,</span> <span class="n">F</span><span class="p">;</span>
    <span class="kt">char</span> <span class="n">resposta</span><span class="p">;</span>

    <span class="k">do</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite a temperatura em Celsius: "</span><span class="p">;</span>
        <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">C</span><span class="p">;</span>

        <span class="n">F</span> <span class="o">=</span> <span class="mf">9.0</span> <span class="o">*</span> <span class="n">C</span> <span class="o">/</span> <span class="mf">5.0</span> <span class="o">+</span> <span class="mf">32.0</span><span class="p">;</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Equivalente em Fahrenheit: "</span> <span class="o">&lt;&lt;</span> <span class="n">F</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>

        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Deseja repetir (s/n)? "</span><span class="p">;</span>
        <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">resposta</span><span class="p">;</span>

    <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">resposta</span> <span class="o">==</span> <span class="sc">'s'</span><span class="p">);</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="-vetores-e-matrizes">📏 Vetores e Matrizes</h2>

<h3 id="vetores-arrays-c-style">Vetores (Arrays C-style)</h3>

<p>Vetores são coleções de tamanho fixo de elementos do mesmo tipo.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;iomanip&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">N</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Quantos numeros voce vai digitar? "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">N</span><span class="p">;</span>

    <span class="kt">double</span> <span class="n">vet</span><span class="p">[</span><span class="n">N</span><span class="p">];</span> <span class="c1">// Vetor C-style de tamanho N</span>

    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">N</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Digite um numero: "</span><span class="p">;</span>
        <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">vet</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
    <span class="p">}</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">fixed</span> <span class="o">&lt;&lt;</span> <span class="n">setprecision</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="err">
</span><span class="s">NUMEROS DIGITADOS:</span><span class="err">
</span><span class="s">"</span><span class="p">;</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">N</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">vet</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="p">}</span>
    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p><strong>Nota Moderna</strong>: Em C++ moderno, prefira usar <code class="language-plaintext highlighter-rouge">std::vector</code> (da biblioteca <code class="language-plaintext highlighter-rouge">&lt;vector&gt;</code>), que é um contêiner dinâmico e mais seguro.</p>

<h3 id="matrizes-arrays-2d-c-style">Matrizes (Arrays 2D C-style)</h3>

<p>Matrizes são estruturas bidimensionais, basicamente um vetor de vetores.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="kt">int</span> <span class="n">M</span><span class="p">,</span> <span class="n">N</span><span class="p">;</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Quantas linhas tera a matriz? "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">M</span><span class="p">;</span>
    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Quantas colunas tera a matriz? "</span><span class="p">;</span>
    <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">N</span><span class="p">;</span>

    <span class="kt">int</span> <span class="n">mat</span><span class="p">[</span><span class="n">M</span><span class="p">][</span><span class="n">N</span><span class="p">];</span>

    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">M</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">N</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
            <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Elemento ["</span> <span class="o">&lt;&lt;</span> <span class="n">i</span> <span class="o">&lt;&lt;</span> <span class="s">","</span> <span class="o">&lt;&lt;</span> <span class="n">j</span> <span class="o">&lt;&lt;</span> <span class="s">"]: "</span><span class="p">;</span>
            <span class="n">cin</span> <span class="o">&gt;&gt;</span> <span class="n">mat</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">];</span>
        <span class="p">}</span>
    <span class="p">}</span>

    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="err">
</span><span class="s">MATRIZ DIGITADA:</span><span class="err">
</span><span class="s">"</span><span class="p">;</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">M</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">N</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
            <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">mat</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="o">&lt;&lt;</span> <span class="s">" "</span><span class="p">;</span>
        <span class="p">}</span>
        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p><strong>Nota Moderna</strong>: Para matrizes dinâmicas em C++, a abordagem recomendada é <code class="language-plaintext highlighter-rouge">std::vector&lt;std::vector&lt;int&gt;&gt;</code>.</p>

<h2 id="-depuração-debugging-no-vs-code">🐞 Depuração (Debugging) no VS Code</h2>

<p>O processo de depuração em C++ no VS Code é idêntico ao de C.</p>

<ol>
  <li><strong>Marcar Breakpoints</strong>: Clique na margem à esquerda do número da linha para criar um ponto de parada.</li>
  <li><strong>Iniciar Depuração</strong>: Pressione <code class="language-plaintext highlighter-rouge">F5</code> para iniciar.</li>
  <li><strong>Controlar Execução</strong>: Use <code class="language-plaintext highlighter-rouge">F10</code> (Step Over) para executar linha por linha e <code class="language-plaintext highlighter-rouge">F5</code> para continuar até o próximo breakpoint.</li>
  <li><strong>Analisar Variáveis</strong>: Inspecione os valores das variáveis na janela <code class="language-plaintext highlighter-rouge">VARIABLES</code> do painel de depuração.</li>
</ol>

<hr />


  </main>

  <!-- Mermaid.js -->
  <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
  <script>
    mermaid.initialize({
      startOnLoad: true,
      theme: "default",
      securityLevel: 'loose'
    });
  </script>
</body>
</html>

2️⃣ Arquivo `_config.yml`

title: "Meu Site com Mermaid e Kroki"
description: "Exemplo de integração de diagramas no GitHub Pages"
theme: minima
markdown: kramdown
plugins:
  - jekyll-feed

3️⃣ Arquivo `index.md`

---
layout: default
title: "Exemplo de Diagramas"
---

# 🖼 Exemplos

## 1. Mermaid - Diagrama de Classes
```mermaid
classDiagram
    class Usuario {
    -nome: String
    -email: String
    +login(): boolean
    +logout(): void
    }
    class Admin {
    +gerenciarUsuarios(): void
    }
    Usuario <|-- Admin
```

---

## 2. Kroki + PlantUML (embed via imagem SVG)
![Diagrama PlantUML via Kroki](https://kroki.io/plantuml/svg/eNpLzkksLlZIzcnJVyjPL8pJAQAJxwXS)

> O link acima foi gerado com um diagrama simples no [Kroki.io](https://kroki.io)

4️⃣ Arquivo `assets/style.css`

body {
    font-family: Arial, sans-serif;
    margin: 2rem;
    background-color: #f9f9f9;
}

main {
    background: #fff;
    padding: 2rem;
    border-radius: 8px;
    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
}

5️⃣ Como configurar no GitHub Pages

Crie um novo repositório no GitHub: meu-site-jekyll.
Clone para sua máquina e copie os arquivos acima.
Faça commit e push para o branch main.
No GitHub, vá em Settings → Pages.
Em Source, escolha:
- Deploy from a branch
- Branch: main
- Pasta: / (root)
Salve.
Aguarde o GitHub Pages publicar (leva 1-2 minutos).
Acesse seu site: https://seuusuario.github.io/meu-site-jekyll/.

6️⃣ Como gerar links Kroki para PlantUML

Vá até https://kroki.io.
Escolha PlantUML no menu.
Cole seu diagrama, por exemplo:
```
@startuml
Alice -> Bob: Olá!
@enduml
```
Clique em GET URL → copie o link gerado (formato PNG ou SVG).
No Markdown, insira como:
```
![Meu Diagrama](URL-GERADO-PELO-KROKI)
```

🥞 Portal de Conteúdos ADS

Portal de Conteúdos ADS

1. Comparativo de Plugins

2. Foco no GitHub Markdown

3. Sugestões de uso prático

4. Minha recomendação para Markdown + GitHub

1️⃣ Mermaid (suporte nativo no GitHub)

2️⃣ PlantUML (mais completo, mas não renderiza direto no GitHub)

Comparação rápida

1️⃣ Mermaid – exemplos com suporte direto no GitHub

UML de Classes

Diagrama de Sequência

Diagrama Entidade-Relacionamento (ERD)

2️⃣ PlantUML – exemplos mais completos (não renderiza direto no GitHub)

UML de Classes com Tema

Diagrama de Sequência com Estilo

Diagrama de Casos de Uso

Código Corrigido

Correção 1: Passando Dados como Argumentos

Correção 2: Usando um Construtor

1️⃣ Suporte no README do GitHub x GitHub Pages (Jekyll)

2️⃣ Como usar no GitHub Pages / Jekyll

Mermaid no Jekyll

PlantUML no Jekyll

Kroki.io no Jekyll

3️⃣ Resumo prático

📂 Estrutura do Template

1️⃣ Arquivo `_layouts/default.html`

2️⃣ Arquivo `_config.yml`

3️⃣ Arquivo `index.md`

4️⃣ Arquivo `assets/style.css`

5️⃣ Como configurar no GitHub Pages

6️⃣ Como gerar links Kroki para PlantUML

1. Comparativo de Plugins

2. Foco no GitHub Markdown

3. Sugestões de uso prático

4. Minha recomendação para Markdown + GitHub

1️⃣ Mermaid (suporte nativo no GitHub)

2️⃣ PlantUML (mais completo, mas não renderiza direto no GitHub)

Comparação rápida

1️⃣ Mermaid – exemplos com suporte direto no GitHub

UML de Classes

Diagrama de Sequência

Diagrama Entidade-Relacionamento (ERD)

2️⃣ PlantUML – exemplos mais completos (não renderiza direto no GitHub)

UML de Classes com Tema

Diagrama de Sequência com Estilo

Diagrama de Casos de Uso

Código Corrigido

Correção 1: Passando Dados como Argumentos

Correção 2: Usando um Construtor

1️⃣ Suporte no README do GitHub x GitHub Pages (Jekyll)

2️⃣ Como usar no GitHub Pages / Jekyll

Mermaid no Jekyll

PlantUML no Jekyll

Kroki.io no Jekyll

3️⃣ Resumo prático

📂 Estrutura do Template

1️⃣ Arquivo _layouts/default.html

2️⃣ Arquivo _config.yml

3️⃣ Arquivo index.md

4️⃣ Arquivo assets/style.css

5️⃣ Como configurar no GitHub Pages

6️⃣ Como gerar links Kroki para PlantUML

1️⃣ Arquivo `_layouts/default.html`

2️⃣ Arquivo `_config.yml`

3️⃣ Arquivo `index.md`

4️⃣ Arquivo `assets/style.css`