#include <iostream>

int main() {
    // Array de 5 enteros (stack)
    int numbers[5] = {10, 20, 30, 40, 50};

    std::cout << "Primer elemento: " << numbers[0] << "
";  // 10
    std::cout << "Tercer elemento: " << numbers[2] << "
";  // 30

    // Modificar elemento
    numbers[2] = 99;
    std::cout << "Nuevo tercer elemento: " << numbers[2] << "
";  // 99

    return 0;
}

int arr[5] = {1, 2, 3, 4, 5};

// Tamaño del array completo
std::cout << sizeof(arr) << "
";  // 20 bytes (5 * 4)

// Tamaño de un elemento
std::cout << sizeof(arr[0]) << "
";  // 4 bytes

// Número de elementos
int length = sizeof(arr) / sizeof(arr[0]);  // 5

#include <iostream>

int main() {
    int x = 42;
    int* ptr = &x;  // ptr almacena la DIRECCIÓN de x

    std::cout << "Valor de x: " << x << "
";       // 42
    std::cout << "Dirección de x: " << &x << "
";  // 0x7fff5fbff5ac (ejemplo)
    std::cout << "Valor de ptr: " << ptr << "
";   // 0x7fff5fbff5ac
    std::cout << "Valor apuntado: " << *ptr << "
";  // 42 (dereferencia)

    // Modificar a través del puntero
    *ptr = 100;
    std::cout << "Nuevo valor de x: " << x << "
";  // 100

    return 0;
}

int arr[5] = {10, 20, 30, 40, 50};
int* ptr = arr;  // ptr apunta al primer elemento

std::cout << *ptr << "
";        // 10
std::cout << *(ptr + 1) << "
";  // 20
std::cout << *(ptr + 2) << "
";  // 30

// Iterar con aritmética de punteros
for (int i = 0; i < 5; i++) {
    std::cout << *(ptr + i) << " ";
}
// Output: 10 20 30 40 50

int arr[5] = {10, 20, 30, 40, 50};

// Estas son equivalentes:
arr[2]           // 30
    * (arr + 2)  // 30
    2 [arr]      // 30 (¡sí, esto compila!)

    // ¿Por qué? Porque arr[i] se traduce a *(arr + i)
    // Y la suma es conmutativa: *(arr + 2) == *(2 + arr)

#include <iostream>

int main() {
    int* ptr = nullptr;  // C++11: puntero nulo

    if (ptr == nullptr) {
        std::cout << "Puntero es nulo
";
    }

    // [X] PELIGRO: dereferencia de puntero nulo
    // *ptr = 42;  // CRASH: Segmentation Fault

    // [OK] Siempre verifica antes de dereferencia
    if (ptr != nullptr) {
        *ptr = 42;
    }

    return 0;
}

int x = 42;
int* ptr = &x;      // ptr apunta a x
int** pptr = &ptr;  // pptr apunta a ptr

std::cout << "Valor de x: " << x << "
";          // 42
std::cout << "Valor de ptr: " << *ptr << "
";     // 42
std::cout << "Valor de pptr: " << **pptr << "
";  // 42 (doble dereferencia)

// Modificar x a través de pptr
**pptr = 100;
std::cout << "Nuevo valor de x: " << x << "
";  // 100

#include <iostream>

int main() {
    // STACK: asignación automática, rápida, limitada
    int stack_var = 42;
    int stack_arr[100];  // 400 bytes en el stack

    // HEAP: asignación manual, lenta, grande
    int* heap_ptr = new int(42);       // 1 entero en el heap
    int* heap_arr = new int[1000000];  // 4MB en el heap

    std::cout << "Stack variable: " << stack_var << "
";
    std::cout << "Heap variable: " << *heap_ptr << "
";

    // ⚠️ IMPORTANTE: liberar memoria del heap
    delete heap_ptr;
    delete[] heap_arr;

    return 0;
}  // stack_var y stack_arr se destruyen automáticamente

// [X] Error 1: Array out of bounds
int arr[5] = {1, 2, 3, 4, 5};
std::cout << arr[10] << "
";  // ¡Undefined Behavior!

// [X] Error 2: Dangling pointer
int* ptr;
{
    int x = 42;
    ptr = &x;
}  // x se destruye aquí
std::cout << *ptr << "
";  // ¡ptr apunta a memoria inválida!

// [X] Error 3: Puntero no inicializado
int* ptr2;   // Contiene basura (dirección aleatoria)
*ptr2 = 42;  // ¡CRASH!

// [X] Error 4: Usar array después de delete
int* arr2 = new int[5];
delete[] arr2;
arr2[0] = 10;  // ¡Undefined Behavior!

void printArray(int* arr, int size) {
    // arr es un puntero, no un array
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << "
";
}

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};

    // El array "decae" a puntero al pasarlo
    printArray(numbers, 5);

    return 0;
}