dame un codigo que sea de los arreglos cola(fifo) y pila(lifo), mas corto

Aquí te dejo un ejemplo de implementación de una cola (FIFO) y una pila (LIFO) en C++:

```cpp
#include <iostream>

// Clase para la cola (FIFO)
class Cola {
private:
    int* elementos;
    int tamMax;
    int tamActual;
public:
    Cola(int tamMax) {
        this->tamMax = tamMax;
        elementos = new int[tamMax];
        tamActual = 0;
    }

    ~Cola() {
        delete[] elementos;
    }

    void agregar(int elemento) {
        if (tamActual < tamMax) {
            elementos[tamActual] = elemento;
            tamActual++;
        } else {
            std::cout << "Cola llena" << std::endl;
        }
    }

    int eliminar() {
        if (tamActual > 0) {
            int elemento = elementos[0];
            for (int i = 1; i < tamActual; i++) {
                elementos[i - 1] = elementos[i];
            }
            tamActual--;
            return elemento;
        } else {
            std::cout << "Cola vacía" << std::endl;
            return -1;
        }
    }

    int obtenerPrimero() {
        if (tamActual > 0) {
            return elementos[0];
        } else {
            std::cout << "Cola vacía" << std::endl;
            return -1;
        }
    }
};

// Clase para la pila (LIFO)
class Pila {
private:
    int* elementos;
    int tamMax;
    int tamActual;
public:
    Pila(int tamMax) {
        this->tamMax = tamMax;
        elementos = new int[tamMax];
        tamActual = 0;
    }

    ~Pila() {
        delete[] elementos;
    }

    void agregar(int elemento) {
        if (tamActual < tamMax) {
            elementos[tamActual] = elemento;
            tamActual++;
        } else {
            std::cout << "Pila llena" << std::endl;
        }
    }

    int eliminar() {
        if (tamActual > 0) {
            int elemento = elementos[tamActual - 1];
            tamActual--;
            return elemento;
        } else {
            std::cout << "Pila vacía" << std::endl;
            return -1;
        }
    }

    int obtenerUltimo() {
        if (tamActual > 0) {
            return elementos[tamActual - 1];
        } else {
            std::cout << "Pila vacía" << std::endl;
            return -1;
        }
    }
};

int main() {
    // Crear una cola con capacidad para 5 elementos
    Cola cola(5);

    // Agregar elementos a la cola
    cola.agregar(1);
    cola.agregar(2);
    cola.agregar(3);

    // Eliminar elementos de la cola
    std::cout << "Elemento eliminado: " << cola.eliminar() << std::endl;
    std::cout << "Elemento eliminado: " << cola.eliminar() << std::endl;

    // Obtener el primer elemento de la cola
    std::cout << "Primer elemento: " << cola.obtenerPrimero() << std::endl;

    // Crear una pila con capacidad para 5 elementos
    Pila pila(5);

    // Agregar elementos a la pila
    pila.agregar(1);
    pila.agregar(2);
    pila.agregar(3);

    // Eliminar elementos de la pila
    std::cout << "Elemento eliminado: " << pila.eliminar() << std::endl;
    std::cout << "Elemento eliminado: " << pila.eliminar() << std::endl;

    // Obtener el último elemento de la pila
    std::cout << "Último elemento: " << pila.obtenerUltimo() << std::endl;

    return 0;
}
```

Este código define dos clases: `Cola` y `Pila`. Cada clase tiene métodos para agregar elementos, eliminar elementos y obtener el primer o último elemento de la estructura. En el `main` se crean instancias de ambas clases y se demuestran sus métodos.