Trucos de gestión de memoria con matrices

Question

Esta es la primera vez que uso StackOverflow para una pregunta, he leído algunas respuestas anteriormente que me han ayudado en algunos casos, así que pensé en registrarme, ya que no puedo encontrar la respuesta específica que estoy buscando. Recientemente hice un sistema de partículas bastante simple que arroja un par de 100 a 1000 de partículas solo para ver si podía hacerlo, antes de comenzar esto hice una lista simple vinculada que usa plantillas para poder usarlo en otros programas si Lo elijo.

Recientemente, después de ver a un colega mío jugando con un sistema de partículas, descubrió que decidí volver a visitar mi proyecto para mejorarlo. Realicé Internet para encontrar un pequeño ejemplo que aparentemente abandona la idea de usar una lista vinculada y, en su lugar, usa y matriz y tres punteros para administrar las partículas. Entiendo la mayor parte del concepto, pero por alguna razón una cosa me escapa.

 /// the first particle in the linked list
    Particle* start=0;

/// the next free particle
Particle* last=0;

/// the end of the memory allocation
Particle* end=0;

void SetSize(unsigned int size) {

    // delete any previous data
    delete [] start;

    // allocate new particles 
    last = start = new Particle[size];

    // set end
    end = start+size;
}

void AddOne() {

    // if we have no more memory left for any particles, ignore
    // the request to creat one.
    if (!IsFull()) {
        *last = Particle();
        ++last;
    }

}

void EraseOne(Particle* p) {

    if (!IsEmpty()) {
        *p = *(--last);
    }

}

Por lo que entiendo del código anterior, los tres punteros actúan como simples punteros a los elementos de la matriz. El puntero de inicio permanece en cero y el puntero final permanece al final de la matriz, mientras que el último comienza desde la misma posición que el puntero de inicio y se mueve como un mostrador de índice hasta que llega al final.

De lo que no estoy seguro es el bit de borrado, supongo en el código anterior que 'P' no se está convirtiendo en la partícula que el último puntero apunta sino el anterior. Desafortunadamente, no tengo idea de por qué se hace de esta manera, ya que seguramente la anterior es una partícula perfectamente viva, pero ¿no haría esto dos instancias de la misma partícula?

Answer 1

Lo primero es que debe usar un continente estándar en lugar de probar una implementación manual a medias. Ahora a la interpretación del código:

El código muestra un patrón común. Básicamente usas tres punteros, uno al comienzo de la memoria asignada (equivalente a begin()), un puntero uno más allá del último elemento (equivalente a end() y un tercer puntero uno más allá del último bloque asignado (para evitar desbordarse.

Con eso en mente, interpretar las funciones no es difícil. En particular, AddOne (Similar a push_back Pero sin cultivar el búfer) actualiza el primer elemento más allá del final, e incrementa el puntero para referirse a uno más allá del nuevo último elemento.

A partir de EraseOne Básicamente realiza la operación inversa: primero disminuye el puntero (por lo que ahora el elemento anterior está fuera del rango válido) y luego copia ese elemento (recuerde que el puntero se refiere a uno más allá del final)