# 1. Variaveis e Tipagem ## Introdução Em C e C++, as variáveis são espaços de memória nomeados que armazenam dados. Diferente do PHP, C/C++ é uma linguagem de **tipagem estática** e **forte**, o que significa que cada variável deve ter um tipo definido em tempo de compilação e esse tipo não pode ser alterado durante a execução. Isso proporciona maior segurança e performance, mas exige atenção redobrada ao gerenciamento de memória e conversões de tipo. ## Definição e Atribuição Em C/C++, as variáveis devem ser declaradas com um tipo antes do uso. ```c char alvo[] = "10.0.0.1"; // String (array de caracteres) int porta = 80; // Inteiro int online = 1; // Booleano em C (0 = false, !=0 = true) float versao = 1.1; // Ponto flutuante ``` * **Sensibilidade:** Nomes de variáveis são Case-Sensitive (`var` != `VAR`). * **Nomenclatura:** Geralmente segue `snake_case` ou `camelCase`. * **Obrigatoriedade:** Toda variável deve ser declarada antes do uso. * **Inicialização:** Variáveis não inicializadas contêm **lixo de memória** (valor indefinido). ```c int a; // Declaração (valor indefinido) int b = 10; // Declaração com inicialização int c = 0, d = 5; // Declaração múltipla ``` ## Tipos de Dados Básicos ### 1. Inteiros (int, short, long) Representam números inteiros, com tamanhos variados conforme arquitetura. | Tipo | Tamanho (bytes)\* | Faixa Aproximada | | ----------- | ----------------- | ------------------------------ | | `char` | 1 | -128 a 127 ou 0 a 255 | | `short` | 2 | -32.768 a 32.767 | | `int` | 4 | -2.147.483.648 a 2.147.483.647 | | `long` | 4 ou 8 | Depende do sistema | | `long long` | 8 | -9.2e18 a 9.2e18 | \*Tamanhos podem variar conforme compilador e arquitetura (use `sizeof()` para verificar) ```c unsigned int idade = 25; // Apenas valores positivos signed int temperatura = -40; // Pode ser negativo (padrão) long populacao = 8000000000L; ``` ### 2. Ponto Flutuante (float, double, long double) Representam números com casas decimais. | Tipo | Tamanho (bytes) | Precisão | | ------------- | --------------- | --------------------- | | `float` | 4 | \~7 dígitos decimais | | `double` | 8 | \~15 dígitos decimais | | `long double` | 10, 12 ou 16 | Precisão estendida | ```c float pi = 3.14159f; // 'f' indica float double e = 2.718281828459; long double grande = 3.141592653589793238L; ``` ### 3. Caracteres (char) Representa um único caractere, armazenado como um número (código ASCII). ```c char letra = 'A'; // Aspas simples char codigo = 65; // Mesmo que 'A' (ASCII) char texto[] = "Hello"; // String (array de chars terminado por '\0') ``` ### 4. Booleanos (bool) Em C, não existe tipo \`bool\` nativo até C99 (\`\`). ```c #include bool online = true; bool ativo = false; ``` Em C++, \`bool\` é nativo. ```c bool online = true; bool ativo = false; ``` ### 5. Void Representa a ausência de tipo. Usado em ponteiros genéricos (`void*`) e funções que não retornam valor. ```c void funcao_sem_retorno() { // Não retorna valor } void *ponteiro_generico; // Pode apontar para qualquer tipo ``` ## Modificadores de Tipo ### const (Constante) O valor não pode ser modificado após a inicialização. ```c const int MAXIMO = 100; MAXIMO = 200; // ERRO! Não pode modificar constante // Ponteiro para constante const int *ptr = &valor; // Não pode modificar o valor apontado int *const ptr2 = &valor; // Não pode modificar o ponteiro (endereço fixo) ``` ### volatile Indica que o valor pode ser alterado externamente (hardware, threads, sinais). ```c volatile int flag = 0; // Pode ser alterada por interrupção ``` ### static * **Dentro de função:** Mantém o valor entre chamadas. * **Fora de função:** Escopo limitado ao arquivo (linkage interno). ```c void contador() { static int chamadas = 0; // Mantém valor entre chamadas chamadas++; printf("Chamada %d\n", chamadas); } ``` ### extern Declara que a variável é definida em outro arquivo. ```c // arquivo1.c int global = 100; // arquivo2.c extern int global; // Referência à variável de arquivo1.c ``` ## Ponteiros (A Base da Manipulação de Memória) Ponteiros são variáveis que armazenam **endereços de memória**. São fundamentais em C/C++ para manipulação direta de memória, arrays dinâmicos e passagem por referência. ### Declaração e Uso Básico ```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("Conteúdo do ponteiro: %p\n", ptr); // Mesmo endereço printf("Valor 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 ``` ### Ponteiro Void (Genérico) ```c void *generico = &valor; // Pode apontar para qualquer tipo int *ptr_int = (int*)generico; // Necessário cast para usar ``` ### Ponteiro Nulo ```c int *ptr = NULL; // Aponta para lugar nenhum if (ptr == NULL) { printf("Ponteiro nulo\n"); } ``` ## Arrays Arrays são sequências contíguas de elementos do mesmo tipo. ### Declaração e Inicialização ```c int numeros[5] = {1, 2, 3, 4, 5}; // Array estático int lista[] = {10, 20, 30}; // Tamanho inferido char texto[20] = "Hello"; // String terminada por '\0' numeros[0] = 100; // Acessando elemento printf("%d\n", numeros[2]); // 3 ``` ### Relação com Ponteiros O nome do array é um ponteiro constante para o primeiro elemento. ```c int arr[5] = {1, 2, 3, 4, 5}; printf("%d\n", arr[0]); // 1 printf("%d\n", *arr); // 1 (mesmo que arr[0]) printf("%d\n", *(arr + 2)); // 3 (mesmo que arr[2]) ``` ### Arrays Multidimensionais ```c int matriz[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }; printf("%d\n", matriz[1][2]); // 7 ``` ## Strings em C Strings em C são arrays de caracteres terminados por `\0` (null terminator). ```c char nome[20] = "Alice"; // Inicialização char sobrenome[] = "Silva"; // Tamanho inferido char *ptr = "Texto literal"; // Ponteiro para string constante // Acessando caracteres printf("%c\n", nome[0]); // 'A' printf("%s\n", nome); // "Alice" // Modificando (cuidado com tamanho) strcpy(nome, "Bob"); // Copia "Bob" para nome strcat(nome, " Silva"); // Concatena ``` ### Funções de String (string.h) ```c #include char str1[20] = "Hello"; char str2[20] = "World"; int len = strlen(str1); // Comprimento (5) strcpy(str1, str2); // Copia str2 para str1 strcat(str1, "!"); // Concatena "!" ao final int cmp = strcmp("abc", "abd"); // Comparação (negativo, zero, positivo) ``` ## Strings em C++ (std::string) C++ oferece a classe `std::string`, que gerencia memória automaticamente. ```cpp #include std::string nome = "Alice"; std::string sobrenome = "Silva"; std::string completo = nome + " " + sobrenome; // Concatenação int tamanho = completo.length(); // Comprimento // Acessando caracteres char letra = nome[0]; // 'A' char ultima = nome.back(); // 'e' // Comparação if (nome == "Alice") { // Igualdade } // Substrings std::string parte = nome.substr(1, 3); // "lic" ``` ## Escopo e Tempo de Vida ### Variáveis Locais (Stack) Alocadas na pilha, existem apenas dentro do bloco onde são declaradas. ```c void funcao() { int local = 10; // Alocada na stack // local existe apenas dentro de funcao() } // local é destruída aqui ``` ### Variáveis Globais (Data Segment) Existem durante toda a execução do programa. ```c int global = 100; // Acessível de qualquer função void funcao1() { global = 200; // Modifica global } ``` ### Variáveis Estáticas (Data Segment) Mantêm valor entre chamadas, mas escopo limitado. ```c void contador() { static int count = 0; // Inicializada apenas uma vez count++; printf("%d\n", count); } ``` ### Variáveis Dinâmicas (Heap) Alocadas manualmente com `malloc`/`new`, existem até serem liberadas. ```c int *dinamico = (int*)malloc(sizeof(int)); // C *dinamico = 42; free(dinamico); // Liberar memória // C++ int *dinamico2 = new int(42); delete dinamico2; ``` ## Conversão de Tipos (Type Casting) ### Conversão Implícita O compilador converte automaticamente quando necessário. ```c int a = 10; float b = a; // 10.0 (int -> float) double c = 5 / 2; // 2.0 (divisão inteira, depois converte) double d = 5.0 / 2; // 2.5 (correto) ``` ### Conversão Explícita (C-Style Cast) ```c float pi = 3.14159; int inteiro = (int)pi; // 3 (trunca) void *ptr = &inteiro; int *ptr_int = (int*)ptr; // Cast de ponteiro ``` ### C++ Casts (Recomendado em C++) ```cpp // static_cast - conversões seguras em tempo de compilação float pi = 3.14159; int inteiro = static_cast(pi); // dynamic_cast - para polimorfismo (runtime) Base* base = new Derivada(); Derivada* derivada = dynamic_cast(base); // const_cast - remove constância const int valor = 10; int *ptr = const_cast(&valor); // reinterpret_cast - conversão de bits (perigoso) int endereco = 0x7fff; void *ptr = reinterpret_cast(endereco); ``` ## Boas Práticas com Variáveis * **Inicialize sempre as variáveis**: Variáveis não inicializadas contêm lixo de memória. ```c int valor = 0; // Sempre inicializar ``` * **Use `const` sempre que possível**: Protege contra modificações acidentais. ```c const int MAX_TENTATIVAS = 3; ``` * **Prefira tipos com tamanho definido** para portabilidade (``): ```c #include int32_t codigo = 100; // Garantidamente 32 bits uint64_t populacao = 8000000000ULL; ``` * **Evite variáveis globais**: Prefira passagem por parâmetro ou encapsulamento. * **Valide ponteiros antes de usar**: ```c int *ptr = malloc(sizeof(int)); if (ptr != NULL) { *ptr = 42; free(ptr); } ``` * **Use `sizeof()` para tamanhos**: ```c int arr[10]; int tamanho_bytes = sizeof(arr); // 40 (em sistemas 32/64 bits) int elementos = sizeof(arr) / sizeof(arr[0]); // 10 ``` ## Ferramentas para Detecção de Erros | Ferramenta | Finalidade | | ----------------------------------------- | ----------------------------------------------- | | `valgrind` | Detecta vazamentos de memória e acesso inválido | | `AddressSanitizer` (`-fsanitize=address`) | Detecta buffer overflow, use-after-free | | `gdb` | Depuração com breakpoints e análise de memória | | `clang-tidy` | Análise estática de código | ## Vulnerabilidades Comuns Relacionadas a Tipos | Vulnerabilidade | Descrição | Exemplo | | ---------------- | --------------------------------- | ------------------------------------------- | | Buffer Overflow | Escrita além dos limites do array | `char buf[10]; strcpy(buf, entrada_longa);` | | Integer Overflow | Estouro de inteiro | `unsigned int a = UINT_MAX; a++` | | Use-After-Free | Acesso a memória já liberada | `free(ptr); *ptr = 42;` | | Double Free | Liberar mesma memória duas vezes | `free(ptr); free(ptr);` | | Ponteiro Nulo | Desreferenciar ponteiro nulo | `int *ptr = NULL; *ptr = 10;` | ## Recursos Adicionais * Manual: `man gcc`, `man gdb` * Documentação: [cppreference.com](https://cppreference.com/) * Livro: "The C Programming Language" (K\&R) * Livro: "The C++ Programming Language" (Bjarne Stroustrup) Esta documentação aborda os fundamentos de variáveis e tipagem em C/C++, com ênfase em ponteiros, gerenciamento de memória e boas práticas de segurança. Para aprofundar, explore a documentação oficial e pratique com exemplos. --- # 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++/1.-variaveis-e-tipagem.md?ask= ``` 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.