# C & C++

## Introdução

**C** é uma linguagem de programação de propósito geral, criada por Dennis Ritchie nos anos 1970, que serve como base para sistemas operacionais, embarcados e software de baixo nível. **C++** é uma extensão do C que adiciona suporte a orientação a objetos, templates e recursos modernos, mantendo compatibilidade com a maioria do código C.

Ambas são linguagens **compiladas**, **estaticamente tipadas** e oferecem **controle direto sobre a memória**, sendo amplamente utilizadas em sistemas operacionais (Linux, Windows), jogos, drivers, sistemas embarcados e aplicações de alta performance.

## Por que C/C++ para Segurança e Sistemas?

O conhecimento de C/C++ é essencial para:

* **Análise de vulnerabilidades**: Buffer overflow, use-after-free, memory leaks.
* **Engenharia reversa**: Entender binários e exploits.
* **Desenvolvimento de sistemas**: Kernels, drivers, firmware.
* **Programação de baixo nível**: Manipulação direta de memória e hardware.
* **Frameworks e bibliotecas**: Qt, Boost, Unreal Engine.

## Estrutura Básica de um Programa C

### Hello World em C

```c
#include <stdio.h>

int main() {
    printf("Olá, mundo!\n");
    return 0;
}
```

### Hello World em C++

```cpp
#include <iostream>

int main() {
    std::cout << "Olá, mundo!" << std::endl;
    return 0;
}
```

### Elementos Fundamentais

| Elemento                 | Descrição                                              |
| ------------------------ | ------------------------------------------------------ |
| `#include <stdio.h>`     | Diretiva de pré-processador que inclui bibliotecas     |
| `int main()`             | Função principal, ponto de entrada do programa         |
| `printf()` / `std::cout` | Funções para saída de dados                            |
| `return 0`               | Código de retorno (0 indica sucesso)                   |
| `;`                      | Ponto e vírgula obrigatório ao final de cada instrução |

## Compilação e Execução

### Compilando C

```bash
# GCC (GNU Compiler Collection)
gcc programa.c -o programa
./programa

# Com warnings e depuração
gcc -Wall -g programa.c -o programa
```

### Compilando C++

```bash
# G++
g++ programa.cpp -o programa
./programa

# Com padrão C++ moderno
g++ -std=c++17 programa.cpp -o programa
```

### Principais Compiladores

| Compilador | Linguagem | Uso Comum                 |
| ---------- | --------- | ------------------------- |
| GCC        | C/C++     | Linux, Unix-like          |
| Clang      | C/C++     | macOS, alternativa ao GCC |
| MSVC       | C/C++     | Windows (Visual Studio)   |
| MinGW      | C/C++     | Windows (ambiente GNU)    |

## Tipos de Dados Básicos

### C e C++ (Comuns)

| Tipo     | Tamanho (bytes)\* | Faixa Aproximada                        |
| -------- | ----------------: | --------------------------------------- |
| `char`   |                 1 | -128 a 127 ou 0 a 255                   |
| `int`    |                 4 | -2.1B a 2.1B                            |
| `short`  |                 2 | -32.768 a 32.767                        |
| `long`   |            4 ou 8 | Dependente do sistema                   |
| `float`  |                 4 | ±1.2E-38 a ±3.4E+38                     |
| `double` |                 8 | ±2.3E-308 a ±1.7E+308                   |
| `void`   |                 - | Sem tipo (usado em ponteiros e funções) |

\*Tamanhos podem variar conforme arquitetura e compilador

### Modificadores de Tipo

```c
unsigned int idade = 25;    // Apenas valores positivos
long int populacao = 8000000000;
short int temperatura = -40;
const float PI = 3.14159;   // Constante, não pode ser alterada
```

## Variáveis e Escopo

### Declaração e Inicialização

```c
int a;              // Declaração (valor indefinido)
int b = 10;         // Inicialização
int c, d = 20;      // c indefinido, d = 20
```

### Escopo de Variáveis

```c
int global = 100;   // Variável global (acessível em todo o programa)

void funcao() {
    int local = 10; // Variável local (apenas dentro da função)
    static int estatica = 0; // Mantém valor entre chamadas
    estatica++;
}
```

### Qualificadores de Tipo

| Qualificador | Descrição                                                          |
| ------------ | ------------------------------------------------------------------ |
| `const`      | Valor não pode ser modificado                                      |
| `volatile`   | Valor pode ser alterado externamente (hardware, threads)           |
| `static`     | Variável local mantém valor; variável global tem escopo de arquivo |
| `extern`     | Declara variável definida em outro arquivo                         |

## Estruturas de Controle

### Condicionais

```c
int idade = 20;

if (idade >= 18) {
    printf("Maior de idade\n");
} else if (idade >= 16) {
    printf("Pode votar, mas não dirigir\n");
} else {
    printf("Menor de idade\n");
}

// Switch
switch (idade) {
    case 18:
        printf("Acabou de atingir maioridade\n");
        break;
    default:
        printf("Idade comum\n");
}
```

### Laços de Repetição

```c
// For
for (int i = 0; i < 10; i++) {
    printf("%d ", i);
}

// While
int i = 0;
while (i < 10) {
    printf("%d ", i);
    i++;
}

// Do-while (executa pelo menos uma vez)
int j = 0;
do {
    printf("%d ", j);
    j++;
} while (j < 10);
```

## Ponteiros (Fundamental em C/C++)

Ponteiros armazenam endereços de memória, permitindo manipulação direta.

```c
int valor = 42;
int *ptr = &valor;      // ptr armazena o endereço de valor

printf("Valor: %d\n", valor);      // 42
printf("Endereço: %p\n", &valor);  // 0x7fff...
printf("Via ponteiro: %d\n", *ptr); // 42 (desreferência)

*ptr = 100;              // Modifica valor através do ponteiro
printf("Novo valor: %d\n", valor); // 100
```

### Ponteiro para Ponteiro

```c
int valor = 42;
int *ptr = &valor;
int **ptr2 = &ptr;      // Ponteiro para ponteiro

printf("%d\n", **ptr2); // 42
```

## Arrays e Strings

### Arrays

```c
int numeros[5] = {1, 2, 3, 4, 5};     // Array estático
int lista[] = {10, 20, 30};            // Tamanho inferido
numeros[0] = 100;                      // Acessando elemento

// Percorrendo array
for (int i = 0; i < 5; i++) {
    printf("%d ", numeros[i]);
}
```

### Strings em C (Arrays de char)

```c
char nome[20] = "Alice";                   // String terminada por '\0'
char *sobrenome = "Silva";                 // Ponteiro para literal

printf("Nome: %s\n", nome);               // Alice
printf("Primeiro caractere: %c\n", nome[0]); // A

// Funções de string (string.h)
#include <string.h>
strcpy(nome, "Bob");                      // Copia
strcat(nome, " Silva");                   // Concatena
int len = strlen(nome);                   // Comprimento
```

### Strings em C++ (`std::string`)

```cpp
#include <string>

std::string nome = "Alice";
std::string sobrenome = "Silva";

std::string completo = nome + " " + sobrenome; // Concatenação
int tamanho = completo.length();               // Comprimento
```

## Funções

### Declaração e Definição

```c
// Protótipo (declaração)
int soma(int a, int b);

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

// Chamada
int resultado = soma(5, 3);
```

### Passagem por Valor vs Referência

```c
// Por valor (cópia)
void incrementar(int x) {
    x++;  // Apenas a cópia é modificada
}

// Por referência (ponteiro)
void incrementar_ptr(int *x) {
    (*x)++;  // Modifica o original
}

// C++: Passagem por referência (mais simples)
void incrementar_ref(int &x) {
    x++;  // Modifica o original
}
```

## Alocação Dinâmica de Memória

### Em C (`malloc`, `calloc`, `free`)

```c
#include <stdlib.h>

int *array = (int*)malloc(5 * sizeof(int));  // Aloca 5 inteiros
if (array == NULL) {
    // Erro: memória insuficiente
}

array[0] = 10;
free(array);  // Libera memória (evitar vazamentos)
```

### Em C++ (`new`, `delete`)

```cpp
int *ptr = new int;      // Aloca um inteiro
*ptr = 42;
delete ptr;              // Libera memória

int *array = new int[10]; // Aloca array
delete[] array;           // Libera array
```

{% hint style="warning" %}
**Memory Leak**: Sempre libere memória alocada dinamicamente. Em C++, prefira smart pointers (`std::unique_ptr`, `std::shared_ptr`) para gerenciamento automático.
{% endhint %}

## Estruturas (`struct`) e Classes (C++)

### Struct em C/C++

```c
struct Pessoa {
    char nome[50];
    int idade;
    float altura;
};

struct Pessoa p1 = {"Alice", 25, 1.65};
p1.idade = 26;
printf("Nome: %s, Idade: %d\n", p1.nome, p1.idade);
```

### Classe em C++

```cpp
class Pessoa {
private:
    std::string nome;
    int idade;
    
public:
    // Construtor
    Pessoa(std::string n, int i) : nome(n), idade(i) {}
    
    // Métodos
    void apresentar() {
        std::cout << "Olá, sou " << nome << " e tenho " << idade << " anos." << std::endl;
    }
    
    // Getters e Setters
    std::string getNome() { return nome; }
    void setIdade(int i) { idade = i; }
};

Pessoa p1("Alice", 25);
p1.apresentar();
```

## Pré-processador

Diretivas executadas antes da compilação.

```c
#define PI 3.14159              // Define constante
#define QUADRADO(x) ((x)*(x))   // Macro

#ifdef DEBUG
    printf("Modo debug ativado\n");
#endif

#ifndef MAX
    #define MAX 100
#endif

#undef PI                       // Remove definição
```

## Boas Práticas

### 1. Gerenciamento de Memória

* Sempre libere memória alocada com `free()` ou `delete`.
* Use `valgrind` para detectar vazamentos de memória.
* Em C++, prefira RAII (Resource Acquisition Is Initialization).

### 2. Segurança

* Evite `gets()` (use `fgets()`).
* Limite tamanhos de entrada com `strncpy()`, `snprintf()`.
* Use `-Wall -Wextra -Werror` para warnings rigorosos.
* Nunca confie em entradas do usuário sem validação.

### 3. Estilo de Código

* Use nomes descritivos para variáveis e funções.
* Comente código complexo, mas evite comentários óbvios.
* Mantenha funções pequenas e com única responsabilidade.
* Use `const` sempre que possível.

### 4. Portabilidade

* Evite assumir tamanhos fixos para tipos (`sizeof()`).
* Use tipos com tamanho definido (`int32_t`, `uint64_t` de `<stdint.h>`).
* Cuidado com `endianness` ao manipular dados binários.

## Compilação Avançada

### Makefile Simples

```makefile
CC = gcc
CFLAGS = -Wall -Wextra -g
TARGET = programa
SOURCES = main.c utils.c

$(TARGET): $(SOURCES)
	$(CC) $(CFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

run: $(TARGET)
	./$(TARGET)
```

### CMake (Moderno)

```cmake
cmake_minimum_required(VERSION 3.10)
project(MeuProjeto)

set(CMAKE_CXX_STANDARD 17)

add_executable(programa main.cpp utils.cpp)
```

## Ferramentas de Análise

| Ferramenta                | Finalidade                                  |
| ------------------------- | ------------------------------------------- |
| `gdb`                     | Depuração (breakpoints, stack trace)        |
| `valgrind`                | Detecção de vazamentos de memória           |
| `asan` (AddressSanitizer) | Detecção de buffer overflow, use-after-free |
| `clang-tidy`              | Análise estática de código                  |
| `cppcheck`                | Análise estática para C/C++                 |
| `objdump` / `nm`          | Análise de binários                         |

## Vulnerabilidades Comuns em C/C++

| Vulnerabilidade  | Descrição                          | Mitigação                                                 |
| ---------------- | ---------------------------------- | --------------------------------------------------------- |
| Buffer Overflow  | Escrita além dos limites do buffer | Usar funções seguras (`strncpy`, `snprintf`), canários    |
| Use-After-Free   | Acesso a memória já liberada       | Smart pointers, setar ponteiros para NULL                 |
| Double Free      | Liberar memória duas vezes         | Evitar, usar RAII                                         |
| Integer Overflow | Estouro de inteiro                 | Validar entradas, usar tipos seguros                      |
| Format String    | Uso incorreto de `printf`          | `printf("%s", user_input)` em vez de `printf(user_input)` |

## Recursos Adicionais

* Documentação: [cppreference.com](https://en.cppreference.com/)
* Livro: "The C Programming Language" (K\&R)
* Livro: "The C++ Programming Language" (Bjarne Stroustrup)
* Manual: `man gcc`, `man gdb`
* Comunidades: Stack Overflow, r/cpp, r/C\_Programming

Esta documentação cobre o essencial para começar com C/C++, com ênfase em conceitos fundamentais, gerenciamento de memória e boas práticas de segurança. Para aprofundar, explore projetos open-source e documentação oficial.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/programacao-e-linguagens/c-and-c++.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.