¿Cómo hago para aumentar un variable que tengo declarada const int y es un Array?

Question

Esto es lo que se me pide:

La implementación del TAD Pila con arrays establece un tamaño máximo de la pila que se controla con la función pilaLlena(). Modificar la función de tal forma que cuando se llene la pila se amplíe el tamaño del array a justamente el doble de la capacidad actual.

Tengo la función que me valida si la pila está llena:

#include<stdlib.h>
#include<iostream>
using namespace std;

const int maximo_pila = 5;

struct pila{
    int frente;
    int dato[maximo_pila];
}q;
//struct Pila q;

int iniciar(){
    q.frente = 0;
    return 0;
}

int llena(){
    return (q.frente == maximo_pila)? 1:0;
}

int vacia(){
    return(q.frente == 0)? 1:0;
    
}

void insertar(int x){
    if(llena()){
        cout<<"LA PILA ESTA LLENA n";
        maximo_pila
        return;
    }
    else{
        cout<<"nIngrese los Datos: ";
        cin>>x;
        q.frente++;
        q.dato[q.frente]=x;
    }
}

void mostrar(){
    if(vacia()){
        cout<<"LA PILA ESTA VACIA! n";
        return;
    }
    else{
        cout<<"Los Datos de la Pila: n";
        for(int d=0;d<=q.frente;d++){
            cout<<q.dato[d]<<"n";
        }
    }
}

int main(){
    iniciar();
    int y,opc;
    
    do{
        cout<<"--MENU--nn1.Insertar n2:Mostrar n3:Salirn";
        cin>>opc;
        switch(opc){
            case 1: insertar(y); system("pause");break;
            case 2: mostrar();system("pause");break;
        }
        system("cls");
    }while(opc != 3);
    
    }

Lo que no sé, es como aumentar el valor de la variable maximo_pila¿Cómo puedo hacer eso?

c++pilas

PaperBirdMaster · Answer

Para empezar a entender la respuesta, tienes que entender todo lo que está mal en tu pregunta:

No tienes una variable const int que es una formación¹, tienes una formación de int cuyo tamaño es const int:

    const int maximo_pila = 5;
 // ^^^^^^^^^ <---- La variable 'maximo_pila' es un entero (int) constante (const).

 struct pila{
     int frente;
     int dato[maximo_pila];
 //  ^^^ <---- La variable 'dato' es una formación de 'maximo_pila' elementos enteros (int).
 }q;

No puedes ampliar el tamaño de la formación porque el tamaño está prefijado en tiempo de compilación y forma parte del tamaño del objeto pila. Si quieres una colección de datos que pueda variar de tamaño no debes usar formaciones.

Para tener una colección de datos que pueda cambiar durante la ejecución, usa un puntero:

int *dato = nullptr;
//  ^ <---- Puntero a entero (int), de momento 'dato' no tiene datos.

Puedes pedir memoria con el operador new:

dato = new int[maximo_pila] {};
//     _/ ______________/ ^^ <--- Se inicializa con '0' porque la lista de datos está vacía.
//      |         |
//      |         --- Son 'maximo_pila' enteros (int).
//      |
//      ---- Creamos memoria dinámica

Si quieres más memoria, sólo tienes que pedirla:

/* Borramos la memoria anterior, para evitar fugas
   ( https://es.wikipedia.org/wiki/Fuga_de_memoria ) */
delete [] dato;
// Pedimos nueva memoria.
dato = new int[maximo_pila * 2] {};

Si haces las cosas así, tienes dos problemas:

Gestionar la memoria manualmente es molesto y propenso a errores.
Se pierden los datos anteriores.

Te propongo lo siguiente:

Usa punteros inteligentes.
No incluyas cabeceras que no usas.
- Elimina <stdlib.h>, que además de no usarla es de C, no de C++.
Estás en C++, usa la programación orientada a objetos.
- Mueve las funciones de gestión de la pila dentro del objeto de la pila.
  - Así evitas tener que crear variables globales.
- Los objetos pueden tener constructores.
En C++ existe el tipo bool para lógica booleana, no uses enteros para ello.

struct pila
{
    using puntero = std::unique_ptr<int[]>;

    pila() : dato { std::make_unique<int[]>(maximo_pila) } {}
    bool llena() const { return frente == maximo_pila; }
    bool vacia() const { return frente == 0; }

    void insertar(int x)
    {
        if (llena())
        {
            // Nuevo buffer
            puntero nuevo = std::make_unique<int[]>(maximo_pila * 2);

            // Copiamos datos antiguos al nuevo bufer y lo intercambiamos
            std::copy(dato.get(), dato.get() + maximo_pila, nuevo.get());
            dato.swap(nuevo);

            // Ampliamos el maximo y anyadimos el dato nuevo
            maximo_pila *= 2;
            return insertar(x);
        }

        dato[frente++] = x;
    }

    void mostrar() const
    {
        for (int indice = 0; indice != frente; ++indice)
            std::cout << dato[indice] << 'n';
    }

private:
    int frente = 0;
    int maximo_pila = 5;
    puntero dato;
};

Puede usarse así:

    pila p;
    p.insertar(0);
    p.insertar(1);
    p.insertar(2);
    p.insertar(3);
    p.insertar(4);

    p.mostrar();
    // Ahora esta llena.
    std::cout << "La pila esta llena? " << std::boolalpha << p.llena() << 'n';

    p.insertar(5);
    p.mostrar();
    // Ahora no esta llena: creció.
    std::cout << "La pila esta llena? " << std::boolalpha << p.llena() << 'n';

¹También conocidas como arreglo o en inglés array.

¿Cómo hago para aumentar un variable que tengo declarada const int y es un Array?

One Answer

Add your own answers!

Ask a Question