Por que este programa se rompe al ingresar unos pocos elementos?

Question

Algoritmo

Al principio el arreglo es de longitud=0. Luego, en cada iteracion, al pretender ingresar un elemento, el arreglo pasa a ser de longitud+1; entonces, dicho elemento ocupa la posición longitud-1.

Objetivo

Que se ingrese de a un elemento al arreglo y este cambie su longitud conforme cada iteracion ocurre.

Problema

El programa se cierra (APPCRASH) al introducir unos pocos valores.

Implementacion

#include <cstdlib>
#include <malloc.h>
#include <iostream>
using namespace std;

int main(int argc, char** argv) {

    int *arreglo, i;
    bool seguir=true;
    size_t longitud=0;
    arreglo=(int*)malloc(longitud*sizeof(int));

    while (seguir!=false) {
        arreglo=(int*)realloc(arreglo,(1)*sizeof(int));
        longitud++;
        arreglo[longitud-1]=5;
        cout<<"seguir: ";
        cin>>seguir;
    }

    for (i=0;i<longitud;i++) cout<<"arreglo["<<i<<"]="<<arreglo[i]<<endl;
    free(arreglo); 
    system("pause");
    return 0;

}

No me doy cuenta de que errores conceptuales estoy cometiendo. He probado varias posibilidades y los problemas persisten.

Trate de simplificar lo mas que pude el programa (a tal punto de que el único elemento que se ingresa es el 5). La idea original era implementar una clase para representar el conjunto de los enteros mediante un arreglo dinámico, y en dicha clase definir operaciones sobre dichos conjuntos. Pero el caso es que se me dificulta construir los conjuntos, y eso no me deja avanzar en el resto del ejercicio.

Espero que me puedan ayudar. Es la primera vez que pido ayuda con un código. Desde ya, muchas gracias.

score 2 · Accepted Answer · 2016-03-29T17:24:57.713

El problema principal está en esta línea:

arreglo=(int*)realloc(arreglo,(1)*sizeof(int));
longitud++;

No estás aumentando el tamaño del arreglo. En su lugar, estás obteniendo una nueva dirección de memoria para un arreglo de longitud 1. Esto es a causa de utilizar este código: (1)*sizeof(int). En lugar de 1 debería ser la longitud deseada del arreglo. Cambia dicha línea de código por la siguiente:

arreglo=(int*)realloc(arreglo,(longitud + 1)*sizeof(int));
                            // aquí está la diferencia
longitud++;

O reduciéndolo a una sola línea:

arreglo=(int*)realloc(arreglo,(++longitud)*sizeof(int));

Asimismo, realloc usualmente devolverá una dirección de memoria diferente a la anterior. Si quieres aumentar el tamaño de tu arreglo en tiempo de ejecución, te recomiendo que realices lo siguiente (corregido gracias al comentario de @eferion):

Almacenar el valor de realloc en una variable temporal. Digamos int* nuevoArreglo.
Si el valor de nuevoArreglo es diferente de NULL, significa que se pudo hacer la relocación de memoria, por ende se puede reasignar el valor del puntero nuevoArreglo a arreglo.

El código sería de esta manera:

//1.
int *nuevoArreglo = (int*)realloc(arreglo,(longitud)*sizeof(int));
if (nuevoArreglo != NULL) {
    //2.
    arreglo = nuevoArreglo;
}

Si `realloc` únicamente te diese una nueva posición de memoria. ¿Cual es la diferencia respecto a `malloc`? `realloc` busca una nueva posición de memoria y, si la encuentra, copia el contenido de la memoria actual a la nueva ubicación y libera la memoria antigua. En caso contrario devuelve `NULL`. La buena práctica es almacenar el resultado de `realloc` en una variable temporal y, si es distinta de `NULL` sustituir el puntero bueno. Esto es así porque si falla la memoria antigua no la libera. — eferion, Mar 29 '16 at 09:13
Entonces, con lo que tu propones: Recorrer todos los elementos de arreglo y asignarlos en las casillas de nuevoArreglo es redundante? — cfrostte, Mar 29 '16 at 16:16

Por que este programa se rompe al ingresar unos pocos elementos?

1 Answers1